Add files using upload-large-folder tool

parse/train/H1ecDoR5Y7/H1ecDoR5Y7.md

@@ -0,0 +1,515 @@
+# LOCAL STABILITY AND PERFORMANCE OF SIMPLE GRADIENT PENALTY $\mu$ -WASSERSTEIN GAN
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Wasserstein GAN(WGAN) is a model that minimizes the Wasserstein distance between a data distribution and sample distribution. Recent studies have proposed stabilizing the training process for the WGAN and implementing the Lipschitz constraint. In this study, we prove the local stability of optimizing the simple gradient penalty $\mu$ -WGAN(SGP $\mu$ -WGAN) under suitable assumptions regarding the equilibrium and penalty measure $\mu$ . The measure valued differentiation concept is employed to deal with the derivative of the penalty terms, which is helpful for handling abstract singular measures with lower dimensional support. Based on this analysis, we claim that penalizing the data manifold or sample manifold is the key to regularizing the original WGAN with a gradient penalty. Experimental results obtained with unintuitive penalty measures that satisfy our assumptions are also provided to support our theoretical results.
+
+# 1 INTRODUCTION
+
+Deep generative models reached a turning point after generative adversarial networks (GANs) were proposed by Goodfellow et al. (2014). GANs are capable of modeling data with complex structures. For example, DCGAN can sample realistic images using a convolutional neural network (CNN) structure(Radford et al., 2015). GANs have been implemented in many applications in the field of computer vision with good results, such as super-resolution, image translation, and text-to-image generation(Ledig et al., 2017; Isola et al., 2017; Zhang et al., 2017; Reed et al., 2016).
+
+However, despite these successes, GANs are affected by training instability and mode collapse problems. GANs often fail to converge, which can result in unrealistic fake samples. Furthermore, even if GANs successfully synthesize realistic data, the fake samples exhibit little variability.
+
+A common solution to this instability problem is injecting an instance noise and finding different divergences. The injection of instance noise into real and fake samples during the training procedure was proposed by Sønderby et al. (2017), where its positive impact on the low dimensional support for the data distribution was shown to be a regularizing factor based on the Wasserstein distance, as demonstrated analytically by Arjovsky & Bottou (2017). In $f$ -GAN, $f$ -divergence between the target and generator distributions was suggested which generalizes the divergence between two distributions(Nowozin et al., 2016). In addition, a gradient penalty term which is related with Sobolev IPM(Integral Probability Metric) between data distribution and sample distribution was suggested by Mroueh et al. (2018).
+
+The Wasserstein GAN (WGAN) is known to resolve the problems of generic GANs by selecting the Wasserstein distance as the divergence(Arjovsky et al., 2017). However, WGAN often fails with simple examples because the Lipschitz constraint on discriminator is rarely achieved during the optimization process and weight clipping. Thus, mimicking the Lipschitz constraint on the discriminator by using a gradient penalty was proposed by Gulrajani et al. (2017).
+
+Noise injection and regularizing with a gradient penalty appear to be equivalent. The addition of instance noise in $f$ -GAN can be approximated to adding a zero centered gradient penalty(Roth et al., 2017). Thus, regularizing GAN with a simple gradient penalty term was suggested by Mescheder et al. (2018) who provided a proof of its stability.
+
+Based on a theoretical analysis of the dynamic system, Nagarajan & Kolter (2017) proved the local exponential stability of the gradient-based optimization dynamics in GANs by treating the simultaneous gradient descent algorithm with a dynamic system approach. These previous studies were useful because they showed that the local behavior of GANs can be explained using dynamic system tools and the related Jacobian’s eigenvalues.
+
+In this study, we aim to prove the convergence property of the simple gradient penalty $\mu$ -Wasserstein GAN(SGP $\mu$ -WGAN) dynamic system under general gradient penalty measures $\mu$ . To the best of our knowledge, our study is the first theoretical approach to GAN stability analysis which deals with abstract singular penalty measure. In addition, measure valued differentiation(Heidergott & Vazquez-Abad, 2008) is applied to take the derivative on the integral with a parametric measure, ´ which is helpful for handling an abstract measure and its integral in our proof.
+
+The main contributions of this study are as follows.
+
+• We prove the regularized effect and local stability of the dynamic system for a general penalty measure under suitable assumptions. The assumptions are written as both a tractable strong version and intractable weak version. To prove the main theorem, we also introduce the measure valued differentiation concept to handle the parametric measure. Based on the proof of the stability, we explain the reason for the success of previous penalty measures. We claim that the support of a penalty measure will be strongly related to the stability, where the weight on the limiting penalty measure might affect the speed of convergence. • We experimentally examined the general convergence results by applying two test penalty measures to several examples. The proposed test measures are unintuitive but they still satisfy the assumptions and similar convergence results were obtained in the experiment.
+
+# 2 PRELIMINARIES
+
+First, we introduce our notations and basic measure-theoretic concepts. Second, we define our SGP $\mu$ -WGAN optimization problem and treat this problem as a continuous dynamic system. Preliminary measure theoretic concepts are required to justify that the dynamic system changes in a sufficiently smooth manner as the parameter changes, so it is possible to use linearization theorem. They are also important for dealing with the parametric measure and its derivative. The problem setting with a simple gradient term is also discussed. The squared gradient size and simple gradient penalty term are used to build a differentiable dynamic system and to apply soft regularization as a resolving constraint, respectively. The continuous dynamic system approach, which is a so-called ODE method, is used to analyze the GAN optimization problem with the simultaneous gradient descent algorithm, as described by Nagarajan & Kolter (2017).
+
+# 2.1 NOTATIONS AND PRELIMINARIES REGARDING MEASURE THEORY
+
+$D ( x ; \psi ) : \mathcal { X } \to \mathbb { R }$ is a discriminator function with its parameter $\psi$ and $G ( z ; \theta ) : \mathcal { Z } \to \mathcal { X }$ is a generator function with its parameter $\theta$ . $p _ { d }$ is the distribution of real data and $p _ { g } ~ = ~ p _ { \theta }$ is the distribution of the generated samples in $\mathcal { X }$ , which is induced from the generator function $G ( z ; \theta )$ and a known initial distribution $p _ { l a t e n t } ( z )$ in the latent space $\mathcal { Z } . \ \Vert \cdot \Vert$ denotes the $L ^ { 2 }$ Euclidean norm if no special subscript is present.
+
+The concept of weak convergence for finite measures is used to ensure the continuity of the integral term over the measure in the dynamic system, which must be checked before applying the theorems related to stability. Throughout this study, we assume that the measures in the sample space are all finite and bounded.
+
+Definition 1. For a set of finite measures $\{ \mu _ { i } \} _ { i \in \mathcal { I } }$ in $( \mathbb { R } ^ { n } , d )$ with euclidean distance $d _ { \mathrm { { z } } }$ , $\{ \mu _ { i } \} _ { i \in \mathbb { Z } }$ is referred to as bounded if there exists some $M > 0$ such that for all $i \in \mathcal { Z }$ ,
+
+$$
+\mu _ { i } ( \mathbb { R } ^ { n } ) \leq M
+$$
+
+For instance, $M$ can be set as 1 if $\{ \mu _ { i } \}$ are probability measures on $\mathbb { R } ^ { n }$ . Assuming that the penalty measures are bounded, Portmanteau theorem offers the equivalent definition of the weak convergence for finite measures. This definition is important for ensuring that the integrals over $p _ { \theta }$ and $\mu$ in the dynamic system change continuously.
+
+Definition 2. (Portmanteau Theorem) For a bounded sequence of finite measures $\{ \mu _ { n } \} _ { n \in \mathbb { N } }$ on the Euclidean space $\mathbb { R } ^ { n }$ with a $\sigma$ -field of Borel subsets $B ( \mathbb { R } ^ { n } )$ , $\mu _ { n }$ converges weakly to $\mu$ if and only $i f$ for every continuous bounded function $\phi$ on $\mathbb { R } ^ { n }$ , its integrals with respect to $\mu _ { n }$ converge to $\int \phi \dot { d \mu }$ , i.e.,
+
+$$
+\mu _ { n }  \mu \Longleftrightarrow \int \phi d \mu _ { n }  \int \phi d \mu
+$$
+
+The most challenging problem in our analysis with the general penalty measure is taking the derivative of the integral, where the measure depends on the variable that we want to differentiate. If our penalty measure is either absolutely continuous or discrete, then it is easy to deal with the integral. However, in the case of singular penalty measure, dealing with the integral term is not an easy task. Therefore, we introduce the concept of a weak derivative of a probability measure in the following(Heidergott & Vazquez-Abad, 2008). The weak derivative of a measure is useful for handling a ´ parametric measure that is not absolutely continuous with low dimensional support.
+
+Definition 3. (Weak Derivatives of a Probability Measure) Consider the Euclidean space and its $\sigma$ -field of Borel subsets $( \mathbb { R } ^ { d } , B ( \mathbb { R } ^ { d } ) )$ . The probability measure $P _ { \theta }$ is called weakly differentiable at $\theta$ if a signed finite measure $P _ { \theta } ^ { \prime }$ exists where
+
+$$
+\frac { d } { d \theta } \int \phi ( x ) d P _ { \theta } = \operatorname * { l i m } _ { \Delta  0 } \frac { 1 } { \Delta } \{ \int \phi ( x ) d P _ { \theta + \Delta } - \int \phi ( x ) d P _ { \theta } \} = \int \phi ( x ) d P _ { \theta } ^ { \prime }
+$$
+
+is satisfied for every continuous bounded function $\phi$ on $\mathbb { R } ^ { n }$ . For the multidimensional parameter $\theta$ , this can be defined similar manner.
+
+We can show that the positive part and negative part of $P _ { \theta } ^ { \prime }$ have the same mass by putting $\phi ( x ) = 1$ and the Hahn–Jordan decomposition on $P _ { \theta } ^ { \prime }$ . Therefore, the following triple $( c _ { \theta } , P _ { \theta } ^ { + } , P _ { \theta } ^ { - } )$ is called a weak derivative of $P _ { \theta }$ , where $P _ { \theta } ^ { \pm }$ are probability measures and $P _ { \theta } ^ { \prime }$ is rewritten as:
+
+$$
+P _ { \theta } ^ { \prime } = c _ { \theta } P _ { \theta } ^ { + } - c _ { \theta } P _ { \theta } ^ { - }
+$$
+
+Therefore,
+
+$$
+\frac { d } { d \theta } \int \phi ( x ) d P _ { \theta } = \int \phi ( x ) d P _ { \theta } ^ { \prime } = c _ { \theta } ( \int \phi ( x ) d P _ { \theta } ^ { + } - \int \phi ( x ) d P _ { \theta } ^ { - } )
+$$
+
+holds for every continuous bounded function $\phi$ on $\mathbb { R } ^ { n }$ . It is known that the representation of $( c _ { \theta } , P _ { \theta } ^ { + } , P _ { \theta } ^ { - } )$ for $P _ { \theta } ^ { \prime }$ is not unique because $( c _ { \theta } + C _ { \theta } , P _ { \theta } ^ { + } + q _ { \theta } , P _ { \theta } ^ { - } + q _ { \theta } )$ is also another representation of $P _ { \theta } ^ { \prime }$ .
+
+For the general finite measure $Q _ { \theta }$ , a normalizing coefficient $M ( \theta ) < \infty$ can be introduced. The product rule for differentiating can also be applied in a similar manner to calculus.
+
+$$
+\frac { d } { d \theta } \int \phi ( x ; \theta ) d P _ { \theta } = \int \nabla _ { \theta } \phi ( x ; \theta ) d P _ { \theta } + \int \phi ( x ; \theta ) d P _ { \theta } ^ { \prime }
+$$
+
+Therefore, for the general finite measure $Q _ { \theta } = M ( \theta ) P _ { \theta }$ , its derivative $Q _ { \theta } ^ { \prime }$ can be represented as below.
+
+$$
+Q _ { \theta } ^ { \prime } = M ^ { \prime } ( \theta ) P _ { \theta } + M ( \theta ) P _ { \theta } ^ { \prime } = M ^ { \prime } ( \theta ) P _ { \theta } + c _ { \theta } M ( \theta ) P _ { \theta } ^ { + } - c _ { \theta } M ( \theta ) P _ { \theta } ^ { - }
+$$
+
+# 2.2 PROBLEM SETTING AS A DYNAMIC SYSTEM
+
+Previous work of Mescheder et al. (2018) showed that the dynamic system of WGAN-GP is not necessarily stable at equilibrium by demonstrating that the sequence of parameters is not Cauchy sequence. This is mainly due to the term $\| x \|$ in the dynamic system which has a derivative $\frac { x } { \| x \| }$ that is not defined at $x = 0$ . WGAN-GP has a penalty term $\mathbb { E } _ { \mu _ { G P } } [ ( \| \nabla _ { x } D ( x ; \psi ) \| - 1 ) ^ { 2 } ]$ that can lead to a discontinuity in its dynamic system.
+
+These problems can be avoided by using the squared value of the gradient’s norm $\| \nabla _ { x } D \| ^ { 2 }$ , which is a differentiable function. In contrast to the WGAN-GP, recent methods based on a gradient penalty such as the simple gradient penalty employed by Mescheder et al. (2018) and the Sobolev GAN used the average of the squared values for the penalty area, whereas the WGAN-GP penalizes the size of the discriminator’s gradient $\lVert \nabla _ { x } D \rVert$ away from 1 in a pointwise manner.
+
+This advantage of squared gradient term1, $\mathbb { E } _ { \mu } [ \| \nabla _ { x } D \| ^ { 2 } ]$ , makes the dynamic system differentiable and we define the WGAN problem with the square of the gradient’s norm as a simple gradient penalty. This simple gradient penalty can be treated as soft regularization based on the size of the discriminator’s gradient, especially in case where $\mu$ is the probability measure (Roth et al., 2017). It is convenient to determine whether the system is stable by observing the spectrum of the Jacobian matrix. In the following, $( D ( x ; \psi ) , p _ { d } , p _ { \theta } , \mu )$ is defined as an SGP $\mu$ -WGAN optimization problem (SGP-form) with a simple gradient penalty term on the penalty measure $\mu$ .
+
+Definition 4. The WGAN optimization problem with a simple gradient penalty term $\| \nabla _ { x } D \| ^ { 2 }$ , penalty measure $\mu _ { ; }$ , and penalty weight hyperparameter $\rho > 0$ is given as follows, where the penalty term is only introduced to update the discriminator.
+
+$$
+\begin{array} { r l } & { \displaystyle \operatorname* { m a x } _ { \psi } : \mathbb { E } _ { p _ { d } } [ D ( x ; \psi ) ] - \mathbb { E } _ { p _ { \theta } } [ D ( x ; \psi ) ] - \frac { \rho } { 2 } \mathbb { E } _ { \mu } [ \| \nabla _ { x } D ( x ; \psi ) \| ^ { 2 } ] } \\ & { \displaystyle \operatorname* { m i n } _ { \theta } : \mathbb { E } _ { p _ { d } } [ D ( x ; \psi ) ] - \mathbb { E } _ { p _ { \theta } } [ D ( x ; \psi ) ] } \end{array}
+$$
+
+According to Nagarajan & Kolter (2017) and many other optimization problem studies, the simultaneous gradient descent algorithm for GAN updating can be viewed as an autonomous dynamic system of discriminator parameters and generator parameters, which we denote as $\psi$ and $\theta$ . As a result, the related dynamic system is given as follows.
+
+$$
+\begin{array} { r l } & { \dot { \boldsymbol { \psi } } = \mathbb { E } _ { \boldsymbol { p } _ { d } } [ \nabla _ { \boldsymbol { \psi } } D ] - \mathbb { E } _ { \boldsymbol { p } _ { \boldsymbol { \theta } } } [ \nabla _ { \boldsymbol { \psi } } D ] - \frac { \rho } { 2 } \nabla _ { \boldsymbol { \psi } } \mathbb { E } _ { \boldsymbol { \mu } } [ \nabla _ { \boldsymbol { x } } ^ { T } D \nabla _ { \boldsymbol { x } } D ] } \\ & { \dot { \boldsymbol { \theta } } = \nabla _ { \boldsymbol { \theta } } \mathbb { E } _ { \boldsymbol { p } _ { \boldsymbol { \theta } } } [ D ] } \end{array}
+$$
+
+# 3 TOY EXAMPLES
+
+We investigate two examples considered in previous studies by Mescheder et al. (2018) and Nagarajan & Kolter (2017). We then generalize the results to a finite measure case. The first example is the univariate Dirac GAN, which was introduced by Mescheder et al. (2018).
+
+Definition 5. (Dirac GAN) The Dirac GAN comprises a linear discriminator $D ( x ; \psi ) = \psi x$ , data distribution $p _ { d } = \delta _ { 0 }$ , and sample distribution $p _ { \theta } = \delta _ { \theta }$ .
+
+The Dirac GAN with a gradient penalty with an arbitrary probability measure is known to be globally convergent(Mescheder et al., 2018). We argue that this result can be generalized to a finite penalty measure case.
+
+Lemma 1. Consider the Dirac GAN problem with SGP form $\begin{array} { r } { ( D ( x ; \psi ) = \psi x , \delta _ { 0 } , \delta _ { \theta } , \mu _ { \psi , \theta } ) } \end{array}$ . Suppose that some small $\eta > 0$ exists such that its finite penalty measure $\mu _ { \psi , \theta }$ with mass $M ( \psi , \theta ) =$ $\mathbf { \bar { \rho } } _ { \int 1 d \mu _ { \psi , \theta } } \geq 0$ satisfies either
+
+$$
+M ( \psi , \theta ) > 0 f o r \left( \psi , \theta \right) \in B _ { \eta } ( ( 0 , 0 ) ) o
+$$
+
+$$
+^ { \prime } \psi \nabla _ { \psi } M ( \psi , \theta ) \geq 0 f o r ( \psi , \theta ) \in B _ { \eta } ( ( 0 , 0 ) ) .
+$$
+
+Then, the SGP $\mu$ -WGAN optimization dynamics with $\begin{array} { r } { ( D ( x ; \psi ) = \psi x , \delta _ { 0 } , \delta _ { \theta } , \mu _ { \psi , \theta } ) } \end{array}$ are locally stable at the origin and the basin of attraction $B = B _ { R } ( ( 0 , 0 ) )$ is open ball with radius $R$ . Its radius is given as follows.
+
+Motivated by this example, we can extend this idea to the other toy example given by Nagarajan & Kolter (2017), where WGAN fails to converge to the equilibrium points $( \psi , \theta ) = ( 0 , \pm 1 )$ .
+
+Lemma 2. Consider the toy example $\begin{array} { r c l } { ( D ( x ; \psi ) } & { = } & { \psi x ^ { 2 } , U ( - 1 , 1 ) , U ( - | \theta | , | \theta | ) , \mu _ { \theta } ) } \end{array}$ where $U ( 0 , 0 ) = \delta _ { 0 }$ and the ideal equilibrium points are given by $( \psi ^ { * } , \theta ^ { * } ) = ( 0 , \pm 1 )$ . For a finite measure $\mu = \mu _ { \theta }$ on $\mathbb { R }$ which is independent of $\psi$ , suppose that $\mu _ { \boldsymbol { \theta } } \to \mu ^ { * }$ with $\mu ^ { * } \neq C \delta _ { 0 }$ for $C \geq 0$ . The dynamic system is locally stable near the desired equilibrium $( 0 , \pm 1 )$ , where the spectrum of the
+
+Jacobian at $( 0 , \pm 1 )$ is given by $\begin{array} { r } { \lambda = - 2 \rho \mathbb { E } _ { \mu ^ { * } } [ x ^ { 2 } ] \pm \sqrt { 4 \rho ^ { 2 } \mathbb { E } _ { \mu ^ { * } } [ x ^ { 2 } ] ^ { 2 } - \frac { 4 } { 9 } } } \end{array}$
+
+# 4 MAIN CONVERGENCE THEOREM
+
+We propose the convergence property of WGAN with a simple gradient penalty on an arbitrary penalty measure $\mu$ for a realizable case: $\theta = \theta ^ { * }$ with $p _ { d } = p _ { \theta ^ { \ast } }$ exists. In subsection 4.1, we provide the necessary assumptions, which comprise our main convergence theorem. In subsection 4.2, we give the main convergence theorem with a sketch of the proof. A more rigorous analysis is given in the Appendix.
+
+# 4.1 ASSUMPTIONS
+
+The first assumption is made regarding the equilibrium condition for GANs, where we state the ideal conditions for the discriminator parameter and generator parameter. As the parameters converge to the ideal equilibrium, the sample distribution $\left( p _ { \theta } \right)$ converges to the real data distribution $\left( p _ { d } \right)$ and the discriminator cannot distinguish the generated sample and the real data.
+
+Assumption 1. $p _ { \theta }  p _ { d }$ as $\theta ~ \to ~ \theta ^ { * }$ and $D ( x ; \psi ^ { * } ) ~ = ~ 0$ on supp $\left( p _ { d } \right)$ and its small open neighborhood, i.e., $x \in \cup _ { x ^ { \prime } \in s u p p ( p _ { d } ) } B _ { \epsilon _ { x ^ { \prime } } } ( x ^ { \prime } )$ implies $D ( x ; \psi ^ { * } ) = 0$ . For simplicity, we denote $\cup _ { x ^ { \prime } \in s u p p ( p _ { d } ) } B _ { \epsilon _ { x ^ { \prime } } } ( x ^ { \prime } )$ as $B ( s u p p ( p _ { d } ) )$ .
+
+The second assumption ensures that the higher order terms cannot affect the stability of the SGP $\mu$ -WGAN. In the Appendix, we consider the case where the WGAN fails to converge when Assumption 2 is not satisfied. Compared with the previous study by Nagarajan & Kolter (2017), the conditions for the discriminator parameter are slightly modified.
+
+# Assumption 2.
+
+$$
+\begin{array} { r } { g ( \theta ) = \| \mathbb { E } _ { p _ { d } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } ) ] - \mathbb { E } _ { p _ { \theta } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } ) ] \| ^ { 2 } , h ( \psi ) = \mathbb { E } _ { \mu _ { \psi , \theta ^ { * } } } [ \| \nabla _ { x } D ( x ; \psi ) \| ^ { 2 } ] } \end{array}
+$$
+
+are locally constant along the nullspace of the Hessian matrix.
+
+The third assumption allows us to extend our results to discrete probability distribution cases, as described by Mescheder et al. (2018).
+
+Assumption 3. $\exists \epsilon _ { g } > 0$ such that $D ( x ; \psi ^ { * } ) = 0$ on $\cup _ { | \theta - \theta ^ { * } | < \epsilon _ { g } } s u p p ( p _ { \theta } ) .$ .
+
+The fourth assumption indicates that there are no other “bad” equilibrium points near $( \psi ^ { * } , \theta ^ { * } )$ , which justifies the projection along the axis perpendicular to the null space.
+
+Assumption 4. A bad equilibrium does not exist near the desired equilibrium point. Thus, $( \psi ^ { * } , \theta ^ { * } )$ is an isolated equilibrium or there exist $\delta _ { d } , \delta _ { g } > 0$ such that all equilibrium points in $B _ { \delta _ { d } } ( \psi ^ { * } ) \times$ $B _ { \delta _ { g } } ( \theta ^ { * } )$ satisfy the other assumptions.
+
+The last assumption is related to the necessary conditions for the penalty measure. A calculation of the gradient penalty based on samples from the data manifold and generator manifold or the interpolation of both was introduced in recent studies (Gulrajani et al., 2017; Roth et al., 2017; Mescheder et al., 2018). First, we propose strong conditions for the penalty measure.
+
+Assumption 5. The finite penalty measure $\mu = \mu _ { \theta }$ satisfies the followings:
+
+a $\mu _ { \theta } \to \mu _ { \theta ^ { * } } = \mu ^ { * }$ and $\mu _ { \theta }$ is independent of the discriminator parameter $\psi$ . $\begin{array} { r l } & { b \ s u p p ( p _ { d } ) \subset s u p p ( \mu ^ { * } ) } \\ & { c \ \exists \epsilon _ { \mu } > 0 \ s u c h \ t h a t \ s u p p ( \mu _ { \theta } ) \subset B ( s u p p ( p _ { d } ) ) f o r \vert \theta - \theta ^ { * } \vert < \epsilon _ { \mu } . } \end{array}$
+
+The assumption given above means that the support of the penalty measure $\mu _ { \theta }$ should approach the data manifolds smoothly as $\theta \to \theta ^ { * }$ . However, the penalty measure from WGAN-GP with a simple gradient penalty still reaches equilibrium without satisfying Assumption 5c. Therefore, we suggest Assumption 6, which is a weak version of Assumption 5. Assumption $6 \mathrm { a } ^ { 2 }$ is technically required to take the derivative of the integral $\mathbb { E } _ { \mu _ { \psi , \theta } } [ \| \nabla _ { x } D ( x ; \psi ) \| ^ { 2 } ]$ with respect to $\psi$ .
+
+Assumption 6. (Weak version of Assumption 5) The finite penalty measure $\mu = \mu _ { \psi , \theta }$ satisfies the following.
+
+a $\mu _ { \psi , \theta }  \mu _ { \psi ^ { * } , \theta ^ { * } } = \mu ^ { * }$ , where supp $( \mu _ { \psi , \theta } )$ only depends on $\theta$ . Near the equilibrium, $\mu _ { \psi , \theta }$ can be weakly differentiated twice with respect to $\psi$ . In addition, its mass $M ( \psi , \theta ) \stackrel { \cdot } { = }$ $\int 1 d \mu _ { \psi , \theta }$ is a twice-differentiable function of $\psi$ and bounded near the equilibrium.
+
+b $E _ { \mu ^ { * } } [ \nabla _ { \psi x } D \nabla _ { \psi x } ^ { T } D ]$ is positive definite or $s u p p ( p _ { d } ) \subset s u p p ( \mu ^ { * } ) .$
+
+c $\ : \exists \epsilon _ { \mu } > 0 \ :$ such that $\operatorname { s u p p } ( \mu _ { \theta } ) \subset V$ for $| \theta - \theta ^ { * } | < \epsilon _ { \mu }$ , where $V = \{ x | \nabla _ { x } D ( x ; \psi ^ { * } ) = 0 \}$ .
+
+The assumption above implies the following situations; The penalty measure’s support approaches to data manifold and its weight changes smoothly with respect to $\psi$ and $\theta$ . At the equilibrium, penalty measure’s support contains data manifold. Also, ideal discriminator will remain flat on the penalty area.
+
+In summary, the gradient penalty regularization term with any penalty measure where the support approaches $B ( s u p p ( p _ { d } ) )$ in a smooth manner works well and this main result can explain the regularization effect of previously proposed penalty measures such as $\mu _ { G P } , p _ { d } , p _ { \ell }$ , and their mixtures.
+
+# 4.2 MAIN CONVERGENCE THEOREM
+
+According to the modified assumptions given above, we prove that the related dynamic system is locally stable near the equilibrium. The tools used for analyzing stability are mainly based on those described by Nagarajan & Kolter (2017). Our main contributions comprise proposing the necessary conditions for the penalty measure and proving the local stability for all penalty measures that satisfy Assumption 6.
+
+Theorem 1. Suppose that our SGP $\mu$ -WGAN optimization problem $( D , p _ { d } , p _ { \theta } , \mu )$ with equilibrium point $( \psi ^ { * } , \theta ^ { * } )$ satisfies the assumptions given above. Then, the related dynamic system is locally stable at the equilibrium.
+
+A detailed proof of the main convergence theorem is given in the Appendix. A sketch of the proof is given in three steps. First, the undesired terms in the Jacobian matrix of the system at the equilibrium are cancelled out. Next, the Jacobian matrix at equilibrium is given by $\left[ \begin{array} { c c } { \therefore } & { \mathbf { 0 } } \\ { R ^ { T } } & { 0 } \end{array} \right]$ , where $Q =$ $\mathbb { E } _ { \mu ^ { * } } [ \nabla _ { \psi x } D \nabla _ { \psi x } ^ { T } D ]$ and $R = \nabla _ { \theta } \mathbb { E } _ { p _ { \theta } } [ \nabla _ { \psi } D ] | _ { \theta = \theta ^ { * } }$ . The system is locally stable when both $Q$ and $R ^ { T } R$ are positive definite. We can complete the proof by dealing with zero eigenvalues by showing that ${ \cal N } ( Q ^ { \hat { T } } ) \subset { \cal N } ( R ^ { T } )$ and the projected system’s stability implies the original system’s stability.
+
+Our analysis mainly focuses on WGAN, which is the simplest case of general GAN minimax optimization
+
+$$
+\begin{array} { r l } & { \underset { \psi } { \operatorname* { m a x } } : \mathbb { E } _ { p _ { d } } [ f ( D ( x ; \psi ) ) ] + \mathbb { E } _ { p _ { \theta } } [ f ( - D ( x ; \psi ) ) ] - \frac { \rho } { 2 } \mathbb { E } _ { \mu } [ \| \nabla _ { x } D ( x ; \psi ) \| ^ { 2 } ] } \\ & { \underset { \theta } { \operatorname* { m i n } } : \mathbb { E } _ { p _ { d } } [ f ( D ( x ; \psi ) ) ] + \mathbb { E } _ { p _ { \theta } } [ f ( - D ( x ; \psi ) ) ] } \end{array}
+$$
+
+with $f ( x ) = x$ . Similar approach is still valid for general GANs with concave function $f$ with $f ^ { \prime \prime } ( x ) < 0$ and $f ^ { \prime } ( 0 ) \neq 0$ .
+
+# 5 EXPERIMENTAL RESULTS
+
+We claim that every penalty measure that satisfies the assumptions can regularize the WGAN and generate similar results to the recently proposed gradient penalty methods. Several penalty measures were tested based on two-dimensional problems (mixture of 8 Gaussians, mixture of 25 Gaussians, and swissroll), MNIST and CIFAR-10 datasets using a simple gradient penalty term. In the comparisons with WGAN, the recently proposed penalty measures and our test penalty measures used the same network settings and hyperparameters. The penalty measures and its detailed sampling methods are listed in Table 1, where $x _ { d } \sim p _ { d } , x _ { g } \sim p _ { \theta }$ , and $\alpha \sim U ( 0 , 1 )$ . $\mathcal { A }$ indicates fixed anchor point in $\mathcal { X }$ .
+
+Table 1: List of benchmark WGANs (WGAN and WGAN-GP with non-zero centered gradient penalty) and 5 penalty measures with a simple gradient penalty term. In this table, WGAN-GP represents the previous model proposed by (Gulrajani et al., 2017), which penalizes the WGAN with non-zero centered gradient penalty terms, whereas $\mu _ { G P }$ represents the simple method. In our experiment, no additional weights are applied on 5 penalty measures and they are all probability distributions.   
+
+<table><tr><td>Penalty</td><td>Penalty term</td><td>Penalty measure, sampling method</td></tr><tr><td>WGAN WGAN-GP</td><td>None(Weight Clipping) Eμ[(IVxD|-1)2]</td><td>None x=axd+(1-α)xg</td></tr><tr><td></td><td>Eμ[VxD|2]</td><td></td></tr><tr><td>Pg Pd</td><td>Eμ[VxDii2]</td><td>x=xg x=xd</td></tr><tr><td>μGP</td><td>EμVDii2]</td><td>x=axd+(1-α)xg</td></tr><tr><td>μmid</td><td>Eμ[VxDii2]</td><td>x= 0.5xd+0.5xg</td></tr><tr><td>μg,anc</td><td>EμVDii2]</td><td>x=αA+(1-α)xg</td></tr></table>
+
+By setting the previously proposed WGAN with weight-clipping(Arjovsky et al., 2017) and WGANGP(Gulrajani et al., 2017) as the baseline models, $\operatorname { S G P } \mu$ -WGAN was examined with various penalty measures comprising three recently proposed measures and two artificially generated measures. $p _ { \theta }$ and $p _ { d }$ were suggested by Mescheder et al. (2018) and $\mu _ { G P }$ was introduced from the WGAN-GP. We analyzed the artificial penalty measures $\mu _ { m i d }$ and $\mu _ { g , a n c }$ as the test penalty measures.
+
+The experiments were conducted based on the implementation of the Gulrajani et al. (2017). The hyperparameters, generator/discriminator structures, and related TensorFlow implementations can be found at https://github.com/igul222/improved_wgan_training (Gulrajani et al., 2017). Only the loss function was modified slightly from a non-zero centered gradient penalty to a simple penalty. For the CIFAR-10 image generation tasks, the inception score(Salimans et al., 2016) and FID(Heusel et al., 2017) were used as benchmark scores to evaluate the generated images.
+
+# 5.1 2D EXAMPLES AND MNIST
+
+We checked the convergence of $p _ { \theta }$ for the 2D examples (8 Gaussians, swissroll data, and 25 Gaussians) and MNIST digit generation for the SGP-WGANs with five penalty measures. MNIST and 25 Gaussians were trained over 200K iterations, the 8 Gaussians were trained for 30K iterations, and the Swiss Roll data were trained for 100K iterations. The anchor $\mathcal { A }$ for $\mu _ { g , a n c }$ was set as $( 2 , - 1 )$ for the 2D examples and 784 gray pixels for MNIST. We only present the results obtained for the MNIST dataset with the penalty measures comprising $\mu _ { m i d }$ and $\mu _ { g , a n c }$ in Figure 1. The others are presented in the Appendix.
+
+![](images/07f5e9693ee7d3a76d2c35b0604f32d9f8eef9b1b58131c18cc2525916acb8b1.jpg)  
+Figure 1: MNIST example. Images generated with $\mu _ { m i d }$ (left) and $\mu _ { g , a n c } ( \mathrm { r i g h t } )$ .
+
+# 5.2 CIFAR-10
+
+DCGAN and ResNet architectures were tested on the CIFAR-10 dataset. The generators were trained for 200K iterations. The anchor $\mathcal { A }$ for $\mu _ { g , a n c }$ during CIFAR-10 generation was set as fixed random pixels. The WGAN, WGAN-GP, and five penalty measures were evaluated based on the inception score and FID, as shown in Table 2, which are useful tools for scoring the quality of generated images. The images generated from $\mu _ { m i d }$ and $\mu _ { g , a n c }$ with ResNet are shown in Figure 2. The others are presented in the Appendix.
+
+Table 2: Benchmark score results obtained based on the CIFAR-10 dataset under DCGAN and ResNet architectures. The higher inception score and lower FID indicate the good quality of the generated images.   
+
+<table><tr><td>Penalty</td><td>DCGAN Inception FID</td><td>ResNet Inception</td><td>FID</td></tr><tr><td>WGAN 3</td><td>5.64 ± 0.09 48.7</td><td>=</td><td>=</td></tr><tr><td>WGAN-GP</td><td>6.48 ± 0.10 35.0</td><td>7.82 ± 0.09</td><td>18.1</td></tr><tr><td>Pg</td><td>6.46 ± 0.09 38.0</td><td>7.63 ± 0.10</td><td>20.9</td></tr><tr><td>pd</td><td>6.33 ± 0.07</td><td>38.9 7.63 ± 0.09</td><td>20.3</td></tr><tr><td>μGP</td><td>6.40 ±0.08</td><td>35.4 7.60 ± 0.09</td><td>18.3</td></tr><tr><td>μmid</td><td>6.60 ± 0.07</td><td>33.9 7.86 ± 0.07</td><td>16.4</td></tr><tr><td>μg,anc</td><td>6.45 ± 0.07</td><td>33.7 7.36 ± 0.09</td><td>22.4</td></tr></table>
+
+![](images/af56d7fca60411caad1f41e50993c7c1651b0890d3dce2a1e967749ed2d6734d.jpg)  
+Figure 2: CIFAR-10 example. Images generated with $\mu _ { m i d }$ (left) and $\mu _ { g , a n c }$ (right) under the ResNet architecture.
+
+# 6 CONCLUSION
+
+In this study, we proved the local stability of simple gradient penalty $\mu$ -WGAN optimization for a general class of finite measure $\mu$ . This proof provides insight into the success of regularization with previously proposed penalty measures. We explored previously proposed analyses based on various gradient penalty methods. Furthermore, our theoretical approach was supported by experiments using unintuitive penalty measures. In future research, our works can be extended to alternative gradient descent algorithm and its related optimal hyperparameters. Stability at non-realizable equilibrium points is one of the important topics on stability of GANs. Optimal penalty measure for achieving the best convergence speed can be also investigated using a spectral theory, which provides the mathematical analysis on stability of GAN with a precise information on the convergence theory.
+
+# REFERENCES
+
+Mart´ın Arjovsky and Leon Bottou. Towards principled methods for training generative adversarial ´ networks. In International Conference on Learning Representations, 2017.
+
+Mart´ın Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. ´ In Proceedings of the 34th International Conference on Machine Learning, pp. 214–223, 2017.
+
+Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron C. Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2672–2680, 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Mart´ın Arjovsky, Vincent Dumoulin, and Aaron C. Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems, pp. 5769–5779, 2017.
+
+B. Heidergott and F. J. Vazquez-Abad. Measure-valued differentiation for markov chains. ´ Journal of Optimization Theory and Applications, 136:187–209, 2008. ISSN 1573-2878. doi: 10.1007/ s10957-007-9297-7.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in Neural Information Processing Systems, pp. 6629–6640, 2017.
+
+Phillip Isola, Jun-Yan Zhu, Tinghui Zhou, and Alexei A. Efros. Image-to-image translation with conditional adversarial networks. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pp. 5967–5976, 2017.
+
+Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro Acosta, Andrew P. Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photorealistic single image super-resolution using a generative adversarial network. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pp. 105–114, 2017.
+
+Lars M. Mescheder, Andreas Geiger, and Sebastian Nowozin. Which training methods for gans do actually converge? In Proceedings of the 35th International Conference on Machine Learning, pp. 3478–3487, 2018.
+
+Youssef Mroueh, Chun-Liang Li, Tom Sercu, Anant Raj, and Yu Cheng. Sobolev GAN. In International Conference on Learning Representations, 2018.
+
+Vaishnavh Nagarajan and J. Zico Kolter. Gradient descent GAN optimization is locally stable. In Advances in Neural Information Processing Systems, pp. 5591–5600, 2017.
+
+Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-gan: Training generative neural samplers using variational divergence minimization. In Advances in Neural Information Processing Systems, pp. 271–279, 2016.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. CoRR, abs/1511.06434, 2015. URL http:// arxiv.org/abs/1511.06434.
+
+Scott E. Reed, Zeynep Akata, Xinchen Yan, Lajanugen Logeswaran, Bernt Schiele, and Honglak Lee. Generative adversarial text to image synthesis. In Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, pp. 1060– 1069, 2016. URL http://jmlr.org/proceedings/papers/v48/reed16.html.
+
+Kevin Roth, Aurelien Lucchi, Sebastian Nowozin, and Thomas Hofmann. Stabilizing training of ´ generative adversarial networks through regularization. In Advances in Neural Information Processing Systems, pp. 2015–2025, 2017.
+
+Tim Salimans, Ian J. Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems, pp. 2226–2234, 2016.
+
+Casper Kaae Sønderby, Jose Caballero, Lucas Theis, Wenzhe Shi, and Ferenc Huszar. Amortised ´ MAP inference for image super-resolution. International Conference on Learning Representations, 2017.
+
+Han Zhang, Tao Xu, and Hongsheng Li. Stackgan: Text to photo-realistic image synthesis with stacked generative adversarial networks. In IEEE International Conference on Computer Vision, ICCV 2017, Venice, Italy, October 22-29, 2017, pp. 5908–5916, 2017.
+
+# APPENDIX A : PROOF OF LEMMAS BASED ON TOY EXAMPLES
+
+Proof of Lemma 1. The related dynamic system of $\begin{array} { r } { ( D ( x ; \psi ) = \psi x , \delta _ { 0 } , \delta _ { \theta } , \mu _ { \psi , \theta } ) } \end{array}$ can be written as follows.
+
+$$
+\begin{array} { l } { \displaystyle \dot { \psi } = - \theta - \frac { \rho } { 2 } \nabla \psi \mathbb { E } _ { \mu _ { \psi , \theta } } [ \psi ^ { 2 } ] } \\ { \displaystyle \dot { \theta } = \psi } \end{array}
+$$
+
+First, the only equilibrium point is given by $( \psi ^ { * } , \theta ^ { * } ) = ( 0 , 0 )$ from
+
+$$
+\begin{array} { l } { 0 = - \theta - 2 \psi M ( \psi , \theta ) - \psi ^ { 2 } \nabla _ { \psi } M ( \psi , \theta ) } \\ { \quad 0 = \psi } \end{array}
+$$
+
+The corresponding Jacobian matrix for the dynamic system is written as:
+
+$$
+J = \left[ { \begin{array} { r r } { Z } & { - 1 } \\ { 1 } & { 0 } \end{array} } \right]
+$$
+
+where
+
+$$
+Z = - \frac { \rho } { 2 } \nabla _ { \psi \psi } \mathbb { E } _ { \mu _ { \psi , \theta } } [ \psi ^ { 2 } ] \bigg | _ { \psi = 0 , \theta = 0 }
+$$
+
+$\nabla _ { \psi } D ( x ; \psi ) = \psi$ does not depend on $x$ , so this can be rewritten as:
+
+$$
+Z = - \frac { \rho } { 2 } \nabla _ { \psi \psi } ( \psi ^ { 2 } \mathbb { E } _ { \mu _ { \psi } , \theta } [ 1 ] ) = - \frac { \rho } { 2 } ( 2 M ( \psi , \theta ) + 4 \psi \nabla _ { \psi } M ( \psi , \theta ) + \psi ^ { 2 } M _ { \psi \psi } ( \psi , \theta ) ) \bigg | _ { \psi = 0 , \theta = 0 }
+$$
+
+Therefore, if $M ( 0 , 0 ) > 0$ , then the given system is locally stable because the eigenvalues of its linearized system have negative real parts. If $M ( 0 , 0 ) = 0$ , then the stability of the system cannot be proved by the linearization theorem. In this case, we consider the following Lyapunov function.
+
+$$
+L ( \psi ( t ) , \theta ( t ) ) = \psi ( t ) ^ { 2 } + \theta ( t ) ^ { 2 }
+$$
+
+By differentiating with $t$ , we obtain
+
+$$
+\begin{array} { r l } & { \dot { L } = 2 ( \psi \psi ^ { \prime } + \theta \theta ^ { \prime } ) = - \rho \psi \nabla _ { \psi } ( \psi ^ { 2 } M ( \psi , \theta ) ) = - \rho \psi ( 2 \psi M ( \psi , \theta ) + \psi ^ { 2 } \nabla _ { \psi } M ( \psi , \theta ) ) } \\ & { \quad = - \rho \psi ^ { 2 } ( 2 M ( \psi , \theta ) + \psi \nabla _ { \psi } M ( \psi , \theta ) ) \leq 0 } \end{array}
+$$
+
+Clearly, $L ( \psi , \theta ) \geq 0$ and the equality holds iff $\psi = \theta = 0$ . In addition, $\dot { L } \leq 0$ since $M ( \psi , \theta ) \geq$ 0 and $\psi \nabla _ { \psi } M ( \psi , \theta ) \geq 0$ from the assumption. Furthermore, it is clear that if $( \psi ( 0 ) , \theta ( 0 ) ) \ \in \qquad $ $B _ { \eta } ( ( 0 , 0 ) )$ , then $( \psi ( \tau ) , \theta ( \tau ) ) \in B _ { \eta } ( ( 0 , 0 ) )$ for all $\tau \geq 0$ because the Lyapunov function (square of the distance between the origin and $( \psi ( \tau ) , \theta ( \tau ) ) )$ always decreases as $\tau  \infty$ . Therefore, the given system is stable according to the Lyapunov stability theorem.
+
+Again, we can check that if $\mu _ { \psi , \theta }$ is a probability measure, then the system is globally stable, as shown by Mescheder et al. (2018). The basin of attraction is given by the whole $\mathbb { R } ^ { 2 }$ plane since $M ( \psi , \theta ) = 1$ , so $\dot { L } = - \rho \psi ^ { 2 } ( 2 M + \psi \nabla _ { \psi } M ) = - 2 \rho \psi ^ { 2 } \leq 0$ for every $( \psi , \theta ) \in \mathbb { R } ^ { 2 }$ . □
+
+Proof of Lemma 2. From the general setup of the $\operatorname { S G P } \mu$ -WGAN optimization problem, the dynamic system corresponding to the simple-GAN in Definition 6 can be written as follows.
+
+$$
+\begin{array} { l } { { \displaystyle { \dot { \psi } = \frac { 1 } { 3 } - \frac { \theta ^ { 2 } } { 3 } - 4 \rho \psi \mathbb { E } _ { \mu } [ x ^ { 2 } ] } } } \\ { { \displaystyle { \dot { \theta } = \frac { 2 \psi \theta } { 3 } } } } \end{array}
+$$
+
+If we let $\mathbb { E } _ { \mu ^ { * } } [ x ^ { 2 } ] = A ^ { 2 }$ , then the Jacobian matrix at the equilibrium $( 0 , \pm 1 )$ is given by ${ \boldsymbol { J } } =$ $\left[ { \begin{array} { c c } { - 4 \rho A ^ { 2 } } & { { \mp } { \frac { 2 } { 3 } } } \\ { \pm { \frac { 2 } { 3 } } } & { 0 } \end{array} } \right]$ Therefore, the given system is locally stable when $A \neq 0$ .
+
+# APPENDIX B : PROOF OF LEMMA RELATED WITH ASSUMPTION 2
+
+Lemma 3. Consider the Dirac-GAN setup and SGP $\mu$ -WGAN optimization system with a slightly changed discriminator function $D _ { 2 } ( x ; \psi ) \stackrel { \textstyle - } { = } \psi x ^ { 2 }$ . The system $( D _ { 2 } , \delta _ { 0 } , \delta _ { \theta } , \mu _ { G P } )$ does not converge to $( 0 , 0 )$ but for any point $( a , 0 )$ with $a < 0$ , the system has equilibrium points on the whole $\psi$ -axis and it violates Assumption 2.
+
+Proof of Lemma 3. For the SGP $\mu$ -WGAN optimization problem $( D _ { 2 } , \delta _ { 0 } , \delta _ { \theta } , \mu _ { G P } )$ , the dynamic system can be written as follows.
+
+$$
+\begin{array} { l } { { \dot { \psi } = - \theta ^ { 2 } - \frac { 4 } { 3 } \rho \psi \theta ^ { 2 } } } \\ { { \dot { \theta } = 2 \psi \theta } } \end{array}
+$$
+
+$2 \psi \theta = 0$ and $\begin{array} { r } { \theta ^ { 2 } ( 1 + \frac { 4 } { 3 } \rho \psi ) = 0 } \end{array}$ implies that $\theta = 0$ , so the $\psi$ -axis is the set of all equilibrium points. By drawing the nullclines $\psi = 0$ and $\begin{array} { r } { \psi = - \frac { 3 } { 4 \rho } } \end{array}$ in the $\psi \theta$ -plane, it is clear that no solution curve converges to $( b , 0 )$ with $b \geq 0$ , as shown in Figure 3. □
+
+![](images/c43c5cb4133543240663135cefcb52ec5abc17c3330a731f348c08a6b7589f1c.jpg)  
+Figure 3: Phase portrait of the SGP $\mu$ -WGAN optimization problem $( D _ { 2 } , \delta _ { 0 } , \delta _ { \theta } , \mu _ { G P } )$ with $\textstyle \rho = { \frac { 3 } { 8 } }$ . Along the line $\theta = 0$ , the system is stable so no updating will occur. Every solution curve that passes the nullcline $\psi = 0$ has $\dot { \theta } = 0$ . For the nullcline $\begin{array} { r } { \psi = - \frac { 3 } { 4 \rho } = - 2 } \end{array}$ , no updating on $\psi$ will occur and only $\theta$ will be updated. Given that the solution curves do not intersect with each other, every solution curve is exactly one of the followinstays in area A. (2) Solution curve converges to $\begin{array} { r } { \bar { ( \psi , \theta ) } \overset { * } { = } ( - \frac { 3 } { 4 \rho } , 0 ) } \end{array}$ trivial cases; (1) Solalong the nullcline $\begin{array} { r } { \psi = - \frac { 3 } { 4 \rho } } \end{array}$ e. (3) Solution curve stays in area B. (4) Solution curve starts from area C, crosses the nullcline $\psi = 0$ perpendicularly, and converges to $( b , 0 )$ with $b < 0$ . Therefore, no solution curve converges to $( 0 , 0 )$ .
+
+# APPENDIX C : PROOF OF THE MAIN CONVERGENCE THEOREM
+
+Proof. Let us consider the Jacobian matrix $J = \left[ \begin{array} { l l } { K _ { D D } } & { K _ { D G } } \\ { K _ { G D } } & { K _ { G G } } \end{array} \right]$ at the first equilibrium $( \psi ^ { * } , \theta ^ { * } ) ^ { 4 }$
+
+$$
+\begin{array} { r l } { J = \left[ \mathbb { E } _ { p _ { d } } [ \nabla _ { \psi \psi } D ] - \mathbb { E } _ { p _ { \theta ^ { \star } } } [ \nabla _ { \psi \psi } D ] - \frac { \rho } { 2 } \nabla _ { \psi \psi } \mathbb { E } _ { \mu } [ \| \nabla _ { x } D \| ^ { 2 } ] } & { - \nabla _ { \theta \psi } \mathbb { E } _ { p _ { \theta } } [ D ] - \frac { \rho } { 2 } \nabla _ { \theta \psi } \mathbb { E } _ { \mu } [ \| \nabla _ { x } D \| ^ { 2 } ] \right] } \\ & { \qquad \nabla _ { \psi \theta } \mathbb { E } _ { p _ { \theta } } [ D ] ^ { 2 } } \end{array}
+$$
+
+First, Assumption 1 implies that $\mathbb { E } _ { p _ { d } } [ \nabla _ { \psi \psi } D ] - \mathbb { E } _ { p _ { \theta ^ { * } } } [ \nabla _ { \psi \psi } D ] = 0$ since $p _ { \theta }  p _ { d }$ as $\theta \to \theta ^ { * }$ . From Assumption 3, $\mathbb { E } _ { p _ { \theta } } [ D ( x ; \psi ^ { * } ) ]$ is locally zero near the equilibrium $\theta ^ { * }$ , which implies that
+
+$$
+K _ { G G } = \nabla _ { \theta \theta } \mathbb { E } _ { p _ { \theta } } [ D ( x ; \psi ^ { * } ) ] \bigg \rvert _ { \theta = \theta ^ { * } } = 0
+$$
+
+We still need to evaluate $\nabla _ { \psi \psi } \mathbb { E } _ { \mu } [ \| \nabla _ { x } D \| ^ { 2 } ]$ and $\nabla _ { \theta \psi } \mathbb { E } _ { \mu } [ \| \nabla _ { x } D \| ^ { 2 } ]$ . According to Assumption 6a, finite signed measures $\mu _ { \psi , \theta } ^ { \prime }$ and $\mu _ { \psi , \theta } ^ { \prime \prime }$ exist5, so they are the first and second weak derivatives of $\mu _ { \psi , \theta }$ with respect to the parameter $\psi$ at $\left( \psi ^ { * } , \theta ^ { * } \right)$ . Therefore, the expectations given above can be rewritten as below.
+
+$$
+\begin{array} { l } { I = \nabla _ { \psi \psi } \displaystyle \int _ { s u p p ( \mu _ { \psi } , \theta ) } \| \nabla _ { x } D \| ^ { 2 } d \mu _ { \psi , \theta } } \\ { = \displaystyle \int _ { s u p p ( \mu _ { \psi , \theta } ) } ( 2 \nabla _ { \psi x } ^ { T } D \nabla _ { \psi x } D + 2 K _ { 0 } ) d \mu _ { \psi , \theta } + \displaystyle \int _ { s u p p ( \mu _ { \psi , \theta } ) } 2 ( \nabla _ { \psi x } ^ { T } D \nabla _ { x } D ) d \mu _ { \psi , \theta } ^ { \prime } + \displaystyle \int _ { s u p p ( \mu _ { \psi , \theta } ) } \| \nabla _ { x } \nabla _ { \psi } D \nabla _ { x } \| ^ { 2 } d \mu _ { \psi , \theta } ^ { \prime } } \\ { \cdot I = \nabla _ { \theta \psi } \displaystyle \int _ { s u p p ( \mu _ { \psi , \theta } ) } \| \nabla _ { x } D \| ^ { 2 } d \mu _ { \psi , \theta } } \\ { = \nabla _ { \theta } ( \displaystyle \int _ { s u p p ( \mu _ { \psi , \theta } ) } 2 ( \nabla _ { \psi x } ^ { T } D \nabla _ { x } D ) d \mu _ { \psi , \theta } + \displaystyle \int _ { s u p p ( \mu _ { \psi , \theta } ) } \| \nabla _ { x } D \| ^ { 2 } d \mu _ { \psi , \theta } ^ { \prime } ) } \end{array}
+$$
+
+where
+
+$$
+\begin{array} { r } { K _ { 0 } ( x ; \psi ) = \left[ \sum _ { k } \frac { \partial ^ { 3 } } { \partial \psi _ { i } \partial \psi _ { j } \partial x _ { k } } D ( x ; \psi ) \frac { \partial } { \partial x _ { k } } D ( x ; \psi ) \right] _ { i j } } \end{array}
+$$
+
+From Assumption 6c and the fact that the weak derivative of $\mu _ { \psi , \theta }$ vanishes outside of $s u p p ( \mu _ { \psi , \theta } )$ , $\nabla _ { x } D ( x ; \psi ^ { * } ) = 0$ on $s u p p ( \mu _ { \psi , \theta } ) \subset V$ for all $\theta$ with $\left| \theta - \theta ^ { * } \right| < \epsilon _ { \mu }$ and $\mu _ { \psi , \theta } ^ { \prime } = \mu _ { \psi , \theta } ^ { \prime \prime } = 0$ on the outside of $s u p p ( \mu _ { \psi , \theta } )$ , which leads to the desired results:
+
+$$
+\begin{array} { c } { \displaystyle { I = \int _ { s u p p ( \mu ^ { * } ) } 2 ( \nabla _ { \psi x } ^ { T } D ( x ; \psi ^ { * } ) \nabla _ { \psi x } D ( x ; \psi ^ { * } ) ) d \mu ^ { * } } } \\ { \displaystyle { I I = 0 } } \end{array}
+$$
+
+After cancelling the undesired terms, the Jacobian matrix at the equilibrium $( \psi ^ { * } , \theta ^ { * } )$ is given as:
+
+$$
+J = \left[ \begin{array} { c c } { - \rho Q } & { - R } \\ { R ^ { T } } & { 0 } \end{array} \right]
+$$
+
+where
+
+$$
+\begin{array} { r } { Q = \mathbb { E } _ { \mu ^ { * } } [ \nabla _ { \psi x } ^ { T } D \nabla _ { \psi x } D ] } \\ { \boldsymbol { R } = \nabla _ { \theta } \mathbb { E } _ { p _ { \theta } } [ \nabla _ { \psi } D ] \bigg | _ { \theta = \theta ^ { * } } } \end{array}
+$$
+
+From the definition of $Q$ , it is easy to check that $Q$ is at least positive semi-definite. It is known that for a negative definite matrix $A$ and full column rank matrix $B$ , the block matrix $\left[ \begin{array} { l l } { A } & { B } \\ { - B ^ { T } } & { 0 } \end{array} \right]$ is Hurwitz, i.e., all eigenvalues of the matrix have a negative real part. Therefore, if $\bar { Q }$ is positive definite and $R$ is full column rank, the proof is complete. We consider the complementary case.
+
+Suppose that $Q$ or $R ^ { T } R$ have some zero eigenvalues. Let $Q = U _ { D } \Lambda _ { D } U _ { D } ^ { T }$ and $R ^ { T } R = U _ { G } \Lambda _ { G } U _ { G } ^ { T }$ with $U _ { D } ~ = ~ \lbrack T _ { D } ~ S _ { D } \rbrack$ and $U _ { G } ~ = ~ [ T _ { G } ^ { ~ - } ~ S _ { G } ]$ , where $T _ { D }$ and $T _ { G }$ are the eigenvectors of $\bar { Q }$ and $R ^ { T } R$ that correspond to non-zero eigenvalues. First, we assume that $T _ { D }$ and $T _ { G }$ are not empty. We can show that $( \psi ^ { * } + \xi v , \theta ^ { * } \overset { \cdot } { + } \nu w )$ is also an equilibrium point for a sufficiently small $\xi , \nu$ and $v \in N ( Q ) , w \in N ( R ^ { T } R )$ by using the techniques given by Nagarajan & Kolter (2017). If the system does not update at the equilibrium point $( \psi ^ { * } , \theta ^ { * } )$ and its small neighborhood $\left( \psi ^ { * } + \xi v , \theta ^ { * } + \nu w \right)$ is perturbed along $N ( Q )$ and $N ( \bar { R } ^ { T } R )$ , then it is reasonable to project the system orthogonal to $N ( Q )$ and $N ( R ^ { T } { \bar { R } } )$ .
+
+First, we assume that $v \in N ( Q )$ . By Assumption 2, $h ( \psi ^ { * } + \xi v ) = h ( \psi ^ { * } ) = 0$ for $| \xi | < \xi _ { d }$ , which implies that $\nabla _ { \boldsymbol { x } } D ( \boldsymbol { x } ; \psi ^ { * } + \xi \boldsymbol { v } ) = 0$ for $x \in s u p p ( \mu _ { \psi ^ { * } + \xi v , \theta ^ { * } } ) = s u p p ( \mu ^ { * } )$ and $| \xi | < \xi _ { d }$ . Thus, we obtain
+
+$$
+\mathbb { E } _ { \mu _ { \psi ^ { * } + \xi v , \theta ^ { * } } } [ \nabla _ { \psi x } ^ { T } D ( x ; \psi ^ { * } + \xi v ) \nabla _ { x } D ( x ; \psi ^ { * } + \xi v ) ] = 0
+$$
+
+and
+
+$$
+\int _ { s u p p ( \mu ^ { * } ) } \left\| \nabla _ { x } D ( x ; \psi ^ { * } + \xi v ) \right\| ^ { 2 } d \mu _ { \psi ^ { * } + \xi v , \theta ^ { * } } ^ { \prime } = 0
+$$
+
+By Assumption 4, $\begin{array} { r } { \mathbb { E } _ { p _ { d } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } + \xi v ) ] - \mathbb { E } _ { p _ { \theta ^ { * } } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } + \xi v ) ] = 0 } \end{array}$ since $p _ { d } = p _ { \theta ^ { \ast } }$ . By adding these equations, we obtain
+
+$$
+\begin{array} { l } { \displaystyle \dot { \psi } = \mathbb { E } _ { p _ { d } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } + \xi v ) ] - \mathbb { E } _ { p _ { \theta ^ { * } } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } + \xi v ) ] } \\ { \displaystyle - \frac { \rho } { 2 } \int _ { s u p p ( \mu _ { \psi ^ { * } + \xi v , \theta ^ { * } } ) } 2 \nabla _ { \psi x } ^ { T } D ( x ; \psi ^ { * } + \xi v ) \nabla _ { x } D ( x ; \psi ^ { * } + \xi v ) d \mu _ { \psi ^ { * } + \xi v , \theta ^ { * } } } \\ { \displaystyle - \frac { \rho } { 2 } \int _ { s u p p ( \mu _ { \psi ^ { * } + \xi v , \theta ^ { * } } ) } \| \nabla _ { x } D ( x ; \psi ^ { * } + \xi v ) \| ^ { 2 } d \mu _ { \psi ^ { * } + \xi v , \theta ^ { * } } ^ { \prime } } \\ { \displaystyle = 0 } \end{array}
+$$
+
+In addition,
+
+$$
+\begin{array} { l } { \displaystyle \dot { \theta } = \frac { \partial } { \partial \theta } \int _ { \mathcal X } D ( x ; \psi ^ { * } + \xi v ) d p _ { \theta } \bigg \vert _ { \theta = \theta ^ { * } } } \\ { \displaystyle = \int _ { \mathcal Z } \nabla _ { \theta } ^ { T } G ( z ; \theta ^ { * } ) \nabla _ { x } D ( G ( z ; \theta ^ { * } ) ; \psi ^ { * } + \xi v ) p _ { l a t e n t } ( z ) d z = 0 . } \end{array}
+$$
+
+Therefore, the point $( \psi ^ { * } + \xi v , \theta ^ { * } )$ with $| \xi | < \xi _ { d }$ is an equilibrium point. According to Assumption 4, $D ( x ; \psi ^ { * } + \xi v )$ is an equilibrium discriminator for $| \xi | < \delta _ { d }$ , and thus $D ( x ; \psi ^ { * } + \bar { \xi } v )$ is already an optimal discriminator for $| \xi | < \operatorname* { m i n } ( \xi _ { d } , \delta _ { d } )$ .
+
+Suppose that $w \ \in \ N ( R ^ { T } R )$ . By Assumption 2, $g ( \theta ^ { * } ) ~ = ~ g ( \theta ^ { * } + \nu w ) ~ = ~ 0$ for $| \nu | < \nu _ { g }$ , and thus $\begin{array} { r l } { \mathbb { E } _ { p _ { d } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } ) ] - \mathbb { E } _ { p _ { \theta ^ { * } + \nu w } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } ) ] ~ = ~ 0 } \end{array}$ for $| \nu | ~ < ~ \nu _ { g }$ . Furthermore, Assumption 3 gives $\mathbb { E } _ { p _ { \theta ^ { * } + \nu w } } [ D ( x ; \psi ^ { * } ) ] = 0$ for a sufficiently close $| \nu | < \epsilon _ { g }$ , which implies that $\begin{array} { r } { \dot { \theta } = \nabla _ { \theta } \mathbb { E } _ { p _ { \theta } } [ D ( x ; \psi ^ { * } ) ] \bigg \rvert _ { \theta = \theta ^ { * } + \nu w } = 0 } \end{array}$ for $| \nu | < \epsilon _ { g }$ . Finally,
+
+$$
+\int _ { s u p p ( \mu _ { \psi ^ { * } , \theta ^ { * } + s w } ) } 2 \nabla _ { \psi x } ^ { T } D ( x ; \psi ^ { * } ) \nabla _ { x } D ( x ; \psi ^ { * } ) d \mu _ { i \psi ^ { * } , \theta ^ { * } + \nu w } + \int _ { s u p p ( \mu _ { \psi ^ { * } , \theta ^ { * } + s w } ) } \| \nabla _ { x } D ( x ; \psi ^ { * } ) \| ^ { 2 } d \mu _ { i \psi ^ { * } , \theta ^ { * } + \nu w } ^ { \prime }
+$$
+
+since $s u p p ( \mu _ { \psi ^ { * } , \theta ^ { * } + \nu w } ) \subset V$ and $\nabla _ { x } D ( x ; \psi ^ { * } ) = 0$ on $V$ for a sufficiently small $| \nu | < \epsilon _ { \mu }$ (Assumption 6c). By adding these results, we obtain
+
+$$
+\begin{array} { l } { \displaystyle \dot { \psi } = \mathbb { E } _ { p _ { d } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } ) ] - \mathbb { E } _ { p _ { \theta ^ { * } + \nu w } } [ \nabla _ { \psi } D ( x ; \psi ^ { * } ) ] } \\ { \displaystyle \quad - \frac { \rho } { 2 } \int _ { s u p p ( \mu _ { \psi ^ { * } , \theta ^ { * } + \nu w } ) } 2 \nabla _ { \psi x } ^ { T } D ( x ; \psi ^ { * } ) \nabla _ { x } D ( x ; \psi ^ { * } ) d \mu _ { \psi ^ { * } , \theta ^ { * } + \nu w } } \\ { \displaystyle \quad - \frac { \rho } { 2 } \int _ { s u p p ( \mu _ { \psi ^ { * } , \theta ^ { * } + \nu w } ) } \left\| \nabla _ { x } D ( x ; \psi ^ { * } ) \right\| ^ { 2 } d \mu _ { \psi ^ { * } , \theta ^ { * } + \nu w } ^ { \prime } } \\ { \displaystyle = 0 } \end{array}
+$$
+
+Therefore, the point $( \psi ^ { * } , \theta ^ { * } + \nu w )$ with $| \nu | < \operatorname* { m i n } ( \epsilon _ { \mu } , \epsilon _ { g } , \nu _ { g } , \delta _ { g } )$ is an equilibrium point, which implies that $p _ { \theta ^ { * } + \nu w } = p _ { d }$ according to Assumption 4.
+
+If we consider the projected system $( \alpha , \beta ) \ : = \ : ( T _ { D } ^ { T } \psi , T _ { G } ^ { T } \theta )$ , then the projected dynamic system’s Jacobian at $( T _ { D } ^ { T } \psi ^ { * } , T _ { G } ^ { T } \theta ^ { * } )$ is given as follows.
+
+$$
+J ^ { \prime } = \left[ \begin{array} { c c } { { - \rho T _ { D } ^ { T } Q T _ { D } } } & { { - T _ { D } ^ { T } R T _ { G } } } \\ { { T _ { G } ^ { T } R ^ { T } T _ { D } } } & { { 0 } } \end{array} \right] = \left[ \begin{array} { c c } { { - \rho \Lambda _ { D } ^ { ( + ) } } } & { { - T _ { D } ^ { T } R T _ { G } } } \\ { { T _ { G } ^ { T } R ^ { T } T _ { D } } } & { { 0 } } \end{array} \right]
+$$
+
+Therefore, we only need to prove that $T _ { D } ^ { T } R T _ { G }$ is of full column rank. Suppose that $u \in N ( Q ^ { T } ) =$ $N ( Q )$ . According to Assumption 2, $h ( \psi )$ is locally constant at $\psi ^ { * }$ along the direction $u$ . Therefore, for a sufficiently small scalar $\xi$ with $| \xi | < \xi _ { u }$ ,
+
+$$
+h ( \psi ^ { * } + \xi u ) = h ( \psi ^ { * } ) = 0
+$$
+
+where the last equality comes from the Assumption 6. This implies that $\nabla _ { x } D ( x ; \psi ^ { * } + \xi u ) = 0$ on $x \in s u p p ( \mu ^ { * } )$ for a small value of $| \xi | < \epsilon _ { u }$ . By taking directional derivative w.r.t. $\psi$ along the direction $u$ , we obtain:
+
+$$
+u ^ { T } \nabla _ { \psi x } ^ { T } D ( x ; \psi ^ { * } ) = 0 , x \in s u p p ( \mu _ { \psi ^ { * } + \xi u , \theta ^ { * } } ) = s u p p ( \mu ^ { * } )
+$$
+
+and thus
+
+$$
+u ^ { T } \nabla _ { \psi x } ^ { T } D ( x ; \psi ^ { * } ) = u ^ { T } \nabla _ { x \psi } D ( x ; \psi ^ { * } ) = 0 , x \in s u p p ( p _ { \theta ^ { + } } ) = s u p p ( p _ { d } )
+$$
+
+according to Assumption $^ \mathrm { 6 b }$ (the inclusion condition that $s u p p ( p _ { d } ) = s u p p ( p _ { \theta ^ { * } } ) \subset s u p p ( \mu ^ { * } )$ is required). By calculating $u ^ { T } R$ directly, we obtain
+
+$$
+\begin{array} { r l } & { \displaystyle \boldsymbol { u } ^ { T } \boldsymbol { R } = u ^ { T } \frac { \partial } { \partial \boldsymbol { \theta } } \int _ { \mathcal { X } } \nabla _ { \boldsymbol { \psi } } D ( \boldsymbol { x } ; \boldsymbol { \psi } ^ { * } ) d p _ { \boldsymbol { \theta } } \bigg \rvert _ { \boldsymbol { \theta = \theta } ^ { = } } } \\ & { \qquad = u ^ { T } \frac { \partial } { \partial \boldsymbol { \theta } } \int _ { \mathcal { X } } \nabla _ { \boldsymbol { \psi } } D ( G ( \boldsymbol { z } ; \boldsymbol { \theta } ) ; \boldsymbol { \psi } ^ { * } ) p _ { l a t e n t } ( \boldsymbol { z } ) d \boldsymbol { z } \bigg \rvert _ { \boldsymbol { \theta = \theta } ^ { * } } } \\ & { \quad = \int _ { \mathcal { X } } u ^ { T } \nabla _ { \boldsymbol { x } \boldsymbol { \psi } } D ( G ( \boldsymbol { z } ; \boldsymbol { \theta } ^ { * } ) ; \boldsymbol { \psi } ^ { * } ) \nabla _ { \boldsymbol { \theta } } G ( \boldsymbol { z } ; \boldsymbol { \theta } ^ { * } ) p _ { l a t e n t } ( \boldsymbol { z } ) d \boldsymbol { z } = 0 } \end{array}
+$$
+
+Thus, we obtain $u \in N ( R ^ { T } )$ , which implies that $N ( Q ^ { T } ) \subset N ( R ^ { T } )$ and $C ( R ) \subset C ( Q )$ . Now, we can check that $R T _ { G }$ is of full column rank since $T _ { G } ^ { T } R ^ { T } R T _ { G } = \Lambda _ { G } ^ { ( + ) }$ is positive definite. Therefore,
+
+$$
+R T _ { G } w = 0 \Rightarrow w = 0
+$$
+
+We note that the projection matrix on $C ( Q )$ is given by $T _ { D } ( T _ { D } ^ { T } T _ { D } ) ^ { - 1 } T _ { D } ^ { T } = T _ { D } T _ { D } ^ { T }$ . In addition, we know that $C ( R T _ { G } ) \subset C ( R ) \subset C ( Q )$ . Therefore,
+
+$$
+\begin{array} { r l } & { T _ { D } ^ { T } R T _ { G } w = 0 } \\ & { \Rightarrow T _ { D } T _ { D } ^ { T } R T _ { G } w = 0 } \\ & { \Rightarrow T _ { D } T _ { D } ^ { T } w ^ { \prime } = 0 , w ^ { \prime } = R T _ { G } w \in C ( R T _ { G } ) } \end{array}
+$$
+
+$$
+\begin{array} { l } { { \Rightarrow w ^ { \prime } = R T _ { G } w = 0 } } \\ { { \Rightarrow w = 0 } } \end{array}
+$$
+
+which completes the proof that $T _ { D } ^ { T } R T _ { G }$ is a full column rank matrix.
+
+Now, we only need to obtain proofs for the trivial cases where either one of $T _ { D }$ or $T _ { G }$ is empty. First, suppose that $T _ { G }$ is empty. Similar to the analysis given above, we can find that the point $( \psi ^ { * } , \theta )$ with $| \theta - \theta ^ { * } | < \mathrm { m i n } ( \epsilon _ { \mu } , \epsilon _ { g } , \delta _ { g } , \nu )$ is an equilibrium point, where $g ( \theta ^ { * } ) = g ( \theta )$ for a sufficiently small $\lvert \theta - \theta ^ { * } \rvert < \nu$ . We conclude that $p _ { \theta } = p _ { d }$ for $| \theta - \theta ^ { * } | < \operatorname * { m i n } ( \epsilon _ { \mu } , \epsilon _ { g } , \delta _ { g } , \nu )$ . Under the generator initialization that is sufficiently close according to $\theta ^ { * }$ , we can only observe the discriminator update
+
+$$
+\dot { \psi } = - \frac { \rho } { 2 } \nabla _ { \psi } \mathbb { E } _ { \mu _ { \psi , \theta } } [ \| \nabla _ { x } D ( x ; \psi ) \| ^ { 2 } ]
+$$
+
+since $\mathbb { E } _ { p _ { d } } [ D ( x ; \psi ) ] - \mathbb { E } _ { p _ { \theta } } [ D ( x ; \psi ) ] = 0$ for any $\psi$ and $| \theta - \theta ^ { * } | < \mathrm { m i n } ( \epsilon _ { \mu } , \epsilon _ { g } , \delta _ { g } , \nu )$ . The discriminator update described above is locally stable system near the equilibrium $\psi = \psi ^ { * }$ since the Jacobian of the update on $\psi$ is given as $- \rho Q$ and the zero eigenvalues can be ignored in a similar manner to the previous step. Therefore, the given system is stable near the equilibrium.
+
+Suppose that $T _ { D }$ is empty. Given that $N ( Q ^ { T } ) \subset N ( R ^ { T } ) .$ , $R = 0$ , then the results are similar to those presented above, but our goal is to show that $( \psi , \theta )$ is an equilibrium point, where $( \psi , \theta )$ is sufficiently close to the original equilibrium point. We note that $( \psi ^ { * } , \theta )$ is also an equilibrium point that satisfies the assumptions.
+
+By Assumption 2, $h ( \psi ) = h ( \psi ^ { * } ) = 0$ for $| \psi - \psi ^ { * } | < \xi$ , which implies that $\nabla _ { x } D ( x ; \psi ) = 0$ for $x \in s u p p ( \mu _ { \psi , \theta ^ { * } } ) = s u p p ( \mu ^ { * } )$ and $| \psi - \psi ^ { * } | < \xi$ . Thus, we obtain
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } _ { \mu _ { \psi , \theta ^ { * } } } \big [ \nabla _ { \psi x } ^ { T } D ( \boldsymbol { x } ; \psi ) \nabla _ { x } D ( \boldsymbol { x } ; \psi ) \big ] = 0 } \\ { \displaystyle \frac { \rho } { 2 } \int _ { s u p p ( \mu ^ { * } ) } \big \| \nabla _ { x } D \big \| ^ { 2 } d \mu _ { \psi , \theta ^ { * } } ^ { \prime } d \boldsymbol { x } = 0 } \end{array}
+$$
+
+By Assumption 4, $\mathbb { E } _ { p _ { d } } [ \nabla _ { \psi } D ( x ; \psi ) ] - \mathbb { E } _ { p _ { \theta ^ { * } } } [ \nabla _ { \psi } D ( x ; \psi ) ] = 0$ since $p _ { d } = p _ { \theta ^ { \ast } }$ . In addition,
+
+$$
+\dot { \theta } = \frac { \partial } { \partial \theta } \int _ { \mathcal { X } } D ( x ; \psi ) d p _ { \theta } \bigg | _ { \theta = \theta ^ { * } } = \int _ { \mathcal { Z } } \nabla _ { \theta } ^ { T } G ( z ; \theta ^ { * } ) \nabla _ { x } D ( G ( z ; \theta ^ { * } ) ; \psi ) p _ { l a t e n t } ( z ) d z = 0
+$$
+
+Therefore, the point $( \psi , \theta ^ { * } )$ with $| \psi - \psi ^ { * } | < \operatorname* { m i n } ( \xi , \delta _ { d } )$ is an equilibrium point. From Assumption 4, $D ( x ; \psi )$ is an equilibrium discriminator, and thus $D ( x ; \psi )$ is already an optimal discriminator for $| \psi - \psi ^ { * } | < \operatorname* { m i n } ( \xi , \delta _ { d } )$ and $p _ { \theta }$ coincides with the data distribution $p _ { d }$ for $| \theta - \bar { \theta } ^ { * } | < \operatorname* { m i n } ( \epsilon _ { \mu } , \epsilon _ { g } , \delta _ { g } )$ , which indicates that every discriminator and generator near $( \psi ^ { * } , \theta ^ { * } )$ is an equilibrium point and this completes the proof of the main theorem. □
+
+# APPENDIX D : DETAILED EXPERIMENTAL RESULTS
+
+![](images/c27519b391c821a8a732501033759f5a0bf8d62bd8c66e63574a2babdc1debb6.jpg)
+
+Figure 4: 2D example on 8 Gaussians, swissroll, 25 Gaussians datasets. Images generated with 5 penalty measures: $\mu _ { G P } , \mu _ { m i d } , p _ { g } , p _ { d } , \mu _ { g , a n c }$ .
+
+![](images/e9add33f13a815a66a7c30fd8fcb4008bda276bf58cd9026c58fd8877cc49d1a.jpg)  
+Figure 5: MNIST example. Images generated with $\mu _ { G P } , \mu _ { m i d } , p _ { g } , p _ { d } , \mu _ { g , a n c }$
+
+![](images/2dd27c24c109293e33374a284d06f390455d2abd1929b0a3508768fbd5710adf.jpg)  
+Figure 6: CIFAR-10 example. Images generated with WGAN, WGAN-GP, $\mu _ { G P } , \mu _ { m i d } , p _ { g } , p _ { d } , \mu _ { g , a n c }$ under the DCGAN architecture.
+
+![](images/d9c4fa273546a3058613783e5118feaf32c9be46e77bdd5be9b4add130cb07b7.jpg)  
+Figure 7: CIFAR-10 example. Images generated with WGAN, WGAN-GP, $\mu _ { G P } , \mu _ { m i d } , p _ { g } , p _ { d } , \mu _ { g , a n c }$ under the ResNet architecture.

parse/train/HyAddcLge/HyAddcLge.md

@@ -0,0 +1,265 @@
+# REVISITING DISTRIBUTED SYNCHRONOUS SGD
+
+Jianmin Chen∗, Xinghao Pan∗†, Rajat Monga, Samy Bengio   
+Google Brain   
+Mountain View, CA, USA   
+{jmchen,xinghao,rajatmonga,bengio}@google.com
+
+Rafal Jozefowicz OpenAI San Francisco, CA, USA rafal@openai.com
+
+# ABSTRACT
+
+Distributed training of deep learning models on large-scale training data is typically conducted with asynchronous stochastic optimization to maximize the rate of updates, at the cost of additional noise introduced from asynchrony. In contrast, the synchronous approach is often thought to be impractical due to idle time wasted on waiting for straggling workers. We revisit these conventional beliefs in this paper, and examine the weaknesses of both approaches. We demonstrate that a third approach, synchronous optimization with backup workers, can avoid asynchronous noise while mitigating for the worst stragglers. Our approach is empirically validated and shown to converge faster and to better test accuracies.
+
+# 1 INTRODUCTION
+
+The recent success of deep learning approaches for domains like speech recognition (Hinton et al., 2012) and computer vision (Ioffe & Szegedy, 2015) stems from many algorithmic improvements but also from the fact that the size of available training data has grown significantly over the years, together with the computing power, in terms of both CPUs and GPUs. While a single GPU often provides algorithmic simplicity and speed up to a given scale of data and model, there exist an operating point where a distributed implementation of training algorithms for deep architectures becomes necessary.
+
+Currently, popular distributed training algorithms include mini-batch versions of stochastic gradient descent (SGD) and other stochastic optimization algorithms such as AdaGrad (Duchi et al., 2011), RMSProp (Tieleman & Hinton, 2012), and ADAM (Kingma & Ba, 2014). Unfortunately, bulksynchronous implementations of stochastic optimization are often slow in practice due to the need to wait for the slowest machine in each synchronous batch. To circumvent this problem, practitioners have resorted to asynchronous approaches which emphasize speed by using potentially stale information for computation. While asynchronous training have proven to be faster than their synchronous counterparts, they often result in convergence to poorer results.
+
+In this paper1, we revisit synchronous learning, and propose a method for mitigating stragglers in synchronous stochastic optimization. Specifically, we synchronously compute a mini-batch gradient with only a subset of worker machines, thus alleviating the straggler effect while avoiding any staleness in our gradients. The primary contributions of our paper are:
+
+• Illustration of how gradient staleness in asynchronous training negatively impacts test accuracy and is exacerbated by deep models.   
+Measurement of machine response times for synchronous stochastic optimization in a large deployment of 100 GPUs, showing how stragglers in the tail end affect convergence speed. Proposal of synchronous stochastic optimization with backup workers to mitigate straggler effects without gradient staleness.   
+• Establishing the need to measure both speed of convergence and test accuracy of optimum for empirical validation.
+
+• Empirical demonstration that our proposed synchronous training method outperforms asynchronous training by converging faster and to better test accuracies.
+
+The remainder of this paper is organized as follows. We briefly present preliminaries and notation in Section 1.1. Section 2 describes asynchronous stochastic optimization and presents experimental evidence of gradient staleness in deep neural network models. We present our approach in Section 3, and exhibit straggler effects that motivate the approach. We then empirically evaluate our approach in Sections 4. Related work is discussed in Section 5, and we conclude in Section 6.
+
+# 1.1 PRELIMINARIES AND NOTATION
+
+Given a dataset $\mathcal { X } = \{ x _ { i } : i = 1 , \ldots , | \mathcal { X } | \}$ , our goal is to learn the parameters $\theta$ of a model with respect to an empirical loss function $f$ , defined as $\begin{array} { r } { f ( \theta ) \stackrel { \Delta } { = } \frac { 1 } { | \mathcal { X } | } \sum _ { i = 1 } ^ { | \mathcal { X } | } F ( x _ { i } ; \theta ) } \end{array}$ , where $F ( x _ { i } ; \theta )$ is the loss with respect to a datapoint $x _ { i }$ and the model $\theta$ .
+
+A first-order stochastic optimization algorithm achieves this by iteratively updating $\theta$ using a stochastic gradient $G \overset { \Delta } { = } \nabla F ( x _ { i } ; \theta )$ computed at a randomly sampled $x _ { i }$ , producing a sequence of models $\theta ^ { ( 0 ) } , \theta ^ { ( 1 ) } , \ldots$ . Stochastic optimization algorithms differ in their update equations. For example, the update of SGD is $\bar { \theta ^ { ( t + 1 ) } } \bar { \bf \Phi } = \theta ^ { ( t ) } - \gamma _ { t } \bar { G } ^ { ( t ) } = \theta ^ { ( t ) } - \gamma _ { t } \nabla F ( x _ { i } ; \bar { \theta } ^ { ( t ) } )$ , where $\gamma _ { t }$ is the learning rate or step size at iteration $t$ . A mini-batch version of the stochastic optimization algorithm computes the stochastic gradient over mini-batch of size $B$ instead of a single datapoint, i.e., $\begin{array} { r } { G \stackrel { \Delta } { = } \frac { 1 } { B } \sum _ { i = 1 } ^ { B } \nabla F ( \widetilde { x } _ { i } ; \theta ^ { ( t ) } ) } \end{array}$ , where $\widetilde { x } _ { i }$ ’s are randomly sampled from $\mathcal { X }$ . We will often evaluate performance on an exponential moving average $\bar { \theta } ^ { ( t ) } = \alpha \bar { \theta } ^ { ( t - 1 ) } + ( 1 - \alpha ) \theta ^ { ( t ) }$ with decay rate $\alpha$ .
+
+Our interest is in distributed stochastic optimization using $N$ worker machines in charge of computing stochastic gradients that are sent to $M$ parameter servers. Each parameter server $j$ is responsible for storing a subset $\theta [ j ]$ of the model, and performing updates on $\theta [ j ]$ . In the synchronous setting, we will also introduce additional $b$ backup workers for straggler mitigation.
+
+# 2 ASYNCHRONOUS STOCHASTIC OPTIMIZATION
+
+An approach for a distributed stochastic gradient descent algorithm was presented in Dean et al. (2012), consisting of two main ingredients. First, the parameters of the model are distributed on multiple servers, depending on the architecture. This set of servers are called the parameter servers. Second, there can be multiple workers processing data in parallel and communicating with the parameter servers. Each worker processes a mini-batch of data independently of the others, as follows:
+
+• The worker fetches from the parameter servers the most up-to-date parameters of the model needed to process the current mini-batch;   
+• It then computes gradients of the loss with respect to these parameters;   
+• Finally, these gradients are sent back to the parameter servers, which then updates the model accordingly.
+
+Since each worker communicates with the parameter servers independently of the others, this is called Asynchronous Stochastic Gradient Descent (Async-SGD), or more generally, Asynchronous Stochastic Optimization (Async-Opt). A similar approach was later proposed by Chilimbi et al. (2014). Async-Opt is presented in Algorithms 1 and 2.
+
+In practice, the updates of Async-Opt are different than those of serially running the stochastic optimization algorithm for two reasons. Firstly, the read operation (Algo 1 Line 2) on a worker may be interleaved with updates by other workers to different parameter servers, so the resultant $\widehat { \theta } _ { k }$ may not be consistent with any parameter incarnation $\boldsymbol { \theta } ^ { ( t ) }$ . Secondly, model updates may have occurred while a worker is computing its stochastic gradient; hence, the resultant gradients are typically computed with respect to outdated parameters. We refer to these as stale gradients, and its staleness as the number of updates that have occurred between its corresponding read and update operations.
+
+Understanding the theoretical impact of staleness is difficult work and the topic of many recent papers, e.g. Recht et al. (2011); Duchi et al. (2013); Leblond et al. (2016); Reddi et al. (2015);
+
+# Algorithm 1: Async-SGD worker $k$
+
+Input: Dataset $\mathcal { X }$   
+Input: $B$ mini-batch size   
+1 while True do   
+2 Read $\widehat { \theta } _ { k } = ( \theta [ 0 ] , \ldots , \theta [ M ] )$ from PSs.   
+3 $G _ { k } ^ { ( t ) } : = 0$ .   
+4 for $i = 1 , \ldots , B$ do   
+5 Sample datapoint $\widetilde { x } _ { i }$ from $\mathcal { X }$ .   
+6 $\begin{array} { r } { G _ { k } ^ { ( t ) }  G _ { k } ^ { ( t ) } + \frac { 1 } { B } \nabla F ( \widetilde { x } _ { i } ; \widehat { \theta } _ { k } ) . } \end{array}$   
+7 end   
+8 Send $G _ { k } ^ { ( t ) }$ to parameter servers.   
+9 end
+
+# Algorithm 2: Async-SGD Parameter Server j
+
+Input: $\gamma _ { 0 } , \gamma _ { 1 } , \ldots$ learning rates. Input: $\alpha$ decay rate. Input: $\theta ^ { ( 0 ) }$ model initialization. 1 for $t = 0 , 1 , \ldots$ do 2 Wait for gradient $G$ from any worker. 3 $\theta ^ { ( t + 1 ) } [ j ]  \theta ^ { ( t ) } [ j ] - \gamma _ { t } G [ j ]$ . 4 $\bar { \theta } ^ { ( t ) } [ j ] = \alpha \bar { \theta } ^ { ( t - 1 ) } [ j ] + ( 1 - \alpha ) \theta ^ { ( t ) } [ j ] ,$ . 5 end
+
+![](images/869a74e931a0a7ff1e7216146dd0c69e43230ff7820846197c9038f2307065dd.jpg)  
+Figure 1: Gradient staleness dependence on model layer. Gradients are computed in a bottom-up forward propagation step followed by a top-down back propagation step. Parameters are read from servers in the forward prop, but gradients are sent to servers during the back prop. Thus, gradients of lower layers are more stale than top layers.
+
+![](images/067a6882cd5a5473a6949076399e8dc649d5d54797b44d7ec5ef733add6828af.jpg)  
+Figure 2: Degradation of test classification error with increasing average gradient staleness in MNIST CNN model.
+
+De Sa et al. (2015); Mania et al. (2015), most of which focus on individual algorithms, under strong assumptions that may not hold up in practice. This is further complicated by deep models with multiple layers, since the times at which model parameters are read and which gradients are computed and sent are dependent on the depth of the layers (Figure 1). To better understand this dependence in real models, we collected staleness statistics on a Async-Opt run with 40 workers on a 18-layer Inception model (Szegedy et al., 2016) trained on the ImageNet Challenge dataset (Russakovsky et al., 2015), as shown in Table 1.
+
+Despite the abovementioned problems, Async-Opt has been shown to be scale well up to a few dozens of workers for some models. However, at larger scales, increasing the number of machines (and thus staleness of gradients) can result in poorer trained models.
+
+<table><tr><td>Layer</td><td>Min</td><td>Mean</td><td>Median</td><td>Max</td><td>Std Dev</td><td>Count</td></tr><tr><td>18</td><td>4</td><td>14.54</td><td>13.94</td><td>29</td><td>3.83</td><td>10908</td></tr><tr><td>12</td><td>5</td><td>11.35</td><td>11.3</td><td>23</td><td>3.09</td><td>44478</td></tr><tr><td>11</td><td>8</td><td>19.8</td><td>19.59</td><td>34</td><td>3.65</td><td>187</td></tr><tr><td>0</td><td>24</td><td>38.97</td><td>38.43</td><td>61</td><td>5.43</td><td>178</td></tr></table>
+
+Table 1: Staleness of gradients in a 18-layer Inception model. Gradients were collected in a run of asynchronous training using 40 machines. Staleness of a gradient is measured as the number of updates that have occurred between its corresponding read and update operations. The staleness of gradients increases from a mean of ${ \sim } 1 4 . 5$ in the top layer (Layer 18) to ${ \sim } 3 9 . 0 $ in the bottom layer (Layer 0).
+
+# 2.1 IMPACT OF STALENESS ON TEST ACCURACY
+
+We explore how increased staleness contributes to training of poorer models. In order to mimic the setting on a smaller scale, we trained a state-of-the-art MNIST CNN model but simulated staleness by using old gradients for the parameter updates. Details of the model and training are provided in Appendix A.1.
+
+The best final classification error on a test set was $0 . 3 6 \%$ , which increases to $0 . 4 7 \%$ with average gradient staleness of 20 steps, and up to $0 . 7 9 \%$ with 50 steps (see Figure 2).
+
+Once the average simulated staleness was chosen to be more than 15 steps, the results started to significantly deteriorate and the training itself became much less stable. We had to employ following tricks to prevent the results from blowing up:
+
+• Slowly increase the staleness over the first 3 epochs of training. This mimics increasing the number of asynchronous workers and is also very important in practice for some of the models we experimented with (e.g. large word-level language models). The trick was not relevant with a simulated staleness less than 15 but became crucial for larger values. Use lower initial learning rates when staleness is at least 20, which reduces a frequency of explosions (train error goes to $90 \%$ ). This observation is similar to what we found in other experiments - we were able to use much larger learning rates with synchronous training and the results were also more stable.   
+Even with above tricks the divergence occurs occasionally and we found that restarting training from random weights can lead to more successful runs. The best results were then chosen based on validation set performance.
+
+# 3 REVISTING SYNCHRONOUS STOCHASTIC OPTIMIZATION
+
+Both Dean et al. (2012) and Chilimbi et al. (2014) use versions of Async-SGD where the main potential problem is that each worker computes gradients over a potentially old version of the model. In order to remove this discrepancy, we propose here to reconsider a synchronous version of distributed stochastic gradient descent (Sync-SGD), or more generally, Synchronous Stochastic Optimization (Sync-Opt), where the parameter servers wait for all workers to send their gradients, aggregate them, and send the updated parameters to all workers afterward. This ensures that the actual algorithm is a true mini-batch stochastic gradient descent, with an effective batch size equal to the sum of all the mini-batch sizes of the workers.
+
+While this approach solves the staleness problem, it also introduces the potential problem that the actual update time now depends on the slowest worker. Although workers have equivalent computation and network communication workload, slow stragglers may result from failing hardware, or contention on shared underlying hardware resources in data centers, or even due to preemption by other jobs.
+
+To alleviate the straggler problem, we introduce backup workers (Dean & Barroso, 2013) as follows: instead of having only $N$ workers, we add $b$ extra workers, but as soon as the parameter servers receive gradients from any $N$ workers, they stop waiting and update their parameters using the $N$ gradients. The slowest $b$ workers’ gradients will be dropped when they arrive. Our method is presented in Algorithms 3, 4.
+
+# Algorithm 3: Sync-SGD worker $k$ , where $k =$ $1 , \ldots , N + b$
+
+Input: Dataset $\mathcal { X }$ Input: $B$ mini-batch size 1 for $t = 0 , 1 , \ldots$ do 2 Wait to read ${ \boldsymbol { \theta } } ^ { ( t ) } = ( { \boldsymbol { \theta } } ^ { ( t ) } [ 0 ] , \dots , { \boldsymbol { \theta } } ^ { ( t ) } [ M ] )$ from parameter servers. 3 $G _ { k } ^ { ( t ) } : = 0$ 4 for $i = 1 , \ldots , B$ do 5 Sample datapoint $\widetilde { x } _ { k , i }$ from $\mathcal { X }$ . 6 $\begin{array} { r } { G _ { k } ^ { ( t ) }  G _ { k } ^ { ( t ) } + \frac { 1 } { B } \nabla F ( \widetilde { x } _ { k , i } ; \theta ^ { ( t ) } ) } \end{array}$ . 7 end 8 Send $( G _ { k } ^ { ( t ) } , t )$ to parameter servers. 9 end
+
+# Algorithm 4: Sync-SGD Parameter Server $j$
+
+Input: $\gamma _ { 0 } , \gamma _ { 1 } , \ldots$ learning rates. Input: $\alpha$ decay rate. Input: $N$ number of mini-batches to aggregate. Input: $\theta ^ { ( 0 ) }$ model initialization. for $t = 0 , 1 , \ldots$ do 2 $\mathcal { G } = \{ \}$ 3 while $| \mathcal { G } | < N$ do 4 Wait for $( G , t ^ { \prime } )$ from any worker. 5 if $t ^ { \prime } = = t$ then ${ \mathcal { G } }  { \mathcal { G } } \cup \{ G \}$ . 6 else Drop gradient $G$ . 7 end 8 $\begin{array} { r } { \theta ^ { ( t + 1 ) } [ j ]  \theta ^ { ( t ) } [ j ] - \frac { \gamma _ { t } } { N } \sum _ { G \in \mathcal { G } } G [ j ] . } \\ { \bar { \theta } ^ { ( t ) } [ j ] = \alpha \bar { \theta } ^ { ( t - 1 ) } [ j ] + ( 1 - \alpha ) \theta ^ { ( t ) } [ j ] . } \end{array}$ 9 10 end
+
+# 3.1 STRAGGLER EFFECTS
+
+The use of backup workers is motivated by the need to mitigate slow stragglers while maximizing computation. We investigate the effect of stragglers on Sync-Opt model training here.
+
+We ran Sync-Opt with $N = 1 0 0$ workers, $b = 0$ backups, and 19 parameter servers on the Inception model. Using one variable as a proxy, we collected for each iteration both the start time of the iteration and the time when the $k$ th gradient of that variable arrived at the parameter server. These times are presented in Figure 3 for $k = 1$ , 50, 90, 97, 98, 99, 100. Note that $80 \%$ of the 98th gradient arrives in under 2s, whereas only $30 \%$ of the final gradient do. Furthermore, the time to collect the final few gradients grows exponentially, resulting in wasted idle resources and time expended to wait for the slowest gradients. This exponential increase is also seen in Figure 4.
+
+![](images/f142cfb5431917c4256dc4d3a33158daba7d846ffc4487f811dfdda3fff7a939.jpg)  
+Figure 3: CDF of time taken to aggregate gradients from $N$ machines. For clarity, we only show times of $\leq 6 \mathrm { s }$ ; the maximum observed time is 310s.
+
+![](images/1faa87f637ff8939e5bbdb8a66acd6d420b49338648b740f8e467c1caef2ee75.jpg)  
+Figure 4: Mean and median times, across all iterations, to collect $k$ gradients on $N = 1 0 0$ workers and $b = 0$ backups. Most mean times fall between 1.4s and 1.8s, except of final few gradients.
+
+Thus, one might choose to drop slow stragglers to decrease the iteration time. However, using fewer machines implies a smaller effective mini-batch size and thus greater gradient variance, which in turn could require more iterations for convergence. We examine this relationship by running Sync-Opt2 with $N = 5 0$ , 70, 80, 90, 100 and $b = 6$ , and note the number of iterations required for convergence in Figure 5. Additional details of this training are provided in Appendix A.2. As $N$ is doubled from 50 to 100, the number of iterations to converge nearly halves from $1 3 7 . 5 e 3$ to $7 6 . 2 e 3$ .
+
+![](images/808b4545e00ca62fea4a8ae6f8ace30f28b4dffb9d1dabc8f1fdf079679549b0.jpg)  
+Figure 5: Number of iterations to converge when aggregating gradient from $N$ machines.
+
+![](images/9b0b18171010653451f924f726f76139bfecb911a4efdc1c7e6e56ca49a25b7b.jpg)  
+Figure 6: Estimated time to converge when aggregating gradients from $N$ machines on a $N + b = \bar { 1 } 0 0$ machine configuration. Convergence is fastest when choosing $N = 9 6$ , $b = 4$ .
+
+Hence, there is a trade-off between dropping more stragglers to reduce iteration time, and waiting for more gradients to improve the gradient quality. Consider a hypothetical setting where we have $N + b = 1 0 0$ machines, and we wish to choose the best configuration of $N$ and $b$ to minimize running time to convergence3. For each configuration, we can estimate the iterations required from Figure 5 (linearly interpolating for values of $N$ for which we did not collect data). We can multiply this with the mean iteration times (Figure 4) to obtain the running time required to converge for each setting of $N$ and $b$ . These results are shown in Figure 6, indicating that $N = 9 6$ , $b = 4$ converges fastest. Therefore, this motivates our choice to use a few backup workers for mitigating stragglers.
+
+# 4 EXPERIMENTS
+
+In this section, we present our empirical comparisons of synchronous and asynchronous distributed stochastic optimization algorithms as applied to models such as Inception and PixelCNN. All experiments in this paper are using the TensorFlow system (Abadi et al., 2015).
+
+# 4.1 METRICS OF COMPARISON: FASTER CONVERGENCE, BETTER OPTIMUM
+
+We are interested in two metrics of comparison for our empirical validation: (1) test error or accuracy, and (2) speed of convergence3. We point out that for non-convex deep learning models, it is possible to converge faster to a poorer local optimum. Here we show a simple example with Inception using different learning rates.
+
+Table 2: Test accuracies at convergence and number of epochs to converge for different initial learning rates $\gamma _ { 0 }$ . Low initial learning rates result in faster convergence to poorer local optimum.   
+
+<table><tr><td>Initial rate 20</td><td>Test precision at convergence</td><td>Epochs to converge</td></tr><tr><td>1.125 2.25</td><td>77.29% 77.75%</td><td>52628 65811</td></tr><tr><td>4.5</td><td></td><td></td></tr><tr><td>9.0</td><td>78.15%</td><td>76209</td></tr><tr><td></td><td>78.17%</td><td>77235</td></tr></table>
+
+![](images/cf7dd8a2918112ad1401df8582e7cb61ac45e2309e2c05a587c225cae4d880a5.jpg)  
+Figure 7: Convergence of Sync-Opt on Inception model using $N =$ 100 workers and $b = 6$ backups, with varying initial learning rates $\gamma _ { 0 }$ . To reach a lower $\epsilon$ test precision, small $\gamma _ { 0 }$ ’s require fewer epochs than large $\gamma _ { 0 }$ ’s. However, small $\gamma _ { 0 }$ ’s either fail to attain high $\epsilon$ precision, or take more epochs than higher $\gamma _ { 0 }$ ’s.
+
+We ran Sync-Opt on Inception with $N = 1 0 0$ and $b = 6$ , but varied the initial learning rate $\gamma _ { 0 }$ between 1.125 and 9.0. (Learning rates are exponentially decreased with iterations.) Table 2 shows that smaller $\gamma _ { 0 }$ converge faster, but to poorer test precisions. Focusing on speed on an early phase of training could lead to misleading conclusions if we fail to account for eventual convergence. For example, Figure 3b shows that using $\gamma _ { 0 } = 1 . 1 2 5$ reaches $\epsilon = 7 5 \%$ precision $1 . 5 \times$ faster than $\gamma _ { 0 } = 4 . 5$ , but is slower for $\epsilon = 7 7 . 7 5 \%$ , and fails to reach higher precisions.
+
+# 4.2 INCEPTION
+
+We conducted experiments on the Inception model (Szegedy et al., 2016) trained on ImageNet Challenge dataset (Russakovsky et al., 2015), where the task is to classify images out of 1000 categories. We used several configurations, varying $N + b$ from 53 to 212 workers. Additional details of the training are provided in Appendix A.3. An epoch is a synchronous iteration for Sync-Opt, or a full pass of $N$ updates for Async-Opt, which represent similar amounts of computation. Results of this experiment are presented in Figure 8.
+
+Figure 8b shows that Sync-Opt outperforms Async-Opt in test precision: Sync-Opt attains ${ \sim } 0 . 5 \%$ better test precision than Async-Opt for comparable $N + b$ workers. Furthermore, Sync-Opt converges 6h and 18h faster than Async-Opt for 106 and 212 workers respectively, and is 3h slower when 53 workers are used, as seen in Figure 8d. This difference in speed is largely due to the fewer epochs (Figure 8c) needed by Sync-Opt, but comparable or better epoch time (Figure 8e).
+
+![](images/4a2795f1f53e652a98aa43d466d16efa8ffdf2c2db7dc3f06c9317fb0d07f46a.jpg)  
+Figure 8: Convergence of Sync-Opt and Async-Opt on Inception model using varying number of machines. Sync-Opt with backup workers converge faster, with fewer epochs, to higher test accuracies.
+
+# 4.3 PIXELCNN EXPERIMENTS
+
+The second model we experimented on is PixelCNN (Oord et al., 2016), a conditional image generation deep neural network, which we train on the CIFAR-10 (Krizhevsky & Hinton, 2009) dataset. Configurations of $N + b = 1 , 8 , 1 6$ workers were used; for Sync-Opt, we always used $b = 1$ backup worker. Additional details are provided in Appendix A.4.
+
+![](images/c0603f807e6115ff2ee2ef1f99ab3da81f0e47d7e4e735a38c20bae4c9c188e1.jpg)  
+Figure 9: Convergence of synchronous and asynchronous training on PixelCNN model. Sync-Opt achieves lower negative log likelihood in less time than Async-Opt.
+
+Convergence of the test negative log likelihood (NLL) on PixelCNN is shown in Figure 9a, where lower is better. Observe that Sync-Opt obtains lower NLL than Async-Opt; in fact, Async-Opt is even outperformed by serial RMSProp with $N = 1$ worker, with degrading performance as $N$ increases from 8 to 16. Figure 9b further shows the time taken to reach $\epsilon$ test NLL. Sync-Opt reduces the time to reach $\epsilon = 2 . 1 4 5$ from 247h to $5 8 . 3 \mathrm { h }$ ; this NLL is not even achieved by Async-Opt.
+
+# 5 RELATED WORK
+
+Multicore and distributed optimization algorithms have received much attention in recent years. Asynchronous algorithms include Recht et al. (2011); Duchi et al. (2013); Zhang et al. (2015a); Reddi et al. (2015); Leblond et al. (2016). Implementations of asynchronous optimization include Xing et al. (2015); Li et al. (2014); Chilimbi et al. (2014). Attempts have also been made in Zinkevich et al. (2010) and Zhang & Jordan (2015) to algorithmically improve synchronous SGD.
+
+An alternative solution, “softsync”, was presented in Zhang et al. (2015b), which proposed batching gradients from multiple machines before performing an asynchronous SGD update, thereby reducing the effective staleness of gradients. Similar to our proposal, softsync avoids stragglers by not forcing updates to wait for the slowest worker. However, softsync allows the use of stale gradients but we do not. The two solutions provide different explorations of the trade-off between high accuracy (by minimizing staleness) and fast throughput (by avoiding stragglers).
+
+Watcharapichat et al. (2016) introduces a distributed deep learning system without parameter servers, by having workers interleave gradient computation and communication in a round-robin pattern. Like Async-Opt, this approach suffers from staleness. We also note that in principle, workers in Sync-Opt can double as parameter servers and execute the update operations and avoid the need to partition hardware resources between workers and servers.
+
+Das et al. (2016) analyzes distributed stochastic optimization and optimizes the system by solving detailed system balance equations. We believe this approach is complimentary to our work, and could potentially be applied to guide the choice of systems configurations for Sync-Opt.
+
+Keskar et al. (2016) suggests that large batch sizes for synchronous stochastic optimization leads to poorer generalization. Our effective batch size increases linearly with the number of workers $N$ . However, we did not observe this effect in our experiments; we believe we are not yet in the large batch size regime examined by Keskar et al. (2016).
+
+# 6 CONCLUSION AND FUTURE WORK
+
+Distributed training strategies for deep learning architectures will become ever more important as the size of datasets increases. In this work, we have shown how both synchronous and asynchronous distributed stochastic optimization suffer from their respective weaknesses of stragglers and staleness. This has motivated our development of synchronous stochastic optimization with backup workers, which we show to be a viable and scalable strategy.
+
+We are currently experimenting with different kinds of datasets, including word-level language models where parts of the model (the embedding layers) are often very sparse, which involves very different communication constraints. We are also working on further improving the performance of synchronous training like combining gradients from multiple workers sharing the same machine before sending them to the parameter servers to reduce the communication overhead. An alternative of using time-outs instead of backup workers is also being explored.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit ´ Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, ´ Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/.
+
+Jianmin Chen, Rajat Monga, Samy Bengio, and Rafal Jozefowicz. Revisiting distributed synchronous sgd. arXiv preprint arXiv:1604.00981, 2016.
+
+T. Chilimbi, Y. Suzue, J. Apacible, and K. Kalyanaraman. Project adam: Building an efficient and scalable deep learning training system. In Proceedings of the 11th USENIX Symposium on Operating Systems Design and Implementation, 2014.
+
+Dipankar Das, Sasikanth Avancha, Dheevatsa Mudigere, Karthikeyan Vaidynathan, Srinivas Sridharan, Dhiraj Kalamkar, Bharat Kaul, and Pradeep Dubey. Distributed deep learning using synchronous stochastic gradient descent. arXiv preprint arXiv:1602.06709, 2016.
+
+Christopher M De Sa, Ce Zhang, Kunle Olukotun, and Christopher Re. Taming the wild: A unified analysis of ´ hogwild-style algorithms. In Advances in Neural Information Processing Systems, pp. 2674–2682, 2015.
+
+J. Dean, G. S. Corrado, R. Monga, K. Chen, M. Devin, Q. V. Le, M. Z. Mao, M. A. Ranzato, A. Senior, P. Tucker, K. Yang, and A. Y. Ng. Large scale distributed deep networks. In Advances in Neural Information Processing Systems, NIPS, 2012.
+
+Jeffrey Dean and Luiz Andr Barroso. The tail at scale. Communications of the ACM, 56:74–80, 2013. URL http://cacm.acm.org/magazines/2013/2/160173-the-tail-at-scale/fulltext.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.
+
+John Duchi, Michael I Jordan, and Brendan McMahan. Estimation, optimization, and parallelism when data is sparse. In Advances in Neural Information Processing Systems, pp. 2832–2840, 2013.
+
+G. Hinton, L. Deng, D. Yu, G. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, and B. Kingsbury. Deep neural networks for acoustic modeling in speech recognition. IEEE Signal Processing Magazine, 29:82–97, 2012.
+
+S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML, 2015.
+
+Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Remi Leblond, Fabian Pedregosa, and Simon Lacoste-Julien. Asaga: Asynchronous parallel saga. ´ arXiv preprint arXiv:1606.04809, 2016.
+
+Mu Li, David G Andersen, Jun Woo Park, Alexander J Smola, Amr Ahmed, Vanja Josifovski, James Long, Eugene J Shekita, and Bor-Yiing Su. Scaling distributed machine learning with the parameter server. In 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pp. 583–598, 2014.
+
+Horia Mania, Xinghao Pan, Dimitris Papailiopoulos, Benjamin Recht, Kannan Ramchandran, and Michael I Jordan. Perturbed iterate analysis for asynchronous stochastic optimization. arXiv preprint arXiv:1507.06970, 2015.
+
+Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional image generation with pixelcnn decoders. arXiv preprint arXiv:1606.05328, 2016.
+
+Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to parallelizing stochastic gradient descent. In Advances in Neural Information Processing Systems, pp. 693–701, 2011.
+
+Sashank J Reddi, Ahmed Hefny, Suvrit Sra, Barnabas Poczos, and Alex J Smola. On variance reduction in stochastic gradient descent and its asynchronous variants. In Advances in Neural Information Processing Systems, pp. 2647–2655, 2015.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual recognition challenge. In International Journal of Computer Vision, 2015.
+
+C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna. Rethinking the inception architecture for computer vision. In ArXiv 1512.00567, 2016.   
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4(2), 2012.   
+Pijika Watcharapichat, Victoria Lopez Morales, Raul Castro Fernandez, and Peter Pietzuch. Ako: Decentralised deep learning with partial gradient exchange. In Proceedings of the Seventh ACM Symposium on Cloud Computing, pp. 84–97. ACM, 2016.   
+Eric P Xing, Qirong Ho, Wei Dai, Jin Kyu Kim, Jinliang Wei, Seunghak Lee, Xun Zheng, Pengtao Xie, Abhimanu Kumar, and Yaoliang Yu. Petuum: A new platform for distributed machine learning on big data. IEEE Transactions on Big Data, 1(2):49–67, 2015.   
+Sixin Zhang, Anna E Choromanska, and Yann LeCun. Deep learning with elastic averaging sgd. In Advances in Neural Information Processing Systems, pp. 685–693, 2015a.   
+Wei Zhang, Suyog Gupta, Xiangru Lian, and Ji Liu. Staleness-aware async-sgd for distributed deep learning. arXiv preprint arXiv:1511.05950, 2015b.   
+Yuchen Zhang and Michael I Jordan. Splash: User-friendly programming interface for parallelizing stochastic algorithms. arXiv preprint arXiv:1506.07552, 2015.   
+Martin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In Advances in neural information processing systems, pp. 2595–2603, 2010.
+
+# A DETAILS OF MODELS AND TRAINING
+
+# A.1 MNIST CNN, SECTION 2.1
+
+The model used in our experiments is a 4-layer CNN that have $3 { \tt X } 3$ filters with max-pooling and weight normalization in every layer. We trained the model with SGD for 25 epochs and evaluated performance on the exponential moving average $\bar { \theta }$ using a decay rate of $\alpha = 0 . 9 9 9 9$ . Initial learning rate was set to be 0.1 and linearly annealed to 0 in the last 10 epochs. We also used small image rotations and zooms as a data augmentation scheme.
+
+# A.2 INCEPTION, SECTION 3.1
+
+For our straggler experiments, we trained the Inception (Szegedy et al., 2016) model on the ImageNet Challenge dataset (Russakovsky et al., 2015). 10 parameter servers were used, and each worker was equipped with a k40 GPU.
+
+The underlying optimizer was RMSProp with momentum, with decay of 0.9 and momentum of 0.9. Mini-batch size $B = 3 2$ was used. Initial learning rates $\gamma _ { 0 }$ were set at $0 . 0 4 5 N$ , which we found to provide good test precisions for Inception. Learning rates were also exponentially decreased with decay rate $\beta = 0 . 9 4$ as $\gamma _ { 0 } \beta ^ { t N / ( 2 T ) }$ , where $T = | { \mathcal { X } } | / B$ is the number of mini-batches in the dataset.
+
+Test precisions were evaluated on the exponential moving average $\bar { \theta }$ using $\alpha = 0 . 9 9 9 9$ .
+
+# A.3 INCEPTION, SECTION 4.2
+
+For experiments comparing Async-Opt and Sync-Opt on the Inception model in Section 4.2, each worker is equipped with a k40 GPU. For $N + b = 5 3$ workers, 17 parameter servers were used; for $N + b = 1 0 6$ workers, we used 27 parameter servers; and 37 parameter servers were used for $N + b = 2 1 2$ .
+
+In the asynchronous training mode, gradient clipping is also needed for stabilization, which requires each worker to collect the gradient across all layers of the deep model, compute the global norm $| | G | |$ and then clip all gradient accordingly. However, synchronization turns out to be very stable so gradient clipping is no longer needed, which means that we can pipeline the update of parameters in different layers: the gradient of top layers’ parameters can be sent to parameter servers while concurrently computing gradients for the lower layers.
+
+The underlying optimizer is RMSProp with momentum, with decay of 0.9 and momentum of 0.9. Mini-batch size $B = 3 2$ was used. Initial learning rates $\gamma _ { 0 }$ for Async-Opt were set to 0.045; for Sync-Opt, we found as a rule-of-thumb that a learning rate of $0 . 0 4 5 N$ worked well for this model. Learning rates were then exponentially decayed with decay rate $\beta = 0 . 9 4$ as $\gamma _ { 0 } \beta ^ { t / ( 2 T ) }$ for AsyncOpt, where $T = | { \mathcal { X } } | / B$ is the number of mini-batches in the dataset. For Sync-Opt, we learning rates were also exponentially decreased at rate of $\gamma _ { 0 } \beta ^ { t N / ( 2 T ) }$ , so that the learning rates after computing the same number of datapoints are comparable for Async-Opt and Sync-Opt.
+
+Test precisions were evaluated on the exponential moving average $\bar { \theta }$ using $\alpha = 0 . 9 9 9 9$
+
+# A.4 PIXELCNN, SECTION 4.3
+
+The PixelCNN (Oord et al., 2016) model was trained on the CIFAR-10 (Krizhevsky & Hinton, 2009) dataset. Configurations of $N + b = 1 , 8 , 1 6$ workers each with a $\mathbf { k } 8 0$ GPU, and 10 parameter servers were used. For Sync-Opt, we always used $b = 1$ backup worker. The underlying optimizer is RMSProp with momentum, using decay of 0.95 and momentum of 0.9. Initial learning rates $\gamma _ { 0 }$ were set to $1 e - 4$ and slowly decreased to $3 e - 6$ after 200,000 iterations. Mini-batch size $B = 4$ was used.

parse/train/HyAddcLge/HyAddcLge_content_list.json

@@ -0,0 +1,1357 @@
+[
+    {
+        "type": "text",
+        "text": "REVISITING DISTRIBUTED SYNCHRONOUS SGD ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            754,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jianmin Chen∗, Xinghao Pan∗†, Rajat Monga, Samy Bengio   \nGoogle Brain   \nMountain View, CA, USA   \n{jmchen,xinghao,rajatmonga,bengio}@google.com ",
+        "bbox": [
+            184,
+            143,
+            622,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rafal Jozefowicz OpenAI San Francisco, CA, USA rafal@openai.com ",
+        "bbox": [
+            643,
+            145,
+            808,
+            200
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            238,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Distributed training of deep learning models on large-scale training data is typically conducted with asynchronous stochastic optimization to maximize the rate of updates, at the cost of additional noise introduced from asynchrony. In contrast, the synchronous approach is often thought to be impractical due to idle time wasted on waiting for straggling workers. We revisit these conventional beliefs in this paper, and examine the weaknesses of both approaches. We demonstrate that a third approach, synchronous optimization with backup workers, can avoid asynchronous noise while mitigating for the worst stragglers. Our approach is empirically validated and shown to converge faster and to better test accuracies. ",
+        "bbox": [
+            233,
+            270,
+            764,
+            395
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            336,
+            438
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The recent success of deep learning approaches for domains like speech recognition (Hinton et al., 2012) and computer vision (Ioffe & Szegedy, 2015) stems from many algorithmic improvements but also from the fact that the size of available training data has grown significantly over the years, together with the computing power, in terms of both CPUs and GPUs. While a single GPU often provides algorithmic simplicity and speed up to a given scale of data and model, there exist an operating point where a distributed implementation of training algorithms for deep architectures becomes necessary. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Currently, popular distributed training algorithms include mini-batch versions of stochastic gradient descent (SGD) and other stochastic optimization algorithms such as AdaGrad (Duchi et al., 2011), RMSProp (Tieleman & Hinton, 2012), and ADAM (Kingma & Ba, 2014). Unfortunately, bulksynchronous implementations of stochastic optimization are often slow in practice due to the need to wait for the slowest machine in each synchronous batch. To circumvent this problem, practitioners have resorted to asynchronous approaches which emphasize speed by using potentially stale information for computation. While asynchronous training have proven to be faster than their synchronous counterparts, they often result in convergence to poorer results. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            670
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper1, we revisit synchronous learning, and propose a method for mitigating stragglers in synchronous stochastic optimization. Specifically, we synchronously compute a mini-batch gradient with only a subset of worker machines, thus alleviating the straggler effect while avoiding any staleness in our gradients. The primary contributions of our paper are: ",
+        "bbox": [
+            176,
+            676,
+            823,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Illustration of how gradient staleness in asynchronous training negatively impacts test accuracy and is exacerbated by deep models.   \nMeasurement of machine response times for synchronous stochastic optimization in a large deployment of 100 GPUs, showing how stragglers in the tail end affect convergence speed. Proposal of synchronous stochastic optimization with backup workers to mitigate straggler effects without gradient staleness.   \n• Establishing the need to measure both speed of convergence and test accuracy of optimum for empirical validation. ",
+        "bbox": [
+            215,
+            744,
+            825,
+            872
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "• Empirical demonstration that our proposed synchronous training method outperforms asynchronous training by converging faster and to better test accuracies. ",
+        "bbox": [
+            209,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The remainder of this paper is organized as follows. We briefly present preliminaries and notation in Section 1.1. Section 2 describes asynchronous stochastic optimization and presents experimental evidence of gradient staleness in deep neural network models. We present our approach in Section 3, and exhibit straggler effects that motivate the approach. We then empirically evaluate our approach in Sections 4. Related work is discussed in Section 5, and we conclude in Section 6. ",
+        "bbox": [
+            174,
+            142,
+            825,
+            213
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 PRELIMINARIES AND NOTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            229,
+            437,
+            244
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given a dataset $\\mathcal { X } = \\{ x _ { i } : i = 1 , \\ldots , | \\mathcal { X } | \\}$ , our goal is to learn the parameters $\\theta$ of a model with respect to an empirical loss function $f$ , defined as $\\begin{array} { r } { f ( \\theta ) \\stackrel { \\Delta } { = } \\frac { 1 } { | \\mathcal { X } | } \\sum _ { i = 1 } ^ { | \\mathcal { X } | } F ( x _ { i } ; \\theta ) } \\end{array}$ , where $F ( x _ { i } ; \\theta )$ is the loss with respect to a datapoint $x _ { i }$ and the model $\\theta$ . ",
+        "bbox": [
+            174,
+            255,
+            825,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A first-order stochastic optimization algorithm achieves this by iteratively updating $\\theta$ using a stochastic gradient $G \\overset { \\Delta } { = } \\nabla F ( x _ { i } ; \\theta )$ computed at a randomly sampled $x _ { i }$ , producing a sequence of models $\\theta ^ { ( 0 ) } , \\theta ^ { ( 1 ) } , \\ldots$ . Stochastic optimization algorithms differ in their update equations. For example, the update of SGD is $\\bar { \\theta ^ { ( t + 1 ) } } \\bar { \\bf \\Phi } = \\theta ^ { ( t ) } - \\gamma _ { t } \\bar { G } ^ { ( t ) } = \\theta ^ { ( t ) } - \\gamma _ { t } \\nabla F ( x _ { i } ; \\bar { \\theta } ^ { ( t ) } )$ , where $\\gamma _ { t }$ is the learning rate or step size at iteration $t$ . A mini-batch version of the stochastic optimization algorithm computes the stochastic gradient over mini-batch of size $B$ instead of a single datapoint, i.e., $\\begin{array} { r } { G \\stackrel { \\Delta } { = } \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } \\nabla F ( \\widetilde { x } _ { i } ; \\theta ^ { ( t ) } ) } \\end{array}$ , where $\\widetilde { x } _ { i }$ ’s are randomly sampled from $\\mathcal { X }$ . We will often evaluate performance on an exponential moving average $\\bar { \\theta } ^ { ( t ) } = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } + ( 1 - \\alpha ) \\theta ^ { ( t ) }$ with decay rate $\\alpha$ . ",
+        "bbox": [
+            173,
+            311,
+            825,
+            440
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our interest is in distributed stochastic optimization using $N$ worker machines in charge of computing stochastic gradients that are sent to $M$ parameter servers. Each parameter server $j$ is responsible for storing a subset $\\theta [ j ]$ of the model, and performing updates on $\\theta [ j ]$ . In the synchronous setting, we will also introduce additional $b$ backup workers for straggler mitigation. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            502
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 ASYNCHRONOUS STOCHASTIC OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            591,
+            537
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An approach for a distributed stochastic gradient descent algorithm was presented in Dean et al. (2012), consisting of two main ingredients. First, the parameters of the model are distributed on multiple servers, depending on the architecture. This set of servers are called the parameter servers. Second, there can be multiple workers processing data in parallel and communicating with the parameter servers. Each worker processes a mini-batch of data independently of the others, as follows: ",
+        "bbox": [
+            176,
+            553,
+            825,
+            622
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• The worker fetches from the parameter servers the most up-to-date parameters of the model needed to process the current mini-batch;   \n• It then computes gradients of the loss with respect to these parameters;   \n• Finally, these gradients are sent back to the parameter servers, which then updates the model accordingly. ",
+        "bbox": [
+            215,
+            633,
+            823,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since each worker communicates with the parameter servers independently of the others, this is called Asynchronous Stochastic Gradient Descent (Async-SGD), or more generally, Asynchronous Stochastic Optimization (Async-Opt). A similar approach was later proposed by Chilimbi et al. (2014). Async-Opt is presented in Algorithms 1 and 2. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            781
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In practice, the updates of Async-Opt are different than those of serially running the stochastic optimization algorithm for two reasons. Firstly, the read operation (Algo 1 Line 2) on a worker may be interleaved with updates by other workers to different parameter servers, so the resultant $\\widehat { \\theta } _ { k }$ may not be consistent with any parameter incarnation $\\boldsymbol { \\theta } ^ { ( t ) }$ . Secondly, model updates may have occurred while a worker is computing its stochastic gradient; hence, the resultant gradients are typically computed with respect to outdated parameters. We refer to these as stale gradients, and its staleness as the number of updates that have occurred between its corresponding read and update operations. ",
+        "bbox": [
+            173,
+            786,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Understanding the theoretical impact of staleness is difficult work and the topic of many recent papers, e.g. Recht et al. (2011); Duchi et al. (2013); Leblond et al. (2016); Reddi et al. (2015); ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Async-SGD worker $k$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            108,
+            413,
+            122
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input: Dataset $\\mathcal { X }$   \nInput: $B$ mini-batch size   \n1 while True do   \n2 Read $\\widehat { \\theta } _ { k } = ( \\theta [ 0 ] , \\ldots , \\theta [ M ] )$ from PSs.   \n3 $G _ { k } ^ { ( t ) } : = 0$ .   \n4 for $i = 1 , \\ldots , B$ do   \n5 Sample datapoint $\\widetilde { x } _ { i }$ from $\\mathcal { X }$ .   \n6 $\\begin{array} { r } { G _ { k } ^ { ( t ) }  G _ { k } ^ { ( t ) } + \\frac { 1 } { B } \\nabla F ( \\widetilde { x } _ { i } ; \\widehat { \\theta } _ { k } ) . } \\end{array}$   \n7 end   \n8 Send $G _ { k } ^ { ( t ) }$ to parameter servers.   \n9 end ",
+        "bbox": [
+            160,
+            126,
+            431,
+            276
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: Async-SGD Parameter Server j ",
+        "text_level": 1,
+        "bbox": [
+            508,
+            107,
+            808,
+            122
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\gamma _ { 0 } , \\gamma _ { 1 } , \\ldots$ learning rates. Input: $\\alpha$ decay rate. Input: $\\theta ^ { ( 0 ) }$ model initialization. 1 for $t = 0 , 1 , \\ldots$ do 2 Wait for gradient $G$ from any worker. 3 $\\theta ^ { ( t + 1 ) } [ j ]  \\theta ^ { ( t ) } [ j ] - \\gamma _ { t } G [ j ]$ . 4 $\\bar { \\theta } ^ { ( t ) } [ j ] = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } [ j ] + ( 1 - \\alpha ) \\theta ^ { ( t ) } [ j ] ,$ . 5 end ",
+        "bbox": [
+            491,
+            126,
+            761,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            161,
+            268,
+            199,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/869a74e931a0a7ff1e7216146dd0c69e43230ff7820846197c9038f2307065dd.jpg",
+        "image_caption": [
+            "Figure 1: Gradient staleness dependence on model layer. Gradients are computed in a bottom-up forward propagation step followed by a top-down back propagation step. Parameters are read from servers in the forward prop, but gradients are sent to servers during the back prop. Thus, gradients of lower layers are more stale than top layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            327,
+            581,
+            430
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/067a6882cd5a5473a6949076399e8dc649d5d54797b44d7ec5ef733add6828af.jpg",
+        "image_caption": [
+            "Figure 2: Degradation of test classification error with increasing average gradient staleness in MNIST CNN model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            602,
+            321,
+            820,
+            446
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "De Sa et al. (2015); Mania et al. (2015), most of which focus on individual algorithms, under strong assumptions that may not hold up in practice. This is further complicated by deep models with multiple layers, since the times at which model parameters are read and which gradients are computed and sent are dependent on the depth of the layers (Figure 1). To better understand this dependence in real models, we collected staleness statistics on a Async-Opt run with 40 workers on a 18-layer Inception model (Szegedy et al., 2016) trained on the ImageNet Challenge dataset (Russakovsky et al., 2015), as shown in Table 1. ",
+        "bbox": [
+            173,
+            546,
+            825,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Despite the abovementioned problems, Async-Opt has been shown to be scale well up to a few dozens of workers for some models. However, at larger scales, increasing the number of machines (and thus staleness of gradients) can result in poorer trained models. ",
+        "bbox": [
+            173,
+            652,
+            415,
+            763
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/02bec36451fb35c343bccde0a8bb365f5fa1c3f48434be8a9f82c3f421e4e645.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Min</td><td>Mean</td><td>Median</td><td>Max</td><td>Std Dev</td><td>Count</td></tr><tr><td>18</td><td>4</td><td>14.54</td><td>13.94</td><td>29</td><td>3.83</td><td>10908</td></tr><tr><td>12</td><td>5</td><td>11.35</td><td>11.3</td><td>23</td><td>3.09</td><td>44478</td></tr><tr><td>11</td><td>8</td><td>19.8</td><td>19.59</td><td>34</td><td>3.65</td><td>187</td></tr><tr><td>0</td><td>24</td><td>38.97</td><td>38.43</td><td>61</td><td>5.43</td><td>178</td></tr></table>",
+        "bbox": [
+            426,
+            642,
+            826,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Staleness of gradients in a 18-layer Inception model. Gradients were collected in a run of asynchronous training using 40 machines. Staleness of a gradient is measured as the number of updates that have occurred between its corresponding read and update operations. The staleness of gradients increases from a mean of ${ \\sim } 1 4 . 5$ in the top layer (Layer 18) to ${ \\sim } 3 9 . 0 $ in the bottom layer (Layer 0). ",
+        "bbox": [
+            426,
+            719,
+            825,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 IMPACT OF STALENESS ON TEST ACCURACY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            790,
+            397,
+            818
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We explore how increased staleness contributes to training of poorer models. In order to mimic the setting on a smaller scale, we trained a state-of-the-art MNIST CNN model but simulated staleness by using old gradients for the parameter updates. Details of the model and training are provided in Appendix A.1. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The best final classification error on a test set was $0 . 3 6 \\%$ , which increases to $0 . 4 7 \\%$ with average gradient staleness of 20 steps, and up to $0 . 7 9 \\%$ with 50 steps (see Figure 2). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Once the average simulated staleness was chosen to be more than 15 steps, the results started to significantly deteriorate and the training itself became much less stable. We had to employ following tricks to prevent the results from blowing up: ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Slowly increase the staleness over the first 3 epochs of training. This mimics increasing the number of asynchronous workers and is also very important in practice for some of the models we experimented with (e.g. large word-level language models). The trick was not relevant with a simulated staleness less than 15 but became crucial for larger values. Use lower initial learning rates when staleness is at least 20, which reduces a frequency of explosions (train error goes to $90 \\%$ ). This observation is similar to what we found in other experiments - we were able to use much larger learning rates with synchronous training and the results were also more stable.   \nEven with above tricks the divergence occurs occasionally and we found that restarting training from random weights can lead to more successful runs. The best results were then chosen based on validation set performance. ",
+        "bbox": [
+            215,
+            160,
+            825,
+            333
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 REVISTING SYNCHRONOUS STOCHASTIC OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            358,
+            676,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Both Dean et al. (2012) and Chilimbi et al. (2014) use versions of Async-SGD where the main potential problem is that each worker computes gradients over a potentially old version of the model. In order to remove this discrepancy, we propose here to reconsider a synchronous version of distributed stochastic gradient descent (Sync-SGD), or more generally, Synchronous Stochastic Optimization (Sync-Opt), where the parameter servers wait for all workers to send their gradients, aggregate them, and send the updated parameters to all workers afterward. This ensures that the actual algorithm is a true mini-batch stochastic gradient descent, with an effective batch size equal to the sum of all the mini-batch sizes of the workers. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While this approach solves the staleness problem, it also introduces the potential problem that the actual update time now depends on the slowest worker. Although workers have equivalent computation and network communication workload, slow stragglers may result from failing hardware, or contention on shared underlying hardware resources in data centers, or even due to preemption by other jobs. ",
+        "bbox": [
+            174,
+            512,
+            823,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To alleviate the straggler problem, we introduce backup workers (Dean & Barroso, 2013) as follows: instead of having only $N$ workers, we add $b$ extra workers, but as soon as the parameter servers receive gradients from any $N$ workers, they stop waiting and update their parameters using the $N$ gradients. The slowest $b$ workers’ gradients will be dropped when they arrive. Our method is presented in Algorithms 3, 4. ",
+        "bbox": [
+            173,
+            589,
+            825,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 3: Sync-SGD worker $k$ , where $k =$ $1 , \\ldots , N + b$ ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            684,
+            490,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: Dataset $\\mathcal { X }$ Input: $B$ mini-batch size 1 for $t = 0 , 1 , \\ldots$ do 2 Wait to read ${ \\boldsymbol { \\theta } } ^ { ( t ) } = ( { \\boldsymbol { \\theta } } ^ { ( t ) } [ 0 ] , \\dots , { \\boldsymbol { \\theta } } ^ { ( t ) } [ M ] )$ from parameter servers. 3 $G _ { k } ^ { ( t ) } : = 0$ 4 for $i = 1 , \\ldots , B$ do 5 Sample datapoint $\\widetilde { x } _ { k , i }$ from $\\mathcal { X }$ . 6 $\\begin{array} { r } { G _ { k } ^ { ( t ) }  G _ { k } ^ { ( t ) } + \\frac { 1 } { B } \\nabla F ( \\widetilde { x } _ { k , i } ; \\theta ^ { ( t ) } ) } \\end{array}$ . 7 end 8 Send $( G _ { k } ^ { ( t ) } , t )$ to parameter servers. 9 end ",
+        "bbox": [
+            160,
+            714,
+            485,
+            886
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 4: Sync-SGD Parameter Server $j$ ",
+        "text_level": 1,
+        "bbox": [
+            508,
+            684,
+            797,
+            698
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\gamma _ { 0 } , \\gamma _ { 1 } , \\ldots$ learning rates. Input: $\\alpha$ decay rate. Input: $N$ number of mini-batches to aggregate. Input: $\\theta ^ { ( 0 ) }$ model initialization. for $t = 0 , 1 , \\ldots$ do 2 $\\mathcal { G } = \\{ \\}$ 3 while $| \\mathcal { G } | < N$ do 4 Wait for $( G , t ^ { \\prime } )$ from any worker. 5 if $t ^ { \\prime } = = t$ then ${ \\mathcal { G } }  { \\mathcal { G } } \\cup \\{ G \\}$ . 6 else Drop gradient $G$ . 7 end 8 $\\begin{array} { r } { \\theta ^ { ( t + 1 ) } [ j ]  \\theta ^ { ( t ) } [ j ] - \\frac { \\gamma _ { t } } { N } \\sum _ { G \\in \\mathcal { G } } G [ j ] . } \\\\ { \\bar { \\theta } ^ { ( t ) } [ j ] = \\alpha \\bar { \\theta } ^ { ( t - 1 ) } [ j ] + ( 1 - \\alpha ) \\theta ^ { ( t ) } [ j ] . } \\end{array}$ 9 10 end ",
+        "bbox": [
+            493,
+            702,
+            787,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 STRAGGLER EFFECTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            362,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The use of backup workers is motivated by the need to mitigate slow stragglers while maximizing computation. We investigate the effect of stragglers on Sync-Opt model training here. ",
+        "bbox": [
+            171,
+            130,
+            823,
+            159
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We ran Sync-Opt with $N = 1 0 0$ workers, $b = 0$ backups, and 19 parameter servers on the Inception model. Using one variable as a proxy, we collected for each iteration both the start time of the iteration and the time when the $k$ th gradient of that variable arrived at the parameter server. These times are presented in Figure 3 for $k = 1$ , 50, 90, 97, 98, 99, 100. Note that $80 \\%$ of the 98th gradient arrives in under 2s, whereas only $30 \\%$ of the final gradient do. Furthermore, the time to collect the final few gradients grows exponentially, resulting in wasted idle resources and time expended to wait for the slowest gradients. This exponential increase is also seen in Figure 4. ",
+        "bbox": [
+            173,
+            165,
+            826,
+            263
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/f142cfb5431917c4256dc4d3a33158daba7d846ffc4487f811dfdda3fff7a939.jpg",
+        "image_caption": [
+            "Figure 3: CDF of time taken to aggregate gradients from $N$ machines. For clarity, we only show times of $\\leq 6 \\mathrm { s }$ ; the maximum observed time is 310s. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            279,
+            486,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/1faa87f637ff8939e5bbdb8a66acd6d420b49338648b740f8e467c1caef2ee75.jpg",
+        "image_caption": [
+            "Figure 4: Mean and median times, across all iterations, to collect $k$ gradients on $N = 1 0 0$ workers and $b = 0$ backups. Most mean times fall between 1.4s and 1.8s, except of final few gradients. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            509,
+            284,
+            818,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, one might choose to drop slow stragglers to decrease the iteration time. However, using fewer machines implies a smaller effective mini-batch size and thus greater gradient variance, which in turn could require more iterations for convergence. We examine this relationship by running Sync-Opt2 with $N = 5 0$ , 70, 80, 90, 100 and $b = 6$ , and note the number of iterations required for convergence in Figure 5. Additional details of this training are provided in Appendix A.2. As $N$ is doubled from 50 to 100, the number of iterations to converge nearly halves from $1 3 7 . 5 e 3$ to $7 6 . 2 e 3$ . ",
+        "bbox": [
+            173,
+            540,
+            825,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/808b4545e00ca62fea4a8ae6f8ace30f28b4dffb9d1dabc8f1fdf079679549b0.jpg",
+        "image_caption": [
+            "Figure 5: Number of iterations to converge when aggregating gradient from $N$ machines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            643,
+            486,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/9b0b18171010653451f924f726f76139bfecb911a4efdc1c7e6e56ca49a25b7b.jpg",
+        "image_caption": [
+            "Figure 6: Estimated time to converge when aggregating gradients from $N$ machines on a $N + b = \\bar { 1 } 0 0$ machine configuration. Convergence is fastest when choosing $N = 9 6$ , $b = 4$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            509,
+            641,
+            816,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hence, there is a trade-off between dropping more stragglers to reduce iteration time, and waiting for more gradients to improve the gradient quality. Consider a hypothetical setting where we have $N + b = 1 0 0$ machines, and we wish to choose the best configuration of $N$ and $b$ to minimize running time to convergence3. For each configuration, we can estimate the iterations required from Figure 5 (linearly interpolating for values of $N$ for which we did not collect data). We can multiply this with the mean iteration times (Figure 4) to obtain the running time required to converge for each setting of $N$ and $b$ . These results are shown in Figure 6, indicating that $N = 9 6$ , $b = 4$ converges fastest. Therefore, this motivates our choice to use a few backup workers for mitigating stragglers. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            236,
+            326,
+            251
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present our empirical comparisons of synchronous and asynchronous distributed stochastic optimization algorithms as applied to models such as Inception and PixelCNN. All experiments in this paper are using the TensorFlow system (Abadi et al., 2015). ",
+        "bbox": [
+            174,
+            267,
+            825,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 METRICS OF COMPARISON: FASTER CONVERGENCE, BETTER OPTIMUM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            325,
+            709,
+            340
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We are interested in two metrics of comparison for our empirical validation: (1) test error or accuracy, and (2) speed of convergence3. We point out that for non-convex deep learning models, it is possible to converge faster to a poorer local optimum. Here we show a simple example with Inception using different learning rates. ",
+        "bbox": [
+            173,
+            352,
+            825,
+            409
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/a5721568a454d9eb4d6b58098695145714eed7c25b8fae79b2905aa7d541c982.jpg",
+        "table_caption": [
+            "Table 2: Test accuracies at convergence and number of epochs to converge for different initial learning rates $\\gamma _ { 0 }$ . Low initial learning rates result in faster convergence to poorer local optimum. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Initial rate 20</td><td>Test precision at convergence</td><td>Epochs to converge</td></tr><tr><td>1.125 2.25</td><td>77.29% 77.75%</td><td>52628 65811</td></tr><tr><td>4.5</td><td></td><td></td></tr><tr><td>9.0</td><td>78.15%</td><td>76209</td></tr><tr><td></td><td>78.17%</td><td>77235</td></tr></table>",
+        "bbox": [
+            173,
+            446,
+            401,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf7dd8a2918112ad1401df8582e7cb61ac45e2309e2c05a587c225cae4d880a5.jpg",
+        "image_caption": [
+            "Figure 7: Convergence of Sync-Opt on Inception model using $N =$ 100 workers and $b = 6$ backups, with varying initial learning rates $\\gamma _ { 0 }$ . To reach a lower $\\epsilon$ test precision, small $\\gamma _ { 0 }$ ’s require fewer epochs than large $\\gamma _ { 0 }$ ’s. However, small $\\gamma _ { 0 }$ ’s either fail to attain high $\\epsilon$ precision, or take more epochs than higher $\\gamma _ { 0 }$ ’s. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            408,
+            422,
+            815,
+            563
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We ran Sync-Opt on Inception with $N = 1 0 0$ and $b = 6$ , but varied the initial learning rate $\\gamma _ { 0 }$ between 1.125 and 9.0. (Learning rates are exponentially decreased with iterations.) Table 2 shows that smaller $\\gamma _ { 0 }$ converge faster, but to poorer test precisions. Focusing on speed on an early phase of training could lead to misleading conclusions if we fail to account for eventual convergence. For example, Figure 3b shows that using $\\gamma _ { 0 } = 1 . 1 2 5$ reaches $\\epsilon = 7 5 \\%$ precision $1 . 5 \\times$ faster than $\\gamma _ { 0 } = 4 . 5$ , but is slower for $\\epsilon = 7 7 . 7 5 \\%$ , and fails to reach higher precisions. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            738
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 INCEPTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            755,
+            292,
+            768
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conducted experiments on the Inception model (Szegedy et al., 2016) trained on ImageNet Challenge dataset (Russakovsky et al., 2015), where the task is to classify images out of 1000 categories. We used several configurations, varying $N + b$ from 53 to 212 workers. Additional details of the training are provided in Appendix A.3. An epoch is a synchronous iteration for Sync-Opt, or a full pass of $N$ updates for Async-Opt, which represent similar amounts of computation. Results of this experiment are presented in Figure 8. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            864
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 8b shows that Sync-Opt outperforms Async-Opt in test precision: Sync-Opt attains ${ \\sim } 0 . 5 \\%$ better test precision than Async-Opt for comparable $N + b$ workers. Furthermore, Sync-Opt converges 6h and 18h faster than Async-Opt for 106 and 212 workers respectively, and is 3h slower when 53 workers are used, as seen in Figure 8d. This difference in speed is largely due to the fewer epochs (Figure 8c) needed by Sync-Opt, but comparable or better epoch time (Figure 8e). ",
+        "bbox": [
+            176,
+            871,
+            825,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a2795f1f53e652a98aa43d466d16efa8ffdf2c2db7dc3f06c9317fb0d07f46a.jpg",
+        "image_caption": [
+            "Figure 8: Convergence of Sync-Opt and Async-Opt on Inception model using varying number of machines. Sync-Opt with backup workers converge faster, with fewer epochs, to higher test accuracies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            816,
+            435
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            507,
+            825,
+            550
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 PIXELCNN EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            574,
+            398,
+            588
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The second model we experimented on is PixelCNN (Oord et al., 2016), a conditional image generation deep neural network, which we train on the CIFAR-10 (Krizhevsky & Hinton, 2009) dataset. Configurations of $N + b = 1 , 8 , 1 6$ workers were used; for Sync-Opt, we always used $b = 1$ backup worker. Additional details are provided in Appendix A.4. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            660
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c0603f807e6115ff2ee2ef1f99ab3da81f0e47d7e4e735a38c20bae4c9c188e1.jpg",
+        "image_caption": [
+            "Figure 9: Convergence of synchronous and asynchronous training on PixelCNN model. Sync-Opt achieves lower negative log likelihood in less time than Async-Opt. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            683,
+            818,
+            881
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Convergence of the test negative log likelihood (NLL) on PixelCNN is shown in Figure 9a, where lower is better. Observe that Sync-Opt obtains lower NLL than Async-Opt; in fact, Async-Opt is even outperformed by serial RMSProp with $N = 1$ worker, with degrading performance as $N$ increases from 8 to 16. Figure 9b further shows the time taken to reach $\\epsilon$ test NLL. Sync-Opt reduces the time to reach $\\epsilon = 2 . 1 4 5$ from 247h to $5 8 . 3 \\mathrm { h }$ ; this NLL is not even achieved by Async-Opt. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            195,
+            344,
+            210
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Multicore and distributed optimization algorithms have received much attention in recent years. Asynchronous algorithms include Recht et al. (2011); Duchi et al. (2013); Zhang et al. (2015a); Reddi et al. (2015); Leblond et al. (2016). Implementations of asynchronous optimization include Xing et al. (2015); Li et al. (2014); Chilimbi et al. (2014). Attempts have also been made in Zinkevich et al. (2010) and Zhang & Jordan (2015) to algorithmically improve synchronous SGD. ",
+        "bbox": [
+            174,
+            227,
+            825,
+            297
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "An alternative solution, “softsync”, was presented in Zhang et al. (2015b), which proposed batching gradients from multiple machines before performing an asynchronous SGD update, thereby reducing the effective staleness of gradients. Similar to our proposal, softsync avoids stragglers by not forcing updates to wait for the slowest worker. However, softsync allows the use of stale gradients but we do not. The two solutions provide different explorations of the trade-off between high accuracy (by minimizing staleness) and fast throughput (by avoiding stragglers). ",
+        "bbox": [
+            174,
+            304,
+            823,
+            387
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Watcharapichat et al. (2016) introduces a distributed deep learning system without parameter servers, by having workers interleave gradient computation and communication in a round-robin pattern. Like Async-Opt, this approach suffers from staleness. We also note that in principle, workers in Sync-Opt can double as parameter servers and execute the update operations and avoid the need to partition hardware resources between workers and servers. ",
+        "bbox": [
+            174,
+            395,
+            823,
+            464
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Das et al. (2016) analyzes distributed stochastic optimization and optimizes the system by solving detailed system balance equations. We believe this approach is complimentary to our work, and could potentially be applied to guide the choice of systems configurations for Sync-Opt. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            513
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Keskar et al. (2016) suggests that large batch sizes for synchronous stochastic optimization leads to poorer generalization. Our effective batch size increases linearly with the number of workers $N$ . However, we did not observe this effect in our experiments; we believe we are not yet in the large batch size regime examined by Keskar et al. (2016). ",
+        "bbox": [
+            174,
+            520,
+            825,
+            577
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            598,
+            495,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Distributed training strategies for deep learning architectures will become ever more important as the size of datasets increases. In this work, we have shown how both synchronous and asynchronous distributed stochastic optimization suffer from their respective weaknesses of stragglers and staleness. This has motivated our development of synchronous stochastic optimization with backup workers, which we show to be a viable and scalable strategy. ",
+        "bbox": [
+            174,
+            631,
+            823,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We are currently experimenting with different kinds of datasets, including word-level language models where parts of the model (the embedding layers) are often very sparse, which involves very different communication constraints. We are also working on further improving the performance of synchronous training like combining gradients from multiple workers sharing the same machine before sending them to the parameter servers to reduce the communication overhead. An alternative of using time-outs instead of backup workers is also being explored. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            813,
+            285,
+            827
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit ´ Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, ´ Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. ",
+        "bbox": [
+            176,
+            834,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Jianmin Chen, Rajat Monga, Samy Bengio, and Rafal Jozefowicz. Revisiting distributed synchronous sgd. arXiv preprint arXiv:1604.00981, 2016. ",
+        "bbox": [
+            171,
+            104,
+            821,
+            131
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "T. Chilimbi, Y. Suzue, J. Apacible, and K. Kalyanaraman. Project adam: Building an efficient and scalable deep learning training system. In Proceedings of the 11th USENIX Symposium on Operating Systems Design and Implementation, 2014. ",
+        "bbox": [
+            176,
+            140,
+            821,
+            179
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dipankar Das, Sasikanth Avancha, Dheevatsa Mudigere, Karthikeyan Vaidynathan, Srinivas Sridharan, Dhiraj Kalamkar, Bharat Kaul, and Pradeep Dubey. Distributed deep learning using synchronous stochastic gradient descent. arXiv preprint arXiv:1602.06709, 2016. ",
+        "bbox": [
+            176,
+            188,
+            823,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christopher M De Sa, Ce Zhang, Kunle Olukotun, and Christopher Re. Taming the wild: A unified analysis of ´ hogwild-style algorithms. In Advances in Neural Information Processing Systems, pp. 2674–2682, 2015. ",
+        "bbox": [
+            173,
+            236,
+            823,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "J. Dean, G. S. Corrado, R. Monga, K. Chen, M. Devin, Q. V. Le, M. Z. Mao, M. A. Ranzato, A. Senior, P. Tucker, K. Yang, and A. Y. Ng. Large scale distributed deep networks. In Advances in Neural Information Processing Systems, NIPS, 2012. ",
+        "bbox": [
+            174,
+            272,
+            823,
+            311
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Dean and Luiz Andr Barroso. The tail at scale. Communications of the ACM, 56:74–80, 2013. URL http://cacm.acm.org/magazines/2013/2/160173-the-tail-at-scale/fulltext. ",
+        "bbox": [
+            173,
+            320,
+            821,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011. ",
+        "bbox": [
+            171,
+            356,
+            823,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Michael I Jordan, and Brendan McMahan. Estimation, optimization, and parallelism when data is sparse. In Advances in Neural Information Processing Systems, pp. 2832–2840, 2013. ",
+        "bbox": [
+            169,
+            392,
+            823,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "G. Hinton, L. Deng, D. Yu, G. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, and B. Kingsbury. Deep neural networks for acoustic modeling in speech recognition. IEEE Signal Processing Magazine, 29:82–97, 2012. ",
+        "bbox": [
+            178,
+            428,
+            823,
+            467
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML, 2015. ",
+        "bbox": [
+            171,
+            477,
+            823,
+            503
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016. ",
+        "bbox": [
+            173,
+            512,
+            823,
+            551
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            560,
+            823,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            169,
+            595,
+            766,
+            611
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Remi Leblond, Fabian Pedregosa, and Simon Lacoste-Julien. Asaga: Asynchronous parallel saga. ´ arXiv preprint arXiv:1606.04809, 2016. ",
+        "bbox": [
+            171,
+            619,
+            823,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mu Li, David G Andersen, Jun Woo Park, Alexander J Smola, Amr Ahmed, Vanja Josifovski, James Long, Eugene J Shekita, and Bor-Yiing Su. Scaling distributed machine learning with the parameter server. In 11th USENIX Symposium on Operating Systems Design and Implementation (OSDI 14), pp. 583–598, 2014. ",
+        "bbox": [
+            174,
+            655,
+            823,
+            695
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Horia Mania, Xinghao Pan, Dimitris Papailiopoulos, Benjamin Recht, Kannan Ramchandran, and Michael I Jordan. Perturbed iterate analysis for asynchronous stochastic optimization. arXiv preprint arXiv:1507.06970, 2015. ",
+        "bbox": [
+            173,
+            704,
+            821,
+            743
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional image generation with pixelcnn decoders. arXiv preprint arXiv:1606.05328, 2016. ",
+        "bbox": [
+            171,
+            752,
+            823,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Recht, Christopher Re, Stephen Wright, and Feng Niu. Hogwild: A lock-free approach to parallelizing stochastic gradient descent. In Advances in Neural Information Processing Systems, pp. 693–701, 2011. ",
+        "bbox": [
+            173,
+            787,
+            825,
+            827
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sashank J Reddi, Ahmed Hefny, Suvrit Sra, Barnabas Poczos, and Alex J Smola. On variance reduction in stochastic gradient descent and its asynchronous variants. In Advances in Neural Information Processing Systems, pp. 2647–2655, 2015. ",
+        "bbox": [
+            173,
+            837,
+            823,
+            876
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. Imagenet large scale visual recognition challenge. In International Journal of Computer Vision, 2015. ",
+        "bbox": [
+            174,
+            885,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "C. Szegedy, V. Vanhoucke, S. Ioffe, J. Shlens, and Z. Wojna. Rethinking the inception architecture for computer vision. In ArXiv 1512.00567, 2016.   \nTijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 4(2), 2012.   \nPijika Watcharapichat, Victoria Lopez Morales, Raul Castro Fernandez, and Peter Pietzuch. Ako: Decentralised deep learning with partial gradient exchange. In Proceedings of the Seventh ACM Symposium on Cloud Computing, pp. 84–97. ACM, 2016.   \nEric P Xing, Qirong Ho, Wei Dai, Jin Kyu Kim, Jinliang Wei, Seunghak Lee, Xun Zheng, Pengtao Xie, Abhimanu Kumar, and Yaoliang Yu. Petuum: A new platform for distributed machine learning on big data. IEEE Transactions on Big Data, 1(2):49–67, 2015.   \nSixin Zhang, Anna E Choromanska, and Yann LeCun. Deep learning with elastic averaging sgd. In Advances in Neural Information Processing Systems, pp. 685–693, 2015a.   \nWei Zhang, Suyog Gupta, Xiangru Lian, and Ji Liu. Staleness-aware async-sgd for distributed deep learning. arXiv preprint arXiv:1511.05950, 2015b.   \nYuchen Zhang and Michael I Jordan. Splash: User-friendly programming interface for parallelizing stochastic algorithms. arXiv preprint arXiv:1506.07552, 2015.   \nMartin Zinkevich, Markus Weimer, Lihong Li, and Alex J Smola. Parallelized stochastic gradient descent. In Advances in neural information processing systems, pp. 2595–2603, 2010. ",
+        "bbox": [
+            169,
+            102,
+            826,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A DETAILS OF MODELS AND TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            521,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 MNIST CNN, SECTION 2.1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            132,
+            411,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The model used in our experiments is a 4-layer CNN that have $3 { \\tt X } 3$ filters with max-pooling and weight normalization in every layer. We trained the model with SGD for 25 epochs and evaluated performance on the exponential moving average $\\bar { \\theta }$ using a decay rate of $\\alpha = 0 . 9 9 9 9$ . Initial learning rate was set to be 0.1 and linearly annealed to 0 in the last 10 epochs. We also used small image rotations and zooms as a data augmentation scheme. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            229
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 INCEPTION, SECTION 3.1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            246,
+            392,
+            261
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For our straggler experiments, we trained the Inception (Szegedy et al., 2016) model on the ImageNet Challenge dataset (Russakovsky et al., 2015). 10 parameter servers were used, and each worker was equipped with a k40 GPU. ",
+        "bbox": [
+            176,
+            272,
+            823,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The underlying optimizer was RMSProp with momentum, with decay of 0.9 and momentum of 0.9. Mini-batch size $B = 3 2$ was used. Initial learning rates $\\gamma _ { 0 }$ were set at $0 . 0 4 5 N$ , which we found to provide good test precisions for Inception. Learning rates were also exponentially decreased with decay rate $\\beta = 0 . 9 4$ as $\\gamma _ { 0 } \\beta ^ { t N / ( 2 T ) }$ , where $T = | { \\mathcal { X } } | / B$ is the number of mini-batches in the dataset. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            378
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Test precisions were evaluated on the exponential moving average $\\bar { \\theta }$ using $\\alpha = 0 . 9 9 9 9$ . ",
+        "bbox": [
+            173,
+            385,
+            743,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.3 INCEPTION, SECTION 4.2 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            416,
+            393,
+            431
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For experiments comparing Async-Opt and Sync-Opt on the Inception model in Section 4.2, each worker is equipped with a k40 GPU. For $N + b = 5 3$ workers, 17 parameter servers were used; for $N + b = 1 0 6$ workers, we used 27 parameter servers; and 37 parameter servers were used for $N + b = 2 1 2$ . ",
+        "bbox": [
+            174,
+            443,
+            825,
+            498
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In the asynchronous training mode, gradient clipping is also needed for stabilization, which requires each worker to collect the gradient across all layers of the deep model, compute the global norm $| | G | |$ and then clip all gradient accordingly. However, synchronization turns out to be very stable so gradient clipping is no longer needed, which means that we can pipeline the update of parameters in different layers: the gradient of top layers’ parameters can be sent to parameter servers while concurrently computing gradients for the lower layers. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            589
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The underlying optimizer is RMSProp with momentum, with decay of 0.9 and momentum of 0.9. Mini-batch size $B = 3 2$ was used. Initial learning rates $\\gamma _ { 0 }$ for Async-Opt were set to 0.045; for Sync-Opt, we found as a rule-of-thumb that a learning rate of $0 . 0 4 5 N$ worked well for this model. Learning rates were then exponentially decayed with decay rate $\\beta = 0 . 9 4$ as $\\gamma _ { 0 } \\beta ^ { t / ( 2 T ) }$ for AsyncOpt, where $T = | { \\mathcal { X } } | / B$ is the number of mini-batches in the dataset. For Sync-Opt, we learning rates were also exponentially decreased at rate of $\\gamma _ { 0 } \\beta ^ { t N / ( 2 T ) }$ , so that the learning rates after computing the same number of datapoints are comparable for Async-Opt and Sync-Opt. ",
+        "bbox": [
+            174,
+            595,
+            825,
+            698
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Test precisions were evaluated on the exponential moving average $\\bar { \\theta }$ using $\\alpha = 0 . 9 9 9 9$ ",
+        "bbox": [
+            176,
+            704,
+            741,
+            718
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.4 PIXELCNN, SECTION 4.3 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            734,
+            397,
+            750
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The PixelCNN (Oord et al., 2016) model was trained on the CIFAR-10 (Krizhevsky & Hinton, 2009) dataset. Configurations of $N + b = 1 , 8 , 1 6$ workers each with a $\\mathbf { k } 8 0$ GPU, and 10 parameter servers were used. For Sync-Opt, we always used $b = 1$ backup worker. The underlying optimizer is RMSProp with momentum, using decay of 0.95 and momentum of 0.9. Initial learning rates $\\gamma _ { 0 }$ were set to $1 e - 4$ and slowly decreased to $3 e - 6$ after 200,000 iterations. Mini-batch size $B = 4$ was used. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            844
+        ],
+        "page_idx": 10
+    }
+]

parse/train/LKoMTwTuQnC/LKoMTwTuQnC.md

@@ -0,0 +1,304 @@
+# Chasing Sparsity in Vision Transformers: An End-to-End Exploration
+
+Tianlong Chen1, Yu Cheng2, Zhe $\mathbf { G a n } ^ { 2 }$ , Lu Yuan2, Lei Zhang3, Zhangyang Wang1 1University of Texas at Austin, 2Microsoft Corporation, 3International Digital Economy Academy {tianlong.chen,atlaswang}@utexas.edu,{yu.cheng,zhe.gan,luyuan}@microsoft.com leizhangcn@ieee.org
+
+# Abstract
+
+Vision transformers (ViTs) have recently received explosive popularity, but their enormous model sizes and training costs remain daunting. Conventional posttraining pruning often incurs higher training budgets. In contrast, this paper aims to trim down both the training memory overhead and the inference complexity, without sacrificing the achievable accuracy. We carry out the first-of-its-kind comprehensive exploration, on taking a unified approach of integrating sparsity in ViTs “from end to end”. Specifically, instead of training full ViTs, we dynamically extract and train sparse subnetworks, while sticking to a fixed small parameter budget. Our approach jointly optimizes model parameters and explores connectivity throughout training, ending up with one sparse network as the final output. The approach is seamlessly extended from unstructured to structured sparsity, the latter by considering to guide the prune-and-grow of self-attention heads inside ViTs. We further co-explore data and architecture sparsity for additional efficiency gains by plugging in a novel learnable token selector to adaptively determine the currently most vital patches. Extensive results on ImageNet with diverse ViT backbones validate the effectiveness of our proposals which obtain significantly reduced computational cost and almost unimpaired generalization. Perhaps most surprisingly, we find that the proposed sparse (co-)training can sometimes improve the ViT accuracy rather than compromising it, making sparsity a tantalizing “free lunch”. For example, our sparsified DeiT-Small at $( 5 \%$ , $5 0 \%$ ) sparsity for (data, architecture), improves $\mathbf { 0 . 2 8 \% }$ top-1 accuracy, and meanwhile enjoys ${ \bf 4 9 . 3 2 \% }$ FLOPs and ${ \bf 4 . 4 \bar { 0 } \% }$ running time savings. Our codes are available at https: //github.com/VITA-Group/SViTE.
+
+# 1 Introduction
+
+Recent years have seen substantial efforts devoted to scaling deep networks to enormous sizes. Parameter counts are frequently measured in billions rather than millions, with the time and financial outlay necessary to train these models growing in concert. The trend undoubtedly continues with the recent forefront of transformers [1–3] for computer vision tasks. By leveraging self-attention, reducing weight sharing such as convolutions, and feeding massive training data, vision transformers have established many new state-of-the-art (SOTA) records in image classification [1, 2], object detection [4–7], image enhancement [8, 9], and image generation [10–12]. Existing vision transformers and variants, despite the impressive empirical performance, have in general suffered from gigantic parameter-counts, heavy run-time memory usages, and tedious training. That naturally calls for the next step research of slimming their inference and training, without compromising the performance.
+
+Model compression and efficient learning are no strangers to deep learning researchers, although their exploration in the emerging vision transformer field remains scarce [13]. Among the large variety of compression means [14], sparsity has been one of the central themes since the beginning [15].
+
+Conventional approaches first train dense networks, and then prune a large portion of parameters in the trained networks to zero. Those methods significantly reduce the inference complexity. However, the price is to cost even more significant computational resources and memory footprints at training, since they commonly require (multiple rounds of) re-training to restore the accuracy loss [15–17]. That price becomes particularly prohibitive for vision transformers, whose vanilla one-pass training is already much more tedious, slow, and unstable compared to training standard convolutional networks.
+
+An emerging subfield has explored the prospect of directly training smaller, sparse subnetworks in place of the full networks without sacrificing performance. The key idea is to reuse the sparsity pattern found through pruning and train a sparse network from scratch. The seminal work of lottery ticket hypothesis (LTH) [18] demonstrated that standard dense networks contain sparse matching subnetworks (sometimes called “winning tickets”) capable of training in isolation to full accuracy. In other words, we could have trained smaller networks from the start if only we had known which subnetworks to choose. Unfortunately, LTH requires to empirically find these intriguing subnetworks by an iterative pruning procedure [18–27] , which still cannot get rid of the expensiveness of posttraining pruning. In view of that, follow-up works reveal that sparsity patterns might emerge at the initialization [28, 29], the early stage of training [30, 31], or in dynamic forms throughout training [32–34] by updating model parameters and architecture typologies simultaneously. These efforts shed light on the appealing prospect of “end to end” efficiency from training to inference, by involving sparsity throughout the full learning lifecycle.
+
+This paper presents the first-of-its-kind comprehensive exploration of integrating sparsity in vision transformers (ViTs) “from end to end”. With (dynamic) sparsity as the unified tool, we can improve the inference efficiency from both model and data perspectives, while also saving training memory costs. Our innovative efforts are unfolded along with the following three thrusts:
+
+• From Dense to (Dynamic) Sparse: Our primary quest is to find sparse ViTs without sacrificing the achievable accuracy, and meanwhile trimming down the training memory overhead. To meet this challenging demand, we draw inspirations from the latest sparse training works [34, 35] that dynamically extract and train sparse subnetworks instead of training the full models. Sticking to a fixed small parameter budget, our technique jointly optimizes model parameters and explores connectivity throughout the entire training process. We term our first basic approach as Sparse Vision Transformer Exploration (SViTE).
+
+• From Unstructured to Structured: Most sparse training works [32, 33, 36–39, 38, 34, 40, 41, 35] restricted discussion to unstructured sparsity. To attain structured sparsity which is more hardware-friendly, unlike classical channel pruning available for convolutional networks, we customize a first-order importance approximation [16, 42] to guide the pruneand-grow of self-attention heads inside ViTs. This seamlessly extends SViTE to its second variant of Structured Sparse Vision Transformer Exploration $\mathbf { \left( S ^ { 2 } V i T E \right) }$ .
+
+• From Model to Data: We further conduct a unified co-exploration towards joint data and architecture sparsity. That is by plugging in a novel learnable token selector to determine the most vital patch embeddings in the current input sample. The resultant framework of Sparse Vision Transformer Co-Exploration $\mathbf { \eta } ( \mathbf { S } \mathbf { V i T E } +$ ) remains to be end-to-end trainable and can gain additional efficiency.
+
+Extensive experiments are conducted on ImageNet with DeiT-Tiny/Small/Base. Results of substantial computation savings and nearly undamaged accuracies consistently endorse our proposals’ effectiveness. Perhaps most impressively, we find that the sparse (co-)training can even improve the ViT accuracy rather than compromising it, making sparsity a tantalizing “free lunch”. For example, applying $\mathrm { S V i T E { + } }$ on DeiT-Small produces superior compressed ViTs at $5 0 \%$ model sparsity plus $5 \%$ data sparsity, saving $4 9 . 3 2 \%$ FLOPs and $4 . 4 \mathrm { { \bar { 0 } } \% }$ running time, while attaining a surprising improvement of $0 . 2 8 \%$ accuracy; even when the data sparsity increases to $1 0 \%$ (the model sparsity unchanged), there is still no accuracy degradation, meanwhile saving $5 2 . 3 8 \%$ FLOPs and $7 . { \bar { 6 3 \% } }$ running time.
+
+# 2 Related Work
+
+Vision Transformer. Transformer [43] stems from natural language processing (NLP) applications. The Vision Transformer (ViT) [1] pioneered to leverage a pure transformer, to encode an image by splitting it into a sequence of patches, projecting them into token embeddings, and feeding them to transformer encoders. With sufficient training data, ViT is able to outperform convolution neural networks on various image classification benchmarks [1, 44]. Many ViT variants have been proposed since then. For example, DeiT [2] and T2T-ViT [45] are proposed to enhance ViT’s training data efficiency, by leveraging teacher-student and better crafted architectures respectively. In addition to image classification, ViT has attracted wide attention in diverse computer vision tasks, including object detection [4–7], segmentation [46, 47], enhancement [8, 9], image generation [10–12], video understanding [48, 49], vision-language [50–57] and 3D point cloud [58].
+
+Despite the impressive empirical performance, ViTs are generally heavy to train, and the trained models remain massive. That naturally motivates the study to reduce ViT inference and training costs, by considering model compression means. Model compression has been well studied in both computer vision and NLP applications [59–61, 42, 62, 21]. Two concurrent works [13, 63] made initial attempts towards ViT post-training compression by pruning the intermediate features and tokens respectively, but did not jointly consider weight pruning nor efficient training. Another loosely related field is the study of efficient attention mechanisms [64, 10, 52, 65–75]. They mainly reduce the calculation complexity for self-attention modules via various approximations such as low-rank decomposition. Our proposed techniques represent an orthogonal direction and can be potentially combined with them, which we leave as future work. Another latest concurrent work [76] introduced an interpretable module to dynamically and gracefully drop the redundant patches, gaining not only inference efficiency but also interpretability. Being a unique and orthogonal effort from ours, their method did not consider the training efficiency yet.
+
+Pruning and Sparse Training. Pruning is well-known to effectively reduce deep network inference costs [77, 15]. It can be roughly categorized into two groups: $( i )$ unstructured pruning by removing insignificant weight elements per certain criterion, such as weight magnitude [78, 15], gradient [16] and hessian [79]; $( i i )$ structured pruning [80–82] by remove model sub-structures, e.g., channels [80, 81] and attention heads [42], which are often more aligned with hardware efficiency. All above require training the full dense model first, usually for several train-prune-retrain rounds.
+
+The recent surge of sparse training seeks to adaptively identify high-quality sparse subnetworks and train only them. Starting from scratch, those methods learn to optimize the model weights together with sparse connectivity simultaneously. [32, 33] first introduced the Sparse Evolutionary Training (SET) technique [32], reaching superior performance compared to training with fixed sparse connectivity [83, 36]. [37–39] leverages “weight reallocation" to improve performance of obtained sparse subnetworks. Furthermore, gradient information from the backward pass is utilized to guide the update of the dynamic sparse connectivity [38, 34], which produces substantial performance gains. The latest investigations [40, 41, 35] demonstrate that more exhaustive exploration in the connectivity space plays a crucial role in the quality of found sparse subnetworks. Current sparse training methods mostly focus on convolutional networks. Most of them discuss unstructured sparsity, except a handful [84, 30] considering training convolutional networks with structured sparsity.
+
+# 3 Methodology
+
+Our SViTE method (and its variants $\mathbf { S } ^ { \mathrm { 2 } } \mathbf { V i T E }$ and $\mathrm { S V i T E { + } }$ ) is inspired from state-of-the-art sparse training approaches [34, 35] in CNNs. This section presents the sparse exploration of ViT architectures, then shows the detailed procedure of input token selection for extra efficiency gains.
+
+# 3.1 Sparse ViT Exploration
+
+Revisiting sparse training. Sparse training starts from a randomly sparsified model; after optimizing several iterations, it shrinks a portion of parameters based on pre-defined pruning criterion, and activates new connections w.r.t. grow indicators. After upgrading the sparse topology, it trains the new subnetwork until the next update of the connectivity. An illustration of the overall procedure is shown in Figure 1. The key factors of sparse training are $\bullet$ sparsity distribution, $\otimes$ update schedule, $\otimes$ pruning and $\bullet$ grow criterion.
+
+Notations. For a consistent description, we follow the standard notations in [34, 35]. Let $\mathcal { D }$ be the training dataset. $b _ { t } \sim \mathcal { D }$ is a randomly sampled data batch for iteration $t$ . $f _ { W } ( \cdot )$ represents the model with parameters $W = ( W ^ { ( 1 ) } , \cdots , W ^ { ( L ) } )$ , where $W ^ { ( l ) } \in \mathbb { R } ^ { N _ { l } } , 1 \le l \le L , N _ { l }$ is the number of prunable parameters in the $l _ { \mathrm { t h } }$ layer, and $L$ denotes the number of transformer layers. Note that the first linear projection layer and the classifier of ViT [1, 2] are not sparsified in our framework. As illust W (l)Q rated in Figure 1(bottom-left), are the weights of the self-atte $W _ { Q } ^ { ( l ) } = \{ W _ { Q } ^ { ( l , h ) } \} _ { h = 1 } ^ { H }$ , W (l)K $W _ { K } ^ { ( l ) } = \{ W _ { K } ^ { ( l , h ) } \} _ { h = 1 } ^ { H }$ , $W _ { V } ^ { ( l ) } = \{ W _ { V } ^ { ( l , h ) } \} _ { h = 1 } ^ { H }$ $l _ { \mathrm { t h } }$ $W ^ { ( l , 1 ) }$ $W ^ { ( l , 2 ) }$ $W ^ { ( l , 3 ) }$ perceptron (MLP) module in the  collectively represent all the para $l _ { \mathrm { t h } }$ layer, andters in the $W ^ { ( l ) } =$ $( W _ { Q } ^ { ( l ) } , W _ { K } ^ { ( l ) } , W _ { V } ^ { ( l ) } , \bar { W } ^ { ( l , 1 ) } , W ^ { ( l , 2 ) } , W ^ { ( \bar { l } , 3 ) } )$ $l _ { \mathrm { t h } }$ where $H$ denotes the number of attention heads, and $Q ^ { ( l ) }$ , , and $V ^ { ( l ) }$ are the corresponding input and intermediate features, respectively. Each sparse layer only maintains a fraction $s _ { l } \in ( 0 , 1 )$ of its connections, and the overall sparsity of a sparse subnetwork is calculated as the ratio of pruned elements to the total parameter counts, i.e., $\frac { \sum _ { l } s _ { l } \times N _ { l } } { \sum _ { l } N _ { l } }$
+
+![](images/03c337fe2dadbbacbee28ecd5811945c8d6e72c346d559e7ef61f5a292efe60e.jpg)  
+Figure 1: The overall procedure of our proposed sparse ViT exploration framework. Upper Figure: first training ViT for $\Delta \mathrm { T }$ iterations, then performing prune-and-grow strategies to explore critical sparse connectivities, repreating until convergence. Bottom Left Figure: enforcing either structured or unstructured sparsity to transformer layers in ViT. Bottom Right Figure: first scoring each input embedding and applying the learnable top- $k$ selection to identify the most informative tokens.
+
+Sparse Vision Transformer Exploration (SViTE). SViTE explores the unstructured sparse topology in vision transformers. To be specific, we adopt Erdo¨s-Re´nyi [32] as our $\bullet$ sparsity distribution. The number of parameters in the sparse layer is scaled by $\begin{array} { r } { 1 - \frac { n _ { l - 1 } + n _ { l } } { n _ { l - 1 } \times n _ { l } } } \end{array}$ , where $n _ { l }$ is the number of neurons at layer l. This distribution allocates higher sparsities to the layers with more parameters by scaling the portion of remaining weights with the sum of the number of output and input neurons/channels. For the $\otimes$ update schedule, it contains: (i) the update interval $\Delta \mathrm { T }$ , which is the number of training iterations between two sparse topology updates; $( i i )$ the end iteration $\mathrm { T _ { e n d } }$ , indicating when to stop updating the sparsity connectivity, and we set $\mathrm { T _ { e n d } }$ to $8 0 \%$ of total training iterations in our experiments; $( i i i )$ the initial fraction $\alpha$ of connections that can be pruned or $5 0 \%$ $( i v )$ a decay schedule of the fraction of changeable connections, where a cosine annealing is used, following [34, 35]. During $\begin{array} { r } { \dot { f } _ { \mathrm { d e c a y } } ( t , \alpha , \mathrm { T } _ { \mathrm { e n d } } ) = \frac { \alpha } { 2 } ( 1 + \cos ( \frac { t \times \pi } { \mathrm { T } _ { \mathrm { e n d } } } ) ) } \end{array}$   
+each connectivity update, we choose the weight magnitude as the pruning indicator, and gradient magnitude as $\bullet$ the grow indicator. Specifically, we eliminate the parameters with the layer-wise smallest weight values by applying a binary mask $m _ { \mathrm { p r u n e } }$ , then grow new connections with the highest magnitude gradients by generating a new binary mask $m _ { \mathrm { g r o w } }$ . Both masks are employed to $W ^ { ( l ) }$ via the element-wise dot product, and note that the number of non-zero elements in $m _ { \mathrm { p r u n e } }$ and $m _ { \mathrm { g r o w } }$ are equal and fixed across the overall procedure. Newly added connections are not activated in the last sparse topology, and are initialized to zero since it produces better performance as demonstrated in [34, 35].
+
+Infrequent gradient calculation [34] is adopted in our case, which computes the gradients in an online manner and only stores the top gradient values. As illustrated in [34], such fashion amortizes the extra effort of gradient calculation, and makes it still proportional to $1 - s$ as long as $\Delta \mathrm { T } \geq { \frac { 1 } { 1 - s } }$ where $s$ is the overall sparsity.
+
+Structured Sparse Vision Transformer Exploration $\mathbf { ( S ^ { 2 } V i T E ) }$ . Although models with unstructured sparsity achieve superior performance, structured sparsity [80–82] is much more hardware friendly and brings practical efficiency on realistic platforms, which motivates us to propose Structured Sparse ViT Exploration $( \mathrm { S ^ { 2 } V i T E } )$ . We inherit the design of $\bullet$ sparsity distribution and $\otimes$ update schedule from the unstructured SViTE, and a round-up function is used to eliminate decimals in the parameter counting. The key differences lie in the new $\otimes$ pruning and $\bullet$ grow strategies.
+
+Pruning criterion: Let $A _ { ( l , h ) }$ denote features computed from the self-attention head {W (l,h)Q , $\{ W _ { Q } ^ { ( \mathit { l } , h ) } , W _ { K } ^ { ( \mathit { l } , h ) } , W _ { V } ^ { ( \mathit { l } , h ) } \}$ and input embeddings $X ^ { ( l ) }$ , as shown in Figure 1. We perform the Taylor expansion to the loss function [16, 42], and derive a proxy score for head importance blow:
+
+# Algorithm 1 Sparse ViT Co-Exploration $\mathrm { ( S V i T E + ) }$ .
+
+$$
+\mathcal { T } _ { p } ^ { ( l , h ) } = \bigg | A _ { ( l , h ) } ^ { \mathrm { T } } \cdot \frac { \partial \mathcal { L } ( X ^ { ( l ) } ) } { \partial A _ { ( l , h ) } } \bigg | ,
+$$
+
+where $\mathcal { L } ( \cdot )$ is the cross-entropy loss as used in ViT. During each topology update, we remove attention heads with the smallest $\mathcal { T } _ { p } ^ { ( l , h ) }$ . For MLPs, we score neurons with $\ell _ { 1 }$ -norm of their associated weight vectors [85], and drop insignificant neurons. For example, the $j _ { \mathrm { t h } }$ neuron of $W ^ { ( l , 1 ) }$ in Figure 1 has an importance score kW (l,1)j,· k $W _ { j , \cdot } ^ { ( l , 1 ) }$ is the $j _ { \mathrm { t h } }$ row $W ^ { ( l , 1 ) }$ , where
+
+Initialize: ViT model $f _ { W }$ , Dataset $\mathcal { D }$ , Sparsity distribution $\begin{array} { r c l } { \mathbb { S } } & { = } & { \{ s _ { 1 } , \dots , s _ { L } \} } \end{array}$ , Update schedule $\{ \Delta \mathrm { T } , \mathrm { T _ { e n d } } , \alpha , f _ { \mathrm { d e c a y } } \}$ , Learning rate $\eta$   
+1: Initialize $f _ { W }$ with random sparsity $\mathbb { S }$ . Highly reduced parameter count.   
+2: for each training iteration $t$ do   
+3: Sampling a batch $b _ { t } \sim \mathcal { D }$   
+4: Scoring the input token embeddings and selecting the top- $k$ informative tokens . Token selection   
+5: if $\mathbf { \chi } _ { t }$ mod $\Delta \mathrm { T } = = 0 \ \mathrm { \Omega }$ ) and $t < \mathrm { T _ { e n d } }$ then   
+6: for each layer $l$ do   
+7: $\rho = f _ { \mathrm { d e c a y } } ( t , \alpha , \mathrm { T } _ { \mathrm { e n d } } ) \cdot ( 1 - s _ { l } ) \cdot N _ { l }$   
+8: Performing prune-and-grow with portion $\rho$ w.r.t. certain criterion, generating masks $m _ { \mathrm { p r u n e } }$ and $m _ { \mathrm { g r o w } }$ to update $f _ { W }$ ’s sparsity patterns $\triangleright$ Connectivity exploration   
+9: end for   
+10: else   
+11: $\begin{array} { r l r l } { W = W - \eta \cdot \nabla _ { W } \mathcal { L } _ { t } } & { { } } & { \triangleright U p d a t i n g \ W e i g h t s } \end{array}$   
+12: end if   
+13: end for   
+14: return a sparse ViT with a trained token selector
+
+Grow criterion: Similar to [34, 35], we active the new units with the highest
+
+magnitude gradients, such as $\| \frac { \partial \bar { \mathcal { L } } ( X ^ { ( l ) } ) } { \partial A _ { ( l , h ) } } \| _ { \ell _ { 1 } }$ k\`1 and $\| \frac { \partial \mathcal { L } ( X ^ { ( l ) } ) } { \partial W _ { j , \cdot } ^ { ( l , 1 ) } } \| _ { \ell _ { 1 } }$ for the $h _ { \mathrm { t h } }$ attention head and the $j _ { \mathrm { t h } }$ neuron of the MLP $( W ^ { ( l , 1 ) } )$ , respectively. The gradients are calculated in the same manner as the one in unstructured SViTE, and newly added units are also initialized to zero.
+
+# 3.2 Data and Architecture Sparsity Co-Exploration for Higher Efficiency
+
+Besides exploring sparse transformer architectures, we further slim the dimension of input token embeddings for extra efficiency bonus by leveraging a learnable token selector, as presented in Figure 1. Meanwhile, the introduced data sparsity also serves as an implicit regularization for ViT training, which potentially leads to improved generalization ability, as evidenced in Table 6. Note that, due to skip connections, the number of input tokens actually determines
+
+Algorithm 2 The top- $k$ selector in a PyTorch-like style.
+
+def topk_selector(logits, k, tau, ${ \dot { \mathsf { d i m } } } = - 1 \cdot$ ):
+
+# Maintain tokens with the top-\$k\$ highest scores gumbels $=$ -torch.empty_like(logits).exponential_().log() gumbels $=$ (logits $^ +$ gumbels) / tau # tau is the temperature y_soft $=$ gumbels.softmax(dim) # Straight through index $=$ y_soft.topk(k, dim $\mathbf { \Psi } _ { 1 } =$ dim)[1] y_hard $=$ scatter(logits, index, k) ret $=$ y_hard - y_soft.detach() $^ +$ y_soft return ret
+
+the dimension of intermediate features, which substantially contributes to the overall computation cost. In other words, the slimmed input token embeddings directly result in compressed intermediate features, and bring substantial efficiency gains.
+
+Table 1: Details of training configurations in our experiments, mainly following the settings in [2].   
+
+<table><tr><td>Backbone</td><td>Update Schedule{△T,Tend,α,fdecay}</td><td>Batch Size</td><td>Epochs</td><td>Inherited Settings from DeiT[2]</td></tr><tr><td>DeiT-Tiny</td><td>{20000,1200000,0.5,cosine}</td><td>512</td><td>600</td><td>AdamW, 0.0005 × batchsize,cosine decay</td></tr><tr><td>DeiT-Small</td><td>{15000,1200000,0.5,cosine}</td><td>512</td><td>600</td><td>warmup 5 epochs,0.05 weight decay</td></tr><tr><td>DeiT-Base</td><td>{7000,600000,0.5,cosine}</td><td>1024</td><td>600</td><td>0.1 label smoothing,augmentations, etc.</td></tr></table>
+
+For the input tokens $X ^ { ( 1 ) } \in \mathbb { R } ^ { n \times d }$ , where $n$ denotes the number of tokens to be shrunk, and $d$ is the dimension of each token embedding that keeps unchanged. As shown in Figure 1, all token embeddings are passed through a learnable scorer function which is parameterized by an MLP in our experiments. Then, a selection of the top- $k$ importance scores $( 1 \leq k \leq d )$ is applied on top of it, aiming to preserve the significant tokens and remove the useless ones. To optimize parameters of the scorer function, we introduce the popular Gumbel-Softmax [86, 87] and straight-through tricks [88] to enable gradient back-propagation through the top- $k$ selection, which provides an efficient solution to draw samples from a discrete probability distribution. A detailed implementation is in Algorithm 2.
+
+The full pipeline of data and architecture co-exploration is summarized in Algorithm 1. We term this approach $\mathrm { S V i T E { + } }$ . We first feed the randomly sampled data batch to the token selector and pick the top- $k$ informative token embeddings. Then, we alternatively train the sparse ViT for $\Delta \mathrm { T }$ iterations and perform prune-and-grow to explore the sparse connectivity in ViTs dynamically. In the end, a sparse ViT model with a trained token selector is returned and ready for evaluation.
+
+# 4 Experiments
+
+Baseline pruning methods. We extend several effective pruning methods from CNN compression as our strong baselines. Unstructured pruning: $( i )$ One-shot weight Magnitude Pruning (OMP) [15], which removes insignificant parameters with the globally smallest weight values; (ii) Gradually Magnitude Pruning (GMP) [17], which seamlessly incorporates gradual pruning techniques within the training process by eliminating a few small magnitude weights per iteration; and (iii) Taylor Pruning (TP) [16], which utilizes the first-order approximation of the training loss to estimate units’ importance for model sparsification. Structured pruning: Salience-based Structured Pruning (SSP). We draw inspiration from [42, 85], and remove sub-modules in ViT (e.g., self-attention heads) by leveraging their weight, activation, and gradient information. Moreover, due to the repetitive architecture of ViT, we can easily reduce the number of transformer layers to create a smaller dense ViT (Small-Dense) baseline that has similar parameter counts to the pruned ViT model.
+
+Implementation details. Our experiments are conducted on ImageNet with DeiTTiny/Small/Base backbones. The detailed training configurations are listed in Table 1, which mainly follows the default setups in [2]. All involved customized hyperparameters are tuned via grid search (later shown in Figure 3). For a better exploration of sparsity connectivities, we increase training epochs to 600 for all experiments. GMP [17] has an additional hyperparameter, i.e., the pruning schedule, which starts from $\frac { 1 } { 6 }$ and ends at ${ \frac { \overline { { \frac { 1 } { 2 } } } } { 2 } }$ of the training epochs with 20 times pruning in total. More details are referred to Appendix A1.
+
+Training time measuring protocol. We strictly measure the running time saving of
+
+![](images/a5ad90174ff1547fe598c114e7c4b77c1f965a37ed3695b0c6fcde1a09ee9c95.jpg)  
+The Overall Performance of SViTE, S 2ViTE, and SViTE+   
+Figure 2: Top-1 accuracy $( \% )$ over FLOPs $( \times 1 0 ^ { 1 0 } )$ on ImageNet of our methods, i.e., SViTE, $\mathrm { S ^ { 2 } V i T E }$ , and ${ \mathrm { S V i T E } } +$ compared to DeiT baselines, trained on Imagenet-1K only.
+
+(sparse) vision transformers on the ImageNet-1K task using CUDA benchmark mode. To be specific, we separately calculate the time elapsed during each iteration, to eliminate the impact of the hardware environment as much as possible. Note that the time for the data I/O is excluded.
+
+Highlight of our findings. The overall performance of SViTE, $\mathbf { S } ^ { \mathrm { 2 } } \mathbf { V i T E }$ , and $\mathrm { S V i T E { + } }$ on DeiT backbones are summarized in Figure 2. We highlight some takeaways below.
+
+Takeaways: ❶ SViTE produces sparse DeiTs with enhanced generalization and substantial reduced FLOPs, compared to its dense counterpart $( { \star } )$ . ${ \mathrm { S V i T E } } +$ further improves the performance of SViTE by selecting the most vital patches. ❷ $\mathbf { S } ^ { \mathrm { 2 } } \mathbf { V i T E }$ achieves matched accuracy on DeiT-Small, and significantly enhances performance on DeiT-Base. Meanwhile, its structural sparsity brings considerable running time savings. $\otimes$ Appropriate data and architecture sparsities can effectively regularize ViT training, leading to a new SOTA win-win between ViT accuracy and efficiency.
+
+# 4.1 SViTE with Unstructured Sparsity
+
+We perform SViTE to mine vital unstructured sparsity in DeiTs [2]. Solid lines in Figure 2 record the top-1 test-set accuracy over FLOPs on ImageNet-1K of SViTE-Small and SViTE-Base with a range of sparsity from $3 0 \%$ to $7 0 \%$ . In general, we observe that SViTE generates superior sparse ViTs with both accuracy and efficiency gains. Table 2, 3, and 5 present the comparison between SViTE and various pruning baselines. From these extensive results, we draw several consistent observations. First, compared to the dense baselines, SViTE-Tiny, -Small, and -Base obtain $2 5 . 5 6 \% \sim 3 4 . 1 6 \%$ , $4 6 . 2 6 \% \sim 5 5 . 4 4 \%$ , and $4 7 . 9 5 \% \sim 5 7 . 5 0 \%$ FLOPs reduction, respectively, at $3 0 \% \sim 6 0 \%$ sparsity levels with only a negligible accuracy drop within $0 . 5 \%$ . It verifies the effectiveness of our proposal, and indicates severe parameter redundancy in ViT. Second, our SViTE models from dynamic explorations consistently surpass other competitive baseline methods, including OMP, GMP, TP, and Small-Dense by a substantial performance margin. Among all the baseline approaches, GMP that advocates a gradual pruning schedule achieves the best accuracy with all three DeiT backbones. Third, in Figure 2, both SViTE-Small (blue solid line) and SViTE-Base (green solid line) show an improved trade-off between accuracy and efficiency, compared to their dense DeiT counterparts. Interestingly, we also observe that with similar parameter counts, a large sparse ViT consistently outperforms the corresponding smaller dense ViT. A possible explanation is those appropriate sparse typologies regularize network training and lead to enhanced generalization, which coincides with recent findings of critical subnetworks (i.e., winning tickets) in dense CNNs [89, 22] and NLP transformer [21, 90] models.
+
+Table 2: Results of SViTE-Tiny on ImageNet-1K. Accuracies $( \% )$ within/out of parenthesis are the reproduced/reported [2] performance.   
+
+<table><tr><td>Models</td><td>Sparsity (#Para.)</td><td>FLOPs Saving</td><td>Accuracy (%)</td></tr><tr><td>DeiT-Tiny</td><td>0% (5.72M)</td><td>0%</td><td>72.20 (71.80)</td></tr><tr><td>SViTE-Tiny</td><td>30% (4.02M)</td><td>25.56%</td><td>71.78</td></tr><tr><td>OMP</td><td>30% (4.02M)</td><td>25.56%</td><td>68.35</td></tr><tr><td>GMP</td><td>30% (4.02M)</td><td>25.56%</td><td>69.56</td></tr><tr><td>TP</td><td>30% (4.02M)</td><td>25.56%</td><td>68.38</td></tr><tr><td>SViTE-Tiny</td><td>40% (3.46M)</td><td>34.16%</td><td>71.75</td></tr><tr><td>OMP</td><td>40% (3.46M)</td><td>34.16%</td><td>66.52</td></tr><tr><td>GMP</td><td>40% (3.46M)</td><td>34.15%</td><td>68.36</td></tr><tr><td>TP</td><td>40% (3.46M)</td><td>34.17%</td><td>65.45</td></tr><tr><td>Small-Dense</td><td>0% (3.94M)</td><td>32.54%</td><td>67.33</td></tr></table>
+
+Table 3: Results of SViTE-Small on ImageNet-1K. Accuracies $( \% )$ within/out of parenthesis are the reproduced/reported [2] performance.   
+
+<table><tr><td>Models</td><td>Sparsity (#Para.)</td><td>FLOPs Saving</td><td>Accuracy (%)</td></tr><tr><td>DeiT-Small</td><td>0% (22.1M)</td><td>0%</td><td>79.90 (79.78)</td></tr><tr><td>SViTE-Small</td><td>50% (11.1M)</td><td>46.26%</td><td>79.72</td></tr><tr><td>OMP</td><td>50% (11.1M)</td><td>46.25%</td><td>76.32</td></tr><tr><td>GMP</td><td>50% (11.1M)</td><td>46.26%</td><td>76.88</td></tr><tr><td>TP</td><td>50% (11.1M)</td><td>46.26%</td><td>76.30</td></tr><tr><td> SViTE-Small</td><td>60% (8.9M)</td><td>55.44%</td><td>79.41</td></tr><tr><td>OMP</td><td>60% (8.9M)</td><td>55.44%</td><td>75.32</td></tr><tr><td>GMP</td><td>60% (8.9M)</td><td>55.44%</td><td>76.79</td></tr><tr><td>TP</td><td>60% (8.9M)</td><td>55.44%</td><td>74.50</td></tr><tr><td>Small-Dense</td><td>0% (11.4M)</td><td>49.32%</td><td>73.93</td></tr></table>
+
+Table 4: Results of $\mathrm { S ^ { 2 } V i T E }$ with structured sparsity on ImageNet-1K with DeiT-Tiny/Small/Base. Accuracies $( \% )$ within/out of parenthesis are the reproduced/reported [2] performance.   
+
+<table><tr><td>Models</td><td>Sparsity (%)</td><td>Parameters</td><td>FLOPs Saving</td><td>Running Time Reduced|Top-1 Accuracy (%)</td><td></td></tr><tr><td>DeiT-Tiny (Dense)</td><td>0%</td><td>5.72M</td><td>0%</td><td>0%</td><td>72.20 (71.80)</td></tr><tr><td>SViTE-Tiny (Unstructured)</td><td>30%</td><td>4.02M</td><td>25.56%</td><td>0%</td><td>71.78</td></tr><tr><td>SSP-Tiny (Structured)</td><td>30%</td><td>4.21M</td><td>23.69%</td><td>10.57%</td><td>68.59</td></tr><tr><td>S2ViTE-Tiny (Structured)</td><td>30%</td><td>4.21M</td><td>23.69%</td><td>10.57%</td><td>70.12</td></tr><tr><td>DeiT-Small (Dense)</td><td>0%</td><td>22.1M</td><td>0%</td><td>0%</td><td>79.90 (79.78)</td></tr><tr><td>SViTE-Small (Unstructured)</td><td>40%</td><td>13.3M</td><td>36.73%</td><td>0%</td><td>80.26</td></tr><tr><td>SSP-Small (Structured)</td><td>40%</td><td>14.6M</td><td>31.63%</td><td>22.65%</td><td>77.74</td></tr><tr><td>S²ViTE-Small (Structured)</td><td>40%</td><td>14.6M</td><td>31.63%</td><td>22.65%</td><td>79.22</td></tr><tr><td>DeiT-Base (Dense)</td><td>0%</td><td>86.6M</td><td>0%</td><td>0%</td><td>81.80 (80.98)</td></tr><tr><td>SViTE-Base (Unstructured)</td><td>40%</td><td>52.0M</td><td>38.30%</td><td>0%</td><td>81.56</td></tr><tr><td>SSP-Base (Structured)</td><td>40%</td><td>56.8M</td><td>33.13%</td><td>24.70%</td><td>80.08</td></tr><tr><td>S2ViTE-Base (Structured)</td><td>40%</td><td>56.8M</td><td>33.13%</td><td>24.70%</td><td>82.22</td></tr></table>
+
+# 4.2 $\mathbf { S } ^ { 2 }$ ViTE with Structured Sparsity
+
+For more practical benefits, we investigate sparse DeiTs with structured sparsity. Results are summarized in Table 4. Besides the obtained $2 3 . { \bar { 7 } } 9 \% \sim 3 3 . 6 3 \%$ FLOPs savings, ${ \mathsf { S } } ^ { \tilde { 2 } }$ ViTE-Tiny, $S ^ { 2 }$ ViTE
+
+Small, and $S ^ { 2 }$ ViTE-Base enjoy an extra $1 0 . 5 7 \%$ , $2 2 . 6 5 \%$ , and $2 4 . 7 0 \%$ running time reduction, respectively, from $3 0 \% \sim \hat { 4 } 0 \%$ structured sparsity with competitive top-1 accuracies. Furthermore, $\mathrm { S ^ { 2 } V i T E }$ consistently outperforms the baseline structured pruning method (SSP), which again demonstrates the superior sparse connectivity learned from dynamic sparse training.
+
+The most impressive results come from $S ^ { 2 }$ ViTE-Base at $4 0 \%$ structured sparsity. It even surpasses the dense DeiT base model by $0 . 4 2 \% \sim 1 . 2 4 \%$ accuracy with $3 4 . 4 1 \%$ parameter counts, $3 3 . 1 3 \%$ FLOPs, and $2 4 . 7 0 \%$ running time reductions. We conclude that $( i )$ an adequate sparsity from $\mathbf { S } ^ { \mathrm { 2 } } \mathbf { V i T E }$ boosts ViT’s generalization ability, which can be regarded as an implicit regularization; $( i i )$ larger ViTs (e.g., DeiT-Base) tend to have more superfluous self-attention heads, and are more amenable to structural sparsification from $\mathbf { S } ^ { \mathrm { 2 } } \mathbf { V i T E }$ , based on Figure 2 where dash lines denote the overall performance of $\hat { \mathbf { S } ^ { 2 } }$ ViTE-Small and $S ^ { 2 }$ ViTE-Base with a range of sparsity from $3 0 \%$ to $7 0 \%$ .
+
+Table 5: Results of SViTE-Base on ImageNet-1K. Accuracies $( \% )$ within/out of parenthesis are the reproduced/reported [2] performance.   
+
+<table><tr><td>Models</td><td>Sparsity (#Para.)</td><td>FLOPs Saving|Accuracy (%)</td><td></td></tr><tr><td>DeiT-Base</td><td>0% (86.6M)</td><td>0%</td><td>81.80 (80.98)</td></tr><tr><td>SViTE-Base</td><td>50% (43.4M)</td><td>47.95%</td><td>81.51</td></tr><tr><td>OMP</td><td>50% (43.4M)</td><td>47.94%</td><td>80.26</td></tr><tr><td>GMP</td><td>50% (43.4M)</td><td>47.95%</td><td>80.79</td></tr><tr><td>TP</td><td>50% (43.4M)</td><td>47.94%</td><td>80.55</td></tr><tr><td>SViTE-Base</td><td>60% (34.8M)</td><td>57.50%</td><td>81.28</td></tr><tr><td>OMP</td><td>60% (34.8M)</td><td>57.50%</td><td>80.25</td></tr><tr><td>GMP</td><td>60% (34.8M)</td><td>57.50%</td><td>80.44</td></tr><tr><td>TP</td><td>60% (34.8M)</td><td>57.49%</td><td>80.37</td></tr><tr><td>Small-Dense</td><td>0% (44.0M)</td><td>49.46%</td><td>78.59</td></tr></table>
+
+Table 6: Results of SViTE $^ +$ -Small on ImageNet-1K. Accuracies $( \% )$ within/out of parenthesis are the reproduced/reported [2] performance.   
+
+<table><tr><td></td><td></td><td>#Tokens (%)|Time ReducedFLOPs Saving|Accuracy (%)</td><td></td></tr><tr><td colspan="4">SViTE+-Small 50% Unstructured Sparsity</td></tr><tr><td>100%</td><td>0%</td><td>46.26%</td><td>79.72</td></tr><tr><td>95%</td><td>4.40%</td><td>49.32%</td><td>80.18</td></tr><tr><td>90%</td><td>7.63%</td><td>52.38%</td><td>79.91</td></tr><tr><td>70%</td><td>19.77%</td><td>63.95%</td><td>77.90</td></tr><tr><td colspan="4">S²ViTE+-Small 40% Structured Sparsity</td></tr><tr><td>100%</td><td>22.65%</td><td>31.63%</td><td>79.22</td></tr><tr><td>95%</td><td>27.17%</td><td>37.76%</td><td>78.44</td></tr><tr><td>90%</td><td>29.21%</td><td>41.50%</td><td>78.16</td></tr><tr><td>70%</td><td>39.10%</td><td>54.96%</td><td>74.77</td></tr></table>
+
+# 4.3 $\mathbf { S V i T E { + } }$ with Data and Architecture Sparsity Co-Exploration
+
+In this section, we study data and architecture sparsity co-exploration for ViTs, i.e., $\mathrm { S V i T E { + } }$ . Blessed by the reduced input token embeddings, even ViTs with unstructured sparsity can have running time savings. The benefits are mainly from the shrunk input and intermediate feature dimensions. Without loss of generality, we consider SViTE $+ \cdot$ -Small with $5 0 \%$ unstructured sparsity and ${ \mathrm { S ^ { 2 } V i T E } } +$ -Small with $4 0 \%$ structured sparsity as examples. As shown in Table 6 and Figure 2, SViTE+-Small at $5 0 \%$ unstructured sparsity is capable of abandoning $5 \% \sim 1 0 \%$ tokens while achieving $4 . 4 0 \% \sim 7 . 6 3 \%$ running time and $4 9 . 3 2 \% \sim 5 2 . 3 8 \%$ FLOPs savings, with even improved top-1 testing accuracy. It again demonstrates that data sparsity as an implicit regularizer plays a beneficial role in ViT training. However, slimming input and intermediate embedding is less effective when incorporated with $\mathbf { S } ^ { \mathrm { 2 } } \mathbf { V i T E }$ , suggesting that aggressively removing structural sub-modules hurts ViT’s generalization.
+
+# 4.4 Ablation and Generalization Study of SViTEs
+
+Update interval in SViTE. The length of the update interval $\Delta \mathrm { T }$ controls one of the essential tradeoffs in our proposed dynamic sparse exploration, since $\Delta \mathrm { T }$ multiplying the number of updates is the pre-defined $\mathrm { T _ { e n d } }$ . On the one hand, a larger updated interval (i.e., smaller update frequency) produces a more well-trained model for improved estimation of units’ importance. On the other hand, a larger update frequency (i.e., smaller $\Delta \mathrm { T }$ ) allows more sufficient exploration of sparse connectivities, which potentially generates higher-quality sparse subnetworks, as demonstrated in [35]. We evaluate this factor in our SViTE context, and collect the results in Figure 3 (Left). We observe that $\Delta \mathrm { T } = 2 0 0 0 0$ works the best for SViTE-Tiny, and both larger and smaller $\Delta \mathrm { T }$ degrade the performance.
+
+![](images/a4655f90e93b2c9a04681fc021da3282c731aba6f4cba193b459acd0b25f0153.jpg)  
+Figure 3: Accuracy of SViTE-Tiny with $5 0 \%$ unstructured sparsity. Left: ablation studies of the update interval $( \bar { \Delta \mathrm { T } } )$ ; Right: ablations studies of the adopted batch size $( b )$ .
+
+![](images/20204951e060810529cbad9a007da6259808df546d2c9563a4a457ffbdf0a012.jpg)  
+Dense DeiT-Base
+
+![](images/33e5e064c5dba74ca99e27db03615dbf08bda7f2b81b68715098af3c25c6d603.jpg)  
+-Base with $4 0 \%$ Structured Sparsity
+
+![](images/fcf8ae89303d80f050af5c5ed88ce6e7bc4eee6a2db8431edf4a7768d4fc9049.jpg)  
+SViTE-Base with $4 0 \%$ Unstructured Sparsity
+
+![](images/a0e0619f2f06fe582065a11779901de10112cfc6477c8e3ec5b96052b7f80f29.jpg)  
+Figure 4: Attention probabilities for DeiT-Base, $S ^ { 2 }$ ViTE-Base, and SViTE-Base models with 12 layers (rows) and 12 heads (columns) using visualization tools provided in [94]. Attention maps are averaged over 100 test samples from ImageNet-1K to present head behavior and remove the dependence on the input content. The black square is the query pixel. indicates pruned attention heads. Zoom-in for better visibility.   
+Figure 5: Learned patch selection patterns of SViTE $+$ -Small at $1 0 \%$ data and $5 0 \%$ architecture sparsity levels. $\widehat { \mathbb { I } }$ indicates removed inessential patches.
+
+Batch size in SViTE. Besides the update interval $\Delta \mathrm { T }$ , batch size (b) also affects the aforementioned trade-off, especially for the data-hungry ViT training. We investigate different batch sizes in Figure 3 (Right), and find that $b = 5 1 2$ outperforms other common options for SViTE-Tiny.
+
+Generalization study of SViTE and its variants. It is worth mentioning that our proposed frameworks (SViTE, $\mathrm { S ^ { 2 } V i T E }$ , $\mathrm { S V i T E { + } }$ ) are independent of the backbone architectures, and can be easily plugged in other vision transformer models [91, 45, 92, 93]. We implemented both SViTE and ${ \bar { \mathbf { S } } } ^ { 2 }$ ViTE on TNT-S [91]. SViTE-TNT-S gains 0.13 accuracy improvements (Ours: 81.63 v.s. TNT-S: 81.50) and $3 7 . 5 4 \%$ FLOPs savings at $4 0 \%$ unstructured sparsity; $S ^ { 2 }$ ViTE-TNT-S obtains $3 2 . 9 6 \%$ FLOPs and $2 3 . 7 1 \%$ running time reductions at $4 0 \%$ structured sparsity with almost unimpaired accuracy (Ours: 81.34 v.s. TNT-S:81.50).
+
+# 4.5 Visualization
+
+Sparse connectivity patterns. We provide unit-wise and element-wise heatmap visualizations for SViTE-Base with $4 0 \%$ structured sparsity in Figure A7 (in Appendix). Similarly, element-wise heatmap visualizations of SViTE-Base with $5 0 \%$ unstructured sparsity are displayed in Figure A6. We find that even unstructured sparsity exploration can develop obvious structural patterns (i.e., “vertical lines” in mask heatmaps), which implies a stronger potential for hardware speedup [95].
+
+Self-attention heatmaps. As shown in Figure 4, we utilize tools in [94] to visualize attention maps of (sparse) ViTs. Multiple attention heads show similar behaviors, which implies the structural redundancy. Fortunately, $\mathbf { S } ^ { \mathrm { 2 } } \mathbf { V i T E }$ eliminates unnecessary heads to some extent. With regard to SViTE-Base’s visual results, it seems to activate fewer attention heads for predictions (darker colors mean larger values), compared to the ones of dense DeiT-Base. We also observe that in the bottom layers, the attention probabilities are more centered at several heads; while in the top layers, the attention probabilities are more uniformly distributed. This kind of tendency is well preserved by our sparse ViT (SViTE) from Dense ViTs.
+
+Learned patch selection patterns. Figure 5 presents the learned behaviors of our token selector in SViTE+. We observe that the useless removed patches are typically distributed around the main object or in the background. Meanwhile, the patches within the objects of interest are largely persevered, which evidences the effectiveness of our learned patch token selector.
+
+# 5 Conclusion and Discussion of Broader Impact
+
+In this work, we introduce sparse ViT exploration algorithms, SViTE, and its variants $\mathbf { S } ^ { \mathrm { 2 } } \mathbf { V i T E }$ and ${ \mathrm { S V i T E } } +$ , to explore high-quality sparse patterns in both ViT’s architecture and input token embeddings, alleviating training memory bottleneck and pursuing inference ultra-efficiency (e.g., running time and FLOPs). Comprehensive experiments on ImageNet validate the effectiveness of our proposal. Our informative visualizations further demonstrate that $\mathrm { S V i T E { + } }$ is capable of mining crucial connections and input tokens by eliminating redundant units and dropping useless token embeddings. Future work includes examining the performance of our sparse ViTs on incoming hardware accelerators [96–100], which will provide better supports for sparsity.
+
+This work is scientific in nature, and we do not believe it has immediate negative societal impacts. Our findings of sparse vision transformers are highly likely to reduce both memory and energy costs substantially, leading to economic deployment in real-world applications (e.g., on smartphones).
+
+# Acknowledgment
+
+Z.W. is in part supported by an NSF RTML project (#2053279).
+
+# References
+
+[1] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   
+[2] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou. Training data-efficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   
+[3] Kai Han, Yunhe Wang, Hanting Chen, Xinghao Chen, Jianyuan Guo, Zhenhua Liu, Yehui Tang, An Xiao, Chunjing Xu, Yixing Xu, et al. A survey on visual transformer. arXiv preprint arXiv:2012.12556, 2020.   
+[4] Minghang Zheng, Peng Gao, Xiaogang Wang, Hongsheng Li, and Hao Dong. End-to-end object detection with adaptive clustering transformer. arXiv preprint arXiv:2011.09315, 2020.   
+[5] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision, pages 213–229. Springer, 2020.   
+[6] Zhigang Dai, Bolun Cai, Yugeng Lin, and Junying Chen. Up-detr: Unsupervised pre-training for object detection with transformers. arXiv preprint arXiv:2011.09094, 2020.   
+[7] Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, and Jifeng Dai. Deformable {detr}: Deformable transformers for end-to-end object detection. In International Conference on Learning Representations, 2021.   
+[8] Hanting Chen, Yunhe Wang, Tianyu Guo, Chang Xu, Yiping Deng, Zhenhua Liu, Siwei Ma, Chunjing Xu, Chao Xu, and Wen Gao. Pre-trained image processing transformer. arXiv preprint arXiv:2012.00364, 2020.   
+[9] Fuzhi Yang, Huan Yang, Jianlong Fu, Hongtao Lu, and Baining Guo. Learning texture transformer network for image super-resolution. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5791–5800, 2020.   
+[10] Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Lukasz Kaiser, Noam Shazeer, Alexander Ku, and Dustin Tran. Image transformer. In International Conference on Machine Learning, pages 4055–4064. PMLR, 2018.   
+[11] Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, and Ilya Sutskever. Generative pretraining from pixels. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 1691–1703. PMLR, 13–18 Jul 2020.   
+[12] Yifan Jiang, Shiyu Chang, and Zhangyang Wang. Transgan: Two transformers can make one strong gan. arXiv preprint arXiv:2102.07074, 2021.   
+[13] Mingjian Zhu, Kai Han, Yehui Tang, and Yunhe Wang. Visual transformer pruning, 2021.   
+[14] Yu Cheng, Duo Wang, Pan Zhou, and Tao Zhang. A survey of model compression and acceleration for deep neural networks. arXiv preprint arXiv:1710.09282, 2017.   
+[15] Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In International Conference on Learning Representations, 2016.   
+[16] Pavlo Molchanov, Arun Mallya, Stephen Tyree, Iuri Frosio, and Jan Kautz. Importance estimation for neural network pruning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11264–11272, 2019.   
+[17] Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. arXiv preprint arXiv:1710.01878, 2017.   
+[18] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2018.   
+[19] Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M Roy, and Michael Carbin. Linear mode connectivity and the lottery ticket hypothesis. arXiv preprint arXiv:1912.05671, 2019.   
+[20] Zhenyu Zhang, Xuxi Chen, Tianlong Chen, and Zhangyang Wang. Efficient lottery ticket finding: Less data is more. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 12380–12390. PMLR, 18–24 Jul 2021.   
+[21] Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Zhangyang Wang, and Michael Carbin. The lottery ticket hypothesis for pre-trained bert networks. arXiv preprint arXiv:2007.12223, 2020.   
+[22] Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Michael Carbin, and Zhangyang Wang. The lottery tickets hypothesis for supervised and self-supervised pre-training in computer vision models. arXiv preprint arXiv:2012.06908, 2020.   
+[23] Xuxi Chen, Zhenyu Zhang, Yongduo Sui, and Tianlong Chen. {GAN}s can play lottery tickets too. In International Conference on Learning Representations, 2021.   
+[24] Haoyu Ma, Tianlong Chen, Ting-Kuei Hu, Chenyu You, Xiaohui Xie, and Zhangyang Wang. Good students play big lottery better. arXiv preprint arXiv:2101.03255, 2021.   
+[25] Zhe Gan, Yen-Chun Chen, Linjie Li, Tianlong Chen, Yu Cheng, Shuohang Wang, and Jingjing Liu. Playing lottery tickets with vision and language. arXiv preprint arXiv:2104.11832, 2021.   
+[26] Tianlong Chen, Yongduo Sui, Xuxi Chen, Aston Zhang, and Zhangyang Wang. A unified lottery ticket hypothesis for graph neural networks. arXiv preprint arXiv:2102.06790, 2021.   
+[27] Tianlong Chen, Yu Cheng, Zhe Gan, Jingjing Liu, and Zhangyang Wang. Ultra-dataefficient gan training: Drawing a lottery ticket first, then training it toughly. arXiv preprint arXiv:2103.00397, 2021.   
+[28] Namhoon Lee, Thalaiyasingam Ajanthan, and Philip Torr. Snip: Single-shot network pruning based on connection sensitivity. In International Conference on Learning Representations, 2019.   
+[29] Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. In International Conference on Learning Representations, 2020.   
+[30] Haoran You, Chaojian Li, Pengfei Xu, Yonggan Fu, Yue Wang, Xiaohan Chen, Richard G. Baraniuk, Zhangyang Wang, and Yingyan Lin. Drawing early-bird tickets: Toward more efficient training of deep networks. In International Conference on Learning Representations, 2020.   
+[31] Xiaohan Chen, Yu Cheng, Shuohang Wang, Zhe Gan, Zhangyang Wang, and Jingjing Liu. Earlybert: Efficient bert training via early-bird lottery tickets. arXiv preprint arXiv:2101.00063, 2020.   
+[32] 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):1–12, 2018.   
+[33] Shiwei Liu, Decebal Constantin Mocanu, Amarsagar Reddy Ramapuram Matavalam, Yulong Pei, and Mykola Pechenizkiy. Sparse evolutionary deep learning with over one million artificial neurons on commodity hardware. Neural Computing and Applications, 2020.   
+[34] Utku Evci, Trevor Gale, Jacob Menick, Pablo Samuel Castro, and Erich Elsen. Rigging the lottery: Making all tickets winners. In International Conference on Machine Learning, pages 2943–2952. PMLR, 2020.   
+[35] Shiwei Liu, Lu Yin, Decebal Constantin Mocanu, and Mykola Pechenizkiy. Do we actually need dense over-parameterization? in-time over-parameterization in sparse training. arXiv preprint arXiv:2102.02887, 2021.   
+[36] Utku Evci, Fabian Pedregosa, Aidan Gomez, and Erich Elsen. The difficulty of training sparse neural networks. arXiv preprint arXiv:1906.10732, 2019.   
+[37] Hesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. In International Conference on Machine Learning, 2019.   
+[38] Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. arXiv preprint arXiv:1907.04840, 2019.   
+[39] Shiwei Liu, Decebal Constantin Mocanu, Yulong Pei, and Mykola Pechenizkiy. Selfish sparse rnn training. arXiv preprint arXiv:2101.09048, 2021.   
+[40] Siddhant Jayakumar, Razvan Pascanu, Jack Rae, Simon Osindero, and Erich Elsen. Top-kast: Top-k always sparse training. Advances in Neural Information Processing Systems, 33, 2020.   
+[41] Md Aamir Raihan and Tor M Aamodt. Sparse weight activation training. arXiv preprint arXiv:2001.01969, 2020.   
+[42] Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one?, 2019.   
+[43] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.   
+[44] Jianyuan Guo, Kai Han, Han Wu, Chang Xu, Yehui Tang, Chunjing Xu, and Yunhe Wang. Cmt: Convolutional neural networks meet vision transformers. arXiv preprint arXiv:2107.06263, 2021.   
+[45] Li Yuan, Yunpeng Chen, Tao Wang, Weihao Yu, Yujun Shi, Zihang Jiang, Francis EH Tay, Jiashi Feng, and Shuicheng Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. arXiv preprint arXiv:2101.11986, 2021.   
+[46] Huiyu Wang, Yukun Zhu, Hartwig Adam, Alan Yuille, and Liang-Chieh Chen. Max-deeplab: End-to-end panoptic segmentation with mask transformers. arXiv preprint arXiv:2012.00759, 2020.   
+[47] Yuqing Wang, Zhaoliang Xu, Xinlong Wang, Chunhua Shen, Baoshan Cheng, Hao Shen, and Huaxia Xia. End-to-end video instance segmentation with transformers. arXiv preprint arXiv:2011.14503, 2020.   
+[48] Yanhong Zeng, Jianlong Fu, and Hongyang Chao. Learning joint spatial-temporal transformations for video inpainting. In European Conference on Computer Vision, pages 528–543. Springer, 2020.   
+[49] Luowei Zhou, Yingbo Zhou, Jason J Corso, Richard Socher, and Caiming Xiong. End-to-end dense video captioning with masked transformer. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8739–8748, 2018.   
+[50] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. arXiv preprint arXiv:1908.02265, 2019.   
+[51] Hao Tan and Mohit Bansal. Lxmert: Learning cross-modality encoder representations from transformers. arXiv preprint arXiv:1908.07490, 2019.   
+[52] Yen-Chun Chen, Linjie Li, Licheng Yu, Ahmed El Kholy, Faisal Ahmed, Zhe Gan, Yu Cheng, and Jingjing Liu. Uniter: Universal image-text representation learning. In European Conference on Computer Vision, pages 104–120. Springer, 2020.   
+[53] Weijie Su, Xizhou Zhu, Yue Cao, Bin Li, Lewei Lu, Furu Wei, and Jifeng Dai. Vl-bert: Pre-training of generic visual-linguistic representations. arXiv preprint arXiv:1908.08530, 2019.   
+[54] Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, and Kai-Wei Chang. Visualbert: A simple and performant baseline for vision and language. arXiv preprint arXiv:1908.03557, 2019.   
+[55] Gen Li, Nan Duan, Yuejian Fang, Ming Gong, and Daxin Jiang. Unicoder-vl: A universal encoder for vision and language by cross-modal pre-training. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 11336–11344, 2020.   
+[56] Xiujun Li, Xi Yin, Chunyuan Li, Pengchuan Zhang, Xiaowei Hu, Lei Zhang, Lijuan Wang, Houdong Hu, Li Dong, Furu Wei, et al. Oscar: Object-semantics aligned pre-training for vision-language tasks. In European Conference on Computer Vision, pages 121–137. Springer, 2020.   
+[57] Luowei Zhou, Hamid Palangi, Lei Zhang, Houdong Hu, Jason Corso, and Jianfeng Gao. Unified vision-language pre-training for image captioning and vqa. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 13041–13049, 2020.   
+[58] Hengshuang Zhao, Li Jiang, Jiaya Jia, Philip Torr, and Vladlen Koltun. Point transformer. arXiv preprint arXiv:2012.09164, 2020.   
+[59] Angela Fan, Edouard Grave, and Armand Joulin. Reducing transformer depth on demand with structured dropout. In International Conference on Learning Representations, 2020.   
+[60] Fu-Ming Guo, Sijia Liu, Finlay S Mungall, Xue Lin, and Yanzhi Wang. Reweighted proximal pruning for large-scale language representation. arXiv preprint arXiv:1909.12486, 2019.   
+[61] Prakhar Ganesh, Yao Chen, Xin Lou, Mohammad Ali Khan, Yin Yang, Deming Chen, Marianne Winslett, Hassan Sajjad, and Preslav Nakov. Compressing large-scale transformer-based models: A case study on bert. arXiv preprint arXiv:2002.11985, 2020.   
+[62] J. S. McCarley, Rishav Chakravarti, and Avirup Sil. Structured pruning of a bert-based question answering model. arXiv preprint arXiv:1910.06360, 2019.   
+[63] Yehui Tang, Kai Han, Yunhe Wang, Chang Xu, Jianyuan Guo, Chao Xu, and Dacheng Tao. Patch slimming for efficient vision transformers. arXiv preprint arXiv:2106.02852, 2021.   
+[64] Pengchuan Zhang, Xiyang Dai, Jianwei Yang, Bin Xiao, Lu Yuan, Lei Zhang, and Jianfeng Gao. Multi-scale vision longformer: A new vision transformer for high-resolution image encoding. arXiv preprint arXiv:2103.15358, 2021.   
+[65] Iz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.   
+[66] Nikita Kitaev, Łukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. arXiv preprint arXiv:2001.04451, 2020.   
+[67] Juho Lee, Yoonho Lee, Jungtaek Kim, Adam Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer: A framework for attention-based permutation-invariant neural networks. In International Conference on Machine Learning, pages 3744–3753. PMLR, 2019.   
+[68] Aurko Roy, Mohammad Saffar, Ashish Vaswani, and David Grangier. Efficient content-based sparse attention with routing transformers. Transactions of the Association for Computational Linguistics, 9:53–68, 2021.   
+[69] Jack W Rae, Anna Potapenko, Siddhant M Jayakumar, and Timothy P Lillicrap. Compressive transformers for long-range sequence modelling. arXiv preprint arXiv:1911.05507, 2019.   
+[70] Jonathan Ho, Nal Kalchbrenner, Dirk Weissenborn, and Tim Salimans. Axial attention in multidimensional transformers. arXiv preprint arXiv:1912.12180, 2019.   
+[71] Angelos Katharopoulos, Apoorv Vyas, Nikolaos Pappas, and François Fleuret. Transformers are rnns: Fast autoregressive transformers with linear attention. In International Conference on Machine Learning, pages 5156–5165. PMLR, 2020.   
+[72] Krzysztof Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamas Sarlos, Peter Hawkins, Jared Davis, Afroz Mohiuddin, Lukasz Kaiser, et al. Rethinking attention with performers. arXiv preprint arXiv:2009.14794, 2020.   
+[73] Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena: A benchmark for efficient transformers. arXiv preprint arXiv:2011.04006, 2020.   
+[74] Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. arXiv preprint arXiv:2009.06732, 2020.   
+[75] Sinong Wang, Belinda Z. Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Selfattention with linear complexity, 2020.   
+[76] Bowen Pan, Yifan Jiang, Rameswar Panda, Zhangyang Wang, Rogerio Feris, and Aude Oliva. Ia-red2: Interpretability-aware redundancy reduction for vision transformers, 2021.   
+[77] Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pages 598–605, 1990.   
+[78] Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett, editors, Advances in Neural Information Processing Systems 28, pages 1135–1143. Curran Associates, Inc., 2015.   
+[79] Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In D. S. Touretzky, editor, Advances in Neural Information Processing Systems 2, pages 598–605. Morgan-Kaufmann, 1990.   
+[80] Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision, pages 2736–2744, 2017.   
+[81] Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, 2017.   
+[82] Hao Zhou, Jose M Alvarez, and Fatih Porikli. Less is more: Towards compact cnns. In European Conference on Computer Vision, pages 662–677. Springer, 2016.   
+[83] Decebal Constantin Mocanu, Elena Mocanu, Phuong H Nguyen, Madeleine Gibescu, and Antonio Liotta. A topological insight into restricted boltzmann machines. Machine Learning, 104(2-3):243–270, 2016. [84] Sangkug Lym, Esha Choukse, Siavash Zangeneh, Wei Wen, Sujay Sanghavi, and Mattan Erez. Prunetrain: fast neural network training by dynamic sparse model reconfiguration. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, pages 1–13, 2019.   
+[85] Brian R Bartoldson, Ari S Morcos, Adrian Barbu, and Gordon Erlebacher. The generalizationstability tradeoff in neural network pruning. arXiv preprint arXiv:1906.03728, 2019. [86] Emit J. Gumbel. Statistical theory of extreme values and some practical applications. The Journal of the Royal Aeronautical Society, 58(527):792–793, 1954.   
+[87] Chris J Maddison, Daniel Tarlow, and Tom Minka. $\mathbf { A } ^ { * }$ sampling. arXiv preprint arXiv:1411.0030, 2014.   
+[88] Penghang Yin, Jiancheng Lyu, Shuai Zhang, Stanley Osher, Yingyong Qi, and Jack Xin. Understanding straight-through estimator in training activation quantized neural nets. arXiv preprint arXiv:1903.05662, 2019.   
+[89] Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M Roy, and Michael Carbin. The lottery ticket hypothesis at scale. arXiv preprint arXiv:1903.01611, 2019.   
+[90] Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. arXiv preprint arXiv:1902.09574, 2019.   
+[91] Kai Han, An Xiao, Enhua Wu, Jianyuan Guo, Chunjing Xu, and Yunhe Wang. Transformer in transformer. arXiv preprint arXiv:2103.00112, 2021.   
+[92] Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, and Ling Shao. Pyramid vision transformer: A versatile backbone for dense prediction without convolutions. arXiv preprint arXiv:2102.12122, 2021.   
+[93] Daquan Zhou, Bingyi Kang, Xiaojie Jin, Linjie Yang, Xiaochen Lian, Zihang Jiang, Qibin Hou, and Jiashi Feng. Deepvit: Towards deeper vision transformer. arXiv preprint arXiv:2103.11886, 2021.   
+[94] Jean-Baptiste Cordonnier, Andreas Loukas, and Martin Jaggi. On the relationship between selfattention and convolutional layers. In International Conference on Learning Representations, 2020.   
+[95] Erich Elsen, Marat Dukhan, Trevor Gale, and Karen Simonyan. Fast sparse convnets. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 14629–14638, 2020.   
+[96] Peiqi Wang, Yu Ji, Chi Hong, Yongqiang Lyu, Dongsheng Wang, and Yuan Xie. Snrram: An efficient sparse neural network computation architecture based on resistive random-access memory. In 2018 55th ACM/ESDA/IEEE Design Automation Conference (DAC), pages 1–6, 2018.   
+[97] Mike Ashby, Christiaan Baaij, Peter Baldwin, Martijn Bastiaan, Oliver Bunting, Aiken Cairncross, Christopher Chalmers, Liz Corrigan, Sam Davis, Nathan van Doorn, et al. Exploiting unstructured sparsity on next-generation datacenter hardware. None, 2019.   
+[98] Chen Liu, Guillaume Bellec, Bernhard Vogginger, David Kappel, Johannes Partzsch, Felix Neumärker, Sebastian Höppner, Wolfgang Maass, Steve B Furber, Robert Legenstein, et al. Memory-efficient deep learning on a spinnaker 2 prototype. Frontiers in neuroscience, 12:840, 2018.   
+[99] Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A. Horowitz, and William J. Dally. Eie: Efficient inference engine on compressed deep neural network. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA), pages 243–254, 2016.   
+[100] Yu-Hsin Chen, Tien-Ju Yang, Joel Emer, and Vivienne Sze. Eyeriss v2: A flexible accelerator for emerging deep neural networks on mobile devices. IEEE Journal on Emerging and Selected Topics in Circuits and Systems, 9(2):292–308, 2019.

parse/train/LKoMTwTuQnC/LKoMTwTuQnC_content_list.json

@@ -0,0 +1,1115 @@
+[
+    {
+        "type": "text",
+        "text": "Chasing Sparsity in Vision Transformers: An End-to-End Exploration ",
+        "text_level": 1,
+        "bbox": [
+            251,
+            122,
+            753,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tianlong Chen1, Yu Cheng2, Zhe $\\mathbf { G a n } ^ { 2 }$ , Lu Yuan2, Lei Zhang3, Zhangyang Wang1 1University of Texas at Austin, 2Microsoft Corporation, 3International Digital Economy Academy {tianlong.chen,atlaswang}@utexas.edu,{yu.cheng,zhe.gan,luyuan}@microsoft.com leizhangcn@ieee.org ",
+        "bbox": [
+            186,
+            223,
+            825,
+            282
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            335
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vision transformers (ViTs) have recently received explosive popularity, but their enormous model sizes and training costs remain daunting. Conventional posttraining pruning often incurs higher training budgets. In contrast, this paper aims to trim down both the training memory overhead and the inference complexity, without sacrificing the achievable accuracy. We carry out the first-of-its-kind comprehensive exploration, on taking a unified approach of integrating sparsity in ViTs “from end to end”. Specifically, instead of training full ViTs, we dynamically extract and train sparse subnetworks, while sticking to a fixed small parameter budget. Our approach jointly optimizes model parameters and explores connectivity throughout training, ending up with one sparse network as the final output. The approach is seamlessly extended from unstructured to structured sparsity, the latter by considering to guide the prune-and-grow of self-attention heads inside ViTs. We further co-explore data and architecture sparsity for additional efficiency gains by plugging in a novel learnable token selector to adaptively determine the currently most vital patches. Extensive results on ImageNet with diverse ViT backbones validate the effectiveness of our proposals which obtain significantly reduced computational cost and almost unimpaired generalization. Perhaps most surprisingly, we find that the proposed sparse (co-)training can sometimes improve the ViT accuracy rather than compromising it, making sparsity a tantalizing “free lunch”. For example, our sparsified DeiT-Small at $( 5 \\%$ , $5 0 \\%$ ) sparsity for (data, architecture), improves $\\mathbf { 0 . 2 8 \\% }$ top-1 accuracy, and meanwhile enjoys ${ \\bf 4 9 . 3 2 \\% }$ FLOPs and ${ \\bf 4 . 4 \\bar { 0 } \\% }$ running time savings. Our codes are available at https: //github.com/VITA-Group/SViTE. ",
+        "bbox": [
+            232,
+            349,
+            764,
+            667
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            688,
+            312,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent years have seen substantial efforts devoted to scaling deep networks to enormous sizes. Parameter counts are frequently measured in billions rather than millions, with the time and financial outlay necessary to train these models growing in concert. The trend undoubtedly continues with the recent forefront of transformers [1–3] for computer vision tasks. By leveraging self-attention, reducing weight sharing such as convolutions, and feeding massive training data, vision transformers have established many new state-of-the-art (SOTA) records in image classification [1, 2], object detection [4–7], image enhancement [8, 9], and image generation [10–12]. Existing vision transformers and variants, despite the impressive empirical performance, have in general suffered from gigantic parameter-counts, heavy run-time memory usages, and tedious training. That naturally calls for the next step research of slimming their inference and training, without compromising the performance. ",
+        "bbox": [
+            174,
+            713,
+            826,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model compression and efficient learning are no strangers to deep learning researchers, although their exploration in the emerging vision transformer field remains scarce [13]. Among the large variety of compression means [14], sparsity has been one of the central themes since the beginning [15]. ",
+        "bbox": [
+            176,
+            858,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conventional approaches first train dense networks, and then prune a large portion of parameters in the trained networks to zero. Those methods significantly reduce the inference complexity. However, the price is to cost even more significant computational resources and memory footprints at training, since they commonly require (multiple rounds of) re-training to restore the accuracy loss [15–17]. That price becomes particularly prohibitive for vision transformers, whose vanilla one-pass training is already much more tedious, slow, and unstable compared to training standard convolutional networks. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An emerging subfield has explored the prospect of directly training smaller, sparse subnetworks in place of the full networks without sacrificing performance. The key idea is to reuse the sparsity pattern found through pruning and train a sparse network from scratch. The seminal work of lottery ticket hypothesis (LTH) [18] demonstrated that standard dense networks contain sparse matching subnetworks (sometimes called “winning tickets”) capable of training in isolation to full accuracy. In other words, we could have trained smaller networks from the start if only we had known which subnetworks to choose. Unfortunately, LTH requires to empirically find these intriguing subnetworks by an iterative pruning procedure [18–27] , which still cannot get rid of the expensiveness of posttraining pruning. In view of that, follow-up works reveal that sparsity patterns might emerge at the initialization [28, 29], the early stage of training [30, 31], or in dynamic forms throughout training [32–34] by updating model parameters and architecture typologies simultaneously. These efforts shed light on the appealing prospect of “end to end” efficiency from training to inference, by involving sparsity throughout the full learning lifecycle. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper presents the first-of-its-kind comprehensive exploration of integrating sparsity in vision transformers (ViTs) “from end to end”. With (dynamic) sparsity as the unified tool, we can improve the inference efficiency from both model and data perspectives, while also saving training memory costs. Our innovative efforts are unfolded along with the following three thrusts: ",
+        "bbox": [
+            176,
+            367,
+            825,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• From Dense to (Dynamic) Sparse: Our primary quest is to find sparse ViTs without sacrificing the achievable accuracy, and meanwhile trimming down the training memory overhead. To meet this challenging demand, we draw inspirations from the latest sparse training works [34, 35] that dynamically extract and train sparse subnetworks instead of training the full models. Sticking to a fixed small parameter budget, our technique jointly optimizes model parameters and explores connectivity throughout the entire training process. We term our first basic approach as Sparse Vision Transformer Exploration (SViTE). ",
+        "bbox": [
+            217,
+            434,
+            825,
+            531
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• From Unstructured to Structured: Most sparse training works [32, 33, 36–39, 38, 34, 40, 41, 35] restricted discussion to unstructured sparsity. To attain structured sparsity which is more hardware-friendly, unlike classical channel pruning available for convolutional networks, we customize a first-order importance approximation [16, 42] to guide the pruneand-grow of self-attention heads inside ViTs. This seamlessly extends SViTE to its second variant of Structured Sparse Vision Transformer Exploration $\\mathbf { \\left( S ^ { 2 } V i T E \\right) }$ . ",
+        "bbox": [
+            217,
+            536,
+            826,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• From Model to Data: We further conduct a unified co-exploration towards joint data and architecture sparsity. That is by plugging in a novel learnable token selector to determine the most vital patch embeddings in the current input sample. The resultant framework of Sparse Vision Transformer Co-Exploration $\\mathbf { \\eta } ( \\mathbf { S } \\mathbf { V i T E } +$ ) remains to be end-to-end trainable and can gain additional efficiency. ",
+        "bbox": [
+            218,
+            625,
+            825,
+            694
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Extensive experiments are conducted on ImageNet with DeiT-Tiny/Small/Base. Results of substantial computation savings and nearly undamaged accuracies consistently endorse our proposals’ effectiveness. Perhaps most impressively, we find that the sparse (co-)training can even improve the ViT accuracy rather than compromising it, making sparsity a tantalizing “free lunch”. For example, applying $\\mathrm { S V i T E { + } }$ on DeiT-Small produces superior compressed ViTs at $5 0 \\%$ model sparsity plus $5 \\%$ data sparsity, saving $4 9 . 3 2 \\%$ FLOPs and $4 . 4 \\mathrm { { \\bar { 0 } } \\% }$ running time, while attaining a surprising improvement of $0 . 2 8 \\%$ accuracy; even when the data sparsity increases to $1 0 \\%$ (the model sparsity unchanged), there is still no accuracy degradation, meanwhile saving $5 2 . 3 8 \\%$ FLOPs and $7 . { \\bar { 6 3 \\% } }$ running time. ",
+        "bbox": [
+            174,
+            707,
+            826,
+            818
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            837,
+            321,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Vision Transformer. Transformer [43] stems from natural language processing (NLP) applications. The Vision Transformer (ViT) [1] pioneered to leverage a pure transformer, to encode an image by splitting it into a sequence of patches, projecting them into token embeddings, and feeding them to transformer encoders. With sufficient training data, ViT is able to outperform convolution neural networks on various image classification benchmarks [1, 44]. Many ViT variants have been proposed since then. For example, DeiT [2] and T2T-ViT [45] are proposed to enhance ViT’s training data efficiency, by leveraging teacher-student and better crafted architectures respectively. In addition to image classification, ViT has attracted wide attention in diverse computer vision tasks, including object detection [4–7], segmentation [46, 47], enhancement [8, 9], image generation [10–12], video understanding [48, 49], vision-language [50–57] and 3D point cloud [58]. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            189
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Despite the impressive empirical performance, ViTs are generally heavy to train, and the trained models remain massive. That naturally motivates the study to reduce ViT inference and training costs, by considering model compression means. Model compression has been well studied in both computer vision and NLP applications [59–61, 42, 62, 21]. Two concurrent works [13, 63] made initial attempts towards ViT post-training compression by pruning the intermediate features and tokens respectively, but did not jointly consider weight pruning nor efficient training. Another loosely related field is the study of efficient attention mechanisms [64, 10, 52, 65–75]. They mainly reduce the calculation complexity for self-attention modules via various approximations such as low-rank decomposition. Our proposed techniques represent an orthogonal direction and can be potentially combined with them, which we leave as future work. Another latest concurrent work [76] introduced an interpretable module to dynamically and gracefully drop the redundant patches, gaining not only inference efficiency but also interpretability. Being a unique and orthogonal effort from ours, their method did not consider the training efficiency yet. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            375
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pruning and Sparse Training. Pruning is well-known to effectively reduce deep network inference costs [77, 15]. It can be roughly categorized into two groups: $( i )$ unstructured pruning by removing insignificant weight elements per certain criterion, such as weight magnitude [78, 15], gradient [16] and hessian [79]; $( i i )$ structured pruning [80–82] by remove model sub-structures, e.g., channels [80, 81] and attention heads [42], which are often more aligned with hardware efficiency. All above require training the full dense model first, usually for several train-prune-retrain rounds. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            473
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The recent surge of sparse training seeks to adaptively identify high-quality sparse subnetworks and train only them. Starting from scratch, those methods learn to optimize the model weights together with sparse connectivity simultaneously. [32, 33] first introduced the Sparse Evolutionary Training (SET) technique [32], reaching superior performance compared to training with fixed sparse connectivity [83, 36]. [37–39] leverages “weight reallocation\" to improve performance of obtained sparse subnetworks. Furthermore, gradient information from the backward pass is utilized to guide the update of the dynamic sparse connectivity [38, 34], which produces substantial performance gains. The latest investigations [40, 41, 35] demonstrate that more exhaustive exploration in the connectivity space plays a crucial role in the quality of found sparse subnetworks. Current sparse training methods mostly focus on convolutional networks. Most of them discuss unstructured sparsity, except a handful [84, 30] considering training convolutional networks with structured sparsity. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            632
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            651,
+            313,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our SViTE method (and its variants $\\mathbf { S } ^ { \\mathrm { 2 } } \\mathbf { V i T E }$ and $\\mathrm { S V i T E { + } }$ ) is inspired from state-of-the-art sparse training approaches [34, 35] in CNNs. This section presents the sparse exploration of ViT architectures, then shows the detailed procedure of input token selection for extra efficiency gains. ",
+        "bbox": [
+            176,
+            683,
+            825,
+            726
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Sparse ViT Exploration ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            742,
+            379,
+            757
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Revisiting sparse training. Sparse training starts from a randomly sparsified model; after optimizing several iterations, it shrinks a portion of parameters based on pre-defined pruning criterion, and activates new connections w.r.t. grow indicators. After upgrading the sparse topology, it trains the new subnetwork until the next update of the connectivity. An illustration of the overall procedure is shown in Figure 1. The key factors of sparse training are $\\bullet$ sparsity distribution, $\\otimes$ update schedule, $\\otimes$ pruning and $\\bullet$ grow criterion. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notations. For a consistent description, we follow the standard notations in [34, 35]. Let $\\mathcal { D }$ be the training dataset. $b _ { t } \\sim \\mathcal { D }$ is a randomly sampled data batch for iteration $t$ . $f _ { W } ( \\cdot )$ represents the model with parameters $W = ( W ^ { ( 1 ) } , \\cdots , W ^ { ( L ) } )$ , where $W ^ { ( l ) } \\in \\mathbb { R } ^ { N _ { l } } , 1 \\le l \\le L , N _ { l }$ is the number of prunable parameters in the $l _ { \\mathrm { t h } }$ layer, and $L$ denotes the number of transformer layers. Note that the first linear projection layer and the classifier of ViT [1, 2] are not sparsified in our framework. As illust W (l)Q rated in Figure 1(bottom-left), are the weights of the self-atte $W _ { Q } ^ { ( l ) } = \\{ W _ { Q } ^ { ( l , h ) } \\} _ { h = 1 } ^ { H }$ , W (l)K $W _ { K } ^ { ( l ) } = \\{ W _ { K } ^ { ( l , h ) } \\} _ { h = 1 } ^ { H }$ , $W _ { V } ^ { ( l ) } = \\{ W _ { V } ^ { ( l , h ) } \\} _ { h = 1 } ^ { H }$ $l _ { \\mathrm { t h } }$ $W ^ { ( l , 1 ) }$ $W ^ { ( l , 2 ) }$ $W ^ { ( l , 3 ) }$ perceptron (MLP) module in the  collectively represent all the para $l _ { \\mathrm { t h } }$ layer, andters in the $W ^ { ( l ) } =$ $( W _ { Q } ^ { ( l ) } , W _ { K } ^ { ( l ) } , W _ { V } ^ { ( l ) } , \\bar { W } ^ { ( l , 1 ) } , W ^ { ( l , 2 ) } , W ^ { ( \\bar { l } , 3 ) } )$ $l _ { \\mathrm { t h } }$ where $H$ denotes the number of attention heads, and $Q ^ { ( l ) }$ , , and $V ^ { ( l ) }$ are the corresponding input and intermediate features, respectively. Each sparse layer only maintains a fraction $s _ { l } \\in ( 0 , 1 )$ of its connections, and the overall sparsity of a sparse subnetwork is calculated as the ratio of pruned elements to the total parameter counts, i.e., $\\frac { \\sum _ { l } s _ { l } \\times N _ { l } } { \\sum _ { l } N _ { l } }$ ",
+        "bbox": [
+            176,
+            867,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/03c337fe2dadbbacbee28ecd5811945c8d6e72c346d559e7ef61f5a292efe60e.jpg",
+        "image_caption": [
+            "Figure 1: The overall procedure of our proposed sparse ViT exploration framework. Upper Figure: first training ViT for $\\Delta \\mathrm { T }$ iterations, then performing prune-and-grow strategies to explore critical sparse connectivities, repreating until convergence. Bottom Left Figure: enforcing either structured or unstructured sparsity to transformer layers in ViT. Bottom Right Figure: first scoring each input embedding and applying the learnable top- $k$ selection to identify the most informative tokens. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            90,
+            821,
+            356
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            453,
+            826,
+            618
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Sparse Vision Transformer Exploration (SViTE). SViTE explores the unstructured sparse topology in vision transformers. To be specific, we adopt Erdo¨s-Re´nyi [32] as our $\\bullet$ sparsity distribution. The number of parameters in the sparse layer is scaled by $\\begin{array} { r } { 1 - \\frac { n _ { l - 1 } + n _ { l } } { n _ { l - 1 } \\times n _ { l } } } \\end{array}$ , where $n _ { l }$ is the number of neurons at layer l. This distribution allocates higher sparsities to the layers with more parameters by scaling the portion of remaining weights with the sum of the number of output and input neurons/channels. For the $\\otimes$ update schedule, it contains: (i) the update interval $\\Delta \\mathrm { T }$ , which is the number of training iterations between two sparse topology updates; $( i i )$ the end iteration $\\mathrm { T _ { e n d } }$ , indicating when to stop updating the sparsity connectivity, and we set $\\mathrm { T _ { e n d } }$ to $8 0 \\%$ of total training iterations in our experiments; $( i i i )$ the initial fraction $\\alpha$ of connections that can be pruned or $5 0 \\%$ $( i v )$ a decay schedule of the fraction of changeable connections, where a cosine annealing is used, following [34, 35]. During $\\begin{array} { r } { \\dot { f } _ { \\mathrm { d e c a y } } ( t , \\alpha , \\mathrm { T } _ { \\mathrm { e n d } } ) = \\frac { \\alpha } { 2 } ( 1 + \\cos ( \\frac { t \\times \\pi } { \\mathrm { T } _ { \\mathrm { e n d } } } ) ) } \\end{array}$   \neach connectivity update, we choose the weight magnitude as the pruning indicator, and gradient magnitude as $\\bullet$ the grow indicator. Specifically, we eliminate the parameters with the layer-wise smallest weight values by applying a binary mask $m _ { \\mathrm { p r u n e } }$ , then grow new connections with the highest magnitude gradients by generating a new binary mask $m _ { \\mathrm { g r o w } }$ . Both masks are employed to $W ^ { ( l ) }$ via the element-wise dot product, and note that the number of non-zero elements in $m _ { \\mathrm { p r u n e } }$ and $m _ { \\mathrm { g r o w } }$ are equal and fixed across the overall procedure. Newly added connections are not activated in the last sparse topology, and are initialized to zero since it produces better performance as demonstrated in [34, 35]. ",
+        "bbox": [
+            173,
+            637,
+            826,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Infrequent gradient calculation [34] is adopted in our case, which computes the gradients in an online manner and only stores the top gradient values. As illustrated in [34], such fashion amortizes the extra effort of gradient calculation, and makes it still proportional to $1 - s$ as long as $\\Delta \\mathrm { T } \\geq { \\frac { 1 } { 1 - s } }$ where $s$ is the overall sparsity. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            148
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Structured Sparse Vision Transformer Exploration $\\mathbf { ( S ^ { 2 } V i T E ) }$ . Although models with unstructured sparsity achieve superior performance, structured sparsity [80–82] is much more hardware friendly and brings practical efficiency on realistic platforms, which motivates us to propose Structured Sparse ViT Exploration $( \\mathrm { S ^ { 2 } V i T E } )$ . We inherit the design of $\\bullet$ sparsity distribution and $\\otimes$ update schedule from the unstructured SViTE, and a round-up function is used to eliminate decimals in the parameter counting. The key differences lie in the new $\\otimes$ pruning and $\\bullet$ grow strategies. ",
+        "bbox": [
+            173,
+            162,
+            826,
+            247
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pruning criterion: Let $A _ { ( l , h ) }$ denote features computed from the self-attention head {W (l,h)Q , $\\{ W _ { Q } ^ { ( \\mathit { l } , h ) } , W _ { K } ^ { ( \\mathit { l } , h ) } , W _ { V } ^ { ( \\mathit { l } , h ) } \\}$ and input embeddings $X ^ { ( l ) }$ , as shown in Figure 1. We perform the Taylor expansion to the loss function [16, 42], and derive a proxy score for head importance blow: ",
+        "bbox": [
+            173,
+            253,
+            433,
+            358
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Sparse ViT Co-Exploration $\\mathrm { ( S V i T E + ) }$ . ",
+        "text_level": 1,
+        "bbox": [
+            446,
+            258,
+            787,
+            273
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/58ba181dad254fa7766be0d4985c1d4c51271ec9a0e6d2401c857e9e157799ed.jpg",
+        "text": "$$\n\\mathcal { T } _ { p } ^ { ( l , h ) } = \\bigg | A _ { ( l , h ) } ^ { \\mathrm { T } } \\cdot \\frac { \\partial \\mathcal { L } ( X ^ { ( l ) } ) } { \\partial A _ { ( l , h ) } } \\bigg | ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            376,
+            390,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } ( \\cdot )$ is the cross-entropy loss as used in ViT. During each topology update, we remove attention heads with the smallest $\\mathcal { T } _ { p } ^ { ( l , h ) }$ . For MLPs, we score neurons with $\\ell _ { 1 }$ -norm of their associated weight vectors [85], and drop insignificant neurons. For example, the $j _ { \\mathrm { t h } }$ neuron of $W ^ { ( l , 1 ) }$ in Figure 1 has an importance score kW (l,1)j,· k $W _ { j , \\cdot } ^ { ( l , 1 ) }$ is the $j _ { \\mathrm { t h } }$ row $W ^ { ( l , 1 ) }$ , where ",
+        "bbox": [
+            173,
+            420,
+            433,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Initialize: ViT model $f _ { W }$ , Dataset $\\mathcal { D }$ , Sparsity distribution $\\begin{array} { r c l } { \\mathbb { S } } & { = } & { \\{ s _ { 1 } , \\dots , s _ { L } \\} } \\end{array}$ , Update schedule $\\{ \\Delta \\mathrm { T } , \\mathrm { T _ { e n d } } , \\alpha , f _ { \\mathrm { d e c a y } } \\}$ , Learning rate $\\eta$   \n1: Initialize $f _ { W }$ with random sparsity $\\mathbb { S }$ . Highly reduced parameter count.   \n2: for each training iteration $t$ do   \n3: Sampling a batch $b _ { t } \\sim \\mathcal { D }$   \n4: Scoring the input token embeddings and selecting the top- $k$ informative tokens . Token selection   \n5: if $\\mathbf { \\chi } _ { t }$ mod $\\Delta \\mathrm { T } = = 0 \\ \\mathrm { \\Omega }$ ) and $t < \\mathrm { T _ { e n d } }$ then   \n6: for each layer $l$ do   \n7: $\\rho = f _ { \\mathrm { d e c a y } } ( t , \\alpha , \\mathrm { T } _ { \\mathrm { e n d } } ) \\cdot ( 1 - s _ { l } ) \\cdot N _ { l }$   \n8: Performing prune-and-grow with portion $\\rho$ w.r.t. certain criterion, generating masks $m _ { \\mathrm { p r u n e } }$ and $m _ { \\mathrm { g r o w } }$ to update $f _ { W }$ ’s sparsity patterns $\\triangleright$ Connectivity exploration   \n9: end for   \n10: else   \n11: $\\begin{array} { r l r l } { W = W - \\eta \\cdot \\nabla _ { W } \\mathcal { L } _ { t } } & { { } } & { \\triangleright U p d a t i n g \\ W e i g h t s } \\end{array}$   \n12: end if   \n13: end for   \n14: return a sparse ViT with a trained token selector ",
+        "bbox": [
+            449,
+            279,
+            830,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Grow criterion: Similar to [34, 35], we active the new units with the highest ",
+        "bbox": [
+            174,
+            578,
+            431,
+            606
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "magnitude gradients, such as $\\| \\frac { \\partial \\bar { \\mathcal { L } } ( X ^ { ( l ) } ) } { \\partial A _ { ( l , h ) } } \\| _ { \\ell _ { 1 } }$ k\\`1 and $\\| \\frac { \\partial \\mathcal { L } ( X ^ { ( l ) } ) } { \\partial W _ { j , \\cdot } ^ { ( l , 1 ) } } \\| _ { \\ell _ { 1 } }$ for the $h _ { \\mathrm { t h } }$ attention head and the $j _ { \\mathrm { t h } }$ neuron of the MLP $( W ^ { ( l , 1 ) } )$ , respectively. The gradients are calculated in the same manner as the one in unstructured SViTE, and newly added units are also initialized to zero. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            662
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Data and Architecture Sparsity Co-Exploration for Higher Efficiency ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            678,
+            694,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Besides exploring sparse transformer architectures, we further slim the dimension of input token embeddings for extra efficiency bonus by leveraging a learnable token selector, as presented in Figure 1. Meanwhile, the introduced data sparsity also serves as an implicit regularization for ViT training, which potentially leads to improved generalization ability, as evidenced in Table 6. Note that, due to skip connections, the number of input tokens actually determines ",
+        "bbox": [
+            173,
+            705,
+            400,
+            898
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 The top- $k$ selector in a PyTorch-like style. ",
+        "bbox": [
+            415,
+            710,
+            741,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "def topk_selector(logits, k, tau, ${ \\dot { \\mathsf { d i m } } } = - 1 \\cdot$ ): ",
+        "bbox": [
+            415,
+            729,
+            735,
+            742
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "# Maintain tokens with the top-\\$k\\$ highest scores gumbels $=$ -torch.empty_like(logits).exponential_().log() gumbels $=$ (logits $^ +$ gumbels) / tau # tau is the temperature y_soft $=$ gumbels.softmax(dim) # Straight through index $=$ y_soft.topk(k, dim $\\mathbf { \\Psi } _ { 1 } =$ dim)[1] y_hard $=$ scatter(logits, index, k) ret $=$ y_hard - y_soft.detach() $^ +$ y_soft return ret ",
+        "bbox": [
+            415,
+            743,
+            828,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "the dimension of intermediate features, which substantially contributes to the overall computation cost. In other words, the slimmed input token embeddings directly result in compressed intermediate features, and bring substantial efficiency gains. ",
+        "bbox": [
+            181,
+            897,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/0f89d381009b3bfa2398de990ca8bf70baef49b3898f0730f7187c6217692cb4.jpg",
+        "table_caption": [
+            "Table 1: Details of training configurations in our experiments, mainly following the settings in [2]. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Backbone</td><td>Update Schedule{△T,Tend,α,fdecay}</td><td>Batch Size</td><td>Epochs</td><td>Inherited Settings from DeiT[2]</td></tr><tr><td>DeiT-Tiny</td><td>{20000,1200000,0.5,cosine}</td><td>512</td><td>600</td><td>AdamW, 0.0005 × batchsize,cosine decay</td></tr><tr><td>DeiT-Small</td><td>{15000,1200000,0.5,cosine}</td><td>512</td><td>600</td><td>warmup 5 epochs,0.05 weight decay</td></tr><tr><td>DeiT-Base</td><td>{7000,600000,0.5,cosine}</td><td>1024</td><td>600</td><td>0.1 label smoothing,augmentations, etc.</td></tr></table>",
+        "bbox": [
+            176,
+            113,
+            823,
+            167
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            178,
+            823,
+            207
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the input tokens $X ^ { ( 1 ) } \\in \\mathbb { R } ^ { n \\times d }$ , where $n$ denotes the number of tokens to be shrunk, and $d$ is the dimension of each token embedding that keeps unchanged. As shown in Figure 1, all token embeddings are passed through a learnable scorer function which is parameterized by an MLP in our experiments. Then, a selection of the top- $k$ importance scores $( 1 \\leq k \\leq d )$ is applied on top of it, aiming to preserve the significant tokens and remove the useless ones. To optimize parameters of the scorer function, we introduce the popular Gumbel-Softmax [86, 87] and straight-through tricks [88] to enable gradient back-propagation through the top- $k$ selection, which provides an efficient solution to draw samples from a discrete probability distribution. A detailed implementation is in Algorithm 2. ",
+        "bbox": [
+            173,
+            212,
+            825,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The full pipeline of data and architecture co-exploration is summarized in Algorithm 1. We term this approach $\\mathrm { S V i T E { + } }$ . We first feed the randomly sampled data batch to the token selector and pick the top- $k$ informative token embeddings. Then, we alternatively train the sparse ViT for $\\Delta \\mathrm { T }$ iterations and perform prune-and-grow to explore the sparse connectivity in ViTs dynamically. In the end, a sparse ViT model with a trained token selector is returned and ready for evaluation. ",
+        "bbox": [
+            174,
+            330,
+            825,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            414,
+            312,
+            431
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baseline pruning methods. We extend several effective pruning methods from CNN compression as our strong baselines. Unstructured pruning: $( i )$ One-shot weight Magnitude Pruning (OMP) [15], which removes insignificant parameters with the globally smallest weight values; (ii) Gradually Magnitude Pruning (GMP) [17], which seamlessly incorporates gradual pruning techniques within the training process by eliminating a few small magnitude weights per iteration; and (iii) Taylor Pruning (TP) [16], which utilizes the first-order approximation of the training loss to estimate units’ importance for model sparsification. Structured pruning: Salience-based Structured Pruning (SSP). We draw inspiration from [42, 85], and remove sub-modules in ViT (e.g., self-attention heads) by leveraging their weight, activation, and gradient information. Moreover, due to the repetitive architecture of ViT, we can easily reduce the number of transformer layers to create a smaller dense ViT (Small-Dense) baseline that has similar parameter counts to the pruned ViT model. ",
+        "bbox": [
+            173,
+            439,
+            826,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation details. Our experiments are conducted on ImageNet with DeiTTiny/Small/Base backbones. The detailed training configurations are listed in Table 1, which mainly follows the default setups in [2]. All involved customized hyperparameters are tuned via grid search (later shown in Figure 3). For a better exploration of sparsity connectivities, we increase training epochs to 600 for all experiments. GMP [17] has an additional hyperparameter, i.e., the pruning schedule, which starts from $\\frac { 1 } { 6 }$ and ends at ${ \\frac { \\overline { { \\frac { 1 } { 2 } } } } { 2 } }$ of the training epochs with 20 times pruning in total. More details are referred to Appendix A1. ",
+        "bbox": [
+            174,
+            602,
+            472,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training time measuring protocol. We strictly measure the running time saving of ",
+        "bbox": [
+            173,
+            805,
+            472,
+            832
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a5ad90174ff1547fe598c114e7c4b77c1f965a37ed3695b0c6fcde1a09ee9c95.jpg",
+        "image_caption": [
+            "The Overall Performance of SViTE, S 2ViTE, and SViTE+ ",
+            "Figure 2: Top-1 accuracy $( \\% )$ over FLOPs $( \\times 1 0 ^ { 1 0 } )$ on ImageNet of our methods, i.e., SViTE, $\\mathrm { S ^ { 2 } V i T E }$ , and ${ \\mathrm { S V i T E } } +$ compared to DeiT baselines, trained on Imagenet-1K only. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            488,
+            607,
+            818,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(sparse) vision transformers on the ImageNet-1K task using CUDA benchmark mode. To be specific, we separately calculate the time elapsed during each iteration, to eliminate the impact of the hardware environment as much as possible. Note that the time for the data I/O is excluded. ",
+        "bbox": [
+            174,
+            833,
+            826,
+            873
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Highlight of our findings. The overall performance of SViTE, $\\mathbf { S } ^ { \\mathrm { 2 } } \\mathbf { V i T E }$ , and $\\mathrm { S V i T E { + } }$ on DeiT backbones are summarized in Figure 2. We highlight some takeaways below. ",
+        "bbox": [
+            174,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Takeaways: ❶ SViTE produces sparse DeiTs with enhanced generalization and substantial reduced FLOPs, compared to its dense counterpart $( { \\star } )$ . ${ \\mathrm { S V i T E } } +$ further improves the performance of SViTE by selecting the most vital patches. ❷ $\\mathbf { S } ^ { \\mathrm { 2 } } \\mathbf { V i T E }$ achieves matched accuracy on DeiT-Small, and significantly enhances performance on DeiT-Base. Meanwhile, its structural sparsity brings considerable running time savings. $\\otimes$ Appropriate data and architecture sparsities can effectively regularize ViT training, leading to a new SOTA win-win between ViT accuracy and efficiency. ",
+        "bbox": [
+            176,
+            90,
+            828,
+            178
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 SViTE with Unstructured Sparsity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            199,
+            452,
+            214
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We perform SViTE to mine vital unstructured sparsity in DeiTs [2]. Solid lines in Figure 2 record the top-1 test-set accuracy over FLOPs on ImageNet-1K of SViTE-Small and SViTE-Base with a range of sparsity from $3 0 \\%$ to $7 0 \\%$ . In general, we observe that SViTE generates superior sparse ViTs with both accuracy and efficiency gains. Table 2, 3, and 5 present the comparison between SViTE and various pruning baselines. From these extensive results, we draw several consistent observations. First, compared to the dense baselines, SViTE-Tiny, -Small, and -Base obtain $2 5 . 5 6 \\% \\sim 3 4 . 1 6 \\%$ , $4 6 . 2 6 \\% \\sim 5 5 . 4 4 \\%$ , and $4 7 . 9 5 \\% \\sim 5 7 . 5 0 \\%$ FLOPs reduction, respectively, at $3 0 \\% \\sim 6 0 \\%$ sparsity levels with only a negligible accuracy drop within $0 . 5 \\%$ . It verifies the effectiveness of our proposal, and indicates severe parameter redundancy in ViT. Second, our SViTE models from dynamic explorations consistently surpass other competitive baseline methods, including OMP, GMP, TP, and Small-Dense by a substantial performance margin. Among all the baseline approaches, GMP that advocates a gradual pruning schedule achieves the best accuracy with all three DeiT backbones. Third, in Figure 2, both SViTE-Small (blue solid line) and SViTE-Base (green solid line) show an improved trade-off between accuracy and efficiency, compared to their dense DeiT counterparts. Interestingly, we also observe that with similar parameter counts, a large sparse ViT consistently outperforms the corresponding smaller dense ViT. A possible explanation is those appropriate sparse typologies regularize network training and lead to enhanced generalization, which coincides with recent findings of critical subnetworks (i.e., winning tickets) in dense CNNs [89, 22] and NLP transformer [21, 90] models. ",
+        "bbox": [
+            173,
+            224,
+            825,
+            486
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/08efc9ac71a6d77f0025d863cb9df9efc84a9ec33de6ce08abe47b7a987eef3b.jpg",
+        "table_caption": [
+            "Table 2: Results of SViTE-Tiny on ImageNet-1K. Accuracies $( \\% )$ within/out of parenthesis are the reproduced/reported [2] performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Sparsity (#Para.)</td><td>FLOPs Saving</td><td>Accuracy (%)</td></tr><tr><td>DeiT-Tiny</td><td>0% (5.72M)</td><td>0%</td><td>72.20 (71.80)</td></tr><tr><td>SViTE-Tiny</td><td>30% (4.02M)</td><td>25.56%</td><td>71.78</td></tr><tr><td>OMP</td><td>30% (4.02M)</td><td>25.56%</td><td>68.35</td></tr><tr><td>GMP</td><td>30% (4.02M)</td><td>25.56%</td><td>69.56</td></tr><tr><td>TP</td><td>30% (4.02M)</td><td>25.56%</td><td>68.38</td></tr><tr><td>SViTE-Tiny</td><td>40% (3.46M)</td><td>34.16%</td><td>71.75</td></tr><tr><td>OMP</td><td>40% (3.46M)</td><td>34.16%</td><td>66.52</td></tr><tr><td>GMP</td><td>40% (3.46M)</td><td>34.15%</td><td>68.36</td></tr><tr><td>TP</td><td>40% (3.46M)</td><td>34.17%</td><td>65.45</td></tr><tr><td>Small-Dense</td><td>0% (3.94M)</td><td>32.54%</td><td>67.33</td></tr></table>",
+        "bbox": [
+            176,
+            529,
+            493,
+            657
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/816fcda684feef4194c0cc774f5f2ee9b3971d35729300758bcabab40dd55fe8.jpg",
+        "table_caption": [
+            "Table 3: Results of SViTE-Small on ImageNet-1K. Accuracies $( \\% )$ within/out of parenthesis are the reproduced/reported [2] performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Sparsity (#Para.)</td><td>FLOPs Saving</td><td>Accuracy (%)</td></tr><tr><td>DeiT-Small</td><td>0% (22.1M)</td><td>0%</td><td>79.90 (79.78)</td></tr><tr><td>SViTE-Small</td><td>50% (11.1M)</td><td>46.26%</td><td>79.72</td></tr><tr><td>OMP</td><td>50% (11.1M)</td><td>46.25%</td><td>76.32</td></tr><tr><td>GMP</td><td>50% (11.1M)</td><td>46.26%</td><td>76.88</td></tr><tr><td>TP</td><td>50% (11.1M)</td><td>46.26%</td><td>76.30</td></tr><tr><td> SViTE-Small</td><td>60% (8.9M)</td><td>55.44%</td><td>79.41</td></tr><tr><td>OMP</td><td>60% (8.9M)</td><td>55.44%</td><td>75.32</td></tr><tr><td>GMP</td><td>60% (8.9M)</td><td>55.44%</td><td>76.79</td></tr><tr><td>TP</td><td>60% (8.9M)</td><td>55.44%</td><td>74.50</td></tr><tr><td>Small-Dense</td><td>0% (11.4M)</td><td>49.32%</td><td>73.93</td></tr></table>",
+        "bbox": [
+            508,
+            529,
+            825,
+            656
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/5d5ed755d309b5b29b419455ac8775093c6ae72f8244f04c130e06cbeeff4bea.jpg",
+        "table_caption": [
+            "Table 4: Results of $\\mathrm { S ^ { 2 } V i T E }$ with structured sparsity on ImageNet-1K with DeiT-Tiny/Small/Base. Accuracies $( \\% )$ within/out of parenthesis are the reproduced/reported [2] performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Sparsity (%)</td><td>Parameters</td><td>FLOPs Saving</td><td>Running Time Reduced|Top-1 Accuracy (%)</td><td></td></tr><tr><td>DeiT-Tiny (Dense)</td><td>0%</td><td>5.72M</td><td>0%</td><td>0%</td><td>72.20 (71.80)</td></tr><tr><td>SViTE-Tiny (Unstructured)</td><td>30%</td><td>4.02M</td><td>25.56%</td><td>0%</td><td>71.78</td></tr><tr><td>SSP-Tiny (Structured)</td><td>30%</td><td>4.21M</td><td>23.69%</td><td>10.57%</td><td>68.59</td></tr><tr><td>S2ViTE-Tiny (Structured)</td><td>30%</td><td>4.21M</td><td>23.69%</td><td>10.57%</td><td>70.12</td></tr><tr><td>DeiT-Small (Dense)</td><td>0%</td><td>22.1M</td><td>0%</td><td>0%</td><td>79.90 (79.78)</td></tr><tr><td>SViTE-Small (Unstructured)</td><td>40%</td><td>13.3M</td><td>36.73%</td><td>0%</td><td>80.26</td></tr><tr><td>SSP-Small (Structured)</td><td>40%</td><td>14.6M</td><td>31.63%</td><td>22.65%</td><td>77.74</td></tr><tr><td>S²ViTE-Small (Structured)</td><td>40%</td><td>14.6M</td><td>31.63%</td><td>22.65%</td><td>79.22</td></tr><tr><td>DeiT-Base (Dense)</td><td>0%</td><td>86.6M</td><td>0%</td><td>0%</td><td>81.80 (80.98)</td></tr><tr><td>SViTE-Base (Unstructured)</td><td>40%</td><td>52.0M</td><td>38.30%</td><td>0%</td><td>81.56</td></tr><tr><td>SSP-Base (Structured)</td><td>40%</td><td>56.8M</td><td>33.13%</td><td>24.70%</td><td>80.08</td></tr><tr><td>S2ViTE-Base (Structured)</td><td>40%</td><td>56.8M</td><td>33.13%</td><td>24.70%</td><td>82.22</td></tr></table>",
+        "bbox": [
+            176,
+            689,
+            825,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 $\\mathbf { S } ^ { 2 }$ ViTE with Structured Sparsity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            442,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For more practical benefits, we investigate sparse DeiTs with structured sparsity. Results are summarized in Table 4. Besides the obtained $2 3 . { \\bar { 7 } } 9 \\% \\sim 3 3 . 6 3 \\%$ FLOPs savings, ${ \\mathsf { S } } ^ { \\tilde { 2 } }$ ViTE-Tiny, $S ^ { 2 }$ ViTE",
+        "bbox": [
+            174,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Small, and $S ^ { 2 }$ ViTE-Base enjoy an extra $1 0 . 5 7 \\%$ , $2 2 . 6 5 \\%$ , and $2 4 . 7 0 \\%$ running time reduction, respectively, from $3 0 \\% \\sim \\hat { 4 } 0 \\%$ structured sparsity with competitive top-1 accuracies. Furthermore, $\\mathrm { S ^ { 2 } V i T E }$ consistently outperforms the baseline structured pruning method (SSP), which again demonstrates the superior sparse connectivity learned from dynamic sparse training. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The most impressive results come from $S ^ { 2 }$ ViTE-Base at $4 0 \\%$ structured sparsity. It even surpasses the dense DeiT base model by $0 . 4 2 \\% \\sim 1 . 2 4 \\%$ accuracy with $3 4 . 4 1 \\%$ parameter counts, $3 3 . 1 3 \\%$ FLOPs, and $2 4 . 7 0 \\%$ running time reductions. We conclude that $( i )$ an adequate sparsity from $\\mathbf { S } ^ { \\mathrm { 2 } } \\mathbf { V i T E }$ boosts ViT’s generalization ability, which can be regarded as an implicit regularization; $( i i )$ larger ViTs (e.g., DeiT-Base) tend to have more superfluous self-attention heads, and are more amenable to structural sparsification from $\\mathbf { S } ^ { \\mathrm { 2 } } \\mathbf { V i T E }$ , based on Figure 2 where dash lines denote the overall performance of $\\hat { \\mathbf { S } ^ { 2 } }$ ViTE-Small and $S ^ { 2 }$ ViTE-Base with a range of sparsity from $3 0 \\%$ to $7 0 \\%$ . ",
+        "bbox": [
+            173,
+            152,
+            825,
+            251
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/facf8afddb44ba3a8d72c8cb6b4b90dee343464081b964fc00623ae2fe190bc3.jpg",
+        "table_caption": [
+            "Table 5: Results of SViTE-Base on ImageNet-1K. Accuracies $( \\% )$ within/out of parenthesis are the reproduced/reported [2] performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Sparsity (#Para.)</td><td>FLOPs Saving|Accuracy (%)</td><td></td></tr><tr><td>DeiT-Base</td><td>0% (86.6M)</td><td>0%</td><td>81.80 (80.98)</td></tr><tr><td>SViTE-Base</td><td>50% (43.4M)</td><td>47.95%</td><td>81.51</td></tr><tr><td>OMP</td><td>50% (43.4M)</td><td>47.94%</td><td>80.26</td></tr><tr><td>GMP</td><td>50% (43.4M)</td><td>47.95%</td><td>80.79</td></tr><tr><td>TP</td><td>50% (43.4M)</td><td>47.94%</td><td>80.55</td></tr><tr><td>SViTE-Base</td><td>60% (34.8M)</td><td>57.50%</td><td>81.28</td></tr><tr><td>OMP</td><td>60% (34.8M)</td><td>57.50%</td><td>80.25</td></tr><tr><td>GMP</td><td>60% (34.8M)</td><td>57.50%</td><td>80.44</td></tr><tr><td>TP</td><td>60% (34.8M)</td><td>57.49%</td><td>80.37</td></tr><tr><td>Small-Dense</td><td>0% (44.0M)</td><td>49.46%</td><td>78.59</td></tr></table>",
+        "bbox": [
+            176,
+            296,
+            500,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/2882166a73083b210a64df1d75c08fbb72b1f4c341db6ad565dde75f4e195c5c.jpg",
+        "table_caption": [
+            "Table 6: Results of SViTE $^ +$ -Small on ImageNet-1K. Accuracies $( \\% )$ within/out of parenthesis are the reproduced/reported [2] performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>#Tokens (%)|Time ReducedFLOPs Saving|Accuracy (%)</td><td></td></tr><tr><td colspan=\"4\">SViTE+-Small 50% Unstructured Sparsity</td></tr><tr><td>100%</td><td>0%</td><td>46.26%</td><td>79.72</td></tr><tr><td>95%</td><td>4.40%</td><td>49.32%</td><td>80.18</td></tr><tr><td>90%</td><td>7.63%</td><td>52.38%</td><td>79.91</td></tr><tr><td>70%</td><td>19.77%</td><td>63.95%</td><td>77.90</td></tr><tr><td colspan=\"4\">S²ViTE+-Small 40% Structured Sparsity</td></tr><tr><td>100%</td><td>22.65%</td><td>31.63%</td><td>79.22</td></tr><tr><td>95%</td><td>27.17%</td><td>37.76%</td><td>78.44</td></tr><tr><td>90%</td><td>29.21%</td><td>41.50%</td><td>78.16</td></tr><tr><td>70%</td><td>39.10%</td><td>54.96%</td><td>74.77</td></tr></table>",
+        "bbox": [
+            508,
+            294,
+            825,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 $\\mathbf { S V i T E { + } }$ with Data and Architecture Sparsity Co-Exploration ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            436,
+            637,
+            452
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study data and architecture sparsity co-exploration for ViTs, i.e., $\\mathrm { S V i T E { + } }$ . Blessed by the reduced input token embeddings, even ViTs with unstructured sparsity can have running time savings. The benefits are mainly from the shrunk input and intermediate feature dimensions. Without loss of generality, we consider SViTE $+ \\cdot$ -Small with $5 0 \\%$ unstructured sparsity and ${ \\mathrm { S ^ { 2 } V i T E } } +$ -Small with $4 0 \\%$ structured sparsity as examples. As shown in Table 6 and Figure 2, SViTE+-Small at $5 0 \\%$ unstructured sparsity is capable of abandoning $5 \\% \\sim 1 0 \\%$ tokens while achieving $4 . 4 0 \\% \\sim 7 . 6 3 \\%$ running time and $4 9 . 3 2 \\% \\sim 5 2 . 3 8 \\%$ FLOPs savings, with even improved top-1 testing accuracy. It again demonstrates that data sparsity as an implicit regularizer plays a beneficial role in ViT training. However, slimming input and intermediate embedding is less effective when incorporated with $\\mathbf { S } ^ { \\mathrm { 2 } } \\mathbf { V i T E }$ , suggesting that aggressively removing structural sub-modules hurts ViT’s generalization. ",
+        "bbox": [
+            173,
+            462,
+            826,
+            601
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Ablation and Generalization Study of SViTEs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            616,
+            529,
+            631
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Update interval in SViTE. The length of the update interval $\\Delta \\mathrm { T }$ controls one of the essential tradeoffs in our proposed dynamic sparse exploration, since $\\Delta \\mathrm { T }$ multiplying the number of updates is the pre-defined $\\mathrm { T _ { e n d } }$ . On the one hand, a larger updated interval (i.e., smaller update frequency) produces a more well-trained model for improved estimation of units’ importance. On the other hand, a larger update frequency (i.e., smaller $\\Delta \\mathrm { T }$ ) allows more sufficient exploration of sparse connectivities, which potentially generates higher-quality sparse subnetworks, as demonstrated in [35]. We evaluate this factor in our SViTE context, and collect the results in Figure 3 (Left). We observe that $\\Delta \\mathrm { T } = 2 0 0 0 0$ works the best for SViTE-Tiny, and both larger and smaller $\\Delta \\mathrm { T }$ degrade the performance. ",
+        "bbox": [
+            173,
+            641,
+            826,
+            753
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a4655f90e93b2c9a04681fc021da3282c731aba6f4cba193b459acd0b25f0153.jpg",
+        "image_caption": [
+            "Figure 3: Accuracy of SViTE-Tiny with $5 0 \\%$ unstructured sparsity. Left: ablation studies of the update interval $( \\bar { \\Delta \\mathrm { T } } )$ ; Right: ablations studies of the adopted batch size $( b )$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            758,
+            813,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/20204951e060810529cbad9a007da6259808df546d2c9563a4a457ffbdf0a012.jpg",
+        "image_caption": [
+            "Dense DeiT-Base "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            90,
+            388,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/33e5e064c5dba74ca99e27db03615dbf08bda7f2b81b68715098af3c25c6d603.jpg",
+        "image_caption": [
+            "-Base with $4 0 \\%$ Structured Sparsity "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            395,
+            92,
+            604,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/fcf8ae89303d80f050af5c5ed88ce6e7bc4eee6a2db8431edf4a7768d4fc9049.jpg",
+        "image_caption": [
+            "SViTE-Base with $4 0 \\%$ Unstructured Sparsity "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            609,
+            90,
+            820,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/a0e0619f2f06fe582065a11779901de10112cfc6477c8e3ec5b96052b7f80f29.jpg",
+        "image_caption": [
+            "Figure 4: Attention probabilities for DeiT-Base, $S ^ { 2 }$ ViTE-Base, and SViTE-Base models with 12 layers (rows) and 12 heads (columns) using visualization tools provided in [94]. Attention maps are averaged over 100 test samples from ImageNet-1K to present head behavior and remove the dependence on the input content. The black square is the query pixel. indicates pruned attention heads. Zoom-in for better visibility. ",
+            "Figure 5: Learned patch selection patterns of SViTE $+$ -Small at $1 0 \\%$ data and $5 0 \\%$ architecture sparsity levels. $\\widehat { \\mathbb { I } }$ indicates removed inessential patches. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            318,
+            820,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Batch size in SViTE. Besides the update interval $\\Delta \\mathrm { T }$ , batch size (b) also affects the aforementioned trade-off, especially for the data-hungry ViT training. We investigate different batch sizes in Figure 3 (Right), and find that $b = 5 1 2$ outperforms other common options for SViTE-Tiny. ",
+        "bbox": [
+            176,
+            479,
+            823,
+            522
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Generalization study of SViTE and its variants. It is worth mentioning that our proposed frameworks (SViTE, $\\mathrm { S ^ { 2 } V i T E }$ , $\\mathrm { S V i T E { + } }$ ) are independent of the backbone architectures, and can be easily plugged in other vision transformer models [91, 45, 92, 93]. We implemented both SViTE and ${ \\bar { \\mathbf { S } } } ^ { 2 }$ ViTE on TNT-S [91]. SViTE-TNT-S gains 0.13 accuracy improvements (Ours: 81.63 v.s. TNT-S: 81.50) and $3 7 . 5 4 \\%$ FLOPs savings at $4 0 \\%$ unstructured sparsity; $S ^ { 2 }$ ViTE-TNT-S obtains $3 2 . 9 6 \\%$ FLOPs and $2 3 . 7 1 \\%$ running time reductions at $4 0 \\%$ structured sparsity with almost unimpaired accuracy (Ours: 81.34 v.s. TNT-S:81.50). ",
+        "bbox": [
+            174,
+            537,
+            825,
+            635
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 Visualization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            651,
+            303,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sparse connectivity patterns. We provide unit-wise and element-wise heatmap visualizations for SViTE-Base with $4 0 \\%$ structured sparsity in Figure A7 (in Appendix). Similarly, element-wise heatmap visualizations of SViTE-Base with $5 0 \\%$ unstructured sparsity are displayed in Figure A6. We find that even unstructured sparsity exploration can develop obvious structural patterns (i.e., “vertical lines” in mask heatmaps), which implies a stronger potential for hardware speedup [95]. ",
+        "bbox": [
+            173,
+            678,
+            825,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Self-attention heatmaps. As shown in Figure 4, we utilize tools in [94] to visualize attention maps of (sparse) ViTs. Multiple attention heads show similar behaviors, which implies the structural redundancy. Fortunately, $\\mathbf { S } ^ { \\mathrm { 2 } } \\mathbf { V i T E }$ eliminates unnecessary heads to some extent. With regard to SViTE-Base’s visual results, it seems to activate fewer attention heads for predictions (darker colors mean larger values), compared to the ones of dense DeiT-Base. We also observe that in the bottom layers, the attention probabilities are more centered at several heads; while in the top layers, the attention probabilities are more uniformly distributed. This kind of tendency is well preserved by our sparse ViT (SViTE) from Dense ViTs. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Learned patch selection patterns. Figure 5 presents the learned behaviors of our token selector in SViTE+. We observe that the useless removed patches are typically distributed around the main object or in the background. Meanwhile, the patches within the objects of interest are largely persevered, which evidences the effectiveness of our learned patch token selector. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion and Discussion of Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            135,
+            588,
+            151
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce sparse ViT exploration algorithms, SViTE, and its variants $\\mathbf { S } ^ { \\mathrm { 2 } } \\mathbf { V i T E }$ and ${ \\mathrm { S V i T E } } +$ , to explore high-quality sparse patterns in both ViT’s architecture and input token embeddings, alleviating training memory bottleneck and pursuing inference ultra-efficiency (e.g., running time and FLOPs). Comprehensive experiments on ImageNet validate the effectiveness of our proposal. Our informative visualizations further demonstrate that $\\mathrm { S V i T E { + } }$ is capable of mining crucial connections and input tokens by eliminating redundant units and dropping useless token embeddings. Future work includes examining the performance of our sparse ViTs on incoming hardware accelerators [96–100], which will provide better supports for sparsity. ",
+        "bbox": [
+            174,
+            162,
+            825,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work is scientific in nature, and we do not believe it has immediate negative societal impacts. Our findings of sparse vision transformers are highly likely to reduce both memory and energy costs substantially, leading to economic deployment in real-world applications (e.g., on smartphones). ",
+        "bbox": [
+            176,
+            280,
+            825,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgment ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            335,
+            321,
+            352
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Z.W. is in part supported by an NSF RTML project (#2053279). ",
+        "bbox": [
+            174,
+            359,
+            593,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            395,
+            266,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   \n[2] Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, and Hervé Jégou. Training data-efficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   \n[3] Kai Han, Yunhe Wang, Hanting Chen, Xinghao Chen, Jianyuan Guo, Zhenhua Liu, Yehui Tang, An Xiao, Chunjing Xu, Yixing Xu, et al. A survey on visual transformer. arXiv preprint arXiv:2012.12556, 2020.   \n[4] Minghang Zheng, Peng Gao, Xiaogang Wang, Hongsheng Li, and Hao Dong. End-to-end object detection with adaptive clustering transformer. arXiv preprint arXiv:2011.09315, 2020.   \n[5] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision, pages 213–229. Springer, 2020.   \n[6] Zhigang Dai, Bolun Cai, Yugeng Lin, and Junying Chen. Up-detr: Unsupervised pre-training for object detection with transformers. arXiv preprint arXiv:2011.09094, 2020.   \n[7] Xizhou Zhu, Weijie Su, Lewei Lu, Bin Li, Xiaogang Wang, and Jifeng Dai. Deformable {detr}: Deformable transformers for end-to-end object detection. In International Conference on Learning Representations, 2021.   \n[8] Hanting Chen, Yunhe Wang, Tianyu Guo, Chang Xu, Yiping Deng, Zhenhua Liu, Siwei Ma, Chunjing Xu, Chao Xu, and Wen Gao. Pre-trained image processing transformer. arXiv preprint arXiv:2012.00364, 2020.   \n[9] Fuzhi Yang, Huan Yang, Jianlong Fu, Hongtao Lu, and Baining Guo. Learning texture transformer network for image super-resolution. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 5791–5800, 2020.   \n[10] Niki Parmar, Ashish Vaswani, Jakob Uszkoreit, Lukasz Kaiser, Noam Shazeer, Alexander Ku, and Dustin Tran. Image transformer. In International Conference on Machine Learning, pages 4055–4064. PMLR, 2018.   \n[11] Mark Chen, Alec Radford, Rewon Child, Jeffrey Wu, Heewoo Jun, David Luan, and Ilya Sutskever. Generative pretraining from pixels. In Hal Daumé III and Aarti Singh, editors, Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pages 1691–1703. PMLR, 13–18 Jul 2020.   \n[12] Yifan Jiang, Shiyu Chang, and Zhangyang Wang. Transgan: Two transformers can make one strong gan. arXiv preprint arXiv:2102.07074, 2021.   \n[13] Mingjian Zhu, Kai Han, Yehui Tang, and Yunhe Wang. Visual transformer pruning, 2021.   \n[14] Yu Cheng, Duo Wang, Pan Zhou, and Tao Zhang. A survey of model compression and acceleration for deep neural networks. arXiv preprint arXiv:1710.09282, 2017.   \n[15] Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In International Conference on Learning Representations, 2016.   \n[16] Pavlo Molchanov, Arun Mallya, Stephen Tyree, Iuri Frosio, and Jan Kautz. Importance estimation for neural network pruning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 11264–11272, 2019.   \n[17] Michael Zhu and Suyog Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. arXiv preprint arXiv:1710.01878, 2017.   \n[18] Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2018.   \n[19] Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M Roy, and Michael Carbin. Linear mode connectivity and the lottery ticket hypothesis. arXiv preprint arXiv:1912.05671, 2019.   \n[20] Zhenyu Zhang, Xuxi Chen, Tianlong Chen, and Zhangyang Wang. Efficient lottery ticket finding: Less data is more. In Marina Meila and Tong Zhang, editors, Proceedings of the 38th International Conference on Machine Learning, volume 139 of Proceedings of Machine Learning Research, pages 12380–12390. PMLR, 18–24 Jul 2021.   \n[21] Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Zhangyang Wang, and Michael Carbin. The lottery ticket hypothesis for pre-trained bert networks. arXiv preprint arXiv:2007.12223, 2020.   \n[22] Tianlong Chen, Jonathan Frankle, Shiyu Chang, Sijia Liu, Yang Zhang, Michael Carbin, and Zhangyang Wang. The lottery tickets hypothesis for supervised and self-supervised pre-training in computer vision models. arXiv preprint arXiv:2012.06908, 2020.   \n[23] Xuxi Chen, Zhenyu Zhang, Yongduo Sui, and Tianlong Chen. {GAN}s can play lottery tickets too. In International Conference on Learning Representations, 2021.   \n[24] Haoyu Ma, Tianlong Chen, Ting-Kuei Hu, Chenyu You, Xiaohui Xie, and Zhangyang Wang. Good students play big lottery better. arXiv preprint arXiv:2101.03255, 2021.   \n[25] Zhe Gan, Yen-Chun Chen, Linjie Li, Tianlong Chen, Yu Cheng, Shuohang Wang, and Jingjing Liu. Playing lottery tickets with vision and language. arXiv preprint arXiv:2104.11832, 2021.   \n[26] Tianlong Chen, Yongduo Sui, Xuxi Chen, Aston Zhang, and Zhangyang Wang. A unified lottery ticket hypothesis for graph neural networks. arXiv preprint arXiv:2102.06790, 2021.   \n[27] Tianlong Chen, Yu Cheng, Zhe Gan, Jingjing Liu, and Zhangyang Wang. Ultra-dataefficient gan training: Drawing a lottery ticket first, then training it toughly. arXiv preprint arXiv:2103.00397, 2021.   \n[28] Namhoon Lee, Thalaiyasingam Ajanthan, and Philip Torr. Snip: Single-shot network pruning based on connection sensitivity. In International Conference on Learning Representations, 2019.   \n[29] Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. In International Conference on Learning Representations, 2020.   \n[30] Haoran You, Chaojian Li, Pengfei Xu, Yonggan Fu, Yue Wang, Xiaohan Chen, Richard G. Baraniuk, Zhangyang Wang, and Yingyan Lin. Drawing early-bird tickets: Toward more efficient training of deep networks. In International Conference on Learning Representations, 2020.   \n[31] Xiaohan Chen, Yu Cheng, Shuohang Wang, Zhe Gan, Zhangyang Wang, and Jingjing Liu. Earlybert: Efficient bert training via early-bird lottery tickets. arXiv preprint arXiv:2101.00063, 2020.   \n[32] 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):1–12, 2018.   \n[33] Shiwei Liu, Decebal Constantin Mocanu, Amarsagar Reddy Ramapuram Matavalam, Yulong Pei, and Mykola Pechenizkiy. Sparse evolutionary deep learning with over one million artificial neurons on commodity hardware. Neural Computing and Applications, 2020.   \n[34] Utku Evci, Trevor Gale, Jacob Menick, Pablo Samuel Castro, and Erich Elsen. Rigging the lottery: Making all tickets winners. In International Conference on Machine Learning, pages 2943–2952. PMLR, 2020.   \n[35] Shiwei Liu, Lu Yin, Decebal Constantin Mocanu, and Mykola Pechenizkiy. Do we actually need dense over-parameterization? in-time over-parameterization in sparse training. arXiv preprint arXiv:2102.02887, 2021.   \n[36] Utku Evci, Fabian Pedregosa, Aidan Gomez, and Erich Elsen. The difficulty of training sparse neural networks. arXiv preprint arXiv:1906.10732, 2019.   \n[37] Hesham Mostafa and Xin Wang. Parameter efficient training of deep convolutional neural networks by dynamic sparse reparameterization. In International Conference on Machine Learning, 2019.   \n[38] Tim Dettmers and Luke Zettlemoyer. Sparse networks from scratch: Faster training without losing performance. arXiv preprint arXiv:1907.04840, 2019.   \n[39] Shiwei Liu, Decebal Constantin Mocanu, Yulong Pei, and Mykola Pechenizkiy. Selfish sparse rnn training. arXiv preprint arXiv:2101.09048, 2021.   \n[40] Siddhant Jayakumar, Razvan Pascanu, Jack Rae, Simon Osindero, and Erich Elsen. Top-kast: Top-k always sparse training. Advances in Neural Information Processing Systems, 33, 2020.   \n[41] Md Aamir Raihan and Tor M Aamodt. Sparse weight activation training. arXiv preprint arXiv:2001.01969, 2020.   \n[42] Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one?, 2019.   \n[43] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pages 5998–6008, 2017.   \n[44] Jianyuan Guo, Kai Han, Han Wu, Chang Xu, Yehui Tang, Chunjing Xu, and Yunhe Wang. Cmt: Convolutional neural networks meet vision transformers. arXiv preprint arXiv:2107.06263, 2021.   \n[45] Li Yuan, Yunpeng Chen, Tao Wang, Weihao Yu, Yujun Shi, Zihang Jiang, Francis EH Tay, Jiashi Feng, and Shuicheng Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. arXiv preprint arXiv:2101.11986, 2021.   \n[46] Huiyu Wang, Yukun Zhu, Hartwig Adam, Alan Yuille, and Liang-Chieh Chen. Max-deeplab: End-to-end panoptic segmentation with mask transformers. arXiv preprint arXiv:2012.00759, 2020.   \n[47] Yuqing Wang, Zhaoliang Xu, Xinlong Wang, Chunhua Shen, Baoshan Cheng, Hao Shen, and Huaxia Xia. End-to-end video instance segmentation with transformers. arXiv preprint arXiv:2011.14503, 2020.   \n[48] Yanhong Zeng, Jianlong Fu, and Hongyang Chao. Learning joint spatial-temporal transformations for video inpainting. In European Conference on Computer Vision, pages 528–543. Springer, 2020.   \n[49] Luowei Zhou, Yingbo Zhou, Jason J Corso, Richard Socher, and Caiming Xiong. End-to-end dense video captioning with masked transformer. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8739–8748, 2018.   \n[50] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. arXiv preprint arXiv:1908.02265, 2019.   \n[51] Hao Tan and Mohit Bansal. Lxmert: Learning cross-modality encoder representations from transformers. arXiv preprint arXiv:1908.07490, 2019.   \n[52] Yen-Chun Chen, Linjie Li, Licheng Yu, Ahmed El Kholy, Faisal Ahmed, Zhe Gan, Yu Cheng, and Jingjing Liu. Uniter: Universal image-text representation learning. In European Conference on Computer Vision, pages 104–120. Springer, 2020.   \n[53] Weijie Su, Xizhou Zhu, Yue Cao, Bin Li, Lewei Lu, Furu Wei, and Jifeng Dai. Vl-bert: Pre-training of generic visual-linguistic representations. arXiv preprint arXiv:1908.08530, 2019.   \n[54] Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, and Kai-Wei Chang. Visualbert: A simple and performant baseline for vision and language. arXiv preprint arXiv:1908.03557, 2019.   \n[55] Gen Li, Nan Duan, Yuejian Fang, Ming Gong, and Daxin Jiang. Unicoder-vl: A universal encoder for vision and language by cross-modal pre-training. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 11336–11344, 2020.   \n[56] Xiujun Li, Xi Yin, Chunyuan Li, Pengchuan Zhang, Xiaowei Hu, Lei Zhang, Lijuan Wang, Houdong Hu, Li Dong, Furu Wei, et al. Oscar: Object-semantics aligned pre-training for vision-language tasks. In European Conference on Computer Vision, pages 121–137. Springer, 2020.   \n[57] Luowei Zhou, Hamid Palangi, Lei Zhang, Houdong Hu, Jason Corso, and Jianfeng Gao. Unified vision-language pre-training for image captioning and vqa. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 34, pages 13041–13049, 2020.   \n[58] Hengshuang Zhao, Li Jiang, Jiaya Jia, Philip Torr, and Vladlen Koltun. Point transformer. arXiv preprint arXiv:2012.09164, 2020.   \n[59] Angela Fan, Edouard Grave, and Armand Joulin. Reducing transformer depth on demand with structured dropout. In International Conference on Learning Representations, 2020.   \n[60] Fu-Ming Guo, Sijia Liu, Finlay S Mungall, Xue Lin, and Yanzhi Wang. Reweighted proximal pruning for large-scale language representation. arXiv preprint arXiv:1909.12486, 2019.   \n[61] Prakhar Ganesh, Yao Chen, Xin Lou, Mohammad Ali Khan, Yin Yang, Deming Chen, Marianne Winslett, Hassan Sajjad, and Preslav Nakov. Compressing large-scale transformer-based models: A case study on bert. arXiv preprint arXiv:2002.11985, 2020.   \n[62] J. S. McCarley, Rishav Chakravarti, and Avirup Sil. Structured pruning of a bert-based question answering model. arXiv preprint arXiv:1910.06360, 2019.   \n[63] Yehui Tang, Kai Han, Yunhe Wang, Chang Xu, Jianyuan Guo, Chao Xu, and Dacheng Tao. Patch slimming for efficient vision transformers. arXiv preprint arXiv:2106.02852, 2021.   \n[64] Pengchuan Zhang, Xiyang Dai, Jianwei Yang, Bin Xiao, Lu Yuan, Lei Zhang, and Jianfeng Gao. Multi-scale vision longformer: A new vision transformer for high-resolution image encoding. arXiv preprint arXiv:2103.15358, 2021.   \n[65] Iz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.   \n[66] Nikita Kitaev, Łukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. arXiv preprint arXiv:2001.04451, 2020.   \n[67] Juho Lee, Yoonho Lee, Jungtaek Kim, Adam Kosiorek, Seungjin Choi, and Yee Whye Teh. Set transformer: A framework for attention-based permutation-invariant neural networks. In International Conference on Machine Learning, pages 3744–3753. PMLR, 2019.   \n[68] Aurko Roy, Mohammad Saffar, Ashish Vaswani, and David Grangier. Efficient content-based sparse attention with routing transformers. Transactions of the Association for Computational Linguistics, 9:53–68, 2021.   \n[69] Jack W Rae, Anna Potapenko, Siddhant M Jayakumar, and Timothy P Lillicrap. Compressive transformers for long-range sequence modelling. arXiv preprint arXiv:1911.05507, 2019.   \n[70] Jonathan Ho, Nal Kalchbrenner, Dirk Weissenborn, and Tim Salimans. Axial attention in multidimensional transformers. arXiv preprint arXiv:1912.12180, 2019.   \n[71] Angelos Katharopoulos, Apoorv Vyas, Nikolaos Pappas, and François Fleuret. Transformers are rnns: Fast autoregressive transformers with linear attention. In International Conference on Machine Learning, pages 5156–5165. PMLR, 2020.   \n[72] Krzysztof Choromanski, Valerii Likhosherstov, David Dohan, Xingyou Song, Andreea Gane, Tamas Sarlos, Peter Hawkins, Jared Davis, Afroz Mohiuddin, Lukasz Kaiser, et al. Rethinking attention with performers. arXiv preprint arXiv:2009.14794, 2020.   \n[73] Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena: A benchmark for efficient transformers. arXiv preprint arXiv:2011.04006, 2020.   \n[74] Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. arXiv preprint arXiv:2009.06732, 2020.   \n[75] Sinong Wang, Belinda Z. Li, Madian Khabsa, Han Fang, and Hao Ma. Linformer: Selfattention with linear complexity, 2020.   \n[76] Bowen Pan, Yifan Jiang, Rameswar Panda, Zhangyang Wang, Rogerio Feris, and Aude Oliva. Ia-red2: Interpretability-aware redundancy reduction for vision transformers, 2021.   \n[77] Yann LeCun, John S Denker, and Sara A Solla. Optimal brain damage. In Advances in neural information processing systems, pages 598–605, 1990.   \n[78] Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In C. Cortes, N. D. Lawrence, D. D. Lee, M. Sugiyama, and R. Garnett, editors, Advances in Neural Information Processing Systems 28, pages 1135–1143. Curran Associates, Inc., 2015.   \n[79] Yann LeCun, John S. Denker, and Sara A. Solla. Optimal brain damage. In D. S. Touretzky, editor, Advances in Neural Information Processing Systems 2, pages 598–605. Morgan-Kaufmann, 1990.   \n[80] Zhuang Liu, Jianguo Li, Zhiqiang Shen, Gao Huang, Shoumeng Yan, and Changshui Zhang. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision, pages 2736–2744, 2017.   \n[81] Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, 2017.   \n[82] Hao Zhou, Jose M Alvarez, and Fatih Porikli. Less is more: Towards compact cnns. In European Conference on Computer Vision, pages 662–677. Springer, 2016.   \n[83] Decebal Constantin Mocanu, Elena Mocanu, Phuong H Nguyen, Madeleine Gibescu, and Antonio Liotta. A topological insight into restricted boltzmann machines. Machine Learning, 104(2-3):243–270, 2016. [84] Sangkug Lym, Esha Choukse, Siavash Zangeneh, Wei Wen, Sujay Sanghavi, and Mattan Erez. Prunetrain: fast neural network training by dynamic sparse model reconfiguration. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, pages 1–13, 2019.   \n[85] Brian R Bartoldson, Ari S Morcos, Adrian Barbu, and Gordon Erlebacher. The generalizationstability tradeoff in neural network pruning. arXiv preprint arXiv:1906.03728, 2019. [86] Emit J. Gumbel. Statistical theory of extreme values and some practical applications. The Journal of the Royal Aeronautical Society, 58(527):792–793, 1954.   \n[87] Chris J Maddison, Daniel Tarlow, and Tom Minka. $\\mathbf { A } ^ { * }$ sampling. arXiv preprint arXiv:1411.0030, 2014.   \n[88] Penghang Yin, Jiancheng Lyu, Shuai Zhang, Stanley Osher, Yingyong Qi, and Jack Xin. Understanding straight-through estimator in training activation quantized neural nets. arXiv preprint arXiv:1903.05662, 2019.   \n[89] Jonathan Frankle, Gintare Karolina Dziugaite, Daniel M Roy, and Michael Carbin. The lottery ticket hypothesis at scale. arXiv preprint arXiv:1903.01611, 2019.   \n[90] Trevor Gale, Erich Elsen, and Sara Hooker. The state of sparsity in deep neural networks. arXiv preprint arXiv:1902.09574, 2019.   \n[91] Kai Han, An Xiao, Enhua Wu, Jianyuan Guo, Chunjing Xu, and Yunhe Wang. Transformer in transformer. arXiv preprint arXiv:2103.00112, 2021.   \n[92] Wenhai Wang, Enze Xie, Xiang Li, Deng-Ping Fan, Kaitao Song, Ding Liang, Tong Lu, Ping Luo, and Ling Shao. Pyramid vision transformer: A versatile backbone for dense prediction without convolutions. arXiv preprint arXiv:2102.12122, 2021.   \n[93] Daquan Zhou, Bingyi Kang, Xiaojie Jin, Linjie Yang, Xiaochen Lian, Zihang Jiang, Qibin Hou, and Jiashi Feng. Deepvit: Towards deeper vision transformer. arXiv preprint arXiv:2103.11886, 2021.   \n[94] Jean-Baptiste Cordonnier, Andreas Loukas, and Martin Jaggi. On the relationship between selfattention and convolutional layers. In International Conference on Learning Representations, 2020.   \n[95] Erich Elsen, Marat Dukhan, Trevor Gale, and Karen Simonyan. Fast sparse convnets. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition, pages 14629–14638, 2020.   \n[96] Peiqi Wang, Yu Ji, Chi Hong, Yongqiang Lyu, Dongsheng Wang, and Yuan Xie. Snrram: An efficient sparse neural network computation architecture based on resistive random-access memory. In 2018 55th ACM/ESDA/IEEE Design Automation Conference (DAC), pages 1–6, 2018.   \n[97] Mike Ashby, Christiaan Baaij, Peter Baldwin, Martijn Bastiaan, Oliver Bunting, Aiken Cairncross, Christopher Chalmers, Liz Corrigan, Sam Davis, Nathan van Doorn, et al. Exploiting unstructured sparsity on next-generation datacenter hardware. None, 2019.   \n[98] Chen Liu, Guillaume Bellec, Bernhard Vogginger, David Kappel, Johannes Partzsch, Felix Neumärker, Sebastian Höppner, Wolfgang Maass, Steve B Furber, Robert Legenstein, et al. Memory-efficient deep learning on a spinnaker 2 prototype. Frontiers in neuroscience, 12:840, 2018.   \n[99] Song Han, Xingyu Liu, Huizi Mao, Jing Pu, Ardavan Pedram, Mark A. Horowitz, and William J. Dally. Eie: Efficient inference engine on compressed deep neural network. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA), pages 243–254, 2016.   \n[100] Yu-Hsin Chen, Tien-Ju Yang, Joel Emer, and Vivienne Sze. Eyeriss v2: A flexible accelerator for emerging deep neural networks on mobile devices. IEEE Journal on Emerging and Selected Topics in Circuits and Systems, 9(2):292–308, 2019. ",
+        "bbox": [
+            181,
+            416,
+            826,
+            914
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            61,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            179,
+            36,
+            828,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            63,
+            828,
+            920
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            42,
+            828,
+            917
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            70,
+            828,
+            912
+        ],
+        "page_idx": 14
+    }
+]

parse/train/tHgJoMfy6nI/tHgJoMfy6nI.md

@@ -0,0 +1,290 @@
+# REMEMBERING FOR THE RIGHT REASONS: EXPLANATIONS REDUCE CATASTROPHIC FORGETTING
+
+Sayna Ebrahimi1, Suzanne Petryk1, Akash Gokul1, William Gan1, Joseph E. Gonzalez1, Marcus Rohrbach2, Trevor Darrell1
+
+1UC Berkeley, 2 Facebook AI Research   
+{sayna,spetryk,akashgokul,wjgan,jegonzal,trevordarrell}@berkeley.edu   
+mrf@fb.com
+
+# ABSTRACT
+
+The goal of continual learning (CL) is to learn a sequence of tasks without suffering from the phenomenon of catastrophic forgetting. Previous work has shown that leveraging memory in the form of a replay buffer can reduce performance degradation on prior tasks. We hypothesize that forgetting can be further reduced when the model is encouraged to remember the evidence for previously made decisions. As a first step towards exploring this hypothesis, we propose a simple novel training paradigm, called Remembering for the Right Reasons (RRR), that additionally stores visual model explanations for each example in the buffer and ensures the model has “the right reasons” for its predictions by encouraging its explanations to remain consistent with those used to make decisions at training time. Without this constraint, there is a drift in explanations and increase in forgetting as conventional continual learning algorithms learn new tasks. We demonstrate how RRR can be easily added to any memory or regularizationbased approach and results in reduced forgetting, and more importantly, improved model explanations. We have evaluated our approach in the standard and few-shot settings and observed a consistent improvement across various CL approaches using different architectures and techniques to generate model explanations and demonstrated our approach showing a promising connection between explainability and continual learning. Our code is available at https://github.com/ SaynaEbrahimi/Remembering-for-the-Right-Reasons.
+
+# 1 INTRODUCTION
+
+Humans are capable of continuously learning novel tasks by leveraging their lifetime knowledge and expanding them when they encounter a new experience. They can remember the majority of their prior knowledge despite the never-ending nature of their learning process by simply keeping a running tally of the observations distributed over time or presented in summary form. The field of continual learning or lifelong learning (Thrun & Mitchell, 1995; Silver et al., 2013) aims at maintaining previous performance and avoiding so-called catastrophic forgetting of previous experience (McCloskey & Cohen, 1989; McClelland et al., 1995) when learning new skills. The goal is to develop algorithms that continually update or add parameters to accommodate an online stream of data over time.
+
+An active line of research in continual learning explores the effectiveness of using small memory budgets to store data points from the training set (Castro et al., 2018; Rajasegaran et al., 2020; Rebuffi et al., 2017; Wu et al., 2019), gradients (Lopez-Paz et al., 2017), or storing an online generative model that can fake them later (Shin et al., 2017). Memory has been also exploited in the form of accommodating space for architecture growth and storage to fully recover the old performance when needed (Ebrahimi et al., 2020b; Rusu et al., 2016). Some methods store an old snapshot of the model to distill the features (Li & Hoiem, 2016) or attention maps (Dhar et al., 2019) between the teacher and student models.
+
+![](images/d0281df291d1cac11c700eef36b889185db8c8c6f64b2f631bab1a588c539ccf.jpg)  
+Figure 1: An illustration of applying RRR paradigm. (Left) In a typical experience replay scenario, samples from prior tasks are kept in a memory buffer $\mathcal { M } ^ { \mathrm { r e p } }$ and revisited during training. (Right) In our proposed idea (RRR), in addition to ${ \mathcal { M } } ^ { \mathrm { r e p } }$ , we also store model explanations (saliency maps) as $\mathcal { M } ^ { \mathrm { R R R } }$ for those samples and encourage the model to remember the original reasoning for the prediction. Note that the saliency maps are small masks resulting in a negligible memory overhead (see Section 4.1).
+
+The internal reasoning process of deep models is often treated as a black box and remains hidden from the user. However, recent work in explainable artificial intelligence (XAI) has developed methods to create human-interpretable explanations for model decisions (Simonyan et al., 2013; Zhang et al., 2018; Petsiuk et al., 2018; Zhou et al., 2016; Selvaraju et al., 2017). We posit that the catastrophic forgetting phenomenon is due in part to not being able to rely on the same reasoning as was used for a previously seen observation. Therefore, we hypothesize that forgetting can be mitigated when the model is encouraged to remember the evidence for previously made decisions. In other words, a model which can remember its final decision and can reconstruct the same prior reasoning. Based on this approach, we develop a novel strategy to exploit explainable models for improving performance.
+
+Among the various explainability techniques proposed in XAI, saliency methods have emerged as a popular tool to identify the support of a model prediction in terms of relevant features in the input. These methods produce saliency maps, defined as regions of visual evidence upon which a network makes a decision. Our goal is to investigate whether augmenting experience replay with explanation replay reduces forgetting and how enforcing to remember the explanations will affect the explanations themselves. Figure 1 illustrates our proposed method.
+
+In this work, we propose RRR, a training strategy guided by model explanations generated by any white-box differentiable explanation method; RRR adds an explanation loss to continual learning. White-box methods generate an explanation by using some internal state of the model, such as gradients, enabling their use in end-to-end training. We evaluate our approach using various popular explanation methods including vanilla backpropagation (Zeiler & Fergus, 2014), backpropagation with smoothing gradients (Smoothgrad) (Smilkov et al., 2017), Guided Backpropagation (Springenberg et al., 2014), and Gradient Class Activation Mapping (Grad-CAM) (Selvaraju et al., 2017) and compare their performance versus their computational feasibility. We integrate RRR into several state of the art class incremental learning (CIL) methods, including iTAML (Rajasegaran et al., 2020), EEIl (Castro et al., 2018), BiC (Wu et al., 2019), TOPIC (Tao et al., 2020), iCaRL (Rebuffi et al., 2017), EWC (Kirkpatrick et al., 2017), and LwF (Li & Hoiem, 2016). Note that RRR does not require task IDs at test time. We qualitatively and quantitatively analyze model explanations in the form of saliency maps and demonstrate that RRR remembers its earlier decisions in a sequence of tasks due to the requirement to focus on the the right evidence. We empirically show the effect of RRR in standard and few-shot class incremental learning (CIL) scenarios on popular benchmark datasets including CIFAR100, ImageNet100, and Caltech-UCSD Birds 200 using different network architectures where RRR improves overall accuracy and forgetting over experience replay and other memory-based method.
+
+Our contribution is threefold: we first propose our novel, simple, yet effective memory constraint, which we call Remembering for the Right Reasons (RRR), and show that it reduces catastrophic forgetting by encouraging the model to look at the same explanations it initially found for its decisions. Second, we show how RRR can be readily combined with memory-based and regularization-based
+
+CL methods to improve performance. Third, we demonstrate how guiding a continual learner to remember its explanations can improve the quality of the explanations themselves; i.e., the model looks at the right region in an image when making correct decisions while it focuses its maximum attention on the background when it misclassifies an object.
+
+# 2 BACKGROUND: WHITE-BOX EXPLANABILITY TECHNIQUES
+
+Here we briefly review the explainability methods we have evaluated our approach with. The core idea behind RRR is to guide explanations or saliency maps during training to preserve their values. Hence, only gradient-based saliency techniques can be used which are differentiable and hence trainable during training for the mainstream task as opposed to black-box saliency methods which can be used only after training to determine important parts of an image.
+
+Vanilla Backpropagation (Zeiler & Fergus, 2014): The simplest way to understand and visualize which pixels are most salient in an image is to look at the gradients. This is typically done by making a forward pass through the model and taking the gradient of the given output class with respect to the input. Those pixel-wise derivative values can be rendered as a normalized heatmap representing the amount of change in the output probability of a class caused by perturbing that pixel. To store a saliency map for each RGB image of size $3 \times W \times H$ , we need an equivalent memory size of storing $W \times H$ pixel values.
+
+Backpropagation with SmoothGrad: Smilkov et al. (2017) showed that the saliency maps obtained using raw gradients are visually noisy and using them as a proxy for feature importance is sub-optimal. They proposed a simple technique for denoising the gradients that adds pixel-wise Gaussian noise to $n$ copies of the image, and simply averages the resulting gradients. SmoothGrad requires the same amount of memory to store the saliency maps while it takes $n$ times longer to repeat generating each saliency map. We found $n = 4 0$ to be large enough to make a noticeable change in the saliencies in our experiments.
+
+Gradient-weighted Class Activation Mapping (Grad-CAM) (Selvaraju et al., 2017): is a whitebox explainability technique which uses gradients to determine the influence of specific feature map activations on a given prediction. Because later layers in a convolutional neural network are known to encode higher-level semantics, taking the gradient of a model output with respect to the activations of these feature maps discovers which high-level semantics are important for the prediction. We refer to this layer as the target layer in our analysis. For example, when using Grad-CAM to visualize explanations for image classification, taking the gradient of the correct class prediction with respect to the last convolutional layer highlights class-discriminative regions in the image (such as the wings of a bird when identifying bird species).
+
+Consider the pre-softmax score $y _ { c }$ for class $c$ in an image classification output. In general, any differentiable activation can be used. Consider also a single convolutional layer with $K$ feature maps, with a single feature map noted as $A ^ { k } \in \mathbb { R } ^ { u \times v }$ . Grad-CAM takes the derivative of $y _ { c }$ with respect to each feature map $A ^ { k }$ . It then performs global average pooling over the height and width dimensions for each of these feature map gradients, getting a vector of length $K$ . Each element in this vector is used as a weight $\alpha _ { k } ^ { c }$ , indicating the importance of feature map $k$ for the prediction $y _ { c }$ . Next, these importance weights are used in computing a linear combination of the feature maps. Followed by a ReLU (Jarrett et al., 2009) to zero-out any activations with a negative influence on the prediction of class $c$ , the final Grad-CAM output (s) is as below with $A _ { i j } ^ { k }$ defined at location $( i , j )$ in feature map $A ^ { k }$ .
+
+$$
+\begin{array} { r l } { \alpha _ { k } ^ { c } = } & { { } \frac { 1 } { u v } \displaystyle \sum _ { i = 1 } ^ { u } \displaystyle \sum _ { j = 1 } ^ { v } \frac { \partial y _ { c } } { \partial A _ { i j } ^ { k } } \qquad s _ { G r a d - C A M } ^ { c } = R e L U \left( \displaystyle \sum _ { k = 1 } ^ { K } \alpha _ { k } ^ { c } A ^ { k } \right) } \end{array}
+$$
+
+Unlike the common saliency map techniques of Guided BackProp (Springenberg et al., 2014), Guided GradCAM (Selvaraju et al., 2016), Integrated Gradients (Sundararajan et al., 2017b), Gradient $\odot$ Input (Shrikumar et al., 2016), Backpropagation with SmoothGrad (Smilkov et al., 2017) etc., vanilla Backpropagation and Grad-CAM pass important “sanity checks” regarding their sensitivity to data and model parameters (Adebayo et al., 2018). We will compare using vanilla Backpropagation, Backpropagation with SmoothGrad, and Grad-CAM in RRR in Section 4. We will refer to the function that computes the output $s$ of these saliency method as $ { \mathcal { X } }  { \mathcal { A } }  { \mathcal { T } }$ .
+
+Algorithm 1 Remembering for the Right Reasons (RRR) for Continual Learning   
+1: function TRAIN $( f _ { \theta } , \mathcal { D } ^ { t r } , \mathcal { D } ^ { t s } )$ function UPDATE MEM(f kθ , Dtrk , Mrep, MRRR)   
+2: $T$ : # of tasks, $n$ : # of samples in task (xi, k, yi) ∼ Dtrk   
+3: R ← 0 ∈ R T ×T Mrep ← Mrep ∪ {(xi, k, yi)}   
+4: Mrep ← {} sˆ ← X AI(f kθ (xi, k))   
+5: $\mathcal { M } ^ { \mathrm { R R R } }  \{ \}$ MRRR ← MRRR ∪ {sˆ}   
+6: for $k = 1$ to T do return Mrep, MRRR   
+7: for $i = 1$ to n do end function   
+8: Compute cross entropy on task $( \mathcal { L } _ { \mathrm { t a s k } } )$   
+9: Compute $\mathcal { L } _ { \mathrm { R R R } }$ using Eq. 2 function EVAL(f kθ , Dts{1···k})   
+10: $\theta ^ { \prime }  \theta - \alpha \nabla _ { \theta } ( \mathcal { L } _ { \mathrm { t a s k } } + \mathcal { L } _ { \mathrm { R R R } } )$ for $i = 1$ to $k$ do   
+11: end for Rk,i = Accuracy $( f _ { \theta } ^ { k } ( x , i ) , y \vert \forall ( x , y ) \in \mathcal { D } _ { i } ^ { t s } )$   
+12: $\begin{array} { r l } & { \mathcal { M } ^ { \mathrm { r e p } } , \mathcal { M } ^ { \mathrm { R R R } } \gets \mathrm { U P D A T E ~ M E M } ( f _ { \theta } ^ { k } , \mathcal { D } _ { k } ^ { t r } , \mathcal { M } ^ { \mathrm { r e p } } , } \\ & { } \\ & { R _ { k , \{ 1 \cdots k \} } \gets \mathrm { E V A L } \left( f _ { \theta } ^ { k } , \mathcal { D } _ { \{ 1 \cdots k \} } ^ { t s } \right) } \end{array}$ , end for   
+return $R$   
+13: end function   
+14: end for   
+15: return $f _ { \boldsymbol { \theta } } , R$   
+16: end function
+
+# 3 REMEMBERING FOR THE RIGHT REASONS (RRR)
+
+Memory-based methods in continual learning have achieved high performance on vision benchmarks using a small amount of memory, i.e. storing a few samples from the training data into the replay buffer to directly train with them when learning new tasks. This simple method, known as experience replay, has been explored and shown to be effective (Rebuffi et al., 2017; Wu et al., 2019; Castro et al., 2018; Rajasegaran et al., 2020; Ebrahimi et al., 2020b; Hayes et al., 2019; Riemer et al., 2018). In this work we aim to go one step further and investigate the role of explanations in continual learning, particularly on mitigating forgetting and change of model explanations.
+
+We consider the problem of learning a sequence of $T$ data distributions $\mathcal { D } ^ { t r } = \{ \mathcal { D } _ { 1 } ^ { t r } , \cdot \cdot \cdot , \mathcal { D } _ { T } ^ { t r } \}$ , where $\mathcal { D } _ { k } ^ { t r } = \{ ( x _ { i } ^ { k } , y _ { i } ^ { k } ) _ { i = 1 } ^ { n _ { k } } \}$ is the data distribution for task $k$ with $n$ sample tuples of input $( \mathbf { x } ^ { k } \subset \mathcal { X } )$ and set of output labels $( \mathbf { y } ^ { k } \subset \mathcal { V } )$ . The goal is to sequentially learn the model $f _ { \theta } : \mathcal { X } \times \mathcal { T }  \mathcal { Y }$ for each task that can map each input $x$ to its target output, $y$ , while maintaining its performance on all prior tasks. We aim to achieve this by using memory to enhance better knowledge transfer as well as better avoidance of catastrophic forgetting. We assume two limited memory pools $\mathcal { M } ^ { \mathrm { r e p } }$ for raw samples and $\mathcal { M } ^ { \mathrm { R R R } }$ for model explanations. In particular, $\mathcal { M } ^ { \mathrm { r e p } } = \{ ( x _ { i } ^ { j } , y _ { i } ^ { j } ) _ { i = 1 } ^ { m } \stackrel { \cdot } { \sim } \mathcal { D } _ { j = 1 \cdots k - 1 } ^ { t r } \}$ stores $m$ samples in total from all prior tasks to $k$ . Similarly $\mathcal { M } ^ { \mathrm { R R R } }$ stores the saliency maps generated based on $f _ { \theta } ^ { k }$ by one of the explanation methods $( { \mathcal { X } } { \mathcal { A } } { \mathcal { T } } )$ discussed in Section 2 for images in $\mathcal { M } ^ { \mathrm { r e p } }$ where $f _ { \theta } ^ { k }$ is $f _ { \theta }$ being trained for task $k$ . We use a single-head architecture where the task ID integer $t$ is not required at test time.
+
+Upon finishing the $k ^ { t h }$ task, we randomly select $m / ( k { - } 1 )$ samples per task from its training data and update our replay buffer memory ${ \mathcal { M } } ^ { \mathrm { r e p } }$ . RRR uses model explanations on memory samples to perform continual learning such that the model preserves its reasoning for previously seen observations. We explore several explanation techniques to compute saliency maps using $f _ { \theta } ^ { \mathbf { \bar { k } } }$ for the stored samples in the replay buffer to populate the xai buffer memory $\mathcal { M } ^ { \mathrm { x a i } }$ . The stored saliency maps will serve as reference explanations during the learning of future tasks to prevent model parameters from being altered resulting in different reasoning for the same samples. We implement RRR using an L1 loss on the error in saliency maps generated after training a new task with respect to their stored reference evidence.
+
+$$
+\mathcal { L } _ { \mathrm { R R R } } \big ( f _ { \theta } , \mathcal { M } ^ { \mathrm { r e p } } , \mathcal { M } ^ { \mathrm { R R R } } \big ) = \mathbb { E } _ { ( ( x , y ) , \hat { s } ) \sim \left( \mathcal { M } ^ { \mathrm { r e p } } , \mathcal { M } ^ { \mathrm { R R R } } \right) } \vert \vert \mathcal { X } \mathcal { A } \mathcal { Z } \big ( f _ { \theta } ^ { k } ( x ) \big ) - \hat { s } \vert \vert _ { 1 }
+$$
+
+where $\mathcal { X } \mathcal { A } \mathcal { T } ( \cdot )$ denotes the explanation method used to compute saliency maps using the model trained on the last seen example from task $k$ , and $\hat { s }$ are the reference saliency maps generated by $\chi \mathcal { A } \mathcal { T } ( f _ { \theta } ^ { k } )$ upon learning each task prior to $T$ and stored in to the memory. We show below that combining RRR into the objective function of state-of-the-art memory and regularization-based methods results in significant performance improvements. The full algorithm for RRR is given in Alg. 1.
+
+![](images/cb3d7154cc20f9b0d8c9e69038bd7edd29572c0f83a7677e8527ca6aa7b2c07f.jpg)  
+Figure 2: Few-shot CIL learning of CUB200 in 11 tasks where each point shows the classification accuracy on all seen classes so far. (Left) Shows ER with and without $\mathcal { L } _ { \mathrm { R R R } }$ using different backbone architectures and saliency map techniques. (Right) Performance of the state-of-the-art existing approaches with and without $\mathcal { L } _ { \mathrm { R R R } }$ on CUB200 including TOPIC (Tao et al., 2020), EEIL (Castro et al., 2018), iCaRL (Rebuffi et al., 2017). Joint training serves as the upper bound. Results for baselines are obtained using their original implementation. All results are averaged over 3 runs and mean and standard deviation values are given in the appendix. Best viewed in color.
+
+# 4 EXPERIMENTS
+
+In this section, we apply RRR in two distinct learning regimes: standard and few-shot class incremental learning. These are the most challenging CL scenarios, in which task descriptions are not available at test time. We first explore the effect of backbone architecture and the saliency map technique on RRR performance. We then report our obtained results integrating $\mathcal { L } _ { \mathrm { R R R } }$ into existing memory-based and regularization-based methods.
+
+# 4.1 FEW-SHOT CIL PERFORMANCE
+
+We first explore CIL of low-data regimes where preventing overfitting to few-shot new classes is another challenge to overcome in addition to avoiding catastrophic forgetting of old classes. We use $C$ classes and $K$ training samples per class as the $C$ -way $K$ -shot few-shot class incrementally learning setting where we have a set of $b$ base classes to learn as the first task while the remaining classes are learned with only a few randomly selected samples. In order to provide a direct comparison to the state-of-the-art work of Tao et al. (2020) we precisely followed their setup and and used the same Caltech-UCSD Birds dataset (Wah et al., 2011), divided into 11 disjoint tasks and a 10-way 5-shot setting, where the first task contains $b = 1 0 0$ base classes resulting in 3000 samples for training and 2834 images for testing. The remaining 100 classes are divided into 10 tasks where 5 samples per class are randomly selected as the training set, while the test set is kept intact containing near 300 images per task. The images in CUB200 are resized to $2 5 6 \times 2 5 6$ and then randomly cropped to $2 2 4 \times 2 2 4$ for training. We store 4 images per class from base classes in the first task and 1 sample per each few-shot class in the remaining 10 tasks (Tao et al., 2020). We used the RAdam (Liu et al., 2019) optimizer with a learning rate of 0.001 which was reduced by 0.2 at epochs 20, 40, and 60 and trained for a total of 70 epochs with a batch size of 128 for the first and 10 for the remaining tasks.
+
+Figure 2 (left) shows results for ER with and without $\mathcal { L } _ { \mathrm { R R R } }$ using different backbone architectures and saliency map techniques. Among the tested saliency map methods, Grad-CAM on ResNet18 outperforms Vanilla Backpropagation and SmoothGrad by $2 { - } 3 \%$ while SmoothGrad and vanilla Backpropagation achieve similar CL performance. To compute the memory overhead of storing the output for a saliency method, if we assume the memory required to store an image is $M$ , vanilla Backpropagation and SmoothGrad generate a pixel-wise saliency map that occupies $M / 3$ of memory. However, in Grad-CAM the saliency map size is equal to the feature map of the target layer in the architecture. In our study with Grad-CAM we chose our target layer to be the last convolution layer before the fully-connected layers. For instance using ResNet18 for colored $2 2 4 \times 2 2 4$ images results in the Grad-CAM output of $7 \times 7$ occupying 196B. Table 2 shows the target layer name and saliency map size for other network architectures used in this work (AlexNet and SqueezeNet1 1) as well.
+
+![](images/c256de790417db433077726ead7e5e774741a08099f8b9eb519352448f894179.jpg)  
+Figure 3: Effect of RRR on existing methods for CIL on CIFAR100 in (a) 10 and (b) 20 tasks and (c) ImageNet100 in 10 tasks. Each point shows the classification accuracy on all seen classes so far. Results for iTAML, BiC, and EEIL are produced with their original implementation while EWC and LwF are re-implemented by us. All results are averaged over 3 runs and mean and standard deviation values are given in the appendix. Best viewed in color.
+
+Figure 2 (right) shows the effect of adding $\mathcal { L } _ { \mathrm { R R R } }$ on existing recent state-of-the-art methods such as TOPIC (Tao et al., 2020), EEIL (Castro et al., 2018), and iCaRL (Rebuffi et al., 2017). Tao et al. (2020) used a neural gas network (Martinetz et al., 1991; Fritzke et al., 1995) which can learn and preserve the topology of the feature manifold formed by different classes and we have followed their experimental protocol for our CUB200 experiment by using identical samples drawn in each task which are used across all the baselines for fair comparison. Adding $\mathcal { L } _ { \mathrm { R R R } }$ improves the performance of all the baselines; TOPIC becomes nearly on-par with joint training which serves as the upper bound and does not adhere to continual learning. The gap between ER and iCaRL is also reduced when ER uses $\mathcal { L } _ { \mathrm { R R R } }$ .
+
+# 4.2 STANDARD CIL PERFORMANCE
+
+In order to provide a direct comparison to the recent work of Rajasegaran et al. (2020) we perform our standard CIL experiment on CIFAR100 (Krizhevsky & Hinton, 2009) and ImageNet100 where we assume a memory budget of 2000 samples which are identical across all the baselines. Following Rajasegaran et al. (2020) we divide CIFAR100 to 10 and 20 disjoint tasks with 10 and 5 classes at a time. Figures 3a and 3b show the classification accuracy upon learning each task on all seen classes. We see a consistent average improvement of $2 - 4 \%$ when $\mathcal { L } _ { \mathrm { R R R } }$ is added as an additional constraint to preserve the model explanations across all methods, from the most naive memory-based method, experience replay (ER), to more sophisticated approaches which store a set of old class exemplars along with meta-learning (iTAML), correct bias for new classes (BiC), and fine tune on the exemplar set (EEIL). We also applied the RRR constraint on regularization-based methods such as EWC and LwF with no memory used as a replay buffer. The accuracy for both improves despite not benefiting from revisiting the raw data. However, they fall behind all memory-based methods with or without $\mathcal { L } _ { \mathrm { R R R } }$ . The final accuracy on the entire sequence for joint training (multi-task learning) with RAdam optimizer (Liu et al., 2019) is $8 0 . 0 3 \%$ which serves as an upper bound as it has access to data from all tasks at all time.
+
+Figure 3c shows our results on learning ImageNet100 in 10 tasks. The effect of adding $\mathcal { L } _ { \mathrm { R R R } }$ to baselines on the ImageNet100 experiment is more significant $( 3 - 6 \% )$ compared to CIFAR100. This is mainly due to the larger size and better quality of images in ImageNet100, resulting in generating larger Grad-CAM saliency maps. These experiments clearly reveal the effectiveness of $\mathcal { L } _ { \mathrm { R R R } }$ on model explanations in a continual learning problem at nearly zero cost of memory overhead when a memory buffer is already created and applied as a catastrophic forgetting avoidance strategy. This makes Grad-CAM the ideal approach to generate saliency maps when applying the RRR training strategy, as it achieves the highest accuracy while utilizing the least storage space to store saliencies. Note that we adopt Grad-CAM to generate saliency maps in the remaining experiments in this paper. We also keep using only ResNet18 for a fair comparison with the literature.
+
+(a) PG localization accuracy and backward transfer   
+
+<table><tr><td>Methods</td><td>PG-ACC (%)</td><td>PG-BWT (%)</td></tr><tr><td>ER</td><td>54.0</td><td>-17.4</td></tr><tr><td>ER+RRR</td><td>58.5</td><td>-15.6</td></tr><tr><td>TOPIC</td><td>72.7</td><td>-0.9</td></tr><tr><td>TOPIC+RRR</td><td>74.2</td><td>-2.1</td></tr></table>
+
+Table 1: PG experiment results on few-shot CIL CUB200 measuring (a) PG-ACC $( \% )$ and PG-BWT $( \% )$ and (b) precision and recall averaged over all tasks. $P r _ { i , i }$ and $R e _ { i , i }$ evaluate the pointing game on each task $\mathbf { t } ^ { \mathrm { i } }$ directly after the model has been trained on $\mathbf { t } ^ { \mathbf { i } }$ . $P r _ { T , i }$ and $R e _ { T , i }$ are obtained by the evaluation for task $\mathbf { t ^ { i } }$ using the model trained for all $T$ tasks.   
+(b) Precision and recall using PG experiment   
+
+<table><tr><td></td><td colspan="2">Precision</td><td colspan="2">Recall</td></tr><tr><td>Methods</td><td>Pri,i</td><td>PrT,i</td><td>Rei,i</td><td>ReT,i</td></tr><tr><td>ER</td><td>80.0</td><td>68.9</td><td>64.1</td><td>65.1</td></tr><tr><td>ER+RRR</td><td>82.1</td><td>70.3</td><td>64.2</td><td>66.8</td></tr><tr><td>TOPIC</td><td>91.0</td><td>88.4</td><td>98.1</td><td>97.4</td></tr><tr><td>TOPIC+RRR</td><td>92.8</td><td>89.1</td><td>99.6</td><td>99.2</td></tr></table>
+
+# 5 ANALYSIS OF MODEL EXPLANATIONS
+
+In this section we want to answer the question “How often does the model remember its decision for the right reason upon learning a sequence of tasks?”. In particular, we want to evaluate how often the model is “pointing” at the right evidence for its predictions, instead of focusing its maximum attention on the background or other objects in the image. We use the Pointing Game experiment (PG) (Zhang et al., 2018) for this evaluation, which was introduced to measure the discriminativeness of a visualization method for target object localization. Here, we use ground truth segmentation annotation labels provided with the CUB-200 dataset to define the true object region.
+
+First, we look into hits and misses defined by the PG experiment. When the location of the maximum in a predicted saliency map falls inside the object, it is considered as a hit and otherwise it is a miss. Figure 5 shows an example from CUB200 where the segmentation annotation is used to determine whether the peak of the predicted saliency map (marked with red cross) falls inside the object region. This example is regarded as hit as the red cross is inside the segmentation mask for the bird. PG localization accuracy is defined as the number of hits over the total number of predictions. We would like to measure both the overall PG performance of a continual learner as well as how much learning new tasks causes it to forget its ability to hit the target object. For these metrics, inspired by (Lopez-Paz et al., 2017), we define $\begin{array} { r } { \mathrm { P G } { \mathrm { - } } \mathrm { A C C } = \frac { 1 } { T } \sum _ { i = 1 } ^ { \bar { T } } \dot { R _ { T , i } } } \end{array}$ as the average PG localization accuracy computed over all prior tasks after training for each new task and $\begin{array} { r } { \mathrm { P G - B W T } = \frac { 1 } { T - 1 } \sum _ { i = 1 } ^ { T - 1 } R _ { T , i } - R _ { i , i } } \end{array}$ (backward transfer) which indicates how much learning new tasks has influenced the PG localization accuracy on previous tasks where $R _ { n , i }$ is the on task $i$ after learning the $n ^ { \mathrm { t h } }$ task. Results for ER and TOPIC with and without $\mathcal { L } _ { \mathrm { R R R } }$ on CUB200 are shown in Table 1a. It shows how constraining different models to remember their initial evidence can lead to better localization of the bird across learning new tasks.
+
+However, PG performance does not capture all of our desired properties for a continual learner. Ideally, we not only want a model to predict the object correctly if it is looking at the right evidence, but also we want it to not predict an object if it is not able to find the right evidence for it. To measure how close our baselines can get to this ideal model when they are combined with $\mathcal { L } _ { \mathrm { R R R } }$ , we measure the precision as $\mathrm { t p / ( t p / \Delta \mathfrak { p } ) }$ , and recall as $\mathrm { t p / ( t p / \Delta \mathfrak { t } f n ) }$ . We evaluate these metrics once immediately after learning each task, denoted as $P r _ { i , i }$ and $R e _ { i , i }$ , respectively, and again at the end of the learning process of final task $T$ denoted as $P r _ { T , i }$ and $R e _ { T , i }$ , where the first subscript refers to the model ID and the second subscript is the test dataset ID on which the model is evaluated. The higher the precision for a model is, the less often it has made the right decision without looking at the right evidence. On the other hand, the higher the recall, the less often it makes a wrong decision despite looking at the correct evidence. We show our evaluation on these metrics in Table 1b for ER and TOPIC with and without $\mathcal { L } _ { \mathrm { R R R } }$ on CUB200 where $\mathcal { L } _ { \mathrm { R R R } }$ increases both precision and recall across all methods, demonstrating that our approach continually makes better predictions because it finds the right evidence for its decisions.
+
+In our final analysis, we would like to visualize the evolution of saliency maps across learning a sequence of tasks. Figure 4 illustrates the evolution of saliency maps for an image from the test-set of the second task, which both ER without $\mathcal { L } _ { \mathrm { R R R } }$ (top row) and with $\mathcal { L } _ { \mathrm { R R R } }$ (bottom row) have seen during training for the second task. We only visualize the generated saliencies after finishing tasks #2, #5, #7, #9, and #11 for simplicity. We indicate the correctness of the prediction made by each model with ‘correct’ or ‘incorrect’ written on top of their corresponding saliency map. Our goal is to visualize if adding the loss term $\mathcal { L } _ { \mathrm { R R R } }$ prevents the drifting of explanations. Given the same input image, the ER without $\mathcal { L } _ { \mathrm { R R R } }$ model makes an incorrect prediction after being continually trained for 11 tasks while never recovering from its mistake. On the other hand, when it is combined with $\mathcal { L } _ { \mathrm { R R R } }$ . it is able to recover from an early mistake after task 5. Considering the saliency map obtained after finishing task one as a reference evidence, we can see that ER’s evidence drifts further from the reference. On the bottom row, the region of focus of ER+RRR remains nearly identical to its initial evidence, apart from one incorrect prediction. As applying $\mathcal { L } _ { \mathrm { R R R } }$ corrects its saliency back to the original, this prediction is corrected as well. This supports the conclusion that retaining the original saliency is important for retaining the original accuracy.
+
+![](images/09c0ee24c47d173aa2e6b5de78cbf95caefed73a635754290317195ebd291fa3.jpg)  
+Figure 4: An illustration of the progression of saliencies on an image from the test set of the second task, evaluated after the model is trained on tasks #2, #5, #7, #9, and #11 on CUB200. Failure case for ER w.o. $\mathcal { L } _ { \mathrm { R R R } }$ (top row), where saliency drifts from the original and the prediction becomes incorrect. $_ \mathrm { E R + R R R }$ (bottom row) retains close to the original saliency as the model trains on more tasks, with the exception of Task #5 which it is able to correct later on. Its performance is retained as well, for saliencies that are close to the original.
+
+# 6 RELATED WORK
+
+Continual learning: Past work in CL has generally made use of either memory, model structure, or regularization to prevent catastrophic forgetting. Memory-based methods store some form of past experience into a replay buffer. However, the definition of “experience” varies between methods. Rehearsal-based methods use episodic memories as raw samples (Robins, 1995; Rebuffi et al., 2017; Riemer et al., 2018) or their gradients (Lopez-Paz et al., 2017; Chaudhry et al., 2019) for the model to revisit. Incremental Classifier and Representation Learning (iCaRL) (Rebuffi et al., 2017), is a class-incremental learner that uses a nearest-exemplar algorithm for classification and prevents catastrophic forgetting by using an episodic memory. iTAML (Rajasegaran et al., 2020) is a task-agnostic meta-learning algorithm that uses a momentum based strategy for meta-update and in addition to the object classification task, it predicts task labels during inference. An end-to-end incremental learning framework (EEIL) (Castro et al., 2018) also uses an exemplar set along with data augmentation and balanced fine-tuning to alleviate the imbalance between the old and new classes. Bias Correction Method (BiC) (Wu et al., 2019) is another class-incremental learning algorithm for large datasets in which a linear model is used to correct bias towards new classes using a fully connected layer. In contrast, pseudo-rehearsal methods generate the replay samples using a generative model such as an autoencoder (Kemker & Kanan, 2017) or a GAN (Kamra et al., 2017; Shin et al., 2017). Regularization-based methods define different metrics to measure importance and limit the changes on parameters accordingly (Kirkpatrick et al., 2017; Zenke et al., 2017; Ebrahimi et al., 2020a; Serra et al., 2018; Li & Hoiem, 2016; Dhar et al., 2019) but in general these methods have limited capacity. Structure-based methods control which portions of a model are responsible for specific tasks such that the model increases its capacity in a controlled fashion as more tasks are added. Inference for different tasks can be restricted to various neurons (Fernando et al., 2017; Yoon et al., 2018), columns (Rusu et al., 2016), task-specific modules (Ebrahimi et al., 2020b), or parameters selected by a mask (Mallya & Lazebnik, 2018; Serra et al., 2018). In RRR we explored the addition of explanations to replay buffer and showed that saliency-based explanations offer performance upgrade as well as improvement in explanations across all memory-based and regularization-based baselines we tried.
+
+Visual explanation approaches or saliency methods attempt to produce a posterior explanation or a pseudo-probability map for the detected signals from the target object in the input image. These approaches can be broadly divided into three categories including activation, gradient, and perturbation based methods. Activation-based methods (Zhou et al., 2016; Selvaraju et al., 2017; Chattopadhay et al., 2018) use a weighted linear combination of feature maps whereas gradient-based methods (Baehrens et al., 2010; Sundararajan et al., 2017a; Springenberg et al., 2014; Shrikumar et al., 2017; Zhang et al., 2018) use the derivative of outputs w.r.t the input image to compute pixel-wise importance scores to generate attention maps. Methods in these categories are only applicable to differentiable models, including convolutional neural networks (CNNs). In contrast, perturbation-based methods are model-agnostic and produce saliency maps by observing the change in prediction when the input is perturbed (Petsiuk et al., 2018; Ribeiro et al., 2016; Ross et al., 2017; Zhou et al., 2014; Seo et al., 2018). While these methods attempt to identify if models are right for the wrong reason, Ross et al. (2017) took a step further and applied penalties to correct the explanations provided in supervised/unsupervised fashion during training. Selvaraju et al. (2019) used human explanations in the form of question and answering to bring model explanations closer to human answers.
+
+# 7 CONCLUSION
+
+In this paper, we proposed the use of model explanations with continual learning algorithms to enhance better knowledge transfer as well as better recall of the previous tasks. The intuition behind our method is that encouraging a model to remember its evidence will increase the generalisability and rationality of recalled predictions and help retrieving the relevant aspects of each task. We advocate for the use of explainable AI as a tool to improve model performance, rather than as an artifact or interpretation of the model itself. We demonstrate that models which incorporate a “remember for the right reasons” constraint as part of a continual learning process can both be interpretable and more accurate. We empirically demonstrated the effectiveness of our approach in a variety of settings and provided an analysis of improved performance and explainability.
+
+# REFERENCES
+
+Julius Adebayo, Justin Gilmer, Michael Muelly, Ian Goodfellow, Moritz Hardt, and Been Kim. Sanity checks for saliency maps. In Advances in Neural Information Processing Systems, pp. 9505–9515, 2018.   
+David Baehrens, Timon Schroeter, Stefan Harmeling, Motoaki Kawanabe, Katja Hansen, and KlausRobert MA˜ zller. How to explain individual classification decisions. ˇ Journal of Machine Learning Research, 11(Jun):1803–1831, 2010.   
+Francisco M Castro, Manuel J Mar´ın-Jimenez, Nicol ´ as Guil, Cordelia Schmid, and Karteek Alahari. ´ End-to-end incremental learning. In Proceedings of the European conference on computer vision (ECCV), pp. 233–248, 2018.   
+Aditya Chattopadhay, Anirban Sarkar, Prantik Howlader, and Vineeth N Balasubramanian. Gradcam $^ { + + }$ : Generalized gradient-based visual explanations for deep convolutional networks. In 2018 IEEE Winter Conference on Applications of Computer Vision (WACV), pp. 839–847. IEEE, 2018.   
+Arslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with A-GEM. In International Conference on Learning Representations, 2019.   
+Prithviraj Dhar, Rajat Vikram Singh, Kuan-Chuan Peng, Ziyan Wu, and Rama Chellappa. Learning without memorizing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5138–5146, 2019.   
+Sayna Ebrahimi, Mohamed Elhoseiny, Trevor Darrell, and Marcus Rohrbach. Uncertainty-guided continual learning with bayesian neural networks. In International Conference on Learning Representations, 2020a.   
+Sayna Ebrahimi, Franziska Meier, Roberto Calandra, Trevor Darrell, and Marcus Rohrbach. Adversarial continual learning. In European Conference on Computer Vision (ECCV), 2020b.
+
+Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. arXiv preprint arXiv:1701.08734, 2017.
+
+Bernd Fritzke et al. A growing neural gas network learns topologies. Advances in neural information processing systems, 7:625–632, 1995.
+
+Tyler L Hayes, Nathan D Cahill, and Christopher Kanan. Memory efficient experience replay for streaming learning. In 2019 International Conference on Robotics and Automation (ICRA), pp. 9769–9776. IEEE, 2019.
+
+Kevin Jarrett, Koray Kavukcuoglu, Marc’Aurelio Ranzato, and Yann LeCun. What is the best multi-stage architecture for object recognition? In 2009 IEEE 12th international conference on computer vision, pp. 2146–2153. IEEE, 2009.
+
+Nitin Kamra, Umang Gupta, and Yan Liu. Deep generative dual memory network for continual learning. arXiv preprint arXiv:1710.10368, 2017.
+
+Ronald Kemker and Christopher Kanan. Fearnet: Brain-inspired model for incremental learning. arXiv preprint arXiv:1711.10563, 2017.
+
+James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, pp. 201611835, 2017.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Zhizhong Li and Derek Hoiem. Learning without forgetting. In European Conference on Computer Vision, pp. 614–629. Springer, 2016.
+
+Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. arXiv preprint arXiv:1908.03265, 2019.
+
+David Lopez-Paz et al. Gradient episodic memory for continual learning. In Advances in Neural Information Processing Systems, pp. 6467–6476, 2017.
+
+Arun Mallya and Svetlana Lazebnik. Packnet: Adding multiple tasks to a single network by iterative pruning. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.
+
+Thomas Martinetz, Klaus Schulten, et al. A” neural-gas” network learns topologies. 1991.
+
+James L McClelland, Bruce L McNaughton, and Randall C O’reilly. Why there are complementary learning systems in the hippocampus and neocortex: insights from the successes and failures of connectionist models of learning and memory. Psychological review, 102(3):419, 1995.
+
+Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pp. 109–165. Elsevier, 1989.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NIPS-W, 2017.
+
+Vitali Petsiuk, Abir Das, and Kate Saenko. Rise: Randomized input sampling for explanation of black-box models. In Proceedings of the British Machine Vision Conference (BMVC), 2018.
+
+Jathushan Rajasegaran, Salman Khan, Munawar Hayat, Fahad Shahbaz Khan, and Mubarak Shah. itaml $:$ An incremental task-agnostic meta-learning approach. The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.
+
+Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl: Incremental classifier and representation learning. In CVPR, 2017.
+
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. ” why should i trust you?” explaining the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pp. 1135–1144, 2016.
+
+Matthew Riemer, Ignacio Cases, Robert Ajemian, Miao Liu, Irina Rish, Yuhai Tu, and Gerald Tesauro. Learning to learn without forgetting by maximizing transfer and minimizing interference. arXiv preprint arXiv:1810.11910, 2018.
+
+Anthony Robins. Catastrophic forgetting, rehearsal and pseudorehearsal. Connection Science, 7(2): 123–146, 1995.
+
+Andrew Slavin Ross, Michael C Hughes, and Finale Doshi-Velez. Right for the right reasons: Training differentiable models by constraining their explanations. arXiv preprint arXiv:1703.03717, 2017.
+
+Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016.
+
+Ramprasaath R Selvaraju, Abhishek Das, Ramakrishna Vedantam, Michael Cogswell, Devi Parikh, and Dhruv Batra. Grad-cam: Why did you say that? arXiv preprint arXiv:1611.07450, 2016.
+
+Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In Proceedings of the IEEE international conference on computer vision, pp. 618–626, 2017.
+
+Ramprasaath R Selvaraju, Stefan Lee, Yilin Shen, Hongxia Jin, Shalini Ghosh, Larry Heck, Dhruv Batra, and Devi Parikh. Taking a hint: Leveraging explanations to make vision and language models more grounded. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 2591–2600, 2019.
+
+Dasom Seo, Kanghan Oh, and Il-Seok Oh. Regional multi-scale approach for visually pleasing explanations of deep neural networks. arXiv preprint arXiv:1807.11720, 2018.
+
+Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 4548–4557. PMLR, 2018.
+
+Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In Advances in Neural Information Processing Systems, pp. 2990–2999, 2017.
+
+Avanti Shrikumar, Peyton Greenside, Anna Shcherbina, and Anshul Kundaje. Not just a black box: Learning important features through propagating activation differences. arXiv preprint arXiv:1605.01713, 2016.
+
+Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3145–3153. JMLR. org, 2017.
+
+Daniel L Silver, Qiang Yang, and Lianghao Li. Lifelong machine learning systems: Beyond learning algorithms. In 2013 AAAI spring symposium series, 2013.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013.
+
+Daniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Viegas, and Martin Wattenberg. Smoothgrad: ´ removing noise by adding noise. arXiv preprint arXiv:1706.03825, 2017.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.
+
+Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3319– 3328. JMLR. org, 2017a.
+
+Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. arXiv preprint arXiv:1703.01365, 2017b.
+
+Xiaoyu Tao, Xiaopeng Hong, Xinyuan Chang, Songlin Dong, Xing Wei, and Yihong Gong. Fewshot class-incremental learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 12183–12192, 2020.
+
+Sebastian Thrun and Tom M Mitchell. Lifelong robot learning. Robotics and autonomous systems, 15(1-2):25–46, 1995.
+
+C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology, 2011.
+
+Yue Wu, Yinpeng Chen, Lijuan Wang, Yuancheng Ye, Zicheng Liu, Yandong Guo, and Yun Fu. Large scale incremental learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 374–382, 2019.
+
+Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. In International Conference on Learning Representations, 2018.
+
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, pp. 818–833. Springer, 2014.
+
+Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 3987–3995. PMLR, 2017.
+
+Jianming Zhang, Sarah Adel Bargal, Zhe Lin, Jonathan Brandt, Xiaohui Shen, and Stan Sclaroff. Top-down neural attention by excitation backprop. International Journal of Computer Vision, 126 (10):1084–1102, 2018.
+
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in deep scene cnns. arXiv preprint arXiv:1412.6856, 2014.
+
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2921–2929, 2016.
+
+# A APPENDIX
+
+# A.1 GRAD-CAM TARGET LAYERS
+
+Table 2 shows the target layer names used in Grad-CAM for different network architectures according to their standard PyTorch (Paszke et al., 2017) implementations. Saliency map size is equal to the activation map of the target layers.
+
+Table 2: Target layer names and activation maps size for saliencies generated by different network architectures in Grad-CAM.   
+
+<table><tr><td></td><td>Target layer name in PyTorch torchvision package</td><td>Saliency map size</td></tr><tr><td>SqueezeNet1_1</td><td>features.0.12.expand3x3</td><td>13 ×13</td></tr><tr><td>AlexNet</td><td>features.0.10</td><td>13 ×13</td></tr><tr><td>ResNet18</td><td>features.7.1.conv2</td><td>7×7</td></tr></table>
+
+# B POINTING GAME VISUALIZATION
+
+Figure 5 shows an example from CUB200 in the Pointing Game. We used the segmentation annotation to verify whether the peak of the predicted saliency map (marked with red cross) falls inside the object region. It is regarded as hit as the red cross is inside the segmentation mask for the bird.
+
+![](images/3e59b0dc386b86facc06d523b925d24c5ac95c5b1d5165a09da8cda4bb4f9375.jpg)  
+Figure 5: An example of PG evaluation as hit for an image in CUB200. Left: image saliency map overlaid on the image. Right: the segmentation label where the red cross marks the peak saliency.
+
+# C TABULAR RESULTS
+
+In this section, we have tabulated results shown in Figure 2 and Figure 3 with means and standard deviations averaged over 3 runs.
+
+Table 3: Classification accuracy of few-shot CIL learning of CUB200 at the end of 11 tasks for ER with and without $\mathcal { L } _ { \mathrm { R R R } }$ using different backbone architectures and saliency map techniques. Results are averaged over 3 runs. Figure 2 (left) in the main paper is generated using numbers in this Table.   
+
+<table><tr><td></td><td>2</td><td></td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td><td>11</td></tr><tr><td>RN18-RRR-GCam</td><td>67.8±0.8</td><td>53.5±0.7</td><td>45.6±0.6 39.6±0.7</td><td></td><td>35.3±0.9</td><td>32.3± 1.1</td><td>29.4±0.9</td><td>25.9±0.8</td><td>25.7±0.6</td><td>26.3±0.7</td><td>23.6±0.7</td></tr><tr><td>RN18-ER</td><td>67.8±0.8</td><td>49.7 ±0.9</td><td>41.7 ±0.8</td><td>35.8 ±0.7</td><td>31.4 ± 0.9</td><td>28.5±0.8</td><td>25.5±0.8</td><td>22.1±0.8</td><td>21.8±0.8</td><td>22.5 ± 1.1</td><td>19.8± 0.9</td></tr><tr><td>RN18-RRR-Smooth</td><td>67.8± 0.8</td><td>50.9±0.6</td><td>43.5 ± 0.9</td><td>37.0±0.8</td><td>33.0±0.7</td><td>29.5± 0.6</td><td>26.8±0.8</td><td>23.9 ±0.8</td><td>23.9±0.8</td><td>23.4± 0.8</td><td>21.5± 0.5</td></tr><tr><td>RN18-RRR-BP</td><td>67.8±0.8</td><td>50.8±0.8</td><td>43.9 ±0.6</td><td>36.6 ±0.4</td><td>32.7±0.6</td><td>28.9±0.6</td><td>27.2± 0.5</td><td>23.8 ±0.6</td><td>23.8±0.6</td><td>24.0± 0.4</td><td>21.5± 0.6</td></tr><tr><td>RN18-Finetune</td><td>67.8± 0.8</td><td>44.8 ± 0.6</td><td>32.2± 0.5</td><td>25.8±0.7</td><td>25.6 ± 0.7</td><td>25.2± 0.7</td><td>20.8±0.6</td><td>16.8 ± 0.7</td><td>18.8± 0.5</td><td>18.3 ± 0.4</td><td>17.1 ± 0.6</td></tr><tr><td>Alex-RRR-GCam</td><td>56.7±0.7</td><td>46.6±0.5</td><td>43.9±0.7</td><td>41.3± 0.7</td><td>33.7 ± 0.5</td><td>27.4± 0.7</td><td>25.3±0.7</td><td>22.0±0.5</td><td>21.5±0.6</td><td>21.4± 0.6</td><td>21.2± 0.6</td></tr><tr><td>Alex-ER</td><td>56.7± 0.7</td><td>44.6 ± 0.7</td><td>41.3 ± 0.7</td><td>38.7±0.7</td><td>31.1 ± 0.7</td><td>24.5± 0.7</td><td>22.6± 0.7</td><td>19.6 ± 0.6</td><td>19.1± 0.8</td><td>18.7 ± 0.8</td><td>19.1± 0.8</td></tr><tr><td>Alex-Finetune</td><td>56.7±0.7</td><td>42.8 ± 0.8</td><td>39.6±0.8</td><td>36.9±0.8</td><td>29.5 ± 0.7</td><td>23.3±0.6</td><td>21.4± 0.8</td><td>17.9 ± 0.7</td><td>18.0 ±0.7</td><td>17.0 ± 0.5</td><td>16.9 ± 0.4</td></tr><tr><td>SQ-RRR-GCam</td><td>46.8± 0.5</td><td>36.2 ±0.4</td><td>30.1±0.6</td><td>28.3±0.4</td><td>25.1 ± 0.5</td><td>23.4± 0.5</td><td>19.3± 0.6</td><td>19.0± 0.6</td><td>18.5± 0.5</td><td>18.4± 0.5</td><td>18.2 ±0.6</td></tr><tr><td>SQ-ER</td><td>46.8 ± 0.5</td><td>33.2±0.5 27.1±0.6</td><td></td><td>25.3±0.6</td><td>22.1±0.52</td><td>20.5±0.5</td><td>16.3± 0.4</td><td>16.0±0.6</td><td>15.5± 0.6</td><td>15.4 ± 0.6</td><td>15.2 ± 0.7</td></tr><tr><td>SQ-Finetune</td><td>46.8 ± 0.5</td><td>32.0±0.7 25.2±0.7</td><td></td><td>23.9±0.7</td><td>20.2±0.81</td><td>19.4 ± 0.4</td><td>14.9 ± 0.4</td><td>14.4 ± 0.5</td><td>13.8± 0.4</td><td>14.2 ± 0.5</td><td>13.7±0.6</td></tr></table>
+
+Table 4: Performance of the state-of-the-art existing approaches with and without $\mathcal { L } _ { \mathrm { R R R } }$ on CUB200 including TOPIC (Tao et al., 2020), EEIL (Castro et al., 2018), iCaRL (Rebuffi et al., 2017). Results for baselines are obtained using their original implementation. Results are averaged over 3 runs. Figure 2 (right) in the main paper is generated using numbers in this Table.   
+
+<table><tr><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td><td>11</td></tr><tr><td>EEIL</td><td>68.6±0.4</td><td>53.6± 0.4</td><td>47.9 ± 0.3</td><td>44.2±0.8</td><td>36.3±0.9</td><td>27.4 ± 1.2</td><td>25.9±0.7</td><td>24.7±0.5</td><td>23.9±0.7</td><td>24.1± 0.7</td><td>22.1 ± 0.5</td></tr><tr><td>EEIL+RRR</td><td>68.6±0.4</td><td>56.6±0.5</td><td>50.9±0.6</td><td>48.3± 0.5</td><td>39.7 ± 1.2</td><td>31.4± 0.7</td><td>28.3± 1.2</td><td>28.0±0.6</td><td>26.5±0.6</td><td>27.4± 0.6</td><td>25.2±0.9</td></tr><tr><td>iCaRL</td><td>68.6±0.4</td><td>52.6±0.7</td><td>48.6± 1.2</td><td>44.1 ± 0.5</td><td>36.6±0.3</td><td>29.5±0.9</td><td>27.8± 0.4</td><td>26.2±0.5</td><td>24.0±0.6</td><td>23.8±0.6</td><td>21.1± 0.7</td></tr><tr><td>iCaRL+RRR</td><td>68.6±0.4</td><td>55.6± 1.2</td><td>53.6±0.7</td><td>47.1 ± 0.8</td><td>39.6±0.5</td><td>32.5±0.8</td><td>31.8 ± 0.4</td><td>29.2±0.6</td><td>27.0±0.8</td><td>27.8±0.6</td><td>24.1 ± 0.3</td></tr><tr><td>TOPIC</td><td>68.6 ± 0.4</td><td>62.4 ± 0.8</td><td>54.8 ± 0.4</td><td>49.9 ± 1.2</td><td>45.2 ±0.6</td><td>41.4± 0.3</td><td>38.3±0.8</td><td>35.3±0.6</td><td>32.2± 0.3</td><td>28.3±0.6</td><td>26.2 ± 1.2</td></tr><tr><td>TOPIC+RRR</td><td>68.6±0.4</td><td>62.5 ± 0.9</td><td>56.8 ± 0.4</td><td>51.5 ± 0.5</td><td>48.2 ± 0.4</td><td>44.4 ± 0.4</td><td>42.3±0.7</td><td>38.3±0.6</td><td>35.2±0.9</td><td>32.3±0.9</td><td>29.2 ± 0.5</td></tr><tr><td>FT</td><td>68.6±0.4</td><td>44.8 ± 0.5</td><td>32.2±0.8</td><td>25.8± 0.4</td><td>25.6 ± 1.1</td><td>25.2± 0.7</td><td>20.8± 1.1</td><td>16.7± 0.4</td><td>18.8 ± 1.1</td><td>18.2± 0.3</td><td>17.1 ± 0.8</td></tr><tr><td>ER</td><td>67.8±0.8</td><td>49.7± 0.9</td><td>41.7 ± 0.8</td><td>35.8 ±0.7</td><td>31.4± 0.9</td><td>28.5±0.8</td><td>25.5±0.8</td><td>22.1± 0.8</td><td>21.8± 0.6</td><td>22.5 ± 1.1</td><td>19.8±0.9</td></tr><tr><td>RRR</td><td>67.8±0.8</td><td>53.5± 0.7</td><td>45.6± 0.6</td><td>39.6± 0.7</td><td>35.3±0.9</td><td>32.3 ± 1.1</td><td>29.4± 0.9</td><td>25.9± 0.8</td><td>25.7±0.6</td><td>26.3±0.7</td><td>23.6±0.7</td></tr><tr><td>JT</td><td>68.6±0.4</td><td>62.4± 0.4</td><td>57.2 ± 0.4</td><td>52.8±0.5</td><td>49.5 ± 0.9</td><td>46.1 ± 0.5</td><td>42.8 ± 1.1</td><td>40.1±0.8</td><td>38.7±0.7</td><td>37.1± 0.5</td><td>35.6±0.9</td></tr></table>
+
+Table 5: Performance of the state-of-the-art existing approaches with and without $\mathcal { L } _ { \mathrm { R R R } }$ on CIFAR100 in 10 tasks. Results for iTAML (Rajasegaran et al., 2020), BiC (Wu et al., 2019), and EEIL (Castro et al., 2018) are produced with their original implementation while EWC (Kirkpatrick et al., 2017) and LwF (Li & Hoiem, 2016) are re-implemented by us. Results are averaged over 3 runs. Figure 3a in the main paper is generated using numbers in this Table.   
+
+<table><tr><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>iTAML+RRR</td><td>89.2± 0.5</td><td>92.3±0.7</td><td>89.5 ± 1.2</td><td>87.5 ± 1.2</td><td>84.1±0.8</td><td>83.5±0.9</td><td>83.9±0.7</td><td>81.2± 0.3</td><td>79.6 ± 0.9</td><td>79.7±0.5</td></tr><tr><td>iTAML</td><td>89.2± 0.5</td><td>88.9±0.5</td><td>87.0 ± 1.1</td><td>85.7 ± 1.1</td><td>84.1 ± 1.1</td><td>81.8 ± 0.3</td><td>80.0±0.6</td><td>79.0± 0.3</td><td>78.6 ±0.8</td><td>77.8 ±0.6</td></tr><tr><td>BiC</td><td>90.3±0.7</td><td>82.1 ± 0.7</td><td>75.1± 0.4</td><td>69.8 ± 1.2</td><td>65.3±0.8</td><td>61.3± 0.9</td><td>57.4± 0.7</td><td>54.9± 0.5</td><td>53.2 ±0.9</td><td>50.3±0.7</td></tr><tr><td>BiC+RRR</td><td>90.3±0.7</td><td>84.9 ± 1.1</td><td>76.4± 0.6</td><td>69.3±0.3</td><td>65.1±0.9</td><td>63.3± 0.4</td><td>59.7 ± 1.1</td><td>55.4± 0.8</td><td>55.8 ± 0.7</td><td>52.1 ± 0.5</td></tr><tr><td>EEIL</td><td>80.0±0.7</td><td>80.5± 1.2</td><td>75.5± 0.9</td><td>71.5± 0.4</td><td>68.0± 1.2</td><td>62.0±0.9</td><td>59.0± 0.7</td><td>55.1 ± 1.2</td><td>51.4 ± 0.8</td><td>48.7 ± 0.4</td></tr><tr><td>EEIL+RRR</td><td>80.0±0.7</td><td>83.5± 0.3</td><td>78.7 ± 1.2</td><td>74.0 ± 1.2</td><td>71.7± 0.3</td><td>65.1 ± 0.4</td><td>61.2± 0.5</td><td>57.6± 0.5</td><td>54.1 ± 0.4</td><td>51.7± 0.3</td></tr><tr><td>LwF</td><td>86.1 ± 1.2</td><td>69.0±0.7</td><td>55.0±0.3</td><td>45.8± 0.3</td><td>40.4± 0.5</td><td>36.7±0.9</td><td>30.8 ±0.7</td><td>28.6±0.5</td><td>26.1 ± 0.7</td><td>24.2 ±0.7</td></tr><tr><td>LwF+RRR</td><td>86.1 ± 1.2</td><td>72.4± 0.8</td><td>57.0 ± 1.1</td><td>48.3 ± 0.3</td><td>43.2 ±0.8</td><td>39.3 ±0.5</td><td>34.1 ± 0.6</td><td>32.1 ± 1.1</td><td>29.8 ±0.7</td><td>27.1± 0.6</td></tr><tr><td>EWC</td><td>86.1 ± 1.2</td><td>52.6 ± 0.4</td><td>48.6± 0.4</td><td>38.5±0.5</td><td>31.1 ± 0.9</td><td>26.5±0.3</td><td>21.7±0.6</td><td>20.0±0.7</td><td>18.9 ± 0.5</td><td>16.6 ±0.9</td></tr><tr><td>EWC+RRR</td><td>86.1 ± 1.2</td><td>56.0± 0.4</td><td>53.9 ± 1.2</td><td>44.4 ± 0.9</td><td>35.1±0.5</td><td>28.6±0.6</td><td>25.1 ± 1.1</td><td>23.1± 0.5</td><td>18.8 ±0.9</td><td>19.0 ± 1.2</td></tr><tr><td>ER</td><td>86.1 ± 1.2</td><td>74.5 ± 0.9</td><td>65.2±0.8</td><td>62.5± 0.8</td><td>56.7±0.7</td><td>50.5± 0.3</td><td>47.6 ± 0.4</td><td>43.4± 0.3</td><td>41.6 ± 0.9</td><td>38.1 ± 1.1</td></tr><tr><td>RRR</td><td>86.1 ± 1.2</td><td>78.5± 0.9</td><td>69.2 ± 1.1</td><td>63.5 ± 1.2</td><td>58.7±0.8</td><td>53.5 ± 1.1</td><td>49.6± 0.7</td><td>44.4± 0.3</td><td>42.6 ± 1.2</td><td>39.1 ± 1.1</td></tr></table>
+
+Table 7: Performance of the state-of-the-art existing approaches with and without $\mathcal { L } _ { \mathrm { R R R } }$ on ImageNet100 in 10 tasks. Results for iTAML (Rajasegaran et al., 2020), BiC (Wu et al., 2019), and EEIL (Castro et al., 2018) are produced with their original implementation while EWC (Kirkpatrick et al., 2017) and LwF (Li & Hoiem, 2016) are re-implemented by us. Results are averaged over 3 runs. Figure 3c in the main paper is generated using numbers in this Table.   
+
+<table><tr><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>iTAML</td><td>99.4± 0.8</td><td>96.4±0.9</td><td>94.4 ± 0.9</td><td>93.0±0.3</td><td>92.4± 1.2</td><td>90.6±0.3</td><td>89.9 ±0.4</td><td>90.3±0.8</td><td>90.3 ±1.1</td><td>89.8±0.4</td></tr><tr><td>iTAML+RRR</td><td>99.4± 0.8</td><td>97.3± 0.5</td><td>96.6±0.7</td><td>96.3 ± 1.1</td><td>95.3 ± 0.5</td><td>93.1 ± 0.5</td><td>92.1 ± 0.6</td><td>92.1±0.6</td><td>92.9±0.9</td><td>91.9 ± 0.4</td></tr><tr><td>EEIL</td><td>99.5 ± 0.4</td><td>98.8 ± 1.1</td><td>95.9±0.9</td><td>93.0 ±0.4</td><td>88.3 ±1.1</td><td>86.7 ± 1.2</td><td>83.0 ±1.2</td><td>81.1± 0.5</td><td>78.2 ±0.7</td><td>75.4± 0.4</td></tr><tr><td>EEIL+RRR</td><td>99.5± 0.4</td><td>98.1 ± 0.7</td><td>97.4 ± 1.1</td><td>96.7 ± 0.4</td><td>93.3 ± 0.5</td><td>89.4 ± 1.1</td><td>86.5±0.3</td><td>86.1 ± 1.1</td><td>81.8 ± 0.4</td><td>77.0± 0.3</td></tr><tr><td>BiC</td><td>98.3±0.7</td><td>94.9 ±0.8</td><td>93.5±0.7</td><td>90.9 ± 1.2</td><td>89.0 ± 1.2</td><td>87.3± 0.6</td><td>85.2±0.7</td><td>83.2 ± 0.4</td><td>82.5±0.9</td><td>81.1 ± 1.1</td></tr><tr><td>BiC+RRR</td><td>98.3±0.7</td><td>98.9 ±0.3</td><td>96.5±0.6</td><td>93.9 ± 0.4</td><td>92.0±0.7</td><td>89.3 ± 1.1</td><td>87.2 ±0.8</td><td>87.2 ± 1.1</td><td>85.5±0.9</td><td>84.1± 0.6</td></tr><tr><td>iCaRL</td><td>99.3±0.4</td><td>97.2 ± 0.9</td><td>93.5±0.9</td><td>91.0 ± 0.3</td><td>87.5 ± 1.2</td><td>82.1 ± 1.2</td><td>77.1 ± 0.4</td><td>72.8± 0.6</td><td>67.1 ±0.8</td><td>63.5 ± 1.1</td></tr><tr><td>iCaRL+RRR</td><td>99.3± 0.4</td><td>97.9 ± 1.2</td><td>94.1 ± 0.7</td><td>92.8 ±0.7</td><td>91.7 ± 0.9</td><td>85.7 ± 1.1</td><td>82.1 ± 0.6</td><td>74.4 ± 0.9</td><td>72.2 ± 0.8</td><td>68.1±0.9</td></tr><tr><td>LwF</td><td>99.3±0.5</td><td>95.2 ± 0.9</td><td>85.9± 0.9</td><td>73.9 ± 1.1</td><td>63.7±0.8</td><td>54.8 ± 0.8</td><td>50.1 ± 0.6</td><td>44.5 ± 0.9</td><td>40.7 ± 0.5</td><td>36.7±0.3</td></tr><tr><td>LwF+RRR</td><td>99.3±0.5</td><td>97.1 ± 1.2</td><td>89.3 ±0.6</td><td>79.1 ± 0.5</td><td>69.1 ± 1.1</td><td>59.4 ± 1.1</td><td>57.2 ± 0.7</td><td>48.2 ± 1.1</td><td>45.1 ± 0.6</td><td>41.5 ± 0.5</td></tr><tr><td>FT</td><td>99.3± 0.5</td><td>49.4 ± 0.3</td><td>32.6±0.3</td><td>24.7 ± 0.6</td><td>20.0 ± 1.2</td><td>16.7 ± 0.3</td><td>13.9 ± 0.3</td><td>12.3 ± 0.7</td><td>11.1 ± 0.6</td><td>9.9 ±0.7</td></tr><tr><td>ER</td><td>99.3± 0.5</td><td>95.2 ± 0.8</td><td>88.1±0.8</td><td>78.1± 0.9</td><td>72.5 ± 0.6</td><td>69.1± 0.8</td><td>67.1 ± 0.6</td><td>61.8 ±0.6</td><td>55.1± 0.3</td><td>50.1 ± 1.1</td></tr><tr><td>RRR</td><td>99.3± 0.5</td><td>96.5 ± 0.3</td><td>93.4±0.8</td><td>84.8±0.7</td><td>78.7 ± 0.4</td><td>74.7 ± 0.4</td><td>73.1 ± 0.5</td><td>68.4±0.8</td><td>60.2±0.3</td><td>55.1 ±0.7</td></tr></table>
+
+Table 6: Performance of the state-of-the-art existing approaches with and without $\mathcal { L } _ { \mathrm { R R R } }$ on CIFAR100 in 20 tasks. Results for iTAML (Rajasegaran et al., 2020), BiC (Wu et al., 2019), and EEIL (Castro et al., 2018) are produced with their original implementation while EWC (Kirkpatrick et al., 2017) and LwF (Li & Hoiem, 2016) are re-implemented by us. Results are averaged over 3 runs. Figure 3b in the main paper is generated using numbers in this Table.   
+(a) Tasks 1-10   
+
+<table><tr><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>iTAML</td><td>84.7±0.6</td><td>85.7 ±0.4</td><td>86.5±0.3</td><td>86.5±0.8</td><td>86.3±1.2</td><td>85.7±0.8</td><td>84.9 ± 1.1</td><td>82.6±0.3</td><td>80.8±0.7</td><td>82.4± 0.3</td></tr><tr><td>iTAML+RRR</td><td>84.7±0.6</td><td>89.9± 0.5</td><td>89.2±0.9</td><td>89.2±0.6</td><td>89.0 ± 1.1</td><td>87.2 ±0.6</td><td>88.0±0.4</td><td>85.6 ± 1.1</td><td>86.6±0.3</td><td>85.4±0.3</td></tr><tr><td>BiC</td><td>95.7±0.6</td><td>90.3±0.9</td><td>80.9±0.8</td><td>75.8 ± 0.8</td><td>73.5±0.6</td><td>71.5 ± 1.2</td><td>67.8±0.4</td><td>65.4±0.8</td><td>62.7 ± 1.2</td><td>61.9 ± 1.2</td></tr><tr><td>BiC+RRR</td><td>95.7± 0.6</td><td>93.3±0.6</td><td>84.7 ± 1.1</td><td>77.5 ± 0.9</td><td>73.4±0.6</td><td>74.8 ± 0.6</td><td>69.6± 0.7</td><td>67.4± 0.3</td><td>65.7± 0.5</td><td>64.9±0.6</td></tr><tr><td>EEIL</td><td>81.9 ± 0.5</td><td>86.3±0.3</td><td>84.9 ± 0.4</td><td>80.7±0.3</td><td>77.7 ±0.6</td><td>74.9± 0.3</td><td>70.9±0.7</td><td>67.4± 0.7</td><td>64.9 ± 0.5</td><td>62.4±0.3</td></tr><tr><td>EEIL+RRR</td><td>81.9±0.5</td><td>88.4±0.8</td><td>87.6±0.7</td><td>82.6 ± 1.2</td><td>78.5 ± 0.6</td><td>76.9 ± 0.4</td><td>71.2 ±0.7</td><td>67.3± 0.4</td><td>67.0 ± 1.2</td><td>64.5±0.3</td></tr><tr><td>LwF</td><td>85.1 ± 0.7</td><td>68.8 ±0.9</td><td>58.6 ±1.1</td><td>50.5 ± 1.2</td><td>43.5±0.9</td><td>37.5 ± 0.6</td><td>33.7±0.9</td><td>30.4±0.9</td><td>26.8 ± 1.1</td><td>24.9 ± 0.7</td></tr><tr><td>LwF+RRR</td><td>85.1±0.7</td><td>71.6 ± 0.6</td><td>61.8±0.7</td><td>54.2 ± 0.5</td><td>46.2±0.9</td><td>40.7 ±0.7</td><td>36.7 ± 1.2</td><td>34.4± 0.4</td><td>29.8±0.7</td><td>27.2 ± 1.2</td></tr><tr><td>EWC</td><td>85.1± 0.7</td><td>61.3± 0.5</td><td>47.4± 0.8</td><td>36.2±0.3</td><td>31.3±0.6</td><td>27.9± 0.5</td><td>23.7 ± 1.1</td><td>22.5± 0.4</td><td>20.8±0.8</td><td>18.9±0.7</td></tr><tr><td>EWC+RRR</td><td>85.1±0.7</td><td>68.9 ±0.5</td><td>52.2 ±0.9</td><td>39.9 ±0.9</td><td>35.2±0.3</td><td>30.0±0.3</td><td>24.3 ± 0.8</td><td>24.0±0.6</td><td>23.7 ± 0.4</td><td>21.0 ± 1.1</td></tr><tr><td>ER</td><td>85.1± 0.7</td><td>83.1± 0.9</td><td>81.8±0.7</td><td>74.9 ± 0.3</td><td>70.4± 0.3</td><td>61.5 ± 1.2</td><td>60.8 ± 1.1</td><td>57.0±0.7</td><td>54.3 ± 0.4</td><td>48.2±0.6</td></tr><tr><td>RRR</td><td>85.1± 0.7</td><td>85.1 ± 0.9</td><td>83.8±0.4</td><td>77.9 ± 0.4</td><td>72.4 ± 1.2</td><td>64.5 ± 0.7</td><td>62.8±0.7</td><td>59.0±0.3</td><td>57.3±0.8</td><td>51.2 ± 1.1</td></tr></table>
+
+(b) Tasks 11-20   
+
+<table><tr><td></td><td>11</td><td>12</td><td>13</td><td>14</td><td>15</td><td>16</td><td>17</td><td>18</td><td>19</td><td>20</td></tr><tr><td>iTAML</td><td>80.0 ± 1.1</td><td>80.6±0.5</td><td>74.3 ± 0.8</td><td>70.7±0.6</td><td>71.3 ± 1.1</td><td>68.3±0.5</td><td>70.3 ±0.8</td><td>68.3±0.6</td><td>69.5 ± 0.3</td><td>66.0±0.6</td></tr><tr><td>iTAML+RRR</td><td>85.5±0.5</td><td>85.2±0.8</td><td>79.7± 0.6</td><td>74.3 ± 0.4</td><td>74.0± 0.9</td><td>73.4 ± 1.1</td><td>74.8± 0.9</td><td>74.4 ± 0.4</td><td>73.9 ±0.5</td><td>71.8±0.9</td></tr><tr><td>BiC</td><td>59.2 ±0.4</td><td>57.0± 0.6</td><td>56.1 ± 1.2</td><td>55.7± 0.6</td><td>53.8±0.5</td><td>52.4 ± 1.2</td><td>49.7 ± 0.6</td><td>49.2 ± 1.2</td><td>47.7 ± 1.1</td><td>46.7 ± 1.2</td></tr><tr><td>BiC+RRR</td><td>62.2 ± 0.5</td><td>59.1 ±0.7</td><td>58.2±0.5</td><td>57.8±0.5</td><td>54.4 ± 1.2</td><td>56.6±0.9</td><td>53.9 ±0.7</td><td>52.4 ± 1.1</td><td>49.5 ± 0.8</td><td>49.4± 0.9</td></tr><tr><td>EEIL</td><td>60.9±0.6</td><td>59.5 ± 0.6</td><td>57.8±0.6</td><td>55.1 ± 0.3</td><td>53.9±0.5</td><td>51.7± 0.3</td><td>50.1±0.8</td><td>49.4± 0.5</td><td>47.4± 0.6</td><td>46.9 ± 0.9</td></tr><tr><td>EEIL+RRR</td><td>63.7±0.6</td><td>62.9 ± 0.4</td><td>59.7 ± 0.4</td><td>57.0±0.3</td><td>55.6±0.8</td><td>53.5± 0.4</td><td>53.5±0.3</td><td>52.7 ± 0.4</td><td>49.1 ± 0.3</td><td>47.8 ± 0.4</td></tr><tr><td>LwF</td><td>23.9 ±0.7</td><td>21.4± 0.7</td><td>20.0±0.7</td><td>19.1 ± 0.9</td><td>18.7±0.8</td><td>17.1 ± 0.8</td><td>15.6 ±0.8</td><td>14.7 ± 0.8</td><td>14.0 ± 0.8</td><td>13.7 ± 1.1</td></tr><tr><td>LwF+RRR</td><td>27.7± 0.7</td><td>26.9 ±0.9</td><td>25.7±0.7</td><td>24.5 ± 1.2</td><td>23.6±0.6</td><td>22.6±0.7</td><td>19.5 ± 0.3</td><td>18.6 ± 0.5</td><td>19.7 ± 0.8</td><td>18.4± 1.2</td></tr><tr><td>EWC</td><td>17.2 ± 1.1</td><td>16.0 ± 0.5</td><td>15.0± 0.8</td><td>14.5 ± 0.8</td><td>13.4 ± 1.1</td><td>12.4 ± 0.4</td><td>12.3 ± 0.4</td><td>11.5 ± 0.8</td><td>11.2 ± 0.8</td><td>9.44± 0.5</td></tr><tr><td>EWC+RRR</td><td>20.7±0.3</td><td>19.5 ± 0.4</td><td>18.4± 0.7</td><td>17.3 ± 0.5</td><td>16.2 ± 0.4</td><td>15.8 ± 0.5</td><td>15.0 ± 0.7</td><td>16.6± 0.9</td><td>14.3 ± 0.4</td><td>13.2± 0.3</td></tr><tr><td>ER</td><td>45.8 ± 0.6</td><td>42.7± 0.7</td><td>41.6 ± 0.6</td><td>41.2 ± 0.6</td><td>36.5±0.4</td><td>36.5±0.6</td><td>33.8± 0.4</td><td>32.4± 1.2</td><td>31.4± 0.7</td><td>30.2±0.5</td></tr><tr><td>RRR</td><td>48.8± 0.3</td><td>46.7 ± 0.9</td><td>43.6 ± 1.1</td><td>44.2 ± 0.7</td><td>39.5±0.3</td><td>38.5±0.9</td><td>35.8±0.3</td><td>33.4± 0.3</td><td>32.4±0.3</td><td>31.2±0.3</td></tr></table>

parse/train/tHgJoMfy6nI/tHgJoMfy6nI_content_list.json

@@ -0,0 +1,1409 @@
+[
+    {
+        "type": "text",
+        "text": "REMEMBERING FOR THE RIGHT REASONS: EXPLANATIONS REDUCE CATASTROPHIC FORGETTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            689,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sayna Ebrahimi1, Suzanne Petryk1, Akash Gokul1, William Gan1, Joseph E. Gonzalez1, Marcus Rohrbach2, Trevor Darrell1 ",
+        "bbox": [
+            183,
+            194,
+            799,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1UC Berkeley, 2 Facebook AI Research   \n{sayna,spetryk,akashgokul,wjgan,jegonzal,trevordarrell}@berkeley.edu   \nmrf@fb.com ",
+        "bbox": [
+            186,
+            228,
+            784,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            310,
+            544,
+            325
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The goal of continual learning (CL) is to learn a sequence of tasks without suffering from the phenomenon of catastrophic forgetting. Previous work has shown that leveraging memory in the form of a replay buffer can reduce performance degradation on prior tasks. We hypothesize that forgetting can be further reduced when the model is encouraged to remember the evidence for previously made decisions. As a first step towards exploring this hypothesis, we propose a simple novel training paradigm, called Remembering for the Right Reasons (RRR), that additionally stores visual model explanations for each example in the buffer and ensures the model has “the right reasons” for its predictions by encouraging its explanations to remain consistent with those used to make decisions at training time. Without this constraint, there is a drift in explanations and increase in forgetting as conventional continual learning algorithms learn new tasks. We demonstrate how RRR can be easily added to any memory or regularizationbased approach and results in reduced forgetting, and more importantly, improved model explanations. We have evaluated our approach in the standard and few-shot settings and observed a consistent improvement across various CL approaches using different architectures and techniques to generate model explanations and demonstrated our approach showing a promising connection between explainability and continual learning. Our code is available at https://github.com/ SaynaEbrahimi/Remembering-for-the-Right-Reasons. ",
+        "bbox": [
+            233,
+            342,
+            764,
+            619
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            648,
+            336,
+            664
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Humans are capable of continuously learning novel tasks by leveraging their lifetime knowledge and expanding them when they encounter a new experience. They can remember the majority of their prior knowledge despite the never-ending nature of their learning process by simply keeping a running tally of the observations distributed over time or presented in summary form. The field of continual learning or lifelong learning (Thrun & Mitchell, 1995; Silver et al., 2013) aims at maintaining previous performance and avoiding so-called catastrophic forgetting of previous experience (McCloskey & Cohen, 1989; McClelland et al., 1995) when learning new skills. The goal is to develop algorithms that continually update or add parameters to accommodate an online stream of data over time. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "An active line of research in continual learning explores the effectiveness of using small memory budgets to store data points from the training set (Castro et al., 2018; Rajasegaran et al., 2020; Rebuffi et al., 2017; Wu et al., 2019), gradients (Lopez-Paz et al., 2017), or storing an online generative model that can fake them later (Shin et al., 2017). Memory has been also exploited in the form of accommodating space for architecture growth and storage to fully recover the old performance when needed (Ebrahimi et al., 2020b; Rusu et al., 2016). Some methods store an old snapshot of the model to distill the features (Li & Hoiem, 2016) or attention maps (Dhar et al., 2019) between the teacher and student models. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/d0281df291d1cac11c700eef36b889185db8c8c6f64b2f631bab1a588c539ccf.jpg",
+        "image_caption": [
+            "Figure 1: An illustration of applying RRR paradigm. (Left) In a typical experience replay scenario, samples from prior tasks are kept in a memory buffer $\\mathcal { M } ^ { \\mathrm { r e p } }$ and revisited during training. (Right) In our proposed idea (RRR), in addition to ${ \\mathcal { M } } ^ { \\mathrm { r e p } }$ , we also store model explanations (saliency maps) as $\\mathcal { M } ^ { \\mathrm { R R R } }$ for those samples and encourage the model to remember the original reasoning for the prediction. Note that the saliency maps are small masks resulting in a negligible memory overhead (see Section 4.1). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            323,
+            101,
+            673,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The internal reasoning process of deep models is often treated as a black box and remains hidden from the user. However, recent work in explainable artificial intelligence (XAI) has developed methods to create human-interpretable explanations for model decisions (Simonyan et al., 2013; Zhang et al., 2018; Petsiuk et al., 2018; Zhou et al., 2016; Selvaraju et al., 2017). We posit that the catastrophic forgetting phenomenon is due in part to not being able to rely on the same reasoning as was used for a previously seen observation. Therefore, we hypothesize that forgetting can be mitigated when the model is encouraged to remember the evidence for previously made decisions. In other words, a model which can remember its final decision and can reconstruct the same prior reasoning. Based on this approach, we develop a novel strategy to exploit explainable models for improving performance. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            513
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Among the various explainability techniques proposed in XAI, saliency methods have emerged as a popular tool to identify the support of a model prediction in terms of relevant features in the input. These methods produce saliency maps, defined as regions of visual evidence upon which a network makes a decision. Our goal is to investigate whether augmenting experience replay with explanation replay reduces forgetting and how enforcing to remember the explanations will affect the explanations themselves. Figure 1 illustrates our proposed method. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            603
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose RRR, a training strategy guided by model explanations generated by any white-box differentiable explanation method; RRR adds an explanation loss to continual learning. White-box methods generate an explanation by using some internal state of the model, such as gradients, enabling their use in end-to-end training. We evaluate our approach using various popular explanation methods including vanilla backpropagation (Zeiler & Fergus, 2014), backpropagation with smoothing gradients (Smoothgrad) (Smilkov et al., 2017), Guided Backpropagation (Springenberg et al., 2014), and Gradient Class Activation Mapping (Grad-CAM) (Selvaraju et al., 2017) and compare their performance versus their computational feasibility. We integrate RRR into several state of the art class incremental learning (CIL) methods, including iTAML (Rajasegaran et al., 2020), EEIl (Castro et al., 2018), BiC (Wu et al., 2019), TOPIC (Tao et al., 2020), iCaRL (Rebuffi et al., 2017), EWC (Kirkpatrick et al., 2017), and LwF (Li & Hoiem, 2016). Note that RRR does not require task IDs at test time. We qualitatively and quantitatively analyze model explanations in the form of saliency maps and demonstrate that RRR remembers its earlier decisions in a sequence of tasks due to the requirement to focus on the the right evidence. We empirically show the effect of RRR in standard and few-shot class incremental learning (CIL) scenarios on popular benchmark datasets including CIFAR100, ImageNet100, and Caltech-UCSD Birds 200 using different network architectures where RRR improves overall accuracy and forgetting over experience replay and other memory-based method. ",
+        "bbox": [
+            173,
+            611,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contribution is threefold: we first propose our novel, simple, yet effective memory constraint, which we call Remembering for the Right Reasons (RRR), and show that it reduces catastrophic forgetting by encouraging the model to look at the same explanations it initially found for its decisions. Second, we show how RRR can be readily combined with memory-based and regularization-based ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "CL methods to improve performance. Third, we demonstrate how guiding a continual learner to remember its explanations can improve the quality of the explanations themselves; i.e., the model looks at the right region in an image when making correct decisions while it focuses its maximum attention on the background when it misclassifies an object. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND: WHITE-BOX EXPLANABILITY TECHNIQUES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            700,
+            196
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here we briefly review the explainability methods we have evaluated our approach with. The core idea behind RRR is to guide explanations or saliency maps during training to preserve their values. Hence, only gradient-based saliency techniques can be used which are differentiable and hence trainable during training for the mainstream task as opposed to black-box saliency methods which can be used only after training to determine important parts of an image. ",
+        "bbox": [
+            174,
+            212,
+            825,
+            281
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Vanilla Backpropagation (Zeiler & Fergus, 2014): The simplest way to understand and visualize which pixels are most salient in an image is to look at the gradients. This is typically done by making a forward pass through the model and taking the gradient of the given output class with respect to the input. Those pixel-wise derivative values can be rendered as a normalized heatmap representing the amount of change in the output probability of a class caused by perturbing that pixel. To store a saliency map for each RGB image of size $3 \\times W \\times H$ , we need an equivalent memory size of storing $W \\times H$ pixel values. ",
+        "bbox": [
+            174,
+            287,
+            825,
+            386
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Backpropagation with SmoothGrad: Smilkov et al. (2017) showed that the saliency maps obtained using raw gradients are visually noisy and using them as a proxy for feature importance is sub-optimal. They proposed a simple technique for denoising the gradients that adds pixel-wise Gaussian noise to $n$ copies of the image, and simply averages the resulting gradients. SmoothGrad requires the same amount of memory to store the saliency maps while it takes $n$ times longer to repeat generating each saliency map. We found $n = 4 0$ to be large enough to make a noticeable change in the saliencies in our experiments. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            491
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gradient-weighted Class Activation Mapping (Grad-CAM) (Selvaraju et al., 2017): is a whitebox explainability technique which uses gradients to determine the influence of specific feature map activations on a given prediction. Because later layers in a convolutional neural network are known to encode higher-level semantics, taking the gradient of a model output with respect to the activations of these feature maps discovers which high-level semantics are important for the prediction. We refer to this layer as the target layer in our analysis. For example, when using Grad-CAM to visualize explanations for image classification, taking the gradient of the correct class prediction with respect to the last convolutional layer highlights class-discriminative regions in the image (such as the wings of a bird when identifying bird species). ",
+        "bbox": [
+            173,
+            497,
+            825,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider the pre-softmax score $y _ { c }$ for class $c$ in an image classification output. In general, any differentiable activation can be used. Consider also a single convolutional layer with $K$ feature maps, with a single feature map noted as $A ^ { k } \\in \\mathbb { R } ^ { u \\times v }$ . Grad-CAM takes the derivative of $y _ { c }$ with respect to each feature map $A ^ { k }$ . It then performs global average pooling over the height and width dimensions for each of these feature map gradients, getting a vector of length $K$ . Each element in this vector is used as a weight $\\alpha _ { k } ^ { c }$ , indicating the importance of feature map $k$ for the prediction $y _ { c }$ . Next, these importance weights are used in computing a linear combination of the feature maps. Followed by a ReLU (Jarrett et al., 2009) to zero-out any activations with a negative influence on the prediction of class $c$ , the final Grad-CAM output (s) is as below with $A _ { i j } ^ { k }$ defined at location $( i , j )$ in feature map $A ^ { k }$ . ",
+        "bbox": [
+            173,
+            628,
+            825,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5911ba57e7dc3c03984f39cc0c9163a4456070f768cfefe513df46d7f04827a6.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\alpha _ { k } ^ { c } = } & { { } \\frac { 1 } { u v } \\displaystyle \\sum _ { i = 1 } ^ { u } \\displaystyle \\sum _ { j = 1 } ^ { v } \\frac { \\partial y _ { c } } { \\partial A _ { i j } ^ { k } } \\qquad s _ { G r a d - C A M } ^ { c } = R e L U \\left( \\displaystyle \\sum _ { k = 1 } ^ { K } \\alpha _ { k } ^ { c } A ^ { k } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            772,
+            709,
+            813
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlike the common saliency map techniques of Guided BackProp (Springenberg et al., 2014), Guided GradCAM (Selvaraju et al., 2016), Integrated Gradients (Sundararajan et al., 2017b), Gradient $\\odot$ Input (Shrikumar et al., 2016), Backpropagation with SmoothGrad (Smilkov et al., 2017) etc., vanilla Backpropagation and Grad-CAM pass important “sanity checks” regarding their sensitivity to data and model parameters (Adebayo et al., 2018). We will compare using vanilla Backpropagation, Backpropagation with SmoothGrad, and Grad-CAM in RRR in Section 4. We will refer to the function that computes the output $s$ of these saliency method as $ { \\mathcal { X } }  { \\mathcal { A } }  { \\mathcal { T } }$ . ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Remembering for the Right Reasons (RRR) for Continual Learning   \n1: function TRAIN $( f _ { \\theta } , \\mathcal { D } ^ { t r } , \\mathcal { D } ^ { t s } )$ function UPDATE MEM(f kθ , Dtrk , Mrep, MRRR)   \n2: $T$ : # of tasks, $n$ : # of samples in task (xi, k, yi) ∼ Dtrk   \n3: R ← 0 ∈ R T ×T Mrep ← Mrep ∪ {(xi, k, yi)}   \n4: Mrep ← {} sˆ ← X AI(f kθ (xi, k))   \n5: $\\mathcal { M } ^ { \\mathrm { R R R } }  \\{ \\}$ MRRR ← MRRR ∪ {sˆ}   \n6: for $k = 1$ to T do return Mrep, MRRR   \n7: for $i = 1$ to n do end function   \n8: Compute cross entropy on task $( \\mathcal { L } _ { \\mathrm { t a s k } } )$   \n9: Compute $\\mathcal { L } _ { \\mathrm { R R R } }$ using Eq. 2 function EVAL(f kθ , Dts{1···k})   \n10: $\\theta ^ { \\prime }  \\theta - \\alpha \\nabla _ { \\theta } ( \\mathcal { L } _ { \\mathrm { t a s k } } + \\mathcal { L } _ { \\mathrm { R R R } } )$ for $i = 1$ to $k$ do   \n11: end for Rk,i = Accuracy $( f _ { \\theta } ^ { k } ( x , i ) , y \\vert \\forall ( x , y ) \\in \\mathcal { D } _ { i } ^ { t s } )$   \n12: $\\begin{array} { r l } & { \\mathcal { M } ^ { \\mathrm { r e p } } , \\mathcal { M } ^ { \\mathrm { R R R } } \\gets \\mathrm { U P D A T E ~ M E M } ( f _ { \\theta } ^ { k } , \\mathcal { D } _ { k } ^ { t r } , \\mathcal { M } ^ { \\mathrm { r e p } } , } \\\\ & { } \\\\ & { R _ { k , \\{ 1 \\cdots k \\} } \\gets \\mathrm { E V A L } \\left( f _ { \\theta } ^ { k } , \\mathcal { D } _ { \\{ 1 \\cdots k \\} } ^ { t s } \\right) } \\end{array}$ , end for   \nreturn $R$   \n13: end function   \n14: end for   \n15: return $f _ { \\boldsymbol { \\theta } } , R$   \n16: end function ",
+        "bbox": [
+            173,
+            102,
+            821,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 REMEMBERING FOR THE RIGHT REASONS (RRR) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            375,
+            619,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Memory-based methods in continual learning have achieved high performance on vision benchmarks using a small amount of memory, i.e. storing a few samples from the training data into the replay buffer to directly train with them when learning new tasks. This simple method, known as experience replay, has been explored and shown to be effective (Rebuffi et al., 2017; Wu et al., 2019; Castro et al., 2018; Rajasegaran et al., 2020; Ebrahimi et al., 2020b; Hayes et al., 2019; Riemer et al., 2018). In this work we aim to go one step further and investigate the role of explanations in continual learning, particularly on mitigating forgetting and change of model explanations. ",
+        "bbox": [
+            173,
+            406,
+            825,
+            503
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider the problem of learning a sequence of $T$ data distributions $\\mathcal { D } ^ { t r } = \\{ \\mathcal { D } _ { 1 } ^ { t r } , \\cdot \\cdot \\cdot , \\mathcal { D } _ { T } ^ { t r } \\}$ , where $\\mathcal { D } _ { k } ^ { t r } = \\{ ( x _ { i } ^ { k } , y _ { i } ^ { k } ) _ { i = 1 } ^ { n _ { k } } \\}$ is the data distribution for task $k$ with $n$ sample tuples of input $( \\mathbf { x } ^ { k } \\subset \\mathcal { X } )$ and set of output labels $( \\mathbf { y } ^ { k } \\subset \\mathcal { V } )$ . The goal is to sequentially learn the model $f _ { \\theta } : \\mathcal { X } \\times \\mathcal { T }  \\mathcal { Y }$ for each task that can map each input $x$ to its target output, $y$ , while maintaining its performance on all prior tasks. We aim to achieve this by using memory to enhance better knowledge transfer as well as better avoidance of catastrophic forgetting. We assume two limited memory pools $\\mathcal { M } ^ { \\mathrm { r e p } }$ for raw samples and $\\mathcal { M } ^ { \\mathrm { R R R } }$ for model explanations. In particular, $\\mathcal { M } ^ { \\mathrm { r e p } } = \\{ ( x _ { i } ^ { j } , y _ { i } ^ { j } ) _ { i = 1 } ^ { m } \\stackrel { \\cdot } { \\sim } \\mathcal { D } _ { j = 1 \\cdots k - 1 } ^ { t r } \\}$ stores $m$ samples in total from all prior tasks to $k$ . Similarly $\\mathcal { M } ^ { \\mathrm { R R R } }$ stores the saliency maps generated based on $f _ { \\theta } ^ { k }$ by one of the explanation methods $( { \\mathcal { X } } { \\mathcal { A } } { \\mathcal { T } } )$ discussed in Section 2 for images in $\\mathcal { M } ^ { \\mathrm { r e p } }$ where $f _ { \\theta } ^ { k }$ is $f _ { \\theta }$ being trained for task $k$ . We use a single-head architecture where the task ID integer $t$ is not required at test time. ",
+        "bbox": [
+            173,
+            510,
+            825,
+            674
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Upon finishing the $k ^ { t h }$ task, we randomly select $m / ( k { - } 1 )$ samples per task from its training data and update our replay buffer memory ${ \\mathcal { M } } ^ { \\mathrm { r e p } }$ . RRR uses model explanations on memory samples to perform continual learning such that the model preserves its reasoning for previously seen observations. We explore several explanation techniques to compute saliency maps using $f _ { \\theta } ^ { \\mathbf { \\bar { k } } }$ for the stored samples in the replay buffer to populate the xai buffer memory $\\mathcal { M } ^ { \\mathrm { x a i } }$ . The stored saliency maps will serve as reference explanations during the learning of future tasks to prevent model parameters from being altered resulting in different reasoning for the same samples. We implement RRR using an L1 loss on the error in saliency maps generated after training a new task with respect to their stored reference evidence. ",
+        "bbox": [
+            173,
+            679,
+            825,
+            808
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca05e2d767f2280955f394944331ecddccfb977bf9d8c8fb3b870434e5a70c13.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { R R R } } \\big ( f _ { \\theta } , \\mathcal { M } ^ { \\mathrm { r e p } } , \\mathcal { M } ^ { \\mathrm { R R R } } \\big ) = \\mathbb { E } _ { ( ( x , y ) , \\hat { s } ) \\sim \\left( \\mathcal { M } ^ { \\mathrm { r e p } } , \\mathcal { M } ^ { \\mathrm { R R R } } \\right) } \\vert \\vert \\mathcal { X } \\mathcal { A } \\mathcal { Z } \\big ( f _ { \\theta } ^ { k } ( x ) \\big ) - \\hat { s } \\vert \\vert _ { 1 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            825,
+            732,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { X } \\mathcal { A } \\mathcal { T } ( \\cdot )$ denotes the explanation method used to compute saliency maps using the model trained on the last seen example from task $k$ , and $\\hat { s }$ are the reference saliency maps generated by $\\chi \\mathcal { A } \\mathcal { T } ( f _ { \\theta } ^ { k } )$ upon learning each task prior to $T$ and stored in to the memory. We show below that combining RRR into the objective function of state-of-the-art memory and regularization-based methods results in significant performance improvements. The full algorithm for RRR is given in Alg. 1. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb3d7154cc20f9b0d8c9e69038bd7edd29572c0f83a7677e8527ca6aa7b2c07f.jpg",
+        "image_caption": [
+            "Figure 2: Few-shot CIL learning of CUB200 in 11 tasks where each point shows the classification accuracy on all seen classes so far. (Left) Shows ER with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ using different backbone architectures and saliency map techniques. (Right) Performance of the state-of-the-art existing approaches with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ on CUB200 including TOPIC (Tao et al., 2020), EEIL (Castro et al., 2018), iCaRL (Rebuffi et al., 2017). Joint training serves as the upper bound. Results for baselines are obtained using their original implementation. All results are averaged over 3 runs and mean and standard deviation values are given in the appendix. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            104,
+            789,
+            260
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            401,
+            326,
+            417
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we apply RRR in two distinct learning regimes: standard and few-shot class incremental learning. These are the most challenging CL scenarios, in which task descriptions are not available at test time. We first explore the effect of backbone architecture and the saliency map technique on RRR performance. We then report our obtained results integrating $\\mathcal { L } _ { \\mathrm { R R R } }$ into existing memory-based and regularization-based methods. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            506
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 FEW-SHOT CIL PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            431,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first explore CIL of low-data regimes where preventing overfitting to few-shot new classes is another challenge to overcome in addition to avoiding catastrophic forgetting of old classes. We use $C$ classes and $K$ training samples per class as the $C$ -way $K$ -shot few-shot class incrementally learning setting where we have a set of $b$ base classes to learn as the first task while the remaining classes are learned with only a few randomly selected samples. In order to provide a direct comparison to the state-of-the-art work of Tao et al. (2020) we precisely followed their setup and and used the same Caltech-UCSD Birds dataset (Wah et al., 2011), divided into 11 disjoint tasks and a 10-way 5-shot setting, where the first task contains $b = 1 0 0$ base classes resulting in 3000 samples for training and 2834 images for testing. The remaining 100 classes are divided into 10 tasks where 5 samples per class are randomly selected as the training set, while the test set is kept intact containing near 300 images per task. The images in CUB200 are resized to $2 5 6 \\times 2 5 6$ and then randomly cropped to $2 2 4 \\times 2 2 4$ for training. We store 4 images per class from base classes in the first task and 1 sample per each few-shot class in the remaining 10 tasks (Tao et al., 2020). We used the RAdam (Liu et al., 2019) optimizer with a learning rate of 0.001 which was reduced by 0.2 at epochs 20, 40, and 60 and trained for a total of 70 epochs with a batch size of 128 for the first and 10 for the remaining tasks. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            776
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 (left) shows results for ER with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ using different backbone architectures and saliency map techniques. Among the tested saliency map methods, Grad-CAM on ResNet18 outperforms Vanilla Backpropagation and SmoothGrad by $2 { - } 3 \\%$ while SmoothGrad and vanilla Backpropagation achieve similar CL performance. To compute the memory overhead of storing the output for a saliency method, if we assume the memory required to store an image is $M$ , vanilla Backpropagation and SmoothGrad generate a pixel-wise saliency map that occupies $M / 3$ of memory. However, in Grad-CAM the saliency map size is equal to the feature map of the target layer in the architecture. In our study with Grad-CAM we chose our target layer to be the last convolution layer before the fully-connected layers. For instance using ResNet18 for colored $2 2 4 \\times 2 2 4$ images results in the Grad-CAM output of $7 \\times 7$ occupying 196B. Table 2 shows the target layer name and saliency map size for other network architectures used in this work (AlexNet and SqueezeNet1 1) as well. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c256de790417db433077726ead7e5e774741a08099f8b9eb519352448f894179.jpg",
+        "image_caption": [
+            "Figure 3: Effect of RRR on existing methods for CIL on CIFAR100 in (a) 10 and (b) 20 tasks and (c) ImageNet100 in 10 tasks. Each point shows the classification accuracy on all seen classes so far. Results for iTAML, BiC, and EEIL are produced with their original implementation while EWC and LwF are re-implemented by us. All results are averaged over 3 runs and mean and standard deviation values are given in the appendix. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            101,
+            812,
+            227
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            347,
+            821,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 (right) shows the effect of adding $\\mathcal { L } _ { \\mathrm { R R R } }$ on existing recent state-of-the-art methods such as TOPIC (Tao et al., 2020), EEIL (Castro et al., 2018), and iCaRL (Rebuffi et al., 2017). Tao et al. (2020) used a neural gas network (Martinetz et al., 1991; Fritzke et al., 1995) which can learn and preserve the topology of the feature manifold formed by different classes and we have followed their experimental protocol for our CUB200 experiment by using identical samples drawn in each task which are used across all the baselines for fair comparison. Adding $\\mathcal { L } _ { \\mathrm { R R R } }$ improves the performance of all the baselines; TOPIC becomes nearly on-par with joint training which serves as the upper bound and does not adhere to continual learning. The gap between ER and iCaRL is also reduced when ER uses $\\mathcal { L } _ { \\mathrm { R R R } }$ . ",
+        "bbox": [
+            174,
+            382,
+            825,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 STANDARD CIL PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            539,
+            434,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to provide a direct comparison to the recent work of Rajasegaran et al. (2020) we perform our standard CIL experiment on CIFAR100 (Krizhevsky & Hinton, 2009) and ImageNet100 where we assume a memory budget of 2000 samples which are identical across all the baselines. Following Rajasegaran et al. (2020) we divide CIFAR100 to 10 and 20 disjoint tasks with 10 and 5 classes at a time. Figures 3a and 3b show the classification accuracy upon learning each task on all seen classes. We see a consistent average improvement of $2 - 4 \\%$ when $\\mathcal { L } _ { \\mathrm { R R R } }$ is added as an additional constraint to preserve the model explanations across all methods, from the most naive memory-based method, experience replay (ER), to more sophisticated approaches which store a set of old class exemplars along with meta-learning (iTAML), correct bias for new classes (BiC), and fine tune on the exemplar set (EEIL). We also applied the RRR constraint on regularization-based methods such as EWC and LwF with no memory used as a replay buffer. The accuracy for both improves despite not benefiting from revisiting the raw data. However, they fall behind all memory-based methods with or without $\\mathcal { L } _ { \\mathrm { R R R } }$ . The final accuracy on the entire sequence for joint training (multi-task learning) with RAdam optimizer (Liu et al., 2019) is $8 0 . 0 3 \\%$ which serves as an upper bound as it has access to data from all tasks at all time. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3c shows our results on learning ImageNet100 in 10 tasks. The effect of adding $\\mathcal { L } _ { \\mathrm { R R R } }$ to baselines on the ImageNet100 experiment is more significant $( 3 - 6 \\% )$ compared to CIFAR100. This is mainly due to the larger size and better quality of images in ImageNet100, resulting in generating larger Grad-CAM saliency maps. These experiments clearly reveal the effectiveness of $\\mathcal { L } _ { \\mathrm { R R R } }$ on model explanations in a continual learning problem at nearly zero cost of memory overhead when a memory buffer is already created and applied as a catastrophic forgetting avoidance strategy. This makes Grad-CAM the ideal approach to generate saliency maps when applying the RRR training strategy, as it achieves the highest accuracy while utilizing the least storage space to store saliencies. Note that we adopt Grad-CAM to generate saliency maps in the remaining experiments in this paper. We also keep using only ResNet18 for a fair comparison with the literature. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/e2b1e19980c3f9b7ecb6e64f1143253a1cb79accb300528e13091a42fd07d04b.jpg",
+        "table_caption": [
+            "(a) PG localization accuracy and backward transfer "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Methods</td><td>PG-ACC (%)</td><td>PG-BWT (%)</td></tr><tr><td>ER</td><td>54.0</td><td>-17.4</td></tr><tr><td>ER+RRR</td><td>58.5</td><td>-15.6</td></tr><tr><td>TOPIC</td><td>72.7</td><td>-0.9</td></tr><tr><td>TOPIC+RRR</td><td>74.2</td><td>-2.1</td></tr></table>",
+        "bbox": [
+            220,
+            188,
+            455,
+            248
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6f54cde8ae181ebad783837edda719aa3df99fab32acb6d83f9cc03ee08894b1.jpg",
+        "table_caption": [
+            "Table 1: PG experiment results on few-shot CIL CUB200 measuring (a) PG-ACC $( \\% )$ and PG-BWT $( \\% )$ and (b) precision and recall averaged over all tasks. $P r _ { i , i }$ and $R e _ { i , i }$ evaluate the pointing game on each task $\\mathbf { t } ^ { \\mathrm { i } }$ directly after the model has been trained on $\\mathbf { t } ^ { \\mathbf { i } }$ . $P r _ { T , i }$ and $R e _ { T , i }$ are obtained by the evaluation for task $\\mathbf { t ^ { i } }$ using the model trained for all $T$ tasks. ",
+            "(b) Precision and recall using PG experiment "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">Precision</td><td colspan=\"2\">Recall</td></tr><tr><td>Methods</td><td>Pri,i</td><td>PrT,i</td><td>Rei,i</td><td>ReT,i</td></tr><tr><td>ER</td><td>80.0</td><td>68.9</td><td>64.1</td><td>65.1</td></tr><tr><td>ER+RRR</td><td>82.1</td><td>70.3</td><td>64.2</td><td>66.8</td></tr><tr><td>TOPIC</td><td>91.0</td><td>88.4</td><td>98.1</td><td>97.4</td></tr><tr><td>TOPIC+RRR</td><td>92.8</td><td>89.1</td><td>99.6</td><td>99.2</td></tr></table>",
+        "bbox": [
+            537,
+            179,
+            794,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS OF MODEL EXPLANATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            276,
+            522,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we want to answer the question “How often does the model remember its decision for the right reason upon learning a sequence of tasks?”. In particular, we want to evaluate how often the model is “pointing” at the right evidence for its predictions, instead of focusing its maximum attention on the background or other objects in the image. We use the Pointing Game experiment (PG) (Zhang et al., 2018) for this evaluation, which was introduced to measure the discriminativeness of a visualization method for target object localization. Here, we use ground truth segmentation annotation labels provided with the CUB-200 dataset to define the true object region. ",
+        "bbox": [
+            173,
+            310,
+            825,
+            409
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "First, we look into hits and misses defined by the PG experiment. When the location of the maximum in a predicted saliency map falls inside the object, it is considered as a hit and otherwise it is a miss. Figure 5 shows an example from CUB200 where the segmentation annotation is used to determine whether the peak of the predicted saliency map (marked with red cross) falls inside the object region. This example is regarded as hit as the red cross is inside the segmentation mask for the bird. PG localization accuracy is defined as the number of hits over the total number of predictions. We would like to measure both the overall PG performance of a continual learner as well as how much learning new tasks causes it to forget its ability to hit the target object. For these metrics, inspired by (Lopez-Paz et al., 2017), we define $\\begin{array} { r } { \\mathrm { P G } { \\mathrm { - } } \\mathrm { A C C } = \\frac { 1 } { T } \\sum _ { i = 1 } ^ { \\bar { T } } \\dot { R _ { T , i } } } \\end{array}$ as the average PG localization accuracy computed over all prior tasks after training for each new task and $\\begin{array} { r } { \\mathrm { P G - B W T } = \\frac { 1 } { T - 1 } \\sum _ { i = 1 } ^ { T - 1 } R _ { T , i } - R _ { i , i } } \\end{array}$ (backward transfer) which indicates how much learning new tasks has influenced the PG localization accuracy on previous tasks where $R _ { n , i }$ is the on task $i$ after learning the $n ^ { \\mathrm { t h } }$ task. Results for ER and TOPIC with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ on CUB200 are shown in Table 1a. It shows how constraining different models to remember their initial evidence can lead to better localization of the bird across learning new tasks. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            631
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "However, PG performance does not capture all of our desired properties for a continual learner. Ideally, we not only want a model to predict the object correctly if it is looking at the right evidence, but also we want it to not predict an object if it is not able to find the right evidence for it. To measure how close our baselines can get to this ideal model when they are combined with $\\mathcal { L } _ { \\mathrm { R R R } }$ , we measure the precision as $\\mathrm { t p / ( t p / \\Delta \\mathfrak { p } ) }$ , and recall as $\\mathrm { t p / ( t p / \\Delta \\mathfrak { t } f n ) }$ . We evaluate these metrics once immediately after learning each task, denoted as $P r _ { i , i }$ and $R e _ { i , i }$ , respectively, and again at the end of the learning process of final task $T$ denoted as $P r _ { T , i }$ and $R e _ { T , i }$ , where the first subscript refers to the model ID and the second subscript is the test dataset ID on which the model is evaluated. The higher the precision for a model is, the less often it has made the right decision without looking at the right evidence. On the other hand, the higher the recall, the less often it makes a wrong decision despite looking at the correct evidence. We show our evaluation on these metrics in Table 1b for ER and TOPIC with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ on CUB200 where $\\mathcal { L } _ { \\mathrm { R R R } }$ increases both precision and recall across all methods, demonstrating that our approach continually makes better predictions because it finds the right evidence for its decisions. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our final analysis, we would like to visualize the evolution of saliency maps across learning a sequence of tasks. Figure 4 illustrates the evolution of saliency maps for an image from the test-set of the second task, which both ER without $\\mathcal { L } _ { \\mathrm { R R R } }$ (top row) and with $\\mathcal { L } _ { \\mathrm { R R R } }$ (bottom row) have seen during training for the second task. We only visualize the generated saliencies after finishing tasks #2, #5, #7, #9, and #11 for simplicity. We indicate the correctness of the prediction made by each model with ‘correct’ or ‘incorrect’ written on top of their corresponding saliency map. Our goal is to visualize if adding the loss term $\\mathcal { L } _ { \\mathrm { R R R } }$ prevents the drifting of explanations. Given the same input image, the ER without $\\mathcal { L } _ { \\mathrm { R R R } }$ model makes an incorrect prediction after being continually trained for 11 tasks while never recovering from its mistake. On the other hand, when it is combined with $\\mathcal { L } _ { \\mathrm { R R R } }$ . it is able to recover from an early mistake after task 5. Considering the saliency map obtained after finishing task one as a reference evidence, we can see that ER’s evidence drifts further from the reference. On the bottom row, the region of focus of ER+RRR remains nearly identical to its initial evidence, apart from one incorrect prediction. As applying $\\mathcal { L } _ { \\mathrm { R R R } }$ corrects its saliency back to the original, this prediction is corrected as well. This supports the conclusion that retaining the original saliency is important for retaining the original accuracy. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/09c0ee24c47d173aa2e6b5de78cbf95caefed73a635754290317195ebd291fa3.jpg",
+        "image_caption": [
+            "Figure 4: An illustration of the progression of saliencies on an image from the test set of the second task, evaluated after the model is trained on tasks #2, #5, #7, #9, and #11 on CUB200. Failure case for ER w.o. $\\mathcal { L } _ { \\mathrm { R R R } }$ (top row), where saliency drifts from the original and the prediction becomes incorrect. $_ \\mathrm { E R + R R R }$ (bottom row) retains close to the original saliency as the model trains on more tasks, with the exception of Task #5 which it is able to correct later on. Its performance is retained as well, for saliencies that are close to the original. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            102,
+            727,
+            243
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            367,
+            825,
+            492
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            343,
+            532
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Continual learning: Past work in CL has generally made use of either memory, model structure, or regularization to prevent catastrophic forgetting. Memory-based methods store some form of past experience into a replay buffer. However, the definition of “experience” varies between methods. Rehearsal-based methods use episodic memories as raw samples (Robins, 1995; Rebuffi et al., 2017; Riemer et al., 2018) or their gradients (Lopez-Paz et al., 2017; Chaudhry et al., 2019) for the model to revisit. Incremental Classifier and Representation Learning (iCaRL) (Rebuffi et al., 2017), is a class-incremental learner that uses a nearest-exemplar algorithm for classification and prevents catastrophic forgetting by using an episodic memory. iTAML (Rajasegaran et al., 2020) is a task-agnostic meta-learning algorithm that uses a momentum based strategy for meta-update and in addition to the object classification task, it predicts task labels during inference. An end-to-end incremental learning framework (EEIL) (Castro et al., 2018) also uses an exemplar set along with data augmentation and balanced fine-tuning to alleviate the imbalance between the old and new classes. Bias Correction Method (BiC) (Wu et al., 2019) is another class-incremental learning algorithm for large datasets in which a linear model is used to correct bias towards new classes using a fully connected layer. In contrast, pseudo-rehearsal methods generate the replay samples using a generative model such as an autoencoder (Kemker & Kanan, 2017) or a GAN (Kamra et al., 2017; Shin et al., 2017). Regularization-based methods define different metrics to measure importance and limit the changes on parameters accordingly (Kirkpatrick et al., 2017; Zenke et al., 2017; Ebrahimi et al., 2020a; Serra et al., 2018; Li & Hoiem, 2016; Dhar et al., 2019) but in general these methods have limited capacity. Structure-based methods control which portions of a model are responsible for specific tasks such that the model increases its capacity in a controlled fashion as more tasks are added. Inference for different tasks can be restricted to various neurons (Fernando et al., 2017; Yoon et al., 2018), columns (Rusu et al., 2016), task-specific modules (Ebrahimi et al., 2020b), or parameters selected by a mask (Mallya & Lazebnik, 2018; Serra et al., 2018). In RRR we explored the addition of explanations to replay buffer and showed that saliency-based explanations offer performance upgrade as well as improvement in explanations across all memory-based and regularization-based baselines we tried. ",
+        "bbox": [
+            173,
+            550,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Visual explanation approaches or saliency methods attempt to produce a posterior explanation or a pseudo-probability map for the detected signals from the target object in the input image. These approaches can be broadly divided into three categories including activation, gradient, and perturbation based methods. Activation-based methods (Zhou et al., 2016; Selvaraju et al., 2017; Chattopadhay et al., 2018) use a weighted linear combination of feature maps whereas gradient-based methods (Baehrens et al., 2010; Sundararajan et al., 2017a; Springenberg et al., 2014; Shrikumar et al., 2017; Zhang et al., 2018) use the derivative of outputs w.r.t the input image to compute pixel-wise importance scores to generate attention maps. Methods in these categories are only applicable to differentiable models, including convolutional neural networks (CNNs). In contrast, perturbation-based methods are model-agnostic and produce saliency maps by observing the change in prediction when the input is perturbed (Petsiuk et al., 2018; Ribeiro et al., 2016; Ross et al., 2017; Zhou et al., 2014; Seo et al., 2018). While these methods attempt to identify if models are right for the wrong reason, Ross et al. (2017) took a step further and applied penalties to correct the explanations provided in supervised/unsupervised fashion during training. Selvaraju et al. (2019) used human explanations in the form of question and answering to bring model explanations closer to human answers. ",
+        "bbox": [
+            174,
+            104,
+            825,
+            311
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            333,
+            318,
+            349
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed the use of model explanations with continual learning algorithms to enhance better knowledge transfer as well as better recall of the previous tasks. The intuition behind our method is that encouraging a model to remember its evidence will increase the generalisability and rationality of recalled predictions and help retrieving the relevant aspects of each task. We advocate for the use of explainable AI as a tool to improve model performance, rather than as an artifact or interpretation of the model itself. We demonstrate that models which incorporate a “remember for the right reasons” constraint as part of a continual learning process can both be interpretable and more accurate. We empirically demonstrated the effectiveness of our approach in a variety of settings and provided an analysis of improved performance and explainability. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            491
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            285,
+            527
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Julius Adebayo, Justin Gilmer, Michael Muelly, Ian Goodfellow, Moritz Hardt, and Been Kim. Sanity checks for saliency maps. In Advances in Neural Information Processing Systems, pp. 9505–9515, 2018.   \nDavid Baehrens, Timon Schroeter, Stefan Harmeling, Motoaki Kawanabe, Katja Hansen, and KlausRobert MA˜ zller. How to explain individual classification decisions. ˇ Journal of Machine Learning Research, 11(Jun):1803–1831, 2010.   \nFrancisco M Castro, Manuel J Mar´ın-Jimenez, Nicol ´ as Guil, Cordelia Schmid, and Karteek Alahari. ´ End-to-end incremental learning. In Proceedings of the European conference on computer vision (ECCV), pp. 233–248, 2018.   \nAditya Chattopadhay, Anirban Sarkar, Prantik Howlader, and Vineeth N Balasubramanian. Gradcam $^ { + + }$ : Generalized gradient-based visual explanations for deep convolutional networks. In 2018 IEEE Winter Conference on Applications of Computer Vision (WACV), pp. 839–847. IEEE, 2018.   \nArslan Chaudhry, Marc’Aurelio Ranzato, Marcus Rohrbach, and Mohamed Elhoseiny. Efficient lifelong learning with A-GEM. In International Conference on Learning Representations, 2019.   \nPrithviraj Dhar, Rajat Vikram Singh, Kuan-Chuan Peng, Ziyan Wu, and Rama Chellappa. Learning without memorizing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5138–5146, 2019.   \nSayna Ebrahimi, Mohamed Elhoseiny, Trevor Darrell, and Marcus Rohrbach. Uncertainty-guided continual learning with bayesian neural networks. In International Conference on Learning Representations, 2020a.   \nSayna Ebrahimi, Franziska Meier, Roberto Calandra, Trevor Darrell, and Marcus Rohrbach. Adversarial continual learning. In European Conference on Computer Vision (ECCV), 2020b. ",
+        "bbox": [
+            171,
+            535,
+            826,
+            925
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chrisantha Fernando, Dylan Banarse, Charles Blundell, Yori Zwols, David Ha, Andrei A Rusu, Alexander Pritzel, and Daan Wierstra. Pathnet: Evolution channels gradient descent in super neural networks. arXiv preprint arXiv:1701.08734, 2017. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bernd Fritzke et al. A growing neural gas network learns topologies. Advances in neural information processing systems, 7:625–632, 1995. ",
+        "bbox": [
+            173,
+            154,
+            823,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tyler L Hayes, Nathan D Cahill, and Christopher Kanan. Memory efficient experience replay for streaming learning. In 2019 International Conference on Robotics and Automation (ICRA), pp. 9769–9776. IEEE, 2019. ",
+        "bbox": [
+            176,
+            190,
+            823,
+            233
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kevin Jarrett, Koray Kavukcuoglu, Marc’Aurelio Ranzato, and Yann LeCun. What is the best multi-stage architecture for object recognition? In 2009 IEEE 12th international conference on computer vision, pp. 2146–2153. IEEE, 2009. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            285
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitin Kamra, Umang Gupta, and Yan Liu. Deep generative dual memory network for continual learning. arXiv preprint arXiv:1710.10368, 2017. ",
+        "bbox": [
+            168,
+            292,
+            825,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronald Kemker and Christopher Kanan. Fearnet: Brain-inspired model for incremental learning. arXiv preprint arXiv:1711.10563, 2017. ",
+        "bbox": [
+            171,
+            329,
+            821,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of sciences, pp. 201611835, 2017. ",
+        "bbox": [
+            173,
+            367,
+            825,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, 2009. ",
+        "bbox": [
+            173,
+            431,
+            821,
+            460
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhizhong Li and Derek Hoiem. Learning without forgetting. In European Conference on Computer Vision, pp. 614–629. Springer, 2016. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            498
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Liyuan Liu, Haoming Jiang, Pengcheng He, Weizhu Chen, Xiaodong Liu, Jianfeng Gao, and Jiawei Han. On the variance of the adaptive learning rate and beyond. arXiv preprint arXiv:1908.03265, 2019. ",
+        "bbox": [
+            173,
+            506,
+            825,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Lopez-Paz et al. Gradient episodic memory for continual learning. In Advances in Neural Information Processing Systems, pp. 6467–6476, 2017. ",
+        "bbox": [
+            174,
+            556,
+            823,
+            587
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arun Mallya and Svetlana Lazebnik. Packnet: Adding multiple tasks to a single network by iterative pruning. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018. ",
+        "bbox": [
+            174,
+            593,
+            823,
+            623
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas Martinetz, Klaus Schulten, et al. A” neural-gas” network learns topologies. 1991. ",
+        "bbox": [
+            173,
+            631,
+            766,
+            646
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James L McClelland, Bruce L McNaughton, and Randall C O’reilly. Why there are complementary learning systems in the hippocampus and neocortex: insights from the successes and failures of connectionist models of learning and memory. Psychological review, 102(3):419, 1995. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael McCloskey and Neal J Cohen. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation, volume 24, pp. 109–165. Elsevier, 1989. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. In NIPS-W, 2017. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            799
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vitali Petsiuk, Abir Das, and Kate Saenko. Rise: Randomized input sampling for explanation of black-box models. In Proceedings of the British Machine Vision Conference (BMVC), 2018. ",
+        "bbox": [
+            173,
+            806,
+            823,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jathushan Rajasegaran, Salman Khan, Munawar Hayat, Fahad Shahbaz Khan, and Mubarak Shah. itaml $:$ An incremental task-agnostic meta-learning approach. The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sylvestre-Alvise Rebuffi, Alexander Kolesnikov, Georg Sperl, and Christoph H Lampert. icarl: Incremental classifier and representation learning. In CVPR, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. ” why should i trust you?” explaining the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pp. 1135–1144, 2016. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew Riemer, Ignacio Cases, Robert Ajemian, Miao Liu, Irina Rish, Yuhai Tu, and Gerald Tesauro. Learning to learn without forgetting by maximizing transfer and minimizing interference. arXiv preprint arXiv:1810.11910, 2018. ",
+        "bbox": [
+            174,
+            156,
+            825,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anthony Robins. Catastrophic forgetting, rehearsal and pseudorehearsal. Connection Science, 7(2): 123–146, 1995. ",
+        "bbox": [
+            173,
+            209,
+            820,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew Slavin Ross, Michael C Hughes, and Finale Doshi-Velez. Right for the right reasons: Training differentiable models by constraining their explanations. arXiv preprint arXiv:1703.03717, 2017. ",
+        "bbox": [
+            174,
+            248,
+            826,
+            290
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Neil C Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. arXiv preprint arXiv:1606.04671, 2016. ",
+        "bbox": [
+            173,
+            301,
+            823,
+            343
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ramprasaath R Selvaraju, Abhishek Das, Ramakrishna Vedantam, Michael Cogswell, Devi Parikh, and Dhruv Batra. Grad-cam: Why did you say that? arXiv preprint arXiv:1611.07450, 2016. ",
+        "bbox": [
+            173,
+            353,
+            823,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In Proceedings of the IEEE international conference on computer vision, pp. 618–626, 2017. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ramprasaath R Selvaraju, Stefan Lee, Yilin Shen, Hongxia Jin, Shalini Ghosh, Larry Heck, Dhruv Batra, and Devi Parikh. Taking a hint: Leveraging explanations to make vision and language models more grounded. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pp. 2591–2600, 2019. ",
+        "bbox": [
+            174,
+            459,
+            825,
+            517
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dasom Seo, Kanghan Oh, and Il-Seok Oh. Regional multi-scale approach for visually pleasing explanations of deep neural networks. arXiv preprint arXiv:1807.11720, 2018. ",
+        "bbox": [
+            169,
+            526,
+            823,
+            556
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joan Serra, Didac Suris, Marius Miron, and Alexandros Karatzoglou. Overcoming catastrophic forgetting with hard attention to the task. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 4548–4557. PMLR, 2018. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            622
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hanul Shin, Jung Kwon Lee, Jaehong Kim, and Jiwon Kim. Continual learning with deep generative replay. In Advances in Neural Information Processing Systems, pp. 2990–2999, 2017. ",
+        "bbox": [
+            173,
+            632,
+            823,
+            662
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Avanti Shrikumar, Peyton Greenside, Anna Shcherbina, and Anshul Kundaje. Not just a black box: Learning important features through propagating activation differences. arXiv preprint arXiv:1605.01713, 2016. ",
+        "bbox": [
+            174,
+            671,
+            825,
+            714
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3145–3153. JMLR. org, 2017. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            767
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel L Silver, Qiang Yang, and Lianghao Li. Lifelong machine learning systems: Beyond learning algorithms. In 2013 AAAI spring symposium series, 2013. ",
+        "bbox": [
+            169,
+            777,
+            823,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv preprint arXiv:1312.6034, 2013. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Viegas, and Martin Wattenberg. Smoothgrad: ´ removing noise by adding noise. arXiv preprint arXiv:1706.03825, 2017. ",
+        "bbox": [
+            171,
+            856,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3319– 3328. JMLR. org, 2017a. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. arXiv preprint arXiv:1703.01365, 2017b. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            183
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaoyu Tao, Xiaopeng Hong, Xinyuan Chang, Songlin Dong, Xing Wei, and Yihong Gong. Fewshot class-incremental learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 12183–12192, 2020. ",
+        "bbox": [
+            174,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Thrun and Tom M Mitchell. Lifelong robot learning. Robotics and autonomous systems, 15(1-2):25–46, 1995. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            272
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C. Wah, S. Branson, P. Welinder, P. Perona, and S. Belongie. The Caltech-UCSD Birds-200-2011 Dataset. Technical Report CNS-TR-2011-001, California Institute of Technology, 2011. ",
+        "bbox": [
+            174,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yue Wu, Yinpeng Chen, Lijuan Wang, Yuancheng Ye, Zicheng Liu, Yandong Guo, and Yun Fu. Large scale incremental learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 374–382, 2019. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jaehong Yoon, Eunho Yang, Jeongtae Lee, and Sung Ju Hwang. Lifelong learning with dynamically expandable networks. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            171,
+            371,
+            825,
+            400
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, pp. 818–833. Springer, 2014. ",
+        "bbox": [
+            173,
+            409,
+            823,
+            438
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Friedemann Zenke, Ben Poole, and Surya Ganguli. Continual learning through synaptic intelligence. In Doina Precup and Yee Whye Teh (eds.), Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 3987–3995. PMLR, 2017. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jianming Zhang, Sarah Adel Bargal, Zhe Lin, Jonathan Brandt, Xiaohui Shen, and Stan Sclaroff. Top-down neural attention by excitation backprop. International Journal of Computer Vision, 126 (10):1084–1102, 2018. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            554
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in deep scene cnns. arXiv preprint arXiv:1412.6856, 2014. ",
+        "bbox": [
+            169,
+            564,
+            823,
+            593
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Learning deep features for discriminative localization. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2921–2929, 2016. ",
+        "bbox": [
+            174,
+            602,
+            821,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 GRAD-CAM TARGET LAYERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            426,
+            150
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows the target layer names used in Grad-CAM for different network architectures according to their standard PyTorch (Paszke et al., 2017) implementations. Saliency map size is equal to the activation map of the target layers. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            204
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/62b7e29ccbad9e6d2bd9434932e28de7bef6864f5424e9df20bf640dcc97999e.jpg",
+        "table_caption": [
+            "Table 2: Target layer names and activation maps size for saliencies generated by different network architectures in Grad-CAM. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Target layer name in PyTorch torchvision package</td><td>Saliency map size</td></tr><tr><td>SqueezeNet1_1</td><td>features.0.12.expand3x3</td><td>13 ×13</td></tr><tr><td>AlexNet</td><td>features.0.10</td><td>13 ×13</td></tr><tr><td>ResNet18</td><td>features.7.1.conv2</td><td>7×7</td></tr></table>",
+        "bbox": [
+            173,
+            258,
+            825,
+            335
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B POINTING GAME VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            382,
+            490,
+            398
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows an example from CUB200 in the Pointing Game. We used the segmentation annotation to verify whether the peak of the predicted saliency map (marked with red cross) falls inside the object region. It is regarded as hit as the red cross is inside the segmentation mask for the bird. ",
+        "bbox": [
+            173,
+            415,
+            821,
+            458
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e59b0dc386b86facc06d523b925d24c5ac95c5b1d5165a09da8cda4bb4f9375.jpg",
+        "image_caption": [
+            "Figure 5: An example of PG evaluation as hit for an image in CUB200. Left: image saliency map overlaid on the image. Right: the segmentation label where the red cross marks the peak saliency. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            354,
+            473,
+            643,
+            584
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C TABULAR RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            656,
+            370,
+            672
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we have tabulated results shown in Figure 2 and Figure 3 with means and standard deviations averaged over 3 runs. ",
+        "bbox": [
+            174,
+            689,
+            823,
+            718
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/d91a0e49a90a15c0b2d1c86bd040faa5f4c70e3caf7ca5895edb811ccb835801.jpg",
+        "table_caption": [
+            "Table 3: Classification accuracy of few-shot CIL learning of CUB200 at the end of 11 tasks for ER with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ using different backbone architectures and saliency map techniques. Results are averaged over 3 runs. Figure 2 (left) in the main paper is generated using numbers in this Table. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>2</td><td></td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td><td>11</td></tr><tr><td>RN18-RRR-GCam</td><td>67.8±0.8</td><td>53.5±0.7</td><td>45.6±0.6 39.6±0.7</td><td></td><td>35.3±0.9</td><td>32.3± 1.1</td><td>29.4±0.9</td><td>25.9±0.8</td><td>25.7±0.6</td><td>26.3±0.7</td><td>23.6±0.7</td></tr><tr><td>RN18-ER</td><td>67.8±0.8</td><td>49.7 ±0.9</td><td>41.7 ±0.8</td><td>35.8 ±0.7</td><td>31.4 ± 0.9</td><td>28.5±0.8</td><td>25.5±0.8</td><td>22.1±0.8</td><td>21.8±0.8</td><td>22.5 ± 1.1</td><td>19.8± 0.9</td></tr><tr><td>RN18-RRR-Smooth</td><td>67.8± 0.8</td><td>50.9±0.6</td><td>43.5 ± 0.9</td><td>37.0±0.8</td><td>33.0±0.7</td><td>29.5± 0.6</td><td>26.8±0.8</td><td>23.9 ±0.8</td><td>23.9±0.8</td><td>23.4± 0.8</td><td>21.5± 0.5</td></tr><tr><td>RN18-RRR-BP</td><td>67.8±0.8</td><td>50.8±0.8</td><td>43.9 ±0.6</td><td>36.6 ±0.4</td><td>32.7±0.6</td><td>28.9±0.6</td><td>27.2± 0.5</td><td>23.8 ±0.6</td><td>23.8±0.6</td><td>24.0± 0.4</td><td>21.5± 0.6</td></tr><tr><td>RN18-Finetune</td><td>67.8± 0.8</td><td>44.8 ± 0.6</td><td>32.2± 0.5</td><td>25.8±0.7</td><td>25.6 ± 0.7</td><td>25.2± 0.7</td><td>20.8±0.6</td><td>16.8 ± 0.7</td><td>18.8± 0.5</td><td>18.3 ± 0.4</td><td>17.1 ± 0.6</td></tr><tr><td>Alex-RRR-GCam</td><td>56.7±0.7</td><td>46.6±0.5</td><td>43.9±0.7</td><td>41.3± 0.7</td><td>33.7 ± 0.5</td><td>27.4± 0.7</td><td>25.3±0.7</td><td>22.0±0.5</td><td>21.5±0.6</td><td>21.4± 0.6</td><td>21.2± 0.6</td></tr><tr><td>Alex-ER</td><td>56.7± 0.7</td><td>44.6 ± 0.7</td><td>41.3 ± 0.7</td><td>38.7±0.7</td><td>31.1 ± 0.7</td><td>24.5± 0.7</td><td>22.6± 0.7</td><td>19.6 ± 0.6</td><td>19.1± 0.8</td><td>18.7 ± 0.8</td><td>19.1± 0.8</td></tr><tr><td>Alex-Finetune</td><td>56.7±0.7</td><td>42.8 ± 0.8</td><td>39.6±0.8</td><td>36.9±0.8</td><td>29.5 ± 0.7</td><td>23.3±0.6</td><td>21.4± 0.8</td><td>17.9 ± 0.7</td><td>18.0 ±0.7</td><td>17.0 ± 0.5</td><td>16.9 ± 0.4</td></tr><tr><td>SQ-RRR-GCam</td><td>46.8± 0.5</td><td>36.2 ±0.4</td><td>30.1±0.6</td><td>28.3±0.4</td><td>25.1 ± 0.5</td><td>23.4± 0.5</td><td>19.3± 0.6</td><td>19.0± 0.6</td><td>18.5± 0.5</td><td>18.4± 0.5</td><td>18.2 ±0.6</td></tr><tr><td>SQ-ER</td><td>46.8 ± 0.5</td><td>33.2±0.5 27.1±0.6</td><td></td><td>25.3±0.6</td><td>22.1±0.52</td><td>20.5±0.5</td><td>16.3± 0.4</td><td>16.0±0.6</td><td>15.5± 0.6</td><td>15.4 ± 0.6</td><td>15.2 ± 0.7</td></tr><tr><td>SQ-Finetune</td><td>46.8 ± 0.5</td><td>32.0±0.7 25.2±0.7</td><td></td><td>23.9±0.7</td><td>20.2±0.81</td><td>19.4 ± 0.4</td><td>14.9 ± 0.4</td><td>14.4 ± 0.5</td><td>13.8± 0.4</td><td>14.2 ± 0.5</td><td>13.7±0.6</td></tr></table>",
+        "bbox": [
+            173,
+            786,
+            825,
+            905
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/b7ce24f962799d22920c982182f82f9d1f679676f53370079e058adf9746ce99.jpg",
+        "table_caption": [
+            "Table 4: Performance of the state-of-the-art existing approaches with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ on CUB200 including TOPIC (Tao et al., 2020), EEIL (Castro et al., 2018), iCaRL (Rebuffi et al., 2017). Results for baselines are obtained using their original implementation. Results are averaged over 3 runs. Figure 2 (right) in the main paper is generated using numbers in this Table. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td><td>11</td></tr><tr><td>EEIL</td><td>68.6±0.4</td><td>53.6± 0.4</td><td>47.9 ± 0.3</td><td>44.2±0.8</td><td>36.3±0.9</td><td>27.4 ± 1.2</td><td>25.9±0.7</td><td>24.7±0.5</td><td>23.9±0.7</td><td>24.1± 0.7</td><td>22.1 ± 0.5</td></tr><tr><td>EEIL+RRR</td><td>68.6±0.4</td><td>56.6±0.5</td><td>50.9±0.6</td><td>48.3± 0.5</td><td>39.7 ± 1.2</td><td>31.4± 0.7</td><td>28.3± 1.2</td><td>28.0±0.6</td><td>26.5±0.6</td><td>27.4± 0.6</td><td>25.2±0.9</td></tr><tr><td>iCaRL</td><td>68.6±0.4</td><td>52.6±0.7</td><td>48.6± 1.2</td><td>44.1 ± 0.5</td><td>36.6±0.3</td><td>29.5±0.9</td><td>27.8± 0.4</td><td>26.2±0.5</td><td>24.0±0.6</td><td>23.8±0.6</td><td>21.1± 0.7</td></tr><tr><td>iCaRL+RRR</td><td>68.6±0.4</td><td>55.6± 1.2</td><td>53.6±0.7</td><td>47.1 ± 0.8</td><td>39.6±0.5</td><td>32.5±0.8</td><td>31.8 ± 0.4</td><td>29.2±0.6</td><td>27.0±0.8</td><td>27.8±0.6</td><td>24.1 ± 0.3</td></tr><tr><td>TOPIC</td><td>68.6 ± 0.4</td><td>62.4 ± 0.8</td><td>54.8 ± 0.4</td><td>49.9 ± 1.2</td><td>45.2 ±0.6</td><td>41.4± 0.3</td><td>38.3±0.8</td><td>35.3±0.6</td><td>32.2± 0.3</td><td>28.3±0.6</td><td>26.2 ± 1.2</td></tr><tr><td>TOPIC+RRR</td><td>68.6±0.4</td><td>62.5 ± 0.9</td><td>56.8 ± 0.4</td><td>51.5 ± 0.5</td><td>48.2 ± 0.4</td><td>44.4 ± 0.4</td><td>42.3±0.7</td><td>38.3±0.6</td><td>35.2±0.9</td><td>32.3±0.9</td><td>29.2 ± 0.5</td></tr><tr><td>FT</td><td>68.6±0.4</td><td>44.8 ± 0.5</td><td>32.2±0.8</td><td>25.8± 0.4</td><td>25.6 ± 1.1</td><td>25.2± 0.7</td><td>20.8± 1.1</td><td>16.7± 0.4</td><td>18.8 ± 1.1</td><td>18.2± 0.3</td><td>17.1 ± 0.8</td></tr><tr><td>ER</td><td>67.8±0.8</td><td>49.7± 0.9</td><td>41.7 ± 0.8</td><td>35.8 ±0.7</td><td>31.4± 0.9</td><td>28.5±0.8</td><td>25.5±0.8</td><td>22.1± 0.8</td><td>21.8± 0.6</td><td>22.5 ± 1.1</td><td>19.8±0.9</td></tr><tr><td>RRR</td><td>67.8±0.8</td><td>53.5± 0.7</td><td>45.6± 0.6</td><td>39.6± 0.7</td><td>35.3±0.9</td><td>32.3 ± 1.1</td><td>29.4± 0.9</td><td>25.9± 0.8</td><td>25.7±0.6</td><td>26.3±0.7</td><td>23.6±0.7</td></tr><tr><td>JT</td><td>68.6±0.4</td><td>62.4± 0.4</td><td>57.2 ± 0.4</td><td>52.8±0.5</td><td>49.5 ± 0.9</td><td>46.1 ± 0.5</td><td>42.8 ± 1.1</td><td>40.1±0.8</td><td>38.7±0.7</td><td>37.1± 0.5</td><td>35.6±0.9</td></tr></table>",
+        "bbox": [
+            173,
+            167,
+            825,
+            273
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/a36c84c93cbd9f6f56147d35481bdbe9a921307573394a0ff7cc54dd55d7ce76.jpg",
+        "table_caption": [
+            "Table 5: Performance of the state-of-the-art existing approaches with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ on CIFAR100 in 10 tasks. Results for iTAML (Rajasegaran et al., 2020), BiC (Wu et al., 2019), and EEIL (Castro et al., 2018) are produced with their original implementation while EWC (Kirkpatrick et al., 2017) and LwF (Li & Hoiem, 2016) are re-implemented by us. Results are averaged over 3 runs. Figure 3a in the main paper is generated using numbers in this Table. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>iTAML+RRR</td><td>89.2± 0.5</td><td>92.3±0.7</td><td>89.5 ± 1.2</td><td>87.5 ± 1.2</td><td>84.1±0.8</td><td>83.5±0.9</td><td>83.9±0.7</td><td>81.2± 0.3</td><td>79.6 ± 0.9</td><td>79.7±0.5</td></tr><tr><td>iTAML</td><td>89.2± 0.5</td><td>88.9±0.5</td><td>87.0 ± 1.1</td><td>85.7 ± 1.1</td><td>84.1 ± 1.1</td><td>81.8 ± 0.3</td><td>80.0±0.6</td><td>79.0± 0.3</td><td>78.6 ±0.8</td><td>77.8 ±0.6</td></tr><tr><td>BiC</td><td>90.3±0.7</td><td>82.1 ± 0.7</td><td>75.1± 0.4</td><td>69.8 ± 1.2</td><td>65.3±0.8</td><td>61.3± 0.9</td><td>57.4± 0.7</td><td>54.9± 0.5</td><td>53.2 ±0.9</td><td>50.3±0.7</td></tr><tr><td>BiC+RRR</td><td>90.3±0.7</td><td>84.9 ± 1.1</td><td>76.4± 0.6</td><td>69.3±0.3</td><td>65.1±0.9</td><td>63.3± 0.4</td><td>59.7 ± 1.1</td><td>55.4± 0.8</td><td>55.8 ± 0.7</td><td>52.1 ± 0.5</td></tr><tr><td>EEIL</td><td>80.0±0.7</td><td>80.5± 1.2</td><td>75.5± 0.9</td><td>71.5± 0.4</td><td>68.0± 1.2</td><td>62.0±0.9</td><td>59.0± 0.7</td><td>55.1 ± 1.2</td><td>51.4 ± 0.8</td><td>48.7 ± 0.4</td></tr><tr><td>EEIL+RRR</td><td>80.0±0.7</td><td>83.5± 0.3</td><td>78.7 ± 1.2</td><td>74.0 ± 1.2</td><td>71.7± 0.3</td><td>65.1 ± 0.4</td><td>61.2± 0.5</td><td>57.6± 0.5</td><td>54.1 ± 0.4</td><td>51.7± 0.3</td></tr><tr><td>LwF</td><td>86.1 ± 1.2</td><td>69.0±0.7</td><td>55.0±0.3</td><td>45.8± 0.3</td><td>40.4± 0.5</td><td>36.7±0.9</td><td>30.8 ±0.7</td><td>28.6±0.5</td><td>26.1 ± 0.7</td><td>24.2 ±0.7</td></tr><tr><td>LwF+RRR</td><td>86.1 ± 1.2</td><td>72.4± 0.8</td><td>57.0 ± 1.1</td><td>48.3 ± 0.3</td><td>43.2 ±0.8</td><td>39.3 ±0.5</td><td>34.1 ± 0.6</td><td>32.1 ± 1.1</td><td>29.8 ±0.7</td><td>27.1± 0.6</td></tr><tr><td>EWC</td><td>86.1 ± 1.2</td><td>52.6 ± 0.4</td><td>48.6± 0.4</td><td>38.5±0.5</td><td>31.1 ± 0.9</td><td>26.5±0.3</td><td>21.7±0.6</td><td>20.0±0.7</td><td>18.9 ± 0.5</td><td>16.6 ±0.9</td></tr><tr><td>EWC+RRR</td><td>86.1 ± 1.2</td><td>56.0± 0.4</td><td>53.9 ± 1.2</td><td>44.4 ± 0.9</td><td>35.1±0.5</td><td>28.6±0.6</td><td>25.1 ± 1.1</td><td>23.1± 0.5</td><td>18.8 ±0.9</td><td>19.0 ± 1.2</td></tr><tr><td>ER</td><td>86.1 ± 1.2</td><td>74.5 ± 0.9</td><td>65.2±0.8</td><td>62.5± 0.8</td><td>56.7±0.7</td><td>50.5± 0.3</td><td>47.6 ± 0.4</td><td>43.4± 0.3</td><td>41.6 ± 0.9</td><td>38.1 ± 1.1</td></tr><tr><td>RRR</td><td>86.1 ± 1.2</td><td>78.5± 0.9</td><td>69.2 ± 1.1</td><td>63.5 ± 1.2</td><td>58.7±0.8</td><td>53.5 ± 1.1</td><td>49.6± 0.7</td><td>44.4± 0.3</td><td>42.6 ± 1.2</td><td>39.1 ± 1.1</td></tr></table>",
+        "bbox": [
+            173,
+            368,
+            825,
+            494
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/e9095d279ac45c96e65fcb06e92f7aa485b9946a5073f03f6f7fc7070deee7c0.jpg",
+        "table_caption": [
+            "Table 7: Performance of the state-of-the-art existing approaches with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ on ImageNet100 in 10 tasks. Results for iTAML (Rajasegaran et al., 2020), BiC (Wu et al., 2019), and EEIL (Castro et al., 2018) are produced with their original implementation while EWC (Kirkpatrick et al., 2017) and LwF (Li & Hoiem, 2016) are re-implemented by us. Results are averaged over 3 runs. Figure 3c in the main paper is generated using numbers in this Table. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>iTAML</td><td>99.4± 0.8</td><td>96.4±0.9</td><td>94.4 ± 0.9</td><td>93.0±0.3</td><td>92.4± 1.2</td><td>90.6±0.3</td><td>89.9 ±0.4</td><td>90.3±0.8</td><td>90.3 ±1.1</td><td>89.8±0.4</td></tr><tr><td>iTAML+RRR</td><td>99.4± 0.8</td><td>97.3± 0.5</td><td>96.6±0.7</td><td>96.3 ± 1.1</td><td>95.3 ± 0.5</td><td>93.1 ± 0.5</td><td>92.1 ± 0.6</td><td>92.1±0.6</td><td>92.9±0.9</td><td>91.9 ± 0.4</td></tr><tr><td>EEIL</td><td>99.5 ± 0.4</td><td>98.8 ± 1.1</td><td>95.9±0.9</td><td>93.0 ±0.4</td><td>88.3 ±1.1</td><td>86.7 ± 1.2</td><td>83.0 ±1.2</td><td>81.1± 0.5</td><td>78.2 ±0.7</td><td>75.4± 0.4</td></tr><tr><td>EEIL+RRR</td><td>99.5± 0.4</td><td>98.1 ± 0.7</td><td>97.4 ± 1.1</td><td>96.7 ± 0.4</td><td>93.3 ± 0.5</td><td>89.4 ± 1.1</td><td>86.5±0.3</td><td>86.1 ± 1.1</td><td>81.8 ± 0.4</td><td>77.0± 0.3</td></tr><tr><td>BiC</td><td>98.3±0.7</td><td>94.9 ±0.8</td><td>93.5±0.7</td><td>90.9 ± 1.2</td><td>89.0 ± 1.2</td><td>87.3± 0.6</td><td>85.2±0.7</td><td>83.2 ± 0.4</td><td>82.5±0.9</td><td>81.1 ± 1.1</td></tr><tr><td>BiC+RRR</td><td>98.3±0.7</td><td>98.9 ±0.3</td><td>96.5±0.6</td><td>93.9 ± 0.4</td><td>92.0±0.7</td><td>89.3 ± 1.1</td><td>87.2 ±0.8</td><td>87.2 ± 1.1</td><td>85.5±0.9</td><td>84.1± 0.6</td></tr><tr><td>iCaRL</td><td>99.3±0.4</td><td>97.2 ± 0.9</td><td>93.5±0.9</td><td>91.0 ± 0.3</td><td>87.5 ± 1.2</td><td>82.1 ± 1.2</td><td>77.1 ± 0.4</td><td>72.8± 0.6</td><td>67.1 ±0.8</td><td>63.5 ± 1.1</td></tr><tr><td>iCaRL+RRR</td><td>99.3± 0.4</td><td>97.9 ± 1.2</td><td>94.1 ± 0.7</td><td>92.8 ±0.7</td><td>91.7 ± 0.9</td><td>85.7 ± 1.1</td><td>82.1 ± 0.6</td><td>74.4 ± 0.9</td><td>72.2 ± 0.8</td><td>68.1±0.9</td></tr><tr><td>LwF</td><td>99.3±0.5</td><td>95.2 ± 0.9</td><td>85.9± 0.9</td><td>73.9 ± 1.1</td><td>63.7±0.8</td><td>54.8 ± 0.8</td><td>50.1 ± 0.6</td><td>44.5 ± 0.9</td><td>40.7 ± 0.5</td><td>36.7±0.3</td></tr><tr><td>LwF+RRR</td><td>99.3±0.5</td><td>97.1 ± 1.2</td><td>89.3 ±0.6</td><td>79.1 ± 0.5</td><td>69.1 ± 1.1</td><td>59.4 ± 1.1</td><td>57.2 ± 0.7</td><td>48.2 ± 1.1</td><td>45.1 ± 0.6</td><td>41.5 ± 0.5</td></tr><tr><td>FT</td><td>99.3± 0.5</td><td>49.4 ± 0.3</td><td>32.6±0.3</td><td>24.7 ± 0.6</td><td>20.0 ± 1.2</td><td>16.7 ± 0.3</td><td>13.9 ± 0.3</td><td>12.3 ± 0.7</td><td>11.1 ± 0.6</td><td>9.9 ±0.7</td></tr><tr><td>ER</td><td>99.3± 0.5</td><td>95.2 ± 0.8</td><td>88.1±0.8</td><td>78.1± 0.9</td><td>72.5 ± 0.6</td><td>69.1± 0.8</td><td>67.1 ± 0.6</td><td>61.8 ±0.6</td><td>55.1± 0.3</td><td>50.1 ± 1.1</td></tr><tr><td>RRR</td><td>99.3± 0.5</td><td>96.5 ± 0.3</td><td>93.4±0.8</td><td>84.8±0.7</td><td>78.7 ± 0.4</td><td>74.7 ± 0.4</td><td>73.1 ± 0.5</td><td>68.4±0.8</td><td>60.2±0.3</td><td>55.1 ±0.7</td></tr></table>",
+        "bbox": [
+            173,
+            601,
+            825,
+            736
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/676956df21d0f00bae734752c33d3bc22a5457a67dca5308216eef3e529b5321.jpg",
+        "table_caption": [
+            "Table 6: Performance of the state-of-the-art existing approaches with and without $\\mathcal { L } _ { \\mathrm { R R R } }$ on CIFAR100 in 20 tasks. Results for iTAML (Rajasegaran et al., 2020), BiC (Wu et al., 2019), and EEIL (Castro et al., 2018) are produced with their original implementation while EWC (Kirkpatrick et al., 2017) and LwF (Li & Hoiem, 2016) are re-implemented by us. Results are averaged over 3 runs. Figure 3b in the main paper is generated using numbers in this Table. ",
+            "(a) Tasks 1-10 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>iTAML</td><td>84.7±0.6</td><td>85.7 ±0.4</td><td>86.5±0.3</td><td>86.5±0.8</td><td>86.3±1.2</td><td>85.7±0.8</td><td>84.9 ± 1.1</td><td>82.6±0.3</td><td>80.8±0.7</td><td>82.4± 0.3</td></tr><tr><td>iTAML+RRR</td><td>84.7±0.6</td><td>89.9± 0.5</td><td>89.2±0.9</td><td>89.2±0.6</td><td>89.0 ± 1.1</td><td>87.2 ±0.6</td><td>88.0±0.4</td><td>85.6 ± 1.1</td><td>86.6±0.3</td><td>85.4±0.3</td></tr><tr><td>BiC</td><td>95.7±0.6</td><td>90.3±0.9</td><td>80.9±0.8</td><td>75.8 ± 0.8</td><td>73.5±0.6</td><td>71.5 ± 1.2</td><td>67.8±0.4</td><td>65.4±0.8</td><td>62.7 ± 1.2</td><td>61.9 ± 1.2</td></tr><tr><td>BiC+RRR</td><td>95.7± 0.6</td><td>93.3±0.6</td><td>84.7 ± 1.1</td><td>77.5 ± 0.9</td><td>73.4±0.6</td><td>74.8 ± 0.6</td><td>69.6± 0.7</td><td>67.4± 0.3</td><td>65.7± 0.5</td><td>64.9±0.6</td></tr><tr><td>EEIL</td><td>81.9 ± 0.5</td><td>86.3±0.3</td><td>84.9 ± 0.4</td><td>80.7±0.3</td><td>77.7 ±0.6</td><td>74.9± 0.3</td><td>70.9±0.7</td><td>67.4± 0.7</td><td>64.9 ± 0.5</td><td>62.4±0.3</td></tr><tr><td>EEIL+RRR</td><td>81.9±0.5</td><td>88.4±0.8</td><td>87.6±0.7</td><td>82.6 ± 1.2</td><td>78.5 ± 0.6</td><td>76.9 ± 0.4</td><td>71.2 ±0.7</td><td>67.3± 0.4</td><td>67.0 ± 1.2</td><td>64.5±0.3</td></tr><tr><td>LwF</td><td>85.1 ± 0.7</td><td>68.8 ±0.9</td><td>58.6 ±1.1</td><td>50.5 ± 1.2</td><td>43.5±0.9</td><td>37.5 ± 0.6</td><td>33.7±0.9</td><td>30.4±0.9</td><td>26.8 ± 1.1</td><td>24.9 ± 0.7</td></tr><tr><td>LwF+RRR</td><td>85.1±0.7</td><td>71.6 ± 0.6</td><td>61.8±0.7</td><td>54.2 ± 0.5</td><td>46.2±0.9</td><td>40.7 ±0.7</td><td>36.7 ± 1.2</td><td>34.4± 0.4</td><td>29.8±0.7</td><td>27.2 ± 1.2</td></tr><tr><td>EWC</td><td>85.1± 0.7</td><td>61.3± 0.5</td><td>47.4± 0.8</td><td>36.2±0.3</td><td>31.3±0.6</td><td>27.9± 0.5</td><td>23.7 ± 1.1</td><td>22.5± 0.4</td><td>20.8±0.8</td><td>18.9±0.7</td></tr><tr><td>EWC+RRR</td><td>85.1±0.7</td><td>68.9 ±0.5</td><td>52.2 ±0.9</td><td>39.9 ±0.9</td><td>35.2±0.3</td><td>30.0±0.3</td><td>24.3 ± 0.8</td><td>24.0±0.6</td><td>23.7 ± 0.4</td><td>21.0 ± 1.1</td></tr><tr><td>ER</td><td>85.1± 0.7</td><td>83.1± 0.9</td><td>81.8±0.7</td><td>74.9 ± 0.3</td><td>70.4± 0.3</td><td>61.5 ± 1.2</td><td>60.8 ± 1.1</td><td>57.0±0.7</td><td>54.3 ± 0.4</td><td>48.2±0.6</td></tr><tr><td>RRR</td><td>85.1± 0.7</td><td>85.1 ± 0.9</td><td>83.8±0.4</td><td>77.9 ± 0.4</td><td>72.4 ± 1.2</td><td>64.5 ± 0.7</td><td>62.8±0.7</td><td>59.0±0.3</td><td>57.3±0.8</td><td>51.2 ± 1.1</td></tr></table>",
+        "bbox": [
+            173,
+            417,
+            825,
+            544
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/86864b17e9f65c5dd7c36dfb6a2e8e7c93eb39b028613fe91a066e5aad2d2c68.jpg",
+        "table_caption": [
+            "(b) Tasks 11-20 "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>11</td><td>12</td><td>13</td><td>14</td><td>15</td><td>16</td><td>17</td><td>18</td><td>19</td><td>20</td></tr><tr><td>iTAML</td><td>80.0 ± 1.1</td><td>80.6±0.5</td><td>74.3 ± 0.8</td><td>70.7±0.6</td><td>71.3 ± 1.1</td><td>68.3±0.5</td><td>70.3 ±0.8</td><td>68.3±0.6</td><td>69.5 ± 0.3</td><td>66.0±0.6</td></tr><tr><td>iTAML+RRR</td><td>85.5±0.5</td><td>85.2±0.8</td><td>79.7± 0.6</td><td>74.3 ± 0.4</td><td>74.0± 0.9</td><td>73.4 ± 1.1</td><td>74.8± 0.9</td><td>74.4 ± 0.4</td><td>73.9 ±0.5</td><td>71.8±0.9</td></tr><tr><td>BiC</td><td>59.2 ±0.4</td><td>57.0± 0.6</td><td>56.1 ± 1.2</td><td>55.7± 0.6</td><td>53.8±0.5</td><td>52.4 ± 1.2</td><td>49.7 ± 0.6</td><td>49.2 ± 1.2</td><td>47.7 ± 1.1</td><td>46.7 ± 1.2</td></tr><tr><td>BiC+RRR</td><td>62.2 ± 0.5</td><td>59.1 ±0.7</td><td>58.2±0.5</td><td>57.8±0.5</td><td>54.4 ± 1.2</td><td>56.6±0.9</td><td>53.9 ±0.7</td><td>52.4 ± 1.1</td><td>49.5 ± 0.8</td><td>49.4± 0.9</td></tr><tr><td>EEIL</td><td>60.9±0.6</td><td>59.5 ± 0.6</td><td>57.8±0.6</td><td>55.1 ± 0.3</td><td>53.9±0.5</td><td>51.7± 0.3</td><td>50.1±0.8</td><td>49.4± 0.5</td><td>47.4± 0.6</td><td>46.9 ± 0.9</td></tr><tr><td>EEIL+RRR</td><td>63.7±0.6</td><td>62.9 ± 0.4</td><td>59.7 ± 0.4</td><td>57.0±0.3</td><td>55.6±0.8</td><td>53.5± 0.4</td><td>53.5±0.3</td><td>52.7 ± 0.4</td><td>49.1 ± 0.3</td><td>47.8 ± 0.4</td></tr><tr><td>LwF</td><td>23.9 ±0.7</td><td>21.4± 0.7</td><td>20.0±0.7</td><td>19.1 ± 0.9</td><td>18.7±0.8</td><td>17.1 ± 0.8</td><td>15.6 ±0.8</td><td>14.7 ± 0.8</td><td>14.0 ± 0.8</td><td>13.7 ± 1.1</td></tr><tr><td>LwF+RRR</td><td>27.7± 0.7</td><td>26.9 ±0.9</td><td>25.7±0.7</td><td>24.5 ± 1.2</td><td>23.6±0.6</td><td>22.6±0.7</td><td>19.5 ± 0.3</td><td>18.6 ± 0.5</td><td>19.7 ± 0.8</td><td>18.4± 1.2</td></tr><tr><td>EWC</td><td>17.2 ± 1.1</td><td>16.0 ± 0.5</td><td>15.0± 0.8</td><td>14.5 ± 0.8</td><td>13.4 ± 1.1</td><td>12.4 ± 0.4</td><td>12.3 ± 0.4</td><td>11.5 ± 0.8</td><td>11.2 ± 0.8</td><td>9.44± 0.5</td></tr><tr><td>EWC+RRR</td><td>20.7±0.3</td><td>19.5 ± 0.4</td><td>18.4± 0.7</td><td>17.3 ± 0.5</td><td>16.2 ± 0.4</td><td>15.8 ± 0.5</td><td>15.0 ± 0.7</td><td>16.6± 0.9</td><td>14.3 ± 0.4</td><td>13.2± 0.3</td></tr><tr><td>ER</td><td>45.8 ± 0.6</td><td>42.7± 0.7</td><td>41.6 ± 0.6</td><td>41.2 ± 0.6</td><td>36.5±0.4</td><td>36.5±0.6</td><td>33.8± 0.4</td><td>32.4± 1.2</td><td>31.4± 0.7</td><td>30.2±0.5</td></tr><tr><td>RRR</td><td>48.8± 0.3</td><td>46.7 ± 0.9</td><td>43.6 ± 1.1</td><td>44.2 ± 0.7</td><td>39.5±0.3</td><td>38.5±0.9</td><td>35.8±0.3</td><td>33.4± 0.3</td><td>32.4±0.3</td><td>31.2±0.3</td></tr></table>",
+        "bbox": [
+            174,
+            579,
+            825,
+            707
+        ],
+        "page_idx": 14
+    }
+]