Add files using upload-large-folder tool

parse/train/HJf9ZhC9FX/HJf9ZhC9FX.md

@@ -0,0 +1,697 @@
+# STOCHASTIC GRADIENT/MIRROR DESCENT: MINIMAX OPTIMALITY AND IMPLICIT REGULARIZATION
+
+Navid Azizan   
+California Institute of Technology   
+Pasadena, CA 91125   
+azizan@caltech.edu   
+Babak Hassibi   
+California Institute of Technology   
+Pasadena, CA 91125   
+hassibi@caltech.edu
+
+# ABSTRACT
+
+Stochastic descent methods (of the gradient and mirror varieties) have become increasingly popular in optimization. In fact, it is now widely recognized that the success of deep learning is not only due to the special deep architecture of the models, but also due to the behavior of the stochastic descent methods used, which play a key role in reaching “good” solutions that generalize well to unseen data. In an attempt to shed some light on why this is the case, we revisit some minimax properties of stochastic gradient descent (SGD) for the square loss of linear models—originally developed in the 1990’s—and extend them to general stochastic mirror descent (SMD) algorithms for general loss functions and nonlinear models. In particular, we show that there is a fundamental identity which holds for SMD (and SGD) under very general conditions, and which implies the minimax optimality of SMD (and SGD) for sufficiently small step size, and for a general class of loss functions and general nonlinear models. We further show that this identity can be used to naturally establish other properties of SMD (and SGD), namely convergence and implicit regularization for over-parameterized linear models (in what is now being called the “interpolating regime”), some of which have been shown in certain cases in prior literature. We also argue how this identity can be used in the so-called “highly over-parameterized” nonlinear setting (where the number of parameters far exceeds the number of data points) to provide insights into why SMD (and SGD) may have similar convergence and implicit regularization properties for deep learning.
+
+# 1 INTRODUCTION
+
+Deep learning has proven to be extremely successful in a wide variety of tasks (Krizhevsky et al., 2012; LeCun et al., 2015; Mnih et al., 2015; Silver et al., 2016; Wu et al., 2016). Despite its tremendous success, the reasons behind the good generalization properties of these methods to unseen data is not fully understood (and, arguably, remains somewhat of a mystery to this day). Initially, this success was mostly attributed to the special deep architecture of these models. However, in the past few years, it has been widely noted that the architecture is only part of the story, and, in fact, the optimization algorithms used to train these models, typically stochastic gradient descent (SGD) and its variants, play a key role in learning parameters that generalize well.
+
+In particular, it has been observed that since these deep models are highly over-parameterized, they have a lot of capacity, and can fit to virtually any (even random) set of data points (Zhang et al., 2016). In other words, highly over-parameterized models can “interpolate” the data, so much so that this regime has been called the “interpolating regime” (Ma et al., 2018). In fact, on a given dataset, the loss function often has (uncountably infinitely) many global minima, which can have drastically different generalization properties, and it is not hard to construct “trivial” global minima that do not generalize. Which minimum among all the possible minima we pick in practice is determined by the optimization algorithm that we use for training the model. Even though it may seem at first that, because of the non-convexity of the loss function, the stochastic descent algorithms may get stuck in local minima or saddle points, in practice they almost always achieve a global minimum (Kawaguchi, 2016; Zhang et al., 2016; Lee et al., 2016), which perhaps can also be justified by the fact that these models are highly over-parameterized. What is even more interesting is that not only do these stochastic descent algorithms converge to global minima, but they converge to “special” ones that generalize well, even in the absence of any explicit regularization or early stopping (Zhang et al., 2016). Furthermore, it has been observed that even among the common optimization algorithms, namely SGD or its variants (AdaGrad (Duchi et al., 2011), RMSProp (Tieleman & Hinton, 2012), Adam (Kingma & Ba, 2014), etc.), there is a discrepancy in the solutions achieved by different algorithms and their generalization capabilities (Wilson et al., 2017), which again highlights the important role of the optimization algorithm in generalization.
+
+There have been many attempts in recent years to explain the behavior and properties of these stochastic optimization algorithms, and many interesting insights have been obtained (Achille & Soatto, 2017; Chaudhari & Soatto, 2018; Shwartz-Ziv & Tishby, 2017; Soltanolkotabi et al., 2017). In particular, it has been argued that the optimization algorithms perform an implicit regularization (Neyshabur et al., 2017; Ma et al., 2017; Gunasekar et al., 2017; 2018a; Soudry et al., 2017; Gunasekar et al., 2018b) while optimizing the loss function, which is perhaps why the solution generalizes well. Despite this recent progress, most results explaining the behavior of the optimization algorithm, even for SGD, are limited to linear or very simplistic models. Therefore, a general characterization of the behavior of stochastic descent algorithms for more general models would be of great interest.
+
+# 1.1 OUR CONTRIBUTION
+
+In this paper, we present an alternative explanation of the behavior of SGD, and more generally, the stochastic mirror descent (SMD) family of algorithms, which includes SGD as a special case. We do so by obtaining a fundamental identity for such algorithms (see Lemmas 2 and 5). Using these identities, we show that for general nonlinear models and general loss functions, when the step size is sufficiently small, SMD (and therefore also SGD) is the optimal solution of a certain minimax filtering (or online learning) problem. The minimax formulation is inspired by, and rooted, in $H ^ { \infty }$ filtering theory, which was originally developed in the 1990’s in the context of robust control theory (Hassibi et al., 1999; Simon, 2006; Hassibi et al., 1996), and we generalize several results from this literature, e.g., (Hassibi et al., 1994; Kivinen et al., 2006). Furthermore, we show that many properties recently proven in the learning/optimization literature, such as the implicit regularization of SMD in the over-parameterized linear case—when convergence happens—(Gunasekar et al., 2018a), naturally follow from this theory. The theory also allows us to establish new results, such as the convergence (in a deterministic sense) of SMD in the over-parameterized linear case. We also use the theory developed in this paper to provide some speculative arguments into why SMD (and SGD) may have similar convergence and implicit regularization properties in the so-called “highly over-parameterized” nonlinear setting (where the number of parameters far exceeds the number of data points) common to deep learning.
+
+In an attempt to make the paper easier to follow, we first describe the main ideas and results in a simpler setting, namely, SGD on the square loss of linear models, in Section 3, and mention the connections to $H ^ { \infty }$ theory. The full results, for SMD on a general class of loss functions and for general nonlinear models, are presented in Section 4. We demonstrate some implications of this theory, such as deterministic convergence and implicit regularization, in Section 5, and we finally conclude with some remarks in Section 6. Most of the formal proofs are relegated to the appendix.
+
+# 2 PRELIMINARIES
+
+Denote the training dataset by $\{ ( x _ { i } , y _ { i } ) : i = 1 , \ldots , n \}$ , where $x _ { i } \in \mathbb { R } ^ { d }$ are the inputs, and $y _ { i } \in \mathbb { R }$ are the labels. We assume that the data is generated through a (possibly nonlinear) model $f _ { i } ( w ) =$ $f ( x _ { i } , w )$ with some parameter vector $w \in \mathbb { R } ^ { m }$ , plus some noise $v _ { i }$ , i.e., $y _ { i } = f ( x _ { i } , w ) + v _ { i }$ for $i = 1 , \ldots , n$ . The noise can be due to actual measurement error, or it can be due to modeling error (if the model $f ( x _ { i } , \cdot )$ is not rich enough to fully represent the data), or it can be a combination of both. As a result, we do not make any assumptions on the noise (such as stationarity, whiteness, Gaussianity, etc.).
+
+Since typical deep models have a lot of capacity and are highly over-parameterized, we are particularly interested in the over-parameterized (so-caled interpolating) regime, i.e., when $m > n$ . In this case, there are many parameter vectors $w$ (in fact, uncountably infinitely many) that are consistent with the observations. We denote the set of these parameter vectors by
+
+$$
+\mathcal { W } = \left\{ w \in \mathbb { R } ^ { m } \mid y _ { i } = f ( x _ { i } , w ) , i = 1 , \ldots , n \right\} .
+$$
+
+(Note the absence of the noise term, since in this regime we can fully interpolate the data.) The set $\mathcal { W }$ is typically an $( m - n )$ -dimensional manifold and depends only on the training data $\left\{ \left( x _ { i } , y _ { i } \right) : \right.$ $i = 1 , \ldots , n \}$ and nonlinear model $f ( \cdot , \cdot )$ .
+
+The total loss on the training set (empirical risk) can be denoted by $\begin{array} { r } { L ( w ) = \sum _ { i = 1 } ^ { n } L _ { i } ( w ) } \end{array}$ , where $L _ { i } ( \cdot )$ is the loss on the individual data point $i$ . We assume that the loss $L _ { i } ( \cdot )$ depends only on the residual, i.e., the difference between the prediction and the true label. In other words,
+
+$$
+L _ { i } ( w ) = l ( y _ { i } - f ( x _ { i } , w ) ) ,
+$$
+
+where $l ( \cdot )$ can be any nonnegative differentiable function with $l ( 0 ) = 0$ . Typical examples of $l ( \cdot )$ include square $( l _ { 2 } )$ loss, Huber loss, etc. We remark that, in the interpolating regime, every parameter vector in the set $\mathcal { W }$ renders each individual loss zero, i.e., $L _ { i } ( w ) = 0$ , for all $w \in \mathcal { W }$ .
+
+# 3 WARM-UP: REVISITING SGD ON SQUARE LOSS OF LINEAR MODELS
+
+In this section, we describe the main ideas and results in a simple setting, i.e., stochastic gradient descent (SGD) for the square loss of a linear model, and we revisit some of the results from $H ^ { \infty }$ theory (Hassibi et al., 1999; Simon, 2006). In this case, the data model is $y _ { i } = x _ { i } ^ { T } w + v _ { i } , i =$ $1 , \ldots , n$ (where there is no assumption on $v _ { i }$ ) and the loss function is $\begin{array} { r } { L _ { i } ( w ) = \frac { 1 } { 2 } ( y _ { i } - x _ { i } ^ { T } w ) ^ { 2 } } \end{array}$ .
+
+Assuming the data is indexed randomly, the SGD updates are defined as $w _ { i } = w _ { i - 1 } - \eta \nabla L _ { i } ( w _ { i - 1 } )$ where $\eta > 0$ is the step size or learning rate.1 The update in this case can be expressed as
+
+$$
+w _ { i } = w _ { i - 1 } + \eta \left( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } \right) x _ { i } ,
+$$
+
+for $i \geq 1$ (for $i > n$ , we can either cycle through the data, or select them at random).
+
+Remark. We should point out that, when the step size $\eta$ is fixed, the SGD recursions have no hope of converging, unless there exists a weight vector $w$ which perfectly interpolates the data $\{ ( \bar { x } _ { i } , y _ { i } ) : i = \bar { 1 } , \bar { . } . . , n \}$ . The reason being that, if this is not the case, for any estimated weight vector in SGD there will exist at least one data point that has a nonzero instantaneous gradient and that will therefore move the estimate by a non-vanishing amount.2 It is for this reason that the results on the convergence of SGD and SMD (Sections 3.3 and 5) pertain to the interpolating regime.
+
+# 3.1 CONSERVATION OF UNCERTAINTY
+
+Prior to the $i$ -th step of any optimization algorithm, we have two sources of uncertainty: our uncertainty about the unknown parameter vector $w$ , which we can represent by $w - w _ { i - 1 }$ , and our uncertainty about the $i$ -th data point $( x _ { i } , y _ { i } )$ , which we can represent by the noise $v _ { i }$ . After the $i$ -th step, the uncertainty about $w$ is transformed to $w - w _ { i }$ . But what about the uncertainty in $v _ { i } ?$ What is it transformed to? In fact, we will view any optimization algorithm as one which redistributes the uncertainties at time $i - 1$ to new uncertainties at time $i$ . The two uncertainties, or error terms, we will consider are $e _ { i }$ and $e _ { p , i }$ , defined as follows.
+
+$$
+e _ { i } : = y _ { i } - x _ { i } ^ { T } w _ { i - 1 } , \mathrm { ~ a n d ~ } e _ { p , i } : = x _ { i } ^ { T } w - x _ { i } ^ { T } w _ { i - 1 } .
+$$
+
+$e _ { i }$ is often referred to as the innvovations and is the error in predicting $y _ { i }$ , given the input $x _ { i }$ . $e _ { p , i }$ is sometimes called the prediction error, since it is the error in predicting the noiseless output $x _ { i } ^ { T } w$ , i.e., in predicting what the best output of the model is. In the absence of noise, $e _ { i }$ and $e _ { p , i }$ coincide.
+
+One can show that SGD transforms the uncertainties in the fashion specified by the following lemma, which was first noted in (Hassibi et al., 1996).
+
+![](images/ffefc79710cb5f9f00f08a76b9dce080a12b786c114b24edef4cf913496ff4f4.jpg)  
+Figure 1: Illustration of Lemma 1. Each step of SGD can be viewed as a transformation of the uncertainties with the right coefficients.
+
+Lemma 1. For any parameter $w$ and noise values $\{ v _ { i } \}$ that satisfy $y _ { i } = x _ { i } ^ { T } w + v _ { i }$ for $i = 1 , \ldots , n ,$ and for any step size $\eta > 0$ , the following relation holds for the SGD iterates $\{ w _ { i } \}$ given in Eq. (3)
+
+$$
+\begin{array} { r } { \| w - w _ { i - 1 } \| ^ { 2 } + \eta v _ { i } ^ { 2 } = \| w - w _ { i } \| ^ { 2 } + \eta \left( 1 - \eta \| x _ { i } \| ^ { 2 } \right) e _ { i } ^ { 2 } + \eta e _ { p , i } ^ { 2 } , \quad \forall i \ge 1 . } \end{array}
+$$
+
+As illustrated in Figure 1, this means that each step of SGD can be thought of as a lossless transformation of the input uncertainties to the output uncertainties, with the specified coefficients.
+
+Once one knows this result, proving it is straightforward. To see that, note that we can write $v _ { i } =$ $y _ { i } - x _ { i } ^ { T } w$ as $v _ { i } = ( y _ { i } - x _ { i } ^ { T } \mathcal { \bar { w } } _ { i - 1 } ) \stackrel { \smile } { - } ( x _ { i } ^ { T } w - \bar { x } _ { i } ^ { T } w _ { i - 1 } )$ . Multiplying both sides by $\sqrt { \eta }$ , we have
+
+$$
+\sqrt { \eta } v _ { i } = \sqrt { \eta } ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) - \sqrt { \eta } ( x _ { i } ^ { T } w - x _ { i } ^ { T } w _ { i - 1 } ) .
+$$
+
+On the other hand, subtracting both sides of the update rule (3) from $w$ yields
+
+$$
+w - w _ { i } = \left( w - w _ { i - 1 } \right) - \eta \left( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } \right) x _ { i } .
+$$
+
+Squaring both sides of (6) and (7), and subtracting the results leads to Equation (5).
+
+A nice property of Equation (5) is that, if we sum over all $i = 1 , \dots , T$ , the terms $\| w - w _ { i } \| ^ { 2 }$ and $\lVert \boldsymbol { w } - \boldsymbol { w } _ { i - 1 } \rVert ^ { 2 }$ on different sides cancel out telescopically, leading to the following important lemma.
+
+Lemma 2. For any parameter $w$ and noise values $\{ v _ { i } \}$ that satisfy $y _ { i } = x _ { i } ^ { T } w + v _ { i }$ for $i = 1 , \ldots , n ,$ , any initialization $w _ { 0 }$ , any step size $\eta > 0$ , and any number of steps $T \geq 1$ , the following relation holds for the SGD iterates $\{ w _ { i } \}$ given in Eq. (3)
+
+$$
+\boxed { \| w - w _ { 0 } \| ^ { 2 } + \eta \sum _ { i = 1 } ^ { T } v _ { i } ^ { 2 } = \| w - w _ { T } \| ^ { 2 } + \eta \sum _ { i = 1 } ^ { T } \left( 1 - \eta \| x _ { i } \| ^ { 2 } \right) e _ { i } ^ { 2 } + \eta \sum _ { i = 1 } ^ { T } e _ { p , i } ^ { 2 } . }
+$$
+
+As we will show next, this identity captures most properties of SGD, and implies several important results in a very transparent fashion. For this reason, this relation can be viewed as a “fundamental identity” for SGD.
+
+# 3.2 MINIMAX OPTIMALITY OF SGD
+
+For a given horizon $T$ , consider the following minimax problem:
+
+$$
+\operatorname* { m i n } _ { \{ w _ { i } \} } \operatorname* { m a x } _ { w , \{ v _ { i } \} } \frac { \Vert w - w _ { T } \Vert ^ { 2 } + \eta \sum _ { i = 1 } ^ { T } e _ { p , i } ^ { 2 } } { \Vert w - w _ { 0 } \Vert ^ { 2 } + \eta \sum _ { i = 1 } ^ { T } v _ { i } ^ { 2 } } .
+$$
+
+This minimax problem is motivated by the theory of $H ^ { \infty }$ control and estimation (Francis, 1987; Hassibi et al., 1999; Bas¸ar & Bernhard, 2008). The denominator of the cost function can be interpreted as the energy of the uncertainties and consists of two terms, $\| w - w _ { 0 } \| ^ { 2 }$ , the energy of our uncertainty of the unknown weight vector at the beginning of learning when we have not yet observed the data, and $\textstyle \sum _ { i = 1 } ^ { T } v _ { i } ^ { 2 }$ , the energy of the uncertainty in the measurements. The numerator denotes the energy of the estimation errors in an online setting. The first term, $\| w - w _ { T } \| ^ { 2 }$ , is the energy of our uncertainty of the unknown weight vector after we have observed $T$ data points, and the second term, P i=1 e p,i $\begin{array} { r } { \sum _ { i = 1 } ^ { T } e _ { p , i } ^ { \dot { 2 } } = \sum _ { i = 1 } ^ { T } ( x _ { i } ^ { T } w - x _ { i } ^ { \hat { T } } w _ { i - 1 } ) ^ { 2 } } \end{array}$ , is the energy of the prediction error, i.e., how well we can predict the true uncorrupted output $x _ { i } ^ { T } w$ using measurements up to time $i - 1$ . The parameter $\eta$ weighs the two energy terms relative to each other. In this minimax problem, nature has access to the unknown weight vector $w$ and the noise sequence $v _ { i }$ and would like to maximize the energy gain from the uncertainties to prediction errors (so that the estimator behaves poorly), whereas the estimator attempts to minimize the energy gain. Such an estimator is referred to as $H ^ { \infty }$ -optimal and is robust because it safeguards against the worst-case noise. It is also conservative—for the exact same reason.3
+
+Theorem 3. For any initialization $w _ { 0 }$ , any step size $\begin{array} { r } { 0 < \eta \leq \operatorname* { m i n } _ { i } { \frac { 1 } { \| x _ { i } \| ^ { 2 } } } } \end{array}$ , and any number of steps $T \geq 1$ , the stochastic gradient descent iterates $\{ w _ { i } \}$ given in Eq. (3) are the optimal solution to the minimax problem (9). Furthermore, the optimal minimax value (achieved by SGD) is 1.
+
+This theorem explains the observed robustness and conservatism of SGD. Despite the conservativeness of safeguarding against the worst-case disturbance, this choice may actually be the rational thing to do in situations where we do not have much knowledge about the disturbances, which is the case in many machine learning tasks.
+
+Theorem 3 holds for any horizon $T \geq 1$ . A variation of this result, i.e., when $T \to \infty$ and without the $\Vert w - w _ { T } \Vert ^ { 2 }$ term in the numerator, was first shown in (Hassibi et al., 1994; 1996). In that case, the ratio $\begin{array} { r } { \frac { \eta \sum _ { i = 1 } ^ { \infty } e _ { p , i } ^ { 2 } } { \Vert w - w _ { 0 } \Vert ^ { 2 } + \eta \sum _ { i = 1 } ^ { \infty } v _ { i } ^ { 2 } } } \end{array}$ in the minimax problem is in fact the √ $H ^ { \infty }$ norm of the transfer operator√ that maps the unknown disturbances $( w - w _ { 0 } , \{ \sqrt { \eta } v _ { i } \} )$ to the prediction errors $\{ \sqrt { \eta } e _ { p , i } \}$ .
+
+We end this section with a stochastic interpretation of SGD (Hassibi et al., 1996). Assume that the true weight vector has a normal distribution with mean $w _ { 0 }$ and covariance matrix $\eta I$ , and that the noise $v _ { i }$ are iid standard normal. Then SGD solves
+
+$$
+\operatorname* { m i n } _ { \{ w _ { i } \} } \mathbb { E } \exp \left( \frac { 1 } { 2 } \cdot \left( \| w - w _ { T } \| ^ { 2 } + \eta \sum _ { i = 1 } ^ { T } ( x _ { i } ^ { T } w - x _ { i } ^ { T } w _ { i - 1 } ) ^ { 2 } \right) \right) ,
+$$
+
+and no exponent larger than $\frac { 1 } { 2 }$ is possible, in the sense that no estimator can keep the expected cost finite. This means that, in the Gaussian setting, SGD minimizes the expected value of an exponential quadratic cost. The algorithm is thus very adverse to large estimation errors, as they are penalized exponentially larger than moderate ones.
+
+# 3.3 CONVERGENCE AND IMPLICIT REGULARIZATION
+
+The over-parameterized (interpolating) linear regression regime is a simple but instructive setting, recently considered in some papers (Gunasekar et al., 2018a; Zhang et al., 2016). In this setting, we can show that, for sufficiently small step, i.e. $\begin{array} { r } { 0 < \eta \leq \operatorname* { m i n } _ { i } \frac { \mathbf { \tilde { 1 } } } { \| x _ { i } \| ^ { 2 } } } \end{array}$ , SGD always converges to a special solution among all the solutions $\mathcal { W }$ , in particular to the one with the smallest $l _ { 2 }$ distance from $w _ { 0 }$ . In other words, if, for example, initialized at zero, SGD implicitly regularizes the solution according to an $l _ { 2 }$ norm. This result follows directly from Lemma 2.
+
+To see that, note that in the interpolating case the $v _ { i }$ are zero, and we have $e _ { i } = y _ { i } - x _ { i } ^ { T } w _ { i - 1 } =$ $x _ { i } ^ { T } w - x _ { i } ^ { T } w _ { i - 1 } = e _ { p , i }$ . Hence, identity (8) reduces to
+
+$$
+\| w - w _ { 0 } \| ^ { 2 } = \| w - w _ { T } \| ^ { 2 } + \eta \sum _ { i = 1 } ^ { T } \left( 2 - \eta \| x _ { i } \| ^ { 2 } \right) e _ { i } ^ { 2 } ,
+$$
+
+for all $w \in \mathbf { \Sigma } \mathcal { W }$ . By dropping the $\| w \mathrm { ~ - ~ } w _ { T } \| ^ { 2 }$ term and taking $\textit { T }  \infty$ , we have $\begin{array} { r } { \eta \sum _ { i = 1 } ^ { \infty } \left( 2 - \eta \| x _ { i } \| ^ { 2 } \right) e _ { i } ^ { 2 } \ \leq \ \| w - w _ { 0 } \| ^ { 2 } } \end{array}$ T , which implies that, for $\begin{array} { r } { 0 < \eta < \operatorname* { m i n } _ { i } \frac { 2 } { \| x _ { i } \| ^ { 2 } } } \end{array}$ , we must have $e _ { i } \to 0$ as $i  \infty$ . When $e _ { i } = y _ { i } - x _ { i } ^ { T } w _ { i - 1 }$ goes to zero, the updates in (3) vanish and we get convergence, i.e., $w  w _ { \infty }$ . Further, again because $e _ { i } \to 0$ , all the data points are being fit, which means $w _ { \infty } \in \mathcal { W }$ . Moreover, it is again very straightforward to see from (11) that the solution converged to is the one with minimum Euclidean norm from the initial point. To see that, notice that the summation term in Eq. (11) is independent of $w$ (it depends only on $x _ { i } , y _ { i }$ and $w _ { 0 }$ ). Therefore, by taking $T \to \infty$ and minimizing both sides with respect to $w \in \mathcal { W }$ , we get
+
+$$
+\boldsymbol { w } _ { \infty } = \underset { \boldsymbol { w } \in \mathcal { W } } { \arg \operatorname* { m i n } } \left\| \boldsymbol { w } - \boldsymbol { w } _ { 0 } \right\| .
+$$
+
+Once again, this also implies that if SGD is initialized at the origin, i.e., $w _ { 0 } = 0$ , then it converges to the minimum- $l _ { 2 }$ -norm solution, among all the solutions.
+
+# 4 MAIN RESULT: GENERAL CHARACTERIZATION OF STOCHASTIC MIRROR DESCENT
+
+Stochastic Mirror Descent (SMD) (Nemirovskii et al., 1983; Beck & Teboulle, 2003; Cesa-Bianchi et al., 2012; Zhou et al., 2017) is one of the most widely used families of algorithms for stochastic optimization, which includes SGD as a special case. In this section, we provide a characterization of the behavior of general SMD, on general loss functions and general nonlinear models, in terms of a fundamental identity and minimax optimality.
+
+For any strictly convex and differentiable potential $\psi ( \cdot )$ , the corresponding SMD updates are defined as
+
+$$
+\boldsymbol { w } _ { i } = \underset { \boldsymbol { w } } { \arg \operatorname* { m i n } } \ \eta \boldsymbol { w } ^ { T } \nabla L _ { i } ( \boldsymbol { w } _ { i - 1 } ) + D _ { \boldsymbol { \psi } } ( \boldsymbol { w } , \boldsymbol { w } _ { i - 1 } ) ,
+$$
+
+where
+
+$$
+D _ { \psi } ( w , w _ { i - 1 } ) = \psi ( w ) - \psi ( w _ { i - 1 } ) - \nabla \psi ( w _ { i - 1 } ) ^ { T } ( w - w _ { i - 1 } )
+$$
+
+is the Bregman divergence with respect to the potential function $\psi ( \cdot )$ . Note that $D _ { \psi } ( \cdot , \cdot )$ is nonnegative, convex in its first argument, and that, due to strict convexity, $D _ { \psi } ( w , w ^ { \prime } ) = \stackrel { . } { 0 }$ iff $w = w ^ { \prime }$ . Moreover, the updates can be equivalently written as
+
+$$
+\nabla \psi ( w _ { i } ) = \nabla \psi ( w _ { i - 1 } ) - \eta \nabla L _ { i } ( w _ { i - 1 } ) ,
+$$
+
+which are uniquely defined because of the invertibility of $\nabla \psi$ (again, implied by the strict convexity of $\psi ( \cdot ) )$ ). In other words, stochastic mirror descent can be thought of as transforming the variable $w$ , with a mirror map $\nabla \psi ( \cdot )$ , and performing the SGD update on the new variable. For this reason, $\nabla \psi ( w )$ is often referred to as the dual variable, while $w$ is the primal variable.
+
+Different choices of the potential function $\psi ( \cdot )$ yield different optimization algorithms, which, as we will see, result in different implicit regularizations. To name a few examples: For the potential function $\psi ( w ) = \textstyle { \frac { 1 } { 2 } } \| w \| ^ { 2 }$ , the Bregman divergence is $\begin{array} { r } { D _ { \psi } ( w , w ^ { \prime } ) = \frac 1 2 \| w - w ^ { \prime } \| ^ { 2 } } \end{array}$ , and the update rule reduces to that of SGD. For $\begin{array} { r } { \psi ( \boldsymbol { w } ) { \bf \bar { \chi } } = \sum _ { j } w _ { j } \operatorname* { l o g } w _ { j } } \end{array}$ , the Bregman divergence becomes the unnormalized relative entropy (Kullback-Leibler divergence) $\begin{array} { r } { D _ { \psi } ( w , w ^ { \prime } ) = \sum _ { j } w _ { j } \log \frac { w _ { j } } { w _ { j } ^ { \prime } } - \sum _ { j } w _ { j } + \sum _ { j } w _ { j } ^ { \prime } } \end{array}$ , which corresponds to the exponentiated gradient descent (aka the exponential weights) algorithm. Other examples include $\begin{array} { r } { \psi ( \dot { w } ) = \frac { 1 } { 2 } \| w \| _ { Q } ^ { 2 } = \frac { 1 } { 2 } w ^ { T } Q w } \end{array}$ for a positive definite matrix $Q$ , which yields $\begin{array} { r } { D _ { \psi } ( w , w ^ { \prime } ) = \frac 1 2 ( w - w ^ { \prime } ) ^ { T } Q ( w - w ^ { \prime } ) } \end{array}$ , and the $q$ -norm squared $\begin{array} { r } { \psi ( w ) = \frac 1 2 \| w \| _ { q } ^ { 2 } } \end{array}$ , which with $\textstyle { \frac { 1 } { p } } + { \frac { 1 } { q } } = 1$ yields the $p$ -norm algorithms (Grove et al., 2001; Gentile, 2003).
+
+In order to derive an equivalent “conservation law” for SMD, similar to the identity (5), we first need to define a new measure for the difference between the parameter vectors $w$ and $w ^ { \prime }$ according to the loss function $L _ { i } ( \cdot )$ . To that end, let us define
+
+$$
+D _ { L _ { i } } ( w , w ^ { \prime } ) : = L _ { i } ( w ) - L _ { i } ( w ^ { \prime } ) - \nabla L _ { i } ( w ^ { \prime } ) ^ { T } ( w - w ^ { \prime } ) ,
+$$
+
+which is defined in a similar way to a Bregman divergence for the loss function.4 The difference though is that, unlike the potential function of the Bregman divergence, the loss function $L _ { i } ( \cdot ) =$ $\ell ( y _ { i } - f ( x _ { i } , \cdot ) )$ need not be convex, even when $\ell ( \cdot )$ is, due to the nonlinearity of $f ( \cdot , \cdot )$ . As a result, $D _ { L _ { i } } ( w , w ^ { \prime } )$ is not necessarily non-negative. The following result, which is the general counterpart of Lemma 1, states the identity that characterizes SMD updates in the general setting.
+
+Lemma 4. For any (nonlinear) model $f ( \cdot , \cdot )$ , any differentiable loss $l ( \cdot )$ , any parameter $w$ and noise values $\{ v _ { i } \}$ that satisfy $y _ { i } = f ( x _ { i } , w ) + v _ { i }$ for $i = 1 , \ldots , n$ , and any step size $\eta > 0$ , the following relation holds for the SMD iterates $\{ w _ { i } \}$ given in Eq. (15)
+
+$$
+D _ { \psi } ( w , w _ { i - 1 } ) + \eta l ( v _ { i } ) = D _ { \psi } ( w , w _ { i } ) + E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta D _ { L _ { i } } ( w , w _ { i - 1 } ) ,
+$$
+
+4It is easy to verify that for linear models and quadratic loss we obtain $D _ { L _ { i } } ( w , w ^ { \prime } ) = ( x _ { i } ^ { T } w - x _ { i } ^ { T } w ^ { \prime } ) ^ { 2 }$
+
+for all $i \geq 1$ , where
+
+$$
+\begin{array} { r } { E _ { i } ( w _ { i } , w _ { i - 1 } ) : = D _ { \psi } ( w _ { i } , w _ { i - 1 } ) - \eta D _ { L _ { i } } ( w _ { i } , w _ { i - 1 } ) + \eta L _ { i } ( w _ { i } ) . } \end{array}
+$$
+
+The proof is provided in Appendix A. Note that $E _ { i } ( w _ { i } , w _ { i - 1 } )$ is not a function of $w$ . Furthermore, even though it does not have to be nonnegative in general, for $\eta$ sufficiently small, it becomes nonnegative, because the Bregman divergence $D _ { \psi } ( . , . )$ is nonnegative.
+
+Summing Equation (17) over all $i = 1 , \dots , T$ leads to the following identity, which is the general counterpart of Lemma 2.
+
+Lemma 5. For any (nonlinear) model $f ( \cdot , \cdot )$ , any differentiable loss $l ( \cdot )$ , any parameter $w$ and noise values $\{ v _ { i } \}$ that satisfy $y _ { i } = f ( x _ { i } , w ) + v _ { i }$ for $i = 1 , \ldots , n$ , any initialization $w _ { 0 }$ , any step size $\eta > 0$ , and any number of steps $T \geq 1$ , the following relation holds for the SMD iterates $\{ w _ { i } \}$ given in Eq. (15)
+
+$$
+\boxed { D _ { \psi } ( w , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( v _ { i } ) = D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \left( E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) . }
+$$
+
+We should reiterate that Lemma 5 is a fundamental property of SMD, which allows one to prove many important results, in a direct way.
+
+In particular, in this setting, we can show that SMD is minimax optimal in a manner that generalizes Theorem 3 of Section 3, in the following 3 ways: 1) General potential $\psi ( \cdot ) , 2 )$ General model $f ( \cdot , \cdot )$ , and 3) General loss function $l ( \cdot )$ . The result is as follows.
+
+Theorem 6. Consider any (nonlinear) model $f ( \cdot , \cdot )$ , any non-negative differentiable loss $l ( \cdot )$ with the property $l ( 0 ) = l ^ { \prime } ( 0 ) \stackrel { . } { = } 0$ , and any initialization $w _ { 0 }$ . For sufficiently small step size, i.e., for any $\eta > 0$ for which ${ \psi } ( w ) - \eta L _ { i } ( w )$ is convex for all $i ,$ , and for any number of steps $T \geq 1$ , the SMD iterates $\{ w _ { i } \}$ given by $E q$ . (15), w.r.t. any strictly convex potential $\psi ( \cdot )$ , is the optimal solution to the following minimization problem
+
+$$
+\operatorname* { m i n } _ { \{ w _ { i } \} } \operatorname* { m a x } _ { w , \{ v _ { i } \} } \frac { D _ { \psi } ( w , w _ { T } ) + \eta \sum _ { i = 1 } ^ { T } D _ { L _ { i } } ( w , w _ { i - 1 } ) } { D _ { \psi } ( w , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( v _ { i } ) } .
+$$
+
+Furthermore, the optimal value (achieved by SMD) is 1.
+
+The proof is provided in Appendix B. For the case of square loss and a linear model, the result reduces to the following form.
+
+Corollary 7. For $\begin{array} { r } { L _ { i } ( w ) = \frac { 1 } { 2 } ( y _ { i } - x _ { i } ^ { T } w ) ^ { 2 } } \end{array}$ , for any initialization $w _ { 0 }$ , any sufficiently small step size, i.e., $\begin{array} { r } { 0 < \eta \leq \frac { \alpha } { \| x _ { i } \| ^ { 2 } } } \end{array}$ , and any number of steps $T \geq 1$ , the SMD iterates $\{ w _ { i } \}$ given by Eq. (15), w.r.t. any $\alpha$ -strongly convex potential $\psi ( \cdot )$ , is the optimal solution to
+
+$$
+\operatorname* { m i n } _ { \{ w _ { i } \} } \operatorname* { m a x } _ { w , \{ v _ { i } \} } \frac { D _ { \psi } ( w , w _ { T } ) + \frac { \eta } { 2 } \sum _ { i = 1 } ^ { T } e _ { p , i } ^ { 2 } } { D _ { \psi } ( w , w _ { 0 } ) + \frac { \eta } { 2 } \sum _ { i = 1 } ^ { T } v _ { i } ^ { 2 } } .
+$$
+
+The optimal value (achieved by SMD) is 1.
+
+We should remark that Theorem 6 and Corollary 7 generalize several known results in the literature. In particular, as mentioned in Section 3, the result of (Hassibi et al., 1994) is a special case of Corollary 7 for $\begin{array} { r } { \psi ( w ) = \frac { 1 } { 2 } \| w \| ^ { 2 } } \end{array}$ . Furthermore, our result generalizes the result of (Kivinen et al., 2006), which is the special case for the $p$ -norm algorithms, again, with square loss and a linear model. Another interesting connection to the literature is that it was shown in (Hassibi & Kailath, 1995) that SGD is locally minimax optimal, with respect to the $H ^ { \infty }$ norm. Strictly speaking, our result is not a generalization of that result; however, Theorem 6 can be interpreted as SGD/SMD being globally minimax optimal, but with respect to different metrics in the numerator and denominator. Namely, the uncertainty about the weight vector $w$ is measured by the Bregman divergence of the potential, the uncertainty about the noise by the loss, and the prediction error by the “Bregman-divergencelike” expression of the loss.
+
+# 5 CONVERGENCE AND IMPLICIT REGULARIZATION IN OVER-PARAMETERIZED MODELS
+
+In this section, we show some of the implications of the theory developed in the previous section. In particular, we show convergence and implicit regularization, in the over-parameterized (so-called interpolating) regime5, for general SMD algorithms. We first consider the linear interpolating case, which has been studied in the literature, and show that the known results follow naturally from our Lemma 5. Further, we shall obtain some new convergence results. Finally, we discuss the implications for nonlinear models, and argue that the same results hold qualitatively in highlyoverparameterized settings, which is the typical scenario in deep learning.
+
+# 5.1 OVER-PARAMETERIZED LINEAR MODELS
+
+In this setting, the $v _ { i }$ are zero, ${ \mathcal { W } } = \left\{ w \mid y _ { i } = x _ { i } ^ { T } w , i = 1 , \ldots , n \right\}$ , and $L _ { i } ( w ) = l ( y _ { i } - x _ { i } ^ { T } w )$ , with any differentiable loss $l ( \cdot )$ . Therefore, Eq. (19) reduces to
+
+$$
+D _ { \psi } ( w , w _ { 0 } ) = D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \left( E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) ,
+$$
+
+for all $w \in \mathcal W$ , where
+
+$$
+\begin{array} { r l } & { { D } _ { L _ { i } } ( w , w _ { i - 1 } ) = L _ { i } ( w ) - L _ { i } ( w _ { i - 1 } ) - \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w - w _ { i - 1 } ) } \\ & { \qquad = 0 - l ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) + l ^ { \prime } ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) x _ { i } ^ { T } ( w - w _ { i - 1 } ) } \\ & { \qquad = - l ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) + l ^ { \prime } ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) } \end{array}
+$$
+
+which is notably independent of $w$ . As a result, we can easily minimize both sides of Eq. (22) with respect to $w \in \mathcal W$ , which for $T \to \infty$ leads to the following result.
+
+Proposition 8. For any differentiable loss $l ( \cdot )$ , any initialization $w _ { 0 }$ , and any step size $\eta _ { ; }$ , consider the SMD iterates given in Eq. (15) with respect to any strictly convex potential $\psi ( \cdot )$ . If the iterates converge to a solution $w _ { \infty } \in \mathcal { W }$ , then
+
+$$
+\boldsymbol { w } _ { \infty } = \underset { \boldsymbol { w } \in \mathcal { W } } { \arg \operatorname* { m i n } } D _ { \psi } ( \boldsymbol { w } , \boldsymbol { w } _ { 0 } ) .
+$$
+
+Remark. In particular, for the initialization $\begin{array} { r } { { w _ { 0 } } = \arg \operatorname* { m i n } _ { w \in \mathbb { R } ^ { m } } \psi ( w ) } \end{array}$ , if the iterates converge to a solution $w _ { \infty } \in \mathcal { W }$ , then
+
+$$
+\boldsymbol { w } _ { \infty } = \arg \operatorname* { m i n } _ { \boldsymbol { w } \in \mathcal { W } } \boldsymbol { \psi } ( \boldsymbol { w } ) .
+$$
+
+An equivalent form of Proposition 8 has been shown recently in, e.g., (Gunasekar et al., 2018a).6 Other implicit regularization results have been shown in (Gunasekar et al., 2018b; Soudry et al., 2017) for classification problems, which are not discussed here. Note that the result of (Gunasekar et al., 2018a) does not say anything about whether the algorithm converges or not. However, our fundamental identity of SMD (Lemma 5) allows us to also establish convergence to the regularized point, for some common cases, which will be shown next.
+
+What Proposition 8 says is that depending on the choice of the potential function $\psi ( \cdot )$ , the optimization algorithm can perform an implicit regularization without any explicit regularization term. In other words, for any desired regularizer, if one chooses a potential function that approximates the regularizer, we can run the optimization without explicit regularization, and if it converges to a solution, the solution must be the one with the minimum potential.
+
+In principle, one can choose the potential function in SMD for any desired convex regularization. For example, we can find the maximum entropy solution by taking the potential to be the negative entropy. Another illustrative example follows.
+
+Example [Compressed Sensing]: In compressed sensing, one seeks the sparsest solution to an under-determined (over-parameterized) system of linear equations. The surrogate convex problem one solves is:
+
+$$
+\begin{array} { r l } { \operatorname* { m i n } } & { { } \| w \| _ { 1 } } \\ { \mathrm { s u b j e c t ~ t o } } & { { } y _ { i } = x _ { i } ^ { T } w , i = 1 , \dots n } \end{array}
+$$
+
+One cannot choose $\psi ( w ) = \| w \| _ { 1 }$ , since it is neither differentiable nor strictly convex. However, $\psi ( w ) = \| w \| _ { 1 + \epsilon }$ , for any $\epsilon > 0$ , can be used. Figure 4 shows a compressed sensing example, with $n = 5 0$ , $m = 1 0 0$ , and sparsity $k = 1 0$ . SMD was used with a step size of $\eta = 0 . 0 0 1$ and the potential function was ${ \psi } ( \cdot ) \mathbf { \bar { \psi } } = \| \cdot \| _ { 1 . 1 }$ . SMD converged to the true sparse solution after around 10,000 iterations. On this example, it was an order of magnitude faster than standard $l _ { 1 }$ optimization.
+
+![](images/e84656572e3d5c97b3946f178da69418e9d2fc71bb761c8306618804b9b53a4e.jpg)  
+Figure 2: The training loss and actual error of stochastic mirror descent for compressed sensing. SMD recovers the actual sparse signal.
+
+Next we establish convergence to the regularized point for the convex case.
+
+Proposition 9. Consider the following two cases.
+
+(i) $l ( \cdot )$ is differentiable and convex and has a unique root at $O$ , $\psi ( \cdot )$ is strictly convex, and $\eta > 0$ is such that $\psi - \eta L _ { i }$ is convex for all $i$ .   
+(ii) $l ( \cdot )$ is differentiable and quasi-convex, $l ^ { \prime } ( \cdot )$ is zero only at zero, $\psi ( \cdot )$ is $\alpha$ -strongly convex, and 0 < η ≤ mini i i i−1 kxik2|l0(yi−xTi wi−1)| .
+
+If either (i) or (ii) holds, then for any $w _ { 0 }$ , the SMD iterates given in Eq. (15) converge to
+
+$$
+\boldsymbol { w } _ { \infty } = \underset { \boldsymbol { w } \in \mathcal { W } } { \arg \operatorname* { m i n } } D _ { \psi } ( \boldsymbol { w } , \boldsymbol { w } _ { 0 } ) .
+$$
+
+The proof is provided in Appendix C.
+
+# 5.2 DISCUSSION OF HIGHLY OVER-PARAMETERIZED NONLINEAR MODELS
+
+Let us consider the highly-overparameterized nonlinear model
+
+$$
+y _ { i } = f ( x _ { i } , w ) , \quad i = 1 , \ldots , n , \quad w \in \mathbb { R } ^ { m }
+$$
+
+where by highly-overparameterized we mean $m \gg n$ . Since the model is highly over-parameterized, it is assumed that we can perfectly interpolate the data points $( x _ { i } , y _ { i } )$ so that the noise $v _ { i }$ is zero. In this case, the set of parameter vectors that interpolate the data is given by $\mathcal { W } = \{ w \in \mathbb { R } ^ { m } \ | \ y _ { i } =$ $f ( x _ { i } , w ) , i = 1 , \ldots , n \}$ , and Eq. (19), again, reduces to
+
+$$
+D _ { \psi } ( w , w _ { 0 } ) = D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \left( E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) ,
+$$
+
+for all $w \in \mathcal W$ . Our proofs of convergence and implicit regularization for SGD and SMD in the linear case relied on two facts: (i) $D _ { L _ { i } } ( w , w _ { i - 1 } )$ was non-negative (this allowed us to show convergence), and (ii) $D _ { L _ { i } } ( w , w _ { i - 1 } )$ was independent of $w$ (this allowed us to show implicit regularization). Unfortunately, neither of these hold in the nonlinear case.
+
+However, they do hold in a local sense. In other words, (i) $D _ { L _ { i } } ( w , w _ { i - 1 } ) \geq 0$ for $w _ { i - 1 }$ “close enough” to $w$ (see Figure 3), and (ii) $D _ { L _ { i } } ( w , w _ { i - 1 } )$ is weakly dependent on $w$ for $w _ { i - 1 }$ “close enough.” (Both statements can be made precise.)
+
+![](images/49dfe5bb9290172d598f96a653adcf84493e8175f6c79cd627b4d96f5db45ac5.jpg)  
+Figure 3: Non-negativity of $D _ { L _ { i } } ( w , w _ { i - 1 } )$ for $w _ { i - 1 }$ “close enough” to $w$ .
+
+Now define
+
+$$
+w _ { * } = \arg \operatorname* { m i n } _ { w \in \mathcal { W } } D _ { \psi } ( w , w _ { 0 } ) .
+$$
+
+Then one can show the following result.
+
+Theorem 10. There exists an $\epsilon > 0$ , such that if $\lVert w _ { * } - w _ { 0 } \rVert < \epsilon$ , then for sufficiently small step size $\eta > 0$ :
+
+1. SMD iterates converge to a point $w _ { \infty } \in \mathcal { W }$
+
+$$
+\| w _ { \infty } - w _ { * } \| = o ( \epsilon )
+$$
+
+This shows that if the initial condition is close enough, then we have convergence to a point $w _ { \infty }$ that interpolates the data, and that $w _ { \infty }$ is an order of magnitude closer to $w _ { * }$ (the implicitly regularized solution) than the initial $w _ { 0 }$ was. At first glance, this result seems rather dissatisfying. It relies on $w _ { 0 }$ being close to the manifold $\mathcal { W }$ which appears hard to guarantee. We would now like to argue that in deep learning $w _ { 0 }$ being close to $\mathcal { W }$ is often the case.
+
+In the highly-overparameterized regime, $m \gg n$ , and so the dimension of the manifold $\mathcal { W }$ is $m - n$ , which is very large. Now if the $x _ { i }$ are sufficiently random, then the tangent space to $\mathcal { W }$ at $w _ { * }$ will be a randomly oriented affine subspace of dimension $m - n$ . This means that any randomly chosen $w _ { 0 }$ will whp have a very large component when projected onto $\mathcal { W }$ . In particular, it can be shown that $\begin{array} { r } { \| w _ { * } ^ { \cdot } - w _ { 0 } \| ^ { 2 } = { \bf \dot { O } } ( \frac { \bar { n } ^ { \cdot } } { m } ) \cdot \| y ^ { \cdot } - f ( x , w ) \| ^ { 2 } } \end{array}$ , where $y = \sec ( y _ { i } , i = 1 , \dots , n )$ and $f ( x , w ) = \sec ( f ( x _ { i } , w ) , i = 1 , \dots , n )$ . Thus, we may expect that, when $m \gg n$ , the distance of any randomly chosen $w _ { 0 }$ to $\mathcal { W }$ will be small and so SMD will converge to a point on $\mathcal { W }$ that approximately performs implicit regularization.
+
+The gist of the argument is that (i) When $m \gg n$ , any random initial condition is “close” to the $n - m$ dimensional solution manifold $\mathcal { W }$ , (ii) when $w _ { 0 }$ is “close” to $w _ { * }$ , then SMD converges to a point $w _ { \infty } \in \mathcal { W }$ , (iii) $w _ { \infty }$ is “an order of magnitude closer” to $w _ { * }$ than $w _ { 0 }$ was, and (iv) thus, when highly overparamatrized, SMD converges to a point that exhibits implicit regularization.
+
+Of course, this was a very heuristic argument that merits a much more careful analysis. But it is suggestive of the fact that SGD and SMD, when performed on highly-overparameterized nonlinear models, as occurs in deep learning, may exhibit implicit regularization.
+
+# 6 CONCLUDING REMARKS
+
+We should remark that all the results stated throughout the paper extend to the case of time-varying step size $\eta _ { i }$ , with minimal modification. In particular, it is easy to show that in this case, the identity (the counterpart of Eq. (19)) becomes
+
+$$
+D _ { \psi } ( w , w _ { 0 } ) + \sum _ { i = 1 } ^ { T } \eta _ { i } l ( v _ { i } ) = D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \left( E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta _ { i } D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) ,
+$$
+
+where $E _ { i } ( w _ { i } , w _ { i - 1 } ) = D _ { \psi } ( w _ { i } , w _ { i - 1 } ) - \eta _ { i } D _ { L _ { i } } ( w _ { i } , w _ { i - 1 } ) + \eta _ { i } L _ { i } ( w _ { i } )$ . As a consequence, our main result will be the same as in Theorem 6, with the only difference that the small-step-size condition in this case is the convexity of ${ \psi } ( w ) - \eta _ { i } L _ { i } ( w )$ for all $i$ , and the SMD with time-varying step size will be the optimal solution to the following minimax problem
+
+$$
+\operatorname* { m i n } _ { \{ w _ { i } \} } \operatorname* { m a x } _ { w , \{ v _ { i } \} } \frac { D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \eta _ { i } D _ { L _ { i } } ( w , w _ { i - 1 } ) } { D _ { \psi } ( w , w _ { 0 } ) + \sum _ { i = 1 } ^ { T } \eta _ { i } l ( v _ { i } ) } .
+$$
+
+Similarly, the convergence and implicit regularization results can be proven under the same conditions (See Appendix D for more details on the time-varying case).
+
+This paper opens up a variety of important directions for future work. Most of the analysis developed here is general, in terms of the model, the loss function, and the potential function. Therefore, it would be interesting to study the implications of this theory for specific classes of models (such as different neural networks), specific losses, and specific mirror maps (which induce different regularization biases). Something for future work.
+
+# ACKNOWLEDGMENTS
+
+This work was supported in part by the National Science Foundation under grants CCF-1423663, CCF-1409204 and ECCS-1509977, by a grant from Qualcomm Inc., by NASA’s Jet Propulsion Laboratory through the President and Director’s Fund, and by Amazon Web Services Inc. and PIMCO LLC through fellowships.
+
+# REFERENCES
+
+Alessandro Achille and Stefano Soatto. On the emergence of invariance and disentangling in deep representations. arXiv preprint arXiv:1706.01350, 2017.
+
+Navid Azizan and Babak Hassibi. A characterization of stochastic mirror descent algorithms and their convergence properties. In IEEE International Conference on Acoustics, Speech and Signal Processing, 2019.
+
+Tamer Bas¸ar and Pierre Bernhard. H-infinity optimal control and related minimax design problems: a dynamic game approach. Springer Science & Business Media, 2008.
+
+Amir Beck and Marc Teboulle. Mirror descent and nonlinear projected subgradient methods for convex optimization. Operations Research Letters, 31(3):167–175, 2003.
+
+Nicolo Cesa-Bianchi, Pierre Gaillard, Gabor Lugosi, and Gilles Stoltz. Mirror descent meets fixed ´ share (and feels no regret). In Advances in Neural Information Processing Systems, pp. 980–988, 2012.
+
+Pratik Chaudhari and Stefano Soatto. Stochastic gradient descent performs variational inference, converges to limit cycles for deep networks. In International Conference on Learning Representations, 2018.
+
+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.
+
+Bruce A Francis. A course in H-infinity control theory. Berlin; New York: Springer-Verlag, 1987.
+
+Claudio Gentile. The robustness of the p-norm algorithms. Machine Learning, 53(3):265–299, 2003.
+
+Adam J Grove, Nick Littlestone, and Dale Schuurmans. General convergence results for linear discriminant updates. Machine Learning, 43(3):173–210, 2001.
+
+Suriya Gunasekar, Blake E Woodworth, Srinadh Bhojanapalli, Behnam Neyshabur, and Nati Srebro. Implicit regularization in matrix factorization. In Advances in Neural Information Processing Systems, pp. 6152–6160, 2017.
+
+Suriya Gunasekar, Jason Lee, Daniel Soudry, and Nathan Srebro. Characterizing implicit bias in terms of optimization geometry. arXiv preprint arXiv:1802.08246, 2018a.
+
+Suriya Gunasekar, Jason Lee, Daniel Soudry, and Nathan Srebro. Implicit bias of gradient descent on linear convolutional networks. arXiv preprint arXiv:1806.00468, 2018b.
+
+Babak Hassibi and Thomas Kailath. Hoo optimal training algorithms and their relation to backpropagation. In Advances in Neural Information Processing Systems 7, pp. 191–198. 1995.
+
+Babak Hassibi, Ali H. Sayed, and Thomas Kailath. Hoo optimality criteria for LMS and backpropagation. In Advances in Neural Information Processing Systems 6, pp. 351–358. 1994.
+
+Babak Hassibi, Ali H Sayed, and Thomas Kailath. Hoo optimality of the LMS algorithm. IEEE Transactions on Signal Processing, 44(2):267–280, 1996.
+
+Babak Hassibi, Ali H Sayed, and Thomas Kailath. Indefinite-Quadratic Estimation and Control: A Unified Approach to H2 and H-infinity Theories, volume 16. SIAM, 1999.
+
+Elad Hazan. Introduction to online convex optimization. Foundations and Trends in Optimization, 2(3-4):157–325, 2016. ISSN 2167-3888.
+
+Kenji Kawaguchi. Deep learning without poor local minima. In Advances in Neural Information Processing Systems, pp. 586–594, 2016.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Jyrki Kivinen, Manfred K Warmuth, and Babak Hassibi. The p-norm generalization of the LMS algorithm for adaptive filtering. IEEE Transactions on Signal Processing, 54(5):1782–1793, 2006.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1097–1105, 2012.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436, 2015.
+
+Jason D Lee, Max Simchowitz, Michael I Jordan, and Benjamin Recht. Gradient descent only converges to minimizers. In Conference on Learning Theory, pp. 1246–1257, 2016.
+
+Cong Ma, Kaizheng Wang, Yuejie Chi, and Yuxin Chen. Implicit regularization in nonconvex statistical estimation: Gradient descent converges linearly for phase retrieval, matrix completion and blind deconvolution. arXiv preprint arXiv:1711.10467, 2017.
+
+Siyuan Ma, Raef Bassily, and Mikhail Belkin. The power of interpolation: Understanding the effectiveness of SGD in modern over-parametrized learning. In Proceedings of the 35th International Conference on Machine Learning, volume 80, pp. 3325–3334. PMLR, 2018.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529, 2015.
+
+Arkadii Nemirovskii, David Borisovich Yudin, and Edgar Ronald Dawson. Problem complexity and method efficiency in optimization. 1983.
+
+Behnam Neyshabur, Ryota Tomioka, Ruslan Salakhutdinov, and Nathan Srebro. Geometry of optimization and implicit regularization in deep learning. arXiv preprint arXiv:1705.03071, 2017.
+
+Shai Shalev-Shwartz. Online learning and online convex optimization. Foundations and Trends in Machine Learning, 4(2):107–194, 2012. ISSN 1935-8237.
+
+Ravid Shwartz-Ziv and Naftali Tishby. Opening the black box of deep neural networks via information. arXiv preprint arXiv:1703.00810, 2017.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Dan Simon. Optimal state estimation: Kalman, H infinity, and nonlinear approaches. John Wiley & Sons, 2006.
+
+Mahdi Soltanolkotabi, Adel Javanmard, and Jason D Lee. Theoretical insights into the optimization landscape of over-parameterized shallow neural networks. arXiv preprint arXiv:1707.04926, 2017.
+
+Daniel Soudry, Elad Hoffer, Mor Shpigel Nacson, Suriya Gunasekar, and Nathan Srebro. The implicit bias of gradient descent on separable data. arXiv preprint arXiv:1710.10345, 2017.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26– 31, 2012.
+
+Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nati Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. In Advances in Neural Information Processing Systems, pp. 4151–4161, 2017.
+
+Yonghui Wu, Mike Schuster, Zhifeng Chen, Quoc V Le, Mohammad Norouzi, Wolfgang Macherey, Maxim Krikun, Yuan Cao, Qin Gao, Klaus Macherey, et al. Google’s neural machine translation system: Bridging the gap between human and machine translation. arXiv preprint arXiv:1609.08144, 2016.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.
+
+Zhengyuan Zhou, Panayotis Mertikopoulos, Nicholas Bambos, Stephen Boyd, and Peter W Glynn. Stochastic mirror descent in variationally coherent optimization problems. In Advances in Neural Information Processing Systems, pp. 7043–7052, 2017.
+
+# Supplementary Material
+
+# A PROOF OF LEMMA 4
+
+Proof. Let us start by expanding the Bregman divergence $D _ { \psi } ( w , w _ { i } )$ based on its definition
+
+$$
+D _ { \psi } ( w , w _ { i } ) = \psi ( w ) - \psi ( w _ { i } ) - \nabla \psi ( w _ { i } ) ^ { T } ( w - w _ { i } ) .
+$$
+
+By plugging the SMD update rule $\nabla \psi ( w _ { i } ) = \nabla \psi ( w _ { i - 1 } ) - \eta \nabla L _ { i } ( w _ { i - 1 } )$ into this, we can write it
+
+$$
+D _ { \psi } ( w , w _ { i } ) = \psi ( w ) - \psi ( w _ { i } ) - \nabla \psi ( w _ { i - 1 } ) ^ { T } ( w - w _ { i } ) + \eta \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w - w _ { i } ) .
+$$
+
+Using the definition of Bregman divergence for $( w , w _ { i - 1 } )$ and $( w _ { i } , w _ { i - 1 } )$ , i.e., $D _ { \psi } ( w , w _ { i - 1 } ) =$ $\psi ( w ) ~ - ~ \psi ( w _ { i - 1 } ) ~ - ~ \nabla \psi ( w _ { i - 1 } ) ^ { T } ( w ~ - ~ w _ { i - 1 } )$ and $D _ { \psi } ( w _ { i } , w _ { i - 1 } ) = \psi ( w _ { i } ) - \psi ( w _ { i - 1 } ) - \psi$ $\nabla \psi ( w _ { i - 1 } ) ^ { T } \big ( w _ { i } - w _ { i - 1 } \big )$ , we can express this as
+
+$$
+\begin{array} { r l } & { D _ { \psi } ( w , w _ { i } ) = D _ { \psi } ( w , w _ { i - 1 } ) + \psi ( w _ { i - 1 } ) + \nabla \psi ( w _ { i - 1 } ) ^ { T } ( w - w _ { i - 1 } ) - \psi ( w _ { i } ) } \\ & { \qquad - \nabla \psi ( w _ { i - 1 } ) ^ { T } ( w - w _ { i } ) + \eta \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w - w _ { i } ) } \\ & { \qquad = D _ { \psi } ( w , w _ { i - 1 } ) + \psi ( w _ { i - 1 } ) - \psi ( w _ { i } ) + \nabla \psi ( w _ { i - 1 } ) ^ { T } ( w _ { i } - w _ { i - 1 } ) } \\ & { \qquad \quad \qquad + \eta \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w - w _ { i } ) } \\ & { \qquad = D _ { \psi } ( w , w _ { i - 1 } ) - D _ { \psi } ( w _ { i } , w _ { i - 1 } ) + \eta \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w - w _ { i } ) . } \end{array}
+$$
+
+Expanding the last term using $w - w _ { i } = ( w - w _ { i - 1 } ) - ( w _ { i } - w _ { i - 1 } )$ , and following the definition of $D _ { L _ { i } } ( . , . )$ from (16) for $( w , w _ { i - 1 } )$ and $( w _ { i } , w _ { i - 1 } )$ , we have
+
+$$
+\begin{array} { r l } & { D _ { \psi } ( w , w _ { i } ) = D _ { \psi } ( w , w _ { i - 1 } ) - D _ { \psi } ( w _ { i } , w _ { i - 1 } ) + \eta \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w - w _ { i - 1 } ) } \\ & { \qquad - \eta \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w _ { i } - w _ { i - 1 } ) } \\ & { \qquad = D _ { \psi } ( w , w _ { i - 1 } ) - D _ { \psi } ( w _ { i } , w _ { i - 1 } ) + \eta \left( L _ { i } ( w ) - L _ { i } ( w _ { i - 1 } ) - D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) } \\ & { \qquad - \eta \left( L _ { i } ( w _ { i } ) - L _ { i } ( w _ { i - 1 } ) - D _ { L _ { i } } ( w _ { i } , w _ { i - 1 } ) \right) } \\ & { \qquad = D _ { \psi } ( w , w _ { i - 1 } ) - D _ { \psi } ( w _ { i } , w _ { i - 1 } ) + \eta \left( L _ { i } ( w ) - D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) } \\ & { \qquad - \eta \left( L _ { i } ( w _ { i } ) - D _ { L _ { i } } ( w _ { i } , w _ { i - 1 } ) \right) } \end{array}
+$$
+
+Defining $E _ { i } ( w _ { i } , w _ { i - 1 } ) : = D _ { \psi } ( w _ { i } , w _ { i - 1 } ) - \eta D _ { L _ { i } } ( w _ { i } , w _ { i - 1 } ) + \eta L _ { i } ( w _ { i } )$ , we can write the above equality as
+
+$$
+D _ { \psi } ( w , w _ { i } ) = D _ { \psi } ( w , w _ { i - 1 } ) - E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta \left( L _ { i } ( w ) - D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) .
+$$
+
+Notice that for any model class with additive noise, and any loss function $L _ { i }$ that depends only on the residual (i.e. the difference between the prediction and the true label), the term $L _ { i } ( w )$ depends only on the noise term, for any “true” parameter $w$ . In other words, for all $w$ that satisfy $y _ { i } =$ $f ( x _ { i } , w ) + v _ { i }$ , we have $L _ { i } ( w ) \stackrel { \cdot } { = } l ( y _ { i } - \stackrel { \cdot } { f } ( x _ { i } , w ) ) = l ( y _ { i } - ( y _ { i } - v _ { i } ) ) = l ( v _ { i } )$ . Finally, reordering the terms leads to
+
+$$
+D _ { \psi } ( w , w _ { i } ) + \eta D _ { L _ { i } } ( w , w _ { i - 1 } ) + E _ { i } ( w _ { i } , w _ { i - 1 } ) = D _ { \psi } ( w , w _ { i - 1 } ) + \eta l ( v _ { i } ) ,
+$$
+
+which concludes the proof.
+
+# B PROOF OF THEOREM 6
+
+Proof. We prove the theorem in two parts. First, we show that the value of the minimax is at least 1. Then we prove that the values is at most 1, and is achieved by stochastic mirror descent for small enough step size.
+
+1. Consider the maximization problem
+
+$$
+\operatorname* { m a x } _ { w , \{ v _ { i } \} } \frac { D _ { \psi } ( w , w _ { T } ) + \eta \sum _ { i = 1 } ^ { T } D _ { L _ { i } } ( w , w _ { i - 1 } ) } { D _ { \psi } ( w , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( v _ { i } ) } .
+$$
+
+Clearly, the optimal solution(s) and the optimal value of this problem can, and will, be a function of $\{ w _ { i } \}$ . Similarly, we can also choose feasible points that depend on $\{ w _ { i } \}$ . Any choice of a feasible point $( \dot { w } , \{ \hat { v } _ { i } \} )$ gives a lower bound on the value of the problem. Before choosing a feasible point, let us first expand the $D _ { L _ { i } } ( w , w _ { i - 1 } )$ term in the numerator, according to its definition.
+
+$$
+D _ { L _ { i } } ( w , w _ { i - 1 } ) = l ( v _ { i } ) - l ( y _ { i } - f _ { i } ( w _ { i - 1 } ) ) + l ^ { \prime } ( y _ { i } - f _ { i } ( w _ { i - 1 } ) ) \nabla f ( w _ { i - 1 } ) ^ { T } ( w - w _ { i - 1 } ) ,
+$$
+
+where we have used the fact that $l ( y _ { i } - f _ { i } ( w ) ) = l ( v _ { i } )$ for all consistent $w$ , in the first term.
+
+Now, we choose a feasible point as follows
+
+$$
+\hat { v } _ { i } = f _ { i } ( w _ { i - 1 } ) - f _ { i } ( \hat { w } ) ,
+$$
+
+where $\hat { w }$ is the choice of $w$ , as will be described soon. The reason for choosing this value for the noise is that it “fools” the estimator by making its loss on the corresponding data point zero. In other words, for this choice, we have
+
+$$
+\begin{array} { r l } & { \cal { D } _ { L _ { i } } ( w , w _ { i - 1 } ) = l ( \hat { v } _ { i } ) - l ( 0 ) + l ^ { \prime } ( 0 ) \nabla f ( w _ { i - 1 } ) ^ { T } ( \hat { w } - w _ { i - 1 } ) } \\ & { \quad \quad \quad \quad = l ( \hat { v } _ { i } ) } \end{array}
+$$
+
+because $l ( 0 ) = l ^ { \prime } ( 0 ) = 0$ . It should be clear at this point that this choice makes the second terms in the numerator and the denominator equal, independent of the choice of $\hat { w }$ . What remains to do, in order to show the 1 lower-bound, is to take care of the other two terms, i.e., $D _ { \psi } ( w , w _ { T } )$ and $D _ { \psi } ( w , w _ { 0 } )$ . As we would like to make the ratio equal to one, we would like to have $D _ { \psi } ( \dot { w } , w _ { T } ) = D _ { \psi } ( w , w _ { 0 } )$ , which is equivalent to having
+
+$$
+\psi ( w ) - \psi ( w _ { T } ) - \nabla \psi ( w _ { T } ) ^ { T } ( w - w _ { T } ) = \psi ( w ) - \psi ( w _ { 0 } ) - \nabla \psi ( w _ { 0 } ) ^ { T } ( w - w _ { 0 } )
+$$
+
+which is, in turn, equivalent to
+
+$$
+\left( \nabla \psi ( \boldsymbol { w } _ { T } ) - \nabla \psi ( \boldsymbol { w } _ { 0 } ) \right) ^ { T } \boldsymbol { w } = - \psi ( \boldsymbol { w } _ { T } ) + \psi ( \boldsymbol { w } _ { 0 } ) + \nabla \psi ( \boldsymbol { w } _ { T } ) ^ { T } \boldsymbol { w } _ { T } - \nabla \psi ( \boldsymbol { w } _ { 0 } ) ^ { T } \boldsymbol { w } _ { 0 } .
+$$
+
+Since $\nabla \psi$ is an invertible function, $\nabla \psi ( w _ { T } ) - \nabla \psi ( w _ { 0 } ) \neq 0$ , if $w _ { T } \neq w _ { 0 }$ . Therefore, the above equation has a solution for $w$ , if $w _ { T } \neq w _ { 0 }$ . As a result, choosing $\hat { w }$ to be a solution to (46) makes $D _ { \psi } ( \hat { w } , w _ { T } ) = D _ { \psi } ( \hat { w } , w _ { 0 } )$ , if $w _ { T } \ne w _ { 0 }$ . For the case when $w _ { T } = w _ { 0 }$ , it is trivial that $D _ { \psi } ( \hat { w } , w _ { T } ) = D _ { \psi } ( \hat { w } , w _ { 0 } )$ for any choice of $\hat { w }$ . In this case, we only need to choose $\hat { w }$ to be different from $w _ { 0 }$ , to avoid making the ratio $\frac { 0 } { 0 }$ . Hence, we have the following choice
+
+$$
+\hat { w } = \left\{ \begin{array} { l l } { \mathrm { a ~ s o l u t i o n ~ o f ~ } ( 4 6 ) } & { \mathrm { ~ f o r ~ } w _ { T } \neq w _ { 0 } } \\ { w _ { 0 } + \delta w \mathrm { ~ f o r ~ s o m e ~ } \delta w \neq 0 } & { \mathrm { ~ f o r ~ } w _ { T } = w _ { 0 } } \end{array} \right.
+$$
+
+Choosing the feasible point $\hat { w } , \{ v _ { i } \}$ according to (47) and (45) leads to
+
+$$
+\begin{array} { r l } & { \displaystyle \operatorname* { m a x } _ { w , \{ v _ { i } \} } \frac { D _ { \psi } ( w , w _ { T } ) + \eta \sum _ { i = 1 } ^ { T } D _ { L _ { i } } ( w , w _ { i - 1 } ) } { D _ { \psi } ( w , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( v _ { i } ) } } \\ & { \quad \quad \quad \quad \quad \geq \displaystyle \frac { D _ { \psi } ( \hat { w } , w _ { T } ) + \eta \sum _ { i = 1 } ^ { T } l ( f _ { i } ( w _ { i - 1 } ) - f _ { i } ( \hat { w } ) ) } { D _ { \psi } ( \hat { w } , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( f _ { i } ( w _ { i - 1 } ) - f _ { i } ( \hat { w } ) ) } . } \end{array}
+$$
+
+Taking the minimum of both sides with respect to $\{ w _ { i } \}$ , we have
+
+$$
+\begin{array} { r l } & { \displaystyle \underset { \{ w _ { i } \} } { \operatorname* { m i n } } \ \underset { w , \{ v _ { i } \} } { \operatorname* { m a x } } \frac { D _ { \psi } ( w , w _ { T } ) + \eta \sum _ { i = 1 } ^ { T } D _ { L _ { i } } ( w , w _ { i - 1 } ) } { D _ { \psi } ( w , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( v _ { i } ) } } \\ & { \qquad \ge \displaystyle \operatorname* { m i n } _ { \{ w _ { i } \} } \frac { D _ { \psi } ( \hat { w } , w _ { T } ) + \eta \sum _ { i = 1 } ^ { T } l ( f _ { i } ( w _ { i - 1 } ) - f _ { i } ( \hat { w } ) ) } { D _ { \psi } ( \hat { w } , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( f _ { i } ( w _ { i - 1 } ) - f _ { i } ( \hat { w } ) ) } = 1 . } \end{array}
+$$
+
+The equality to 1 comes from the fact the that the optimal solution of the minimization either has $w _ { T } ^ { * } = w _ { 0 }$ or $w _ { T } ^ { * } \neq w _ { 0 }$ , and in both cases the ratio is equal to 1.
+
+2. Now we prove that, under the small step size condition (convexity of ${ \psi } ( w ) - \eta L _ { i } ( w )$ for all $i$ ), SMD makes the minimax value at most 1, which means that it is indeed an optimal solution. Recall from Lemma 5 that
+
+$$
+D _ { \psi } ( w , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( v _ { i } ) = D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta \sum _ { i = 1 } ^ { T } D _ { L _ { i } } ( w , w _ { i - 1 } ) ,
+$$
+
+where
+
+$$
+\begin{array} { r } { E _ { i } ( w _ { i } , w _ { i - 1 } ) = D _ { \psi } ( w _ { i } , w _ { i - 1 } ) - \eta D _ { L _ { i } } ( w _ { i } , w _ { i - 1 } ) + \eta L _ { i } ( w _ { i } ) . } \end{array}
+$$
+
+It is easy to check that when ${ \psi } ( w ) - \eta L _ { i } ( w )$ is convex, $D _ { \psi } ( w _ { i } , w _ { i - 1 } ) - \eta D _ { L _ { i } } ( w _ { i } , w _ { i - 1 } )$ is in fact a Bregman divergence (i.e. the Bregman divergence with respect to the potential ${ \psi } ( w ) - \eta L _ { i } ( w ) )$ , and therefore it is nonnegative for any $w _ { i }$ and $w _ { i - 1 }$ . Furthermore, we know that the loss $L _ { i } ( w _ { i } )$ is also nonnegative for all $w _ { i }$ . It follows that $E _ { i } ( w _ { i } , w _ { i - 1 } )$ is nonnegative for all values of $w _ { i } , w _ { i - 1 }$ and $i$ . As a result, we have the following bound.
+
+$$
+D _ { \psi } ( w , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( v _ { i } ) \ge D _ { \psi } ( w , w _ { T } ) + \eta \sum _ { i = 1 } ^ { T } D _ { L _ { i } } ( w , w _ { i - 1 } ) .
+$$
+
+Since the Bregman divergence $D _ { \psi } ( w , w _ { 0 } )$ and the loss $l ( v _ { i } )$ are nonnegative, the left-hand side expression is nonnegative, and it follows that
+
+$$
+\frac { D _ { \psi } ( w , w _ { T } ) + \eta \sum _ { i = 1 } ^ { T } D _ { L _ { i } } ( w , w _ { i - 1 } ) } { D _ { \psi } ( w , w _ { 0 } ) + \eta \sum _ { i = 1 } ^ { T } l ( v _ { i } ) } \le 1 .
+$$
+
+In fact, this means that independent of the choice of the maximizer (i.e. for all $\{ v _ { i } \}$ and $w$ ), as long as the step size condition is met, SMD makes the ratio less than or equal to 1.
+
+Combining the results of 1 and 2 above concludes the proof.
+
+# B.1 PROOF OF THEOREM 3
+
+Proof. This result is a special case of Theorem 6, which was proven above. In this case, $\psi ( w ) = $ $\scriptstyle { \frac { 1 } { 2 } } \| w \| ^ { 2 }$ , $f ( x _ { i } , w ) = x _ { i } ^ { T } \dot { w }$ , and $\begin{array} { r } { l ( z ) = \frac { 1 } { 2 } z ^ { 2 } } \end{array}$ . Therefore, $\begin{array} { r } { D _ { \psi } ( w , \dot { w } _ { T } ) = \frac { 1 } { 2 } \| w - w _ { T } \| ^ { 2 } , D _ { \psi } ( \dot { w } , \dot { w } _ { 0 } ) = } \end{array}$ $\begin{array} { r } { \frac 1 2 \| w - w _ { 0 } \| ^ { 2 } , D _ { L _ { i } } ( w , w _ { i - 1 } ) = \frac 1 2 ( x _ { i } ^ { T } w ^ { - } { x _ { i } ^ { T } } w _ { i - 1 } ) ^ { 2 } } \end{array}$ , and $\begin{array} { r } { l ( v _ { i } ) = \frac 1 2 v _ { i } ^ { 2 } } \end{array}$ , which leads to the result. $\boxed { \begin{array} { r l } \end{array} }$
+
+# C PROOF OF PROPOSITION 9
+
+Proof. To prove convergence, we appeal again to Equation (22), i.e.
+
+$$
+D _ { \psi } ( w , w _ { 0 } ) = D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \left( E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) ,
+$$
+
+for all $w \in \mathcal W$ . We prove the two cases separately.
+
+1. The proof of case (i) is straightforward. When $l ( \cdot )$ is differentiable and convex, $L _ { i }$ is also convex, and therefore $D _ { L _ { i } } ( w , w _ { i - 1 } )$ is nonnegative. Moreover, when $\psi - \eta L _ { i }$ is convex, $E _ { i } ( w _ { i } , w _ { i - 1 } )$ is also nonnegative. Therefore, the entire summand in Eq. (52) is nonnegative, and has to go to zero for $i  \infty$ . That is because as $T \to \infty$ , the sum should remain bounded, i.e., $\begin{array} { r } { \sum _ { i = 1 } ^ { \infty } \left( E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) \le D _ { \psi } ( w , w _ { 0 } ) } \end{array}$ . As a result of the non-negativity of both terms in the sum, we have both $E _ { i } ( w _ { i } , w _ { i - 1 } )  0$ and $D _ { L _ { i } } ( w , w _ { i - 1 } ) \to 0$ as $i \to \infty$ , the latter of which implies $L _ { i } ( w _ { i - 1 } ) \to \mathrm { 0 }$ . This implies that the updates in (15) vanish and we get convergence, i.e., $w  w _ { \infty }$ . Further, again because $L _ { i } ( w _ { i - 1 } )  0$ , and 0 is the unique root of $l ( \cdot )$ , all the data point are being fit, which means $w _ { \infty } \in \mathcal { W }$ .
+
+2. To prove case (ii), note that we have
+
+$$
+\begin{array} { r l } & { { D } _ { L _ { i } } ( w , w _ { i - 1 } ) = L _ { i } ( w ) - L _ { i } ( w _ { i - 1 } ) - \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w - w _ { i - 1 } ) } \\ & { \phantom { D } = 0 - l ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) + l ^ { \prime } ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) x _ { i } ^ { T } ( w - w _ { i - 1 } ) } \\ & { \phantom { D } = - l ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) + l ^ { \prime } ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) , } \end{array}
+$$
+
+and
+
+$$
+\begin{array} { r l r } {  { E _ { i } ( w _ { i } , w _ { i - 1 } ) = D _ { \psi } ( w _ { i } , w _ { i - 1 } ) - \eta D _ { L _ { i } } ( w _ { i } , w _ { i - 1 } ) + \eta L _ { i } ( w _ { i } ) } } & { ( 5 6 ) } \\ & { } & { = D _ { \psi } ( w _ { i } , w _ { i - 1 } ) + \eta ( L _ { i } ( w _ { i - 1 } ) + \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w _ { i } - w _ { i - 1 } ) ) \qquad ( 5 7 ) } \\ & { } & { = D _ { \psi } ( w _ { i } , w _ { i - 1 } ) + \eta ( l ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) - l ^ { \prime } ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) x _ { i } ^ { T } ( w _ { i } - w _ { i - 1 } ) ) . } \end{array}
+$$
+
+It follows from (55) and (58) that the summand in Equation (52) is
+
+$$
+E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta D _ { L _ { i } } ( w , w _ { i - 1 } ) = D _ { \psi } ( w _ { i } , w _ { i - 1 } ) + \eta l ^ { \prime } ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) ( y _ { i } - x _ { i } ^ { T } w _ { i } ) .
+$$
+
+The first term is a Bregman divergence, and is therefore nonnegative. In order to establish convergence, one needs to argue that the second term is nonnegative as well, so that the summand goes to zero as $i \to \infty$ . Since $l ( \cdot )$ is increasing for positive values and decreasing for negative values, it is enough to show that ${ y } _ { i } - { x } _ { i } ^ { T } { w } _ { i - 1 }$ and $\stackrel { \cdot } { y _ { i } } - x _ { i } ^ { T } w _ { i }$ have the same sign, in order to establish nonnegativity. It is not hard to see that if the distance between the two points is less than or equal to the distance of $y _ { i } - x _ { i } ^ { T } w _ { i }$ from the origin, then the signs are the same. In other words, if $| ( y _ { i } - x _ { i } ^ { T } w _ { i } ) - ( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } ) | = | x _ { i } ^ { T } ( w _ { i } - w _ { i - 1 } ) | \leq | y _ { i } - x _ { i } ^ { T } w _ { i - 1 } | .$ , then the sign are the same.
+
+Note that by the definition of $\alpha$ -strong convexity of $\psi ( \cdot )$ , we have
+
+$$
+\begin{array} { r } { ( \nabla \psi ( w _ { i } ) - \nabla \psi ( w _ { i - 1 } ) ) ^ { T } ( w _ { i } - w _ { i - 1 } ) \geq \alpha \| w _ { i } - w _ { i - 1 } \| ^ { 2 } , } \end{array}
+$$
+
+which implies
+
+$$
+- \eta \nabla L _ { i } ( w _ { i - 1 } ) ^ { T } ( w _ { i } - w _ { i - 1 } ) \geq \alpha \| w _ { i } - w _ { i - 1 } \| ^ { 2 } ,
+$$
+
+by substituting from the SMD update rule. Upper-bounding the left-hand side by $\eta \| \nabla L _ { i } ( w _ { i - 1 } ) \| \| ( w _ { i } - w _ { i - 1 } ) \|$ implies
+
+$$
+\eta \| \nabla L _ { i } ( w _ { i - 1 } ) \| \geq \alpha \| w _ { i } - w _ { i - 1 } \| .
+$$
+
+This implies that we have the following bound
+
+$$
+| x _ { i } ^ { T } ( w _ { i } - w _ { i - 1 } ) | \leq \| x _ { i } \| \| w _ { i } - w _ { i - 1 } \| \leq \frac { \eta \| x _ { i } \| \| \nabla L _ { i } ( w _ { i - 1 } ) \| } { \alpha } .
+$$
+
+It follows that if $\begin{array} { r } { \eta ~ \leq ~ \frac { \alpha | y _ { i } - x _ { i } ^ { T } w _ { i - 1 } | } { \| x _ { i } \| \| \nabla L _ { i } ( w _ { i - 1 } ) \| } } \end{array}$ , for all $i$ , then the signs are the same, and the summand in Eq.(52) is indeed nonnegative. This condition can be equivalently expressed as $\begin{array} { r } { \eta \leq \frac { \alpha | y _ { i } - x _ { i } ^ { T } w _ { i - 1 } | } { \| x _ { i } \| ^ { 2 } | l ^ { \prime } \left( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } \right) | } } \end{array}$ for all $i$ , or $\begin{array} { r } { \eta \leq \operatorname* { m i n } _ { i } \frac { \alpha | y _ { i } - x _ { i } ^ { T } w _ { i - 1 } | } { \| x _ { i } \| ^ { 2 } | l ^ { \prime } \left( y _ { i } - x _ { i } ^ { T } w _ { i - 1 } \right) | } } \end{array}$ , which is the condition in the statement of the proposition.
+
+Now that we have argued that the summand is nonnegative, the convergence to $w _ { \infty } \in \mathcal { W }$ is immediate. The reason is that both $D _ { \psi } ( w _ { i } , w _ { i - 1 } )  0$ and $l ^ { \prime } ( y _ { i } - x _ { i } ^ { T } \bar { w } _ { i - 1 } ) ( y _ { i } - x _ { i } ^ { T } w _ { i } ) $ $0$ , as $i  \infty$ . The first one implies convergence to a point $w _ { \infty }$ . The second one implies that either $y _ { i } - x _ { i } ^ { T } w _ { i - 1 } = 0$ or $\mathbf { \bar { \Psi } } y _ { i } - x _ { i } ^ { T } w _ { i } \bar { = } 0$ , which, in turn, implies $w _ { \infty } \in \mathcal { W }$ .
+
+# D TIME-VARYING STEP-SIZE
+
+The update rule for the stochastic mirror descent with time-varying step size is as follows.
+
+$$
+\boldsymbol { w } _ { i } = \mathop { \mathrm { a r g } \mathrm { m i n } } _ { \boldsymbol { w } } \ \eta _ { i } \boldsymbol { w } ^ { T } \nabla L _ { i } ( \boldsymbol { w } _ { i - 1 } ) + D _ { \boldsymbol { \psi } } ( \boldsymbol { w } , \boldsymbol { w } _ { i - 1 } ) ,
+$$
+
+which can be equivalently expressed as $\nabla \psi ( w _ { i } ) = \nabla \psi ( w _ { i - 1 } ) - \eta _ { i } \nabla L _ { i } ( w _ { i - 1 } )$ , for all $i$ . The main results in this case are as follows.
+
+Lemma 11. For any (nonlinear) model $f ( \cdot , \cdot )$ , any differentiable loss $l ( \cdot )$ , any parameter $w$ and noise values $\{ v _ { i } \}$ that satisfy $y _ { i } = f ( x _ { i } , w ) + v _ { i }$ for $i = 1 , \ldots , n$ , any initialization $w _ { 0 }$ , any step size sequence $\{ \eta _ { i } \}$ , and any number of steps $T \geq 1$ , the following relation holds for the SMD iterates $\{ w _ { i } \}$ given in Eq. (64)
+
+$$
+D _ { \psi } ( w , w _ { 0 } ) + \sum _ { i = 1 } ^ { T } \eta _ { i } l ( v _ { i } ) = D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \left( E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta _ { i } D _ { L _ { i } } ( w , w _ { i - 1 } ) \right) ,
+$$
+
+Proof. The proof is straightforward by summing the following equation for all $i = 1 , \dots , T$
+
+$$
+D _ { \psi } ( w , w _ { i - 1 } ) + \eta _ { i } l ( v _ { i } ) = D _ { \psi } ( w , w _ { i } ) + E _ { i } ( w _ { i } , w _ { i - 1 } ) + \eta _ { i } D _ { L _ { i } } ( w , w _ { i - 1 } ) ,
+$$
+
+which can be easily shown in the same way as in the proof of Lemma 4 in Appendix A.
+
+Theorem 12. Consider any general model $f ( \cdot , \cdot )$ , and any differentiable loss function $l ( \cdot )$ with property $l ( 0 ) = l ^ { \prime } ( 0 ) = 0$ . For sufficiently small step size, i.e., for any sequence $\{ \eta _ { i } \}$ for which ${ \psi } ( w ) - \eta _ { i } L _ { i } ( w )$ is convex for all $i$ , the SMD iterates $\{ w _ { i } \}$ given by Eq. (64) are the optimal solution to the following minimization problem
+
+$$
+\operatorname* { m i n } _ { \{ w _ { i } \} } \operatorname* { m a x } _ { w , \{ v _ { i } \} } \frac { D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \eta _ { i } D _ { L _ { i } } ( w , w _ { i - 1 } ) } { D _ { \psi } ( w , w _ { 0 } ) + \sum _ { i = 1 } ^ { T } \eta _ { i } l ( v _ { i } ) } .
+$$
+
+Furthermore, the optimal value (achieved by SMD) is 1.
+
+Proof. The proof is similar to that of Theorem 6, as presented in Appendix B. The argument for the upper-bound of 1 is exactly the same. For the second part of the proof, we use the previous Lemma. It follows from the convexity of ${ \psi } ( w ) - \eta _ { i } L _ { i } ( w )$ that $E _ { i } ( w _ { i } , w _ { i - 1 } ) \ge 0$ , and as a result we have
+
+$$
+\frac { D _ { \psi } ( w , w _ { T } ) + \sum _ { i = 1 } ^ { T } \eta _ { i } D _ { L _ { i } } ( w , w _ { i - 1 } ) } { D _ { \psi } ( w , w _ { 0 } ) + \sum _ { i = 1 } ^ { T } \eta _ { i } l ( v _ { i } ) } \le 1
+$$
+
+for SMD updates, which concludes the proof.
+
+The convergence and implicit regularization results hold similarly, and can be formally stated as follows.
+
+Proposition 13. Consider the following two cases.
+
+(i) $l ( \cdot )$ is differentiable and convex and has a unique root at $O _ { ; }$ , $\psi ( \cdot )$ is strictly convex, and the positive sequence $\{ \eta _ { i } \}$ is such that $\psi - \eta _ { i } L _ { i }$ is convex for all i.   
+(ii) $l ( \cdot )$ is differentiable and quasi-convex and has zero derivative only at $O$ , $\psi ( \cdot )$ is $\alpha$ -strongly convex, and 0 < ηi ≤ i i i−1 kxik2|l0(yi−xTi wi−1)| for all $i$ .
+
+If either (i) or (ii) holds, then for any initialization $w _ { 0 }$ , the SMD iterates given in Eq. (64) converge to
+
+$$
+\boldsymbol { w } _ { \infty } = \underset { \boldsymbol { w } \in \mathcal { W } } { \arg \operatorname* { m i n } } D _ { \psi } ( \boldsymbol { w } , \boldsymbol { w } _ { 0 } ) .
+$$
+
+Proof. The proof is similar to that of Proposition 9, as provided in Appendix C.

parse/train/HkGmDsR9YQ/HkGmDsR9YQ.md

@@ -0,0 +1,288 @@
+# GENERALIZATION AND REGULARIZATION IN DQN
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep reinforcement learning (RL) algorithms have shown an impressive ability to learn complex control policies in high-dimensional environments. However, despite the ever-increasing performance on popular benchmarks like the Arcade Learning Environment (ALE), policies learned by deep RL algorithms can struggle to generalize when evaluated in remarkably similar environments. These results are unexpected given the fact that, in supervised learning, deep neural networks often learn robust features that generalize across tasks. In this paper, we study the generalization capabilities of DQN in order to aid in understanding this mismatch between generalization in deep RL and supervised learning methods. We provide evidence suggesting that DQN overspecializes to the domain it is trained on. We then comprehensively evaluate the impact of traditional methods of regularization from supervised learning, $\ell _ { 2 }$ and dropout, and of reusing learned representations to improve the generalization capabilities of DQN. We perform this study using different game modes of Atari 2600 games, a recently introduced modification for the ALE which supports slight variations of the Atari 2600 games used for benchmarking in the field. Despite regularization being largely underutilized in deep RL, we show that it can, in fact, help DQN learn more general features. These features can then be reused and fine-tuned on similar tasks, considerably improving the sample efficiency of DQN.
+
+# 1 INTRODUCTION
+
+Recently, reinforcement learning (RL) has proven very successful on complex high-dimensional problems, in large part due to the increase in computational power and to the use of deep neural networks for function approximation (e.g., Mnih et al., 2015; Silver et al., 2016). Despite the generality of the proposed solutions, applying these algorithms to slightly different environments generally requires agents to learn the new task from scratch. Practitioners often realize that the learned policies rarely generalize to other domains, even when they are remarkably similar, and that the learned representations are seldom reusable.
+
+Deep neural networks, though, are lauded for their generalization capabilities (e.g., LeCun et al., 1998). Some communities heavily rely on reusing representations learned by neural networks. In computer vision, classification and segmentation algorithms are rarely trained from scratch; instead they are initialized with pre-trained models from larger datasets like ImageNet (e.g., Razavian et al., 2014; Long et al., 2015). The field of natural language processing has also seen successes in reusing and refining weights from certain layers of neural networks using pre-trained word embeddings, with more recent techniques able to reuse all weights of the network (e.g., Howard & Ruder, 2018).
+
+In light of the successes of traditional supervised learning methods, the current lack of generalization or reusable knowledge (e.g., policies, representation) acquired by current deep RL algorithms is somewhat surprising. In this paper we investigate whether the representation learned by deep RL methods can be generalized, or at the very least reused and refined on small variations to the task at hand. First, we evaluate the generalization capabilities of DQN (Mnih et al., 2015). We further explore whether the experience gained by the supervised learning community to improve generalization and to avoid overfitting could be used in deep RL. We employ conventional supervised learning techniques, albeit largely unexplored in deep RL, such as fine-tuning (i.e., reusing and refining the representation) and regularization. We show that a learned representation trained with regularization allows us to learn more general features capable of being reused and fine-tuned. Besides improving the generalization capabilities of the learned policies this fine-tuning procedure has the potential to greatly improve sample efficiency on settings in which an agent might face multiple variations of the same task. Finally, the results we present here also can be seen as paving a way towards novel curriculum learning approaches for deep RL.
+
+We perform our experiments using different game modes and difficulties of Atari 2600 games, a newly introduced feature of the Arcade Learning Environment (ALE; Bellemare et al., 2013). These game modes allow agents to be trained in one environment while being evaluated in a slightly different environment that still captures key concepts of the original environment (e.g., game sprites, agent goals, dynamics). This use of game modes is itself a novel approach for measuring our progress toward a longstanding goal of agents that can learn to be generally competent and generalize across tasks (Bellemare et al., 2013; Machado et al., 2018; Nichol et al., 2018). This paper also introduces the first baselines for the different modes of Atari 2600 games.
+
+# 2 BACKGROUND
+
+# 2.1 REINFORCEMENT LEARNING
+
+Reinforcement learning (RL) is a problem where an agent interacts with an environment with the goal of maximizing some form of cumulative long term reward. RL problems are often modeled as a Markov decision process (MDP), defined by a 5-tuple $\langle \mathcal { S } , \mathcal { A } , p , r , \gamma \rangle$ . At a discrete time step $t$ the agent observes the current state $S _ { t } ~ \in ~ \mathcal { S }$ and chooses an action $A _ { t } \in \mathcal A$ to probabilistically transition to the next state $S _ { t + 1 } \in \mathcal S$ according to the transition dynamics function $p ( s ^ { \prime } \mid s , a ) \ { \stackrel { . } { = } }$ $P ( S _ { t + 1 } = s ^ { \prime } | S _ { t } = s , A _ { t } = \stackrel { . } { a } )$ . The agent receives a reward signal $R _ { t + 1 }$ according to the reward function $r : \mathcal { S } \times \mathcal { A }  \mathbb { R }$ . The agents goal is to learn a policy $\pi : \mathcal { S } \times \mathcal { A }$ defined as the conditional probability of taking action $a$ in state $s$ written as $\pi ( a | s )$ . The learning agent refines its policy with the objective of maximizing the expected return, that is, the cumulative discounted reward incurred from time $t$ , defined by $\begin{array} { r } { G _ { t } \stackrel {  } { = } \sum _ { k = 0 } ^ { \infty ^ { \bullet } } \gamma ^ { k } R _ { t + k + 1 } } \end{array}$ where $\gamma \in [ 0 , 1 )$ is the discount factor.
+
+Q-learning (Watkins & Dayan, 1992) is a traditional approach to learning an optimal policy from samples obtained from interactions with the environment. It is used to learn an optimal state-action value function via a bootstrapped iterative method. For a given policy $\pi$ we define the state-action value function as the expected return conditioned on a state and action $q _ { \pi } ( s , a ) \doteq \mathbb { E } _ { \pi } \bigl [ G _ { t } | S _ { t } = s , A _ { t } = a \bigr ]$ . The agent iteratively updates the state-action value function based on samples from the environment using the update rule
+
+$$
+Q ( S _ { t } , A _ { t } )  Q ( S _ { t } , A _ { t } ) + \alpha \big [ R _ { t + 1 } + \gamma \operatorname* { m a x } _ { a ^ { \prime } \in A } Q ( S _ { t + 1 } , a ^ { \prime } ) - Q ( S _ { t } , A _ { t } ) \big ]
+$$
+
+where $t$ denotes the current timestep and $\alpha$ the step size. Generally, due to the exploding size of the state space in many real-world problems, it is intractable to learn a state-action pairing for the entire MDP, with researchers and practitioners often resorting to learning an approximate to $q _ { \pi }$ .
+
+DQN approximates the state-action value function such that $q _ { \pi } ( s , a ) \approx Q ( s , a ; \theta )$ , where $\theta$ denotes the weights of a neural network. The network takes as input some encoding of the current state $S _ { t }$ and outputs $| { \cal A } |$ scalars corresponding to the state-action values for that given state. DQN is trained to minimize
+
+$$
+L ^ { \mathrm { { D Q N } } } = \underset { S _ { t } , A _ { t } , R _ { t + 1 } , S _ { t + 1 } \sim U ( \cdot ) } { \mathbb { E } } \left[ \left( R _ { t + 1 } + \underset { a ^ { \prime } \in A } { \operatorname* { m a x } } Q ( S _ { t + 1 } , a ^ { \prime } ; \theta ^ { - } ) - Q ( S _ { t } , A _ { t } ; \theta ) \right) ^ { 2 } \right]
+$$
+
+where $( S _ { t } , A _ { t } , R _ { t + 1 } , S _ { t + 1 } )$ are uniformly sampled from $U ( \cdot )$ , the experience replay buffer filled with experience collected by the agent. The weights $\theta ^ { - }$ of a duplicate network are updated less frequently for stability purposes.
+
+# 2.2 SUPERVISED LEARNING
+
+In the supervised learning problem we are given a dataset of examples represented by a matrix $X \in \mathbb { R } ^ { m \times n }$ with $m$ training examples of dimension $n$ , and a vector $\mathbf { y } ^ { \star } \in \mathbb { R } ^ { 1 \times m }$ denoting the output target $y _ { i }$ for each training example $X _ { i }$ . We want to learn a function which maps each training example $X _ { i }$ to its predicted output label $\hat { y } _ { i }$ . The goal is to learn a robust model that accurately predicts $y _ { i }$ from $X _ { i }$ while also being able to generalize to unseen training examples. In this paper we focus on using a neural network parameterized by the weights $\theta$ to learn the function $f$ such that $\hat { y } _ { i } = f ( X _ { i } ; \theta )$ . We typically train these models by minimizing
+
+$$
+\operatorname* { m i n } _ { \theta } \ \frac { \lambda } { 2 } \ \| \theta \| _ { 2 } ^ { 2 } + \frac { 1 } { m } \sum _ { i = 1 } ^ { m } L ( y _ { i } , \hat { y } _ { i } ) = \operatorname* { m i n } _ { \theta } \ \frac { \lambda } { 2 } \ \| \theta \| _ { 2 } ^ { 2 } + \frac { 1 } { m } \sum _ { i = 1 } ^ { m } L ( y _ { i } , f ( X _ { i } ; \theta ) )
+$$
+
+where $L$ is a differentiable loss function which outputs a scalar determining the quality of the prediction (e.g., squared error loss). The first term is a form of regularization, i.e., $\ell _ { 2 }$ regularization, which encourages generalization. $\ell _ { 2 }$ regularization imposes a penalty on large weight vectors with $\lambda$ being the weighted importance of the regularization term.
+
+Another popular regularization technique is dropout (Srivastava et al., 2014). When using dropout, during forward propagation each neural unit has a chance of being set to zero according to a Bernoulli distribution with probability $p \in [ 0 , 1 ]$ , referred to as the dropout rate. Dropout discourages the network from relying on a small number of neurons to make a prediction, making it hard for the network to memorize the dataset.
+
+Prior to training, the network parameters are usually initialized through a stochastic process (e.g., Xavier initialization; Glorot & Bengio, 2010). We can also initialize the network using pre-trained weights from a different task. If we reuse one or more pre-trained layers we say the weights encoded by those layers will be fine-tuned during training (e.g., Razavian et al., 2014; Long et al., 2015).
+
+# 3 THE ALE AS A PLATFORM FOR EVALUATING GENERALIZATION
+
+The Arcade Learning Environment (ALE) is a platform used to evaluate agents across dozens of Atari 2600 games (Bellemare et al., 2013). It has become one of the standard evaluation platforms in the field and has led to a number of exciting algorithmic advances (e.g., Mnih et al., 2015). The ALE poses the problem of general competency by having agents use the same learning algorithm to perform well in as many games as possible, while learning without using game specific knowledge. Learning to play multiple games with the same agent, or learning to play a game faster by leveraging knowledge acquired in a different game is much harder, with fewer successes being known (e.g., Rusu et al., 2016; Kirkpatrick et al., 2016; Parisotto et al., 2016; Schwarz et al., 2018; Espeholt et al., 2018).
+
+In this paper, we use the different modes and difficulties of Atari 2600 games to evaluate a neural network’s ability to generalize in high-dimensional state spaces. Game modes, originally native to the Atari console, were recently added in the ALE (Machado et al., 2018). They give us modifications of the default environment dynamics and state space, often modifying sprites, velocities, and partial observability. These modes pose a tractable way to investigate generalization of RL agents in a high-dimensional environment. Instead of requiring an agent to play multiple games that are visually very different or even non-analogous, it requires agents to play games that are visually very similar and that can be played with policies that are very similar, at least from a human perspective.
+
+We use 13 flavours (combinations of a mode and a difficulty) obtained from 4 games: FREEWAY, HERO, BREAKOUT, and SPACE INVADERS. In FREEWAY, the different modes vary the speed and number of vehicles, while different difficulties change how the player is penalized for running into a vehicle. In HERO, subsequent modes start the player off at increasingly harder levels of the game. The mode we use in BREAKOUT makes the bricks partially observable. The used modes in SPACE INVADERS allow for oscillating shield barriers, increasing the width of the player sprite, and partially observable aliens. Full explanations of specific games, their modes, and their difficulties can be found in Appendix A. Figure 1 provides screenshots showing side by side comparisons of some of the modes explored in this paper. When reading the analyses of this paper it is important to keep in mind how remarkably similar these modes are.
+
+# 4 GENERALIZATION OF THE LEARNED POLICIES AND OVERFITTING
+
+In order to test the generalization capabilities of DQN we first evaluate whether a policy learned in one flavour can perform well in a different flavour. As afformentioned, different modes and difficulties of a single game look very similar. If the representation encodes a robust policy we might expect it to be able to generalize to slight variations of the underlying reward signal, game dynamics, or observations. Evaluating the learned policy in a similar but different flavour can be seen as evaluating generalization in RL, similar to cross-validation in supervised learning.
+
+![](images/7e16ca4fc99a7529db72180bc5d0a6ac0bac1a6a9f7957b98bd044776a97649b.jpg)  
+Figure 1: Each column shows variation between two selected flavours of each game. From left to right: FREEWAY, HERO, BREAKOUT, and SPACE INVADERS.
+
+To evaluate DQN’s ability to generalize across flavours we evaluate the learned $\epsilon$ -greedy policy on a new flavour after being trained for 50M frames in the default flavour, $\mathrm { m 0 d 0 }$ (mode 0, difficulty 0). We measure the cumulative reward averaged over 100 episodes in the new flavour, adhering to the evaluation protocol suggested by Machado et al. (2018). The results are summarized in Table 1. Baseline results where the agent is trained from scratch for 50M frames in the flavour we use for evaluation are summarized in the baseline column. Theoretically, this baseline can be seen as an upper bound on the performance DQN can achieve in that flavour, as it represents the agent’s performance when evaluated in the same flavour it was trained on. Full baseline results with the agent’s performance after different number of frames can be found in Appendix B.
+
+We can see in the results that the policies learned by DQN do not generalize well to different flavours, even when the flavours are remarkably similar. For example, in FREEWAY, a high-level policy applicable to all flavours is to go up while avoiding cars. Perhaps surprisingly, this does not seem to be what DQN learns. For example, the default flavour $\mathrm { m 0 d 0 }$ and $\scriptstyle \mathrm { m 4 d 0 }$ have exactly the same sprites on the screen, the only difference is that in $\mathrm { m 4 d 0 }$ some cars accelerate and decelerate over time. The close to optimal policy learned in $\mathrm { m 0 d 0 }$ is only able to score 15.8 points when evaluated on $\scriptstyle \mathrm { m 4 d 0 }$ , which is approximately half of what the policy learned from scratch in that flavour achieves (29.9 points). The learned policy when evaluated on flavours that differ more from $\mathrm { m 0 d 0 }$ perform even worse.
+
+As previously mentioned, the different modes of HERO can be seen as giving the agent a curriculum or a natural progression. Interestingly, the agent trained in the default mode for 50M frames can progress to at least level 3 and sometimes level 4. Mode 1 starts the agent off at level 5, and performance in this mode suffers greatly during evaluation. There are very few game mechanics added to level 5, indicating that perhaps the agent is memorizing trajectories instead of learning a robust policy capable of solving each level.
+
+The results in some flavours suggest that the agent is overfitting to the flavour it is trained on. We tested this hypothesis by periodically evaluating the policy being learned in each of the other flavours of that game. This process involved taking checkpoints of the network at every 500, 000 frames and evaluating the $\epsilon$ -greedy policy in the prescribed flavour for 100 episodes, again further averaged over five runs. The obtained results in FREEWAY, the most pronounced game in which we see this overfitting trend, are depicted in Figure 2. Learning curves for all flavours can be found in Appendix C.
+
+In FREEWAY, while we see the policy’s performance flattening out in $\mathrm { m 4 d 0 }$ , we do see the traditional bell-shaped curve associated to overfitting in the other modes. At first, improvements in the original policy do correspond to improvements in the performance of that policy in other domains. With time, it seems that it starts to refine its policy for the specific flavour it is being trained on, overfitting to that flavour. With other game flavours being significantly more complex in their dynamics and gameplay, we do not observe this prominent bell-shaped curve though. For example, in BREAKOUT, we actually observe a monotonic increase in performance throughout the evaluation process.
+
+Table 1: Direct policy evaluation. Each game was initially trained in the default mode for 50M frames then evaluated in each listed game flavour. Reported numbers are the average over 5 runs. Standard deviation is reported between parentheses.   
+
+<table><tr><td colspan="2">GAME VARIANT</td><td>EVALUATION</td><td>LEARN SCRATCH</td></tr><tr><td rowspan="3">FREEWAY</td><td>m1d0</td><td>0.2 (0.2)</td><td>4.8 (9.3)</td></tr><tr><td>m1d1</td><td>0.1 (0.1)</td><td>0.0 (0.0)</td></tr><tr><td>m4d0</td><td>15.8 (1.0)</td><td>29.9 (0.7)</td></tr><tr><td rowspan="2">HERO</td><td>m1d0</td><td>82.1 (89.3)</td><td>1425.2 (1755.1)</td></tr><tr><td>m2d0</td><td>33.9 (38.7)</td><td>326.1 (130.4)</td></tr><tr><td>BREAKOUT</td><td>m12d0</td><td>43.4 (11.1)</td><td>67.6 (32.4)</td></tr><tr><td rowspan="3">SPACE INVADERS</td><td>m1d0</td><td>258.9 (88.3)</td><td>753.6 (31.6)</td></tr><tr><td>m1d1</td><td>140.4 (61.4)</td><td>698.5 (31.3)</td></tr><tr><td>m9d0</td><td>179.0 (75.1)</td><td>518.0 (16.7)</td></tr></table>
+
+![](images/e32eeeaacc66511639a1e09440b8ebe1528f57a96c854659d6ffb8b951741981.jpg)  
+Freeway Policy Evaluation   
+Figure 2: Performance of an agent that was trained in the default mode of FREEWAY and evaluated at every 500, 000 frames in each corresponding mode. Results are averaged over five seeds. The y-axis is log scaled.
+
+In conclusion, when looking at Table 1, it seems that the policies learned by DQN struggle to generalize to even small variations encountered in game flavours. This lack of generalization is surprising, and results as seen in FREEWAY exhibit a troubling notion of overfitting. Based on these results we aim to evaluate whether deep RL could benefit from established methods from supervised learning promoting generalization and reducing overfitting.
+
+# 5 REGULARIZATION IN DEEP RL
+
+In order to evaluate the hypothesis that the observed lack of generalization is due to overfitting, we revisit some popular regularization methods from the supervised learning literature. The two forms of regularization we test are dropout and $\ell _ { 2 }$ regularization.
+
+First we want to understand the effect of regularization on evaluating the learned policy in a different flavour. We do so by applying dropout to the first four layers of the network during training, that is, the three convolutional layers and the first fully connected layer. We simultaneously apply $\ell _ { 2 }$ regularization on all weights in the network based on preliminary experiments that showed an additive effect when combining dropout and $\ell _ { 2 }$ regularization. This confirms, for example, Srivastava et al.’s (2014) result that these methods provide benefit in tandem.
+
+We follow the same evaluation scheme described when evaluating the unregularized policy to different flavours. We evaluate the policy learned after 50M frames of the default mode of each game. A grid search was performed on FREEWAY to find reasonable hyperparameters for the dropout rate $p \in$ $\{ 0 . 0 5 , 0 . 1 , 0 . 2 , \bar { 0 } . 3 , 0 . 4 , 0 . 5 \}$ and the weighted regularization parameter $\lambda \in \{ 1 0 ^ { - 2 } , \dot { 1 } 0 ^ { - 3 } , 1 0 ^ { - 4 } \}$ . These parameters were then used for each subsequent flavour. Notably, significantly smaller dropout values were required compared to heuristics used in supervised learning, although this could be due to the small size of the network in question. We ended up choosing $\lambda \stackrel { = } { = } 1 0 ^ { - 4 }$ , $p = 0 . 0 5$ for the first three convolutional layers, and $p = 0 . 1$ for the first fully connected layer. We contrast these results with the results presented in the previous section. This evaluation protocol allows us to directly evaluate the effect of regularization on the learned policy’s ability to generalize. A baseline agent trained from scratch for 50M frames in each flavour is also provided. The results are presented in Table 2 with the evaluation learning curves being available in the Appendix.
+
+When using regularization during training we sometimes observe a performance hit in the default flavour. Dropout generally requires increased training iterations to reach the same level of performance sans-dropout. Suprisingly, we did not observe this performance hit in all games. Nevertheless, maximal performance in one flavour is not our goal. We are interested in the setting where one may be willing to take lower performance on one task in order to obtain higher performance, or adaptability, on future tasks. Nevertheless, full baseline results using regularization in the default flavour can also be found in Table 7 in the Appendix.
+
+Table 2: Policy evaluation using regularization. Each game was initially trained in the default mode for 50M frames with dropout and $\ell _ { 2 }$ regularization then evaluated on each listed flavour. Reported numbers are the average over 5 runs. Standard deviation is reported between parentheses.   
+
+<table><tr><td colspan="2">GAME VARIANT</td><td>EVAL. WITH REGULARIZATION</td><td></td><td>EVAL.WITHOUT REGULARIZATION</td><td>LEARN SCRATCH</td><td></td></tr><tr><td rowspan="3">FREEWAY</td><td>m1do</td><td>5.8</td><td>(3.5)</td><td>0.2 (0.2)</td><td>4.8</td><td>(9.3)</td></tr><tr><td>m1d1</td><td>4.4</td><td>(2.3)</td><td>0.1 (0.1)</td><td>0.0</td><td>(0.0)</td></tr><tr><td>m4d0</td><td>20.6</td><td>(0.7)</td><td>15.8 (1.0)</td><td>29.9</td><td>(0.7)</td></tr><tr><td rowspan="2">HERO</td><td>m1d0o</td><td>116.8</td><td>(76.0)</td><td>82.1 (89.3)</td><td>1425.2</td><td>(1755.1)</td></tr><tr><td>m2d0</td><td>30.0</td><td>(36.7)</td><td>33.9 (38.7)</td><td>326.1</td><td>(130.4)</td></tr><tr><td>BREAKOUT</td><td>m12d0</td><td>31.0</td><td>(8.6)</td><td>43.4 (11.1)</td><td>67.6</td><td>(32.4)</td></tr><tr><td rowspan="3">SPACE INVADERS</td><td>m1d0</td><td>456.0</td><td>(221.4)</td><td>258.9 (88.3)</td><td>753.6</td><td>(31.6)</td></tr><tr><td>m1d1</td><td>146.0</td><td>(84.5)</td><td>140.4 (61.4)</td><td>698.5</td><td>(31.3)</td></tr><tr><td>m9d0</td><td>290.0</td><td>(257.8)</td><td>179.0 (75.1)</td><td>518.0</td><td>(16.7)</td></tr></table>
+
+![](images/f5e5f10f47bd42958285ee27360663615f449cc18168450b5ef8d6803a3ade84.jpg)  
+Freeway Policy Evaluation w/ Regularization   
+Figure 3: Performance of an agent that was evaluated every 500, 000 frames after being trained in the default flavour of FREEWAY with dropout and $\ell _ { 2 }$ regularization. Results are averaged over five seeds. The y-axis is log scaled.
+
+In most flavours, evaluating the policy trained with regularization does not negatively impact performance when compared to the performance of the policy trained without regularization. In some flavours we even see an increase in performance. Interestingly, when using regularization the agent in FREEWAY improves for all flavours and even learns a policy capable of outperforming the baseline learned from scratch in two of the three flavours. Moreover, in FREEWAY we now observe increasing performance during evaluation throughout most of the learning procedure as depicted in Figure 3. These results seem to confirm the notion of overfitting observed in Figure 2.
+
+Despite slight improvements from these techniques, regularization by itself does not seem sufficient to enable policies to generalize across flavours. As shown in the next section, perhaps the real benefit of regularization in deep RL comes from the ability to learn more general features. These features may lead to a more adaptable representation which can be reused and subsequently fine-tuned on other flavours, which is often the case in supervised learning.
+
+# 6 VALUE FUNCTION FINE-TUNING
+
+We hypothesize that the benefit of regularizing deep RL algorithms may not come from improvements during evaluation, but instead in having a good parameter initialization that can be adapted to new tasks that are similar. We evaluate this hypothesis using two common practices in machine learning. First, we the use the weights trained with regularization as the initialization for the entire network. We subsequently fine-tune all weights in the network. This is similar to what is performed in computer vision with supervised classification methods (e.g., Razavian et al., 2014). Secondly, we evaluate reusing and fine-tuning only early layers of the network. This has been shown to improve generalization in some settings (e.g., Yosinski et al., 2014), and is sometimes used in natural language processing (e.g., Mou et al., 2016; Howard & Ruder, 2018).
+
+When fine-tuning the entire network, we take the weights of the network trained in the default flavour for 50M frames and use them to initialize the network commencing training in the new flavour for 50M frames. We perform this set of experiments twice. Once for the weights trained without regularization, and again for the weights trained with regularization, as described in the previous section. Each run is averaged over five seeds. For comparison we provide a baseline trained from scratch for 50M and 100M frames in each flavour. Directly comparing the performance obtained after fine-tuning to the performance after 50M frames (SCRATCH) shows the benefit of re-using a representation learned in a different task instead of randomly initializing the network. Comparing the performance obtained after fine-tuning to the performance of 100M frames (SCRATCH) lets us take into consideration the whole learning process. The results are presented in Table 3.
+
+Fine-tuning from an unregularized representation yields conflicting conclusions. Although in FREEWAY we obtained positive fine-tuning results, we note that rewards are so sparse in m1d0 and m1d1 that this initialization is likely to be simply acting as a form of optimistic initialization, biasing the agent to go up. The agent observes rewards more often, therefore, it learns quicker about the new flavour. However, the agent is still unable to reach the maximum score in these flavours.
+
+Table 3: Experiments fine-tuning the entire network with and without regularization (dropout $+ \ell _ { 2 } .$ ). An agent is trained with dropout $+ ~ \ell _ { 2 }$ regularization in the default flavour of each game for 50M frames, then DQN’s parameters $\theta$ were used to initialize the fine-tuning procedure on each new flavour for 50M frames. The baseline agent is trained from scratch up to 100M frames. Standard deviation reported between parenthesis.   
+
+<table><tr><td colspan="2"></td><td colspan="4">FINE-TUNING</td><td colspan="4">REGULARIZED FINE-TUNING</td><td colspan="4">SCRATCH</td></tr><tr><td colspan="2">GAME VARIANT</td><td colspan="2">10M</td><td colspan="2">50M</td><td colspan="2">10M</td><td colspan="2">50M</td><td colspan="2">50M</td><td colspan="2">100M</td></tr><tr><td rowspan="3">FREEWAY</td><td>m1d0</td><td>2.9</td><td>(3.7)</td><td>22.5</td><td>(7.5)</td><td>20.2</td><td>(1.9)</td><td>25.4</td><td>(0.2)</td><td>4.8</td><td>(9.3)</td><td>7.5</td><td>(11.5)</td></tr><tr><td>m1d1</td><td>0.1</td><td>(0.2)</td><td>17.4</td><td>(11.4)</td><td>18.5</td><td>(2.8)</td><td>25.4</td><td>(0.4)</td><td>0.0</td><td>(0.0)</td><td>2.5</td><td>(7.3)</td></tr><tr><td>m4d0</td><td>20.8</td><td>(1.1)</td><td>31.4</td><td>(0.5)</td><td>22.6</td><td>(0.7)</td><td>32.2</td><td>(0.5)</td><td>29.9</td><td>(0.7)</td><td>32.8</td><td>(0.2)</td></tr><tr><td rowspan="2">HERO</td><td>m1d0</td><td>220.7</td><td>(98.2)</td><td>496.7</td><td>(362.8)</td><td>322.5</td><td>(39.3)</td><td>4104.6</td><td>(2192.8)</td><td>1425.2</td><td>(1755.1)</td><td>5026.8</td><td>(2174.6)</td></tr><tr><td>m2d0</td><td>74.4</td><td>(31.7)</td><td>92.5</td><td>(26.2)</td><td>84.8</td><td>(56.1)</td><td>211.0</td><td>(100.6)</td><td>326.1</td><td>(130.4)</td><td>323.5</td><td>(76.4)</td></tr><tr><td>BREAKOUT</td><td>m12d0</td><td>11.5</td><td>(10.7)</td><td>69.1</td><td>(14.9)</td><td>48.2</td><td>(4.1)</td><td>96.1</td><td>(11.2)</td><td>67.6</td><td>(32.4)</td><td>55.2</td><td>(37.2)</td></tr><tr><td rowspan="3">SPACE INVADERS</td><td>m1d0</td><td>617.8</td><td>(55.9)</td><td>926.1</td><td>(56.6)</td><td>701.8</td><td>(28.5)</td><td>1033.5</td><td>(89.7)</td><td>753.6</td><td>(31.6)</td><td>979.7</td><td>(39.8)</td></tr><tr><td>m1d1</td><td>482.6</td><td>(63.4)</td><td>799.4</td><td>(52.5)</td><td>656.7</td><td>(25.5)</td><td>920.0</td><td>(83.5)</td><td>698.5</td><td>(31.3)</td><td>906.9</td><td>(56.5)</td></tr><tr><td>m9d0</td><td>354.8</td><td>(59.4)</td><td>574.1</td><td>(37.0)</td><td>519.0</td><td>(31.1)</td><td>583.0</td><td>(17.5)</td><td>518.0</td><td>(16.7)</td><td>567.7</td><td>(40.1)</td></tr></table>
+
+The results of fine-tuning the regularized representation are more exciting. In FREEWAY we observe the highest scores on $\mathrm { m l d 0 }$ and m1d1 throughout the whole paper. In HERO we vastly outperform fine-tuning from an unregularized representation. In SPACE INVADERS we obtain higher scores across the board on average when comparing to the same amount of experience. These results suggest that reusing a regularized representation in deep RL might allow us to learn more general features which can be more successfully fine-tuned.
+
+Moreover, initializing the network with a regularized representation has a big impact on the agent’s performance when compared to initializing the network randomly. These results are impressive when we consider the potential regularization has in reducing the sample complexity of deep RL algorithms. Such an observation also holds when we take the total number of frames seen between two flavours into consideration. When directly comparing one row of REGULARIZED FINE-TUNING to SCRATCH we are comparing two algorithms that observed 100M frames. However, to generate two rows of SCRATCH we used 200M frames while two rows of REGULARIZED FINE-TUNING used 150M frames (50M from scratch $\mathbf { \Gamma } + 5 0 \mathbf { M }$ in each row). The distinction becomes bigger and bigger as more tasks are taken into consideration.
+
+We further investigate which layers may encode general features able to be fine-tuned. Inspiration was taken from other studies that have shown that neural networks can re-learn co-adaptations when their final layers are randomly initialized, sometimes improving generalization (Yosinski et al., 2014). We conjectured DQN may benefit from re-learning the co-adaptations between early layers comprising general features and the randomly initialized layers which ultimately assign state-action values. We hypothesized that it might be beneficial to re-learn the final layers from scratch since state-action values are ultimately conditioned on the flavour at hand. Therefore, we also evaluated whether fine-tuning only the convolutional layers, or the convolutional layers and the first fully connected layer was more effective than fine-tuning the whole network. Suprisingly, this does not seem to be the case. The performance obtained when the whole network is fine-tuned (Table 3) is consistently better than when it is not (Table 4). We speculate that this might not be the case on more dissimilar tasks.
+
+# 7 DISCUSSION AND CONCLUSION
+
+Many studies have tried to explain generalization of deep neural networks in supervised learning settings (e.g., Zhang et al., 2018; Dinh et al., 2017). Analyzing generalization and overfitting in deep RL has its own issues on top of the challenges posed in the supervised learning case. Actually, generalization in RL can be seen in different ways. We can talk about generalization in RL in terms of conditioned sub-goals within an environment (e.g., Andrychowicz et al., 2017; Sutton, 1995), learning multiple tasks at once (e.g., Teh et al., 2017; Parisotto et al., 2016), or sequential task learning as in a continual learning setting (e.g., Schwarz et al., 2018; Kirkpatrick et al., 2016). In this paper we evaluated generalization in terms of small variations of high-dimensional control tasks. This provides a candid evaluation method to study how well features and policies learned by deep neural networks in RL problems can generalize. The approach of studying generalization with respect to the representation learning problem intersects nicely with the aforementioned problems in RL where generalization is key.
+
+REGULARIZED FINE-TUNING 3CONV   
+REGULARIZED FINE-TUNING REGULARIZED 3CONV+1FC FINE-TUNING   
+Table 4: Experiments fine-tuning early layers of the network trained with regularization. An agent is trained with dropout $+ \ell _ { 2 }$ regularization in the default flavour of each game for 50M frames, then DQN’s parameters $\theta$ were used to initialize the corresponding layers to be further fine-tuned on each new flavour. Remaining layers were randomly initialized. Compared against fine-tuning the entire network from Table 3. Standard deviation reported between parenthesis.   
+
+<table><tr><td colspan="2">GAME VARIANT</td><td colspan="2">10M</td><td colspan="2">50M</td><td colspan="2">10M</td><td colspan="2">50M</td><td colspan="2">50M</td></tr><tr><td rowspan="3">FREEWAY</td><td>m1d0</td><td>0.0</td><td>(0.0)</td><td>0.7</td><td>(1.4)</td><td>0.1</td><td>(0.1)</td><td>4.9 (9.9)</td><td></td><td>25.4 (0.2)</td></tr><tr><td>m1d1</td><td>0.0</td><td>(0.0)</td><td>0.0</td><td>(0.0)</td><td>0.1</td><td>(0.1)</td><td>10.0 (12.3)</td><td></td><td>25.4 (0.4)</td></tr><tr><td>m4d0</td><td>7.3</td><td>(3.5)</td><td>30.4</td><td>(0.6)</td><td>4.9</td><td>(4.8)</td><td>30.7 (1.7)</td><td></td><td>32.2 （0.5)</td></tr><tr><td rowspan="2">HERO</td><td>m1d0</td><td>405.1</td><td>(82.0)</td><td>1949.1</td><td>(2076.4)</td><td>350.3</td><td>(52.1)</td><td>3085.3 (2055.6)</td><td></td><td>4104.6 (2192.8)</td></tr><tr><td>m2d0</td><td>232.1</td><td>(30.1)</td><td>455.2</td><td>(170.4)</td><td>150.4</td><td>(38.5)</td><td>307.6 (64.8)</td><td>211.0</td><td>(100.6)</td></tr><tr><td>BREAKOUT</td><td>m12d0</td><td>4.3</td><td>(1.7)</td><td>63.7</td><td>(26.6)</td><td>5.4</td><td>(0.8)</td><td>89.1 (16.7)</td><td></td><td>96.1 (11.2)</td></tr><tr><td rowspan="3">SPACE INVADERS</td><td>m1d0</td><td>669.3</td><td>(29.1)</td><td>998.1</td><td>(78.8)</td><td>681.3</td><td>(17.2) 989.6</td><td>(39.4)</td><td>1033.5</td><td>(89.7)</td></tr><tr><td>m1d1</td><td>609.8</td><td>(16.6)</td><td>836.3</td><td>(55.9)</td><td>638.7</td><td>(19.1)</td><td>883.4 (38.1)</td><td></td><td>920.0 (83.5)</td></tr><tr><td>m9d0</td><td>436.1</td><td>(18.9)</td><td>581.0</td><td>(12.2)</td><td>439.9</td><td>(40.3) 586.7</td><td>(39.7)</td><td>583.0</td><td>(17.5)</td></tr></table>
+
+The empirical evaluation presented in this paper has shown that traditional DQN seems to generalize poorly even between very similar high-dimensional control tasks. Given this lack of generality we investigated how dropout and $\ell _ { 2 }$ regularization can be used to improve generalization in deep RL. Other forms of regularization in RL that have been explored in the past are sticky-actions, random initial states, entropy regularization (Zhang et al., 2018), and procedural generation of environments (Justesen et al., 2018). More related to our work, regularization in the form of weight constraints has been applied in the continual learning setting in order to reduce the catastrophic forgetting exhibited by fine-tuning on many sequential tasks (Kirkpatrick et al., 2016; Schwarz et al., 2018). Similar weight constraint methods have been explored in multitask learning (Teh et al., 2017).
+
+Evaluation practices in RL often focuses on training and evaluating agents on exactly the same task. Consequently, regularization has traditionally been underutilized in deep RL. With a renewed emphasis on generalization in RL, regularization applied to the representation learning problem can be a feasible method to improving generalization on closely related tasks. Our results suggest that dropout and $\ell _ { 2 }$ regularization seem to be able to learn more general purpose features which can be adapted to similar problems. Although other communities relying on deep neural networks have shown similar successes, this is of particular importance for the deep RL community which struggles with sample efficiency (Henderson et al., 2018). This work is also related to recent metalearning procedures like MAML (Finn et al., 2017) which aim to find a parameter initialization that can be quickly adapted to new tasks. In fact, some of the results here can also be seen under the light of curriculum learning. The regularization techniques we’ve evaluated here seem to be effective in leveraging situations where an easier task is presented first, sometimes leading to unseen performance levels (e.g., FREEWAY).
+
+Finally, we believe it would be extremely beneficial for the field if we were able to develop algorithms that can generalize across tasks. Ultimately we want agents that can keep learning as they interact with the world in a continual learning fashion. The ability to generalize is essential. Throughout this paper we often avoided the expression transfer learning because we believe that succeeding in slightly different environments should be actually seen as a problem of generalization. Our results suggested that regularizing and fine-tuning representations in deep RL might be a viable approach towards improving sample efficiency and generalization on multiple tasks. It is particularly interesting that fine-tuning a regularized network was the most successful approach because this might also be applicable in the continual learning settings where the environment changes without the agent being told so, and re-initializing layers of a network is obviously not an option. In this setting, the work from Kirkpatrick et al. (2016), and Schwarz et al. (2018) might be a great starting point as they provide a more thorough discussion of generalization in continual learning.
+
+# REFERENCES
+
+Marcin Andrychowicz, Dwight Crow, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems (NIPS), pp. 5055–5065, 2017.
+
+Marc G. Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The Arcade Learning Environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.
+
+Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. In Proceedings of the International Conference on Machine Learning (ICML), pp. 1019–1028, 2017.
+
+Lasse Espeholt, Hubert Soyer, Rémi Munos, Karen Simonyan, Volodymyr Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, Shane Legg, and Koray Kavukcuoglu. IMPALA: Scalable distributed deep-RL with importance weighted actor-learner architectures. In Proceedings of the International Conference on Machine Learning (ICML), pp. 1406–1415, 2018.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the International Conference on Machine Learning (ICML), pp. 1126–1135, 2017.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the International Conference on Artificial Intelligence and Statistics (AISTATS), pp. 249–256, 2010.
+
+Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. In Proceedings of the AAAI Conference on Artificial Intelligence, 2018.
+
+Jeremy Howard and Sebastian Ruder. Fine-tuned language models for text classification. CoRR, abs/1801.06146, 2018.
+
+Niels Justesen, Ruben Rodriguez Torrado, Philip Bontrager, Ahmed Khalifa, Julian Togelius, and Sebastian Risi. Procedural level generation improves generality of deep reinforcement learning. CoRR, abs/1806.10729, 2018.
+
+James Kirkpatrick, Razvan Pascanu, Neil C. Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, Claudia Clopath, Dharshan Kumaran, and Raia Hadsell. Overcoming catastrophic forgetting in neural networks. CoRR, abs/1612.00796, 2016.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3431–3440, 2015.
+
+Marlos C. Machado, Marc G. Bellemare, Erik Talvitie, Joel Veness, Matthew J. Hausknecht, and Michael Bowling. Revisiting the Arcade Learning Environment: Evaluation protocols and open problems for general agents. Journal of Artificial Intelligence Research, 61:523–562, 2018.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin A. Riedmiller, Andreas Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Lili Mou, Zhao Meng, Rui Yan, Ge Li, Yan Xu, Lu Zhang, and Zhi Jin. How transferable are neural networks in NLP applications? In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 479–489, 2016.
+
+Alex Nichol, Vicki Pfau, Christopher Hesse, Oleg Klimov, and John Schulman. Gotta learn fast: A new benchmark for generalization in RL. CoRR, abs/1804.03720, 2018.
+
+Emilio Parisotto, Lei Jimmy Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2016.
+
+Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. CNN features offthe-shelf: An astounding baseline for recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, pp. 512–519, 2014.
+
+Andrei A. Rusu, Neil C. Rabinowitz, Guillaume Desjardins, Hubert Soyer, James Kirkpatrick, Koray Kavukcuoglu, Razvan Pascanu, and Raia Hadsell. Progressive neural networks. CoRR, abs/1606.04671, 2016.
+
+Jonathan Schwarz, Wojciech Czarnecki, Jelena Luketina, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell. Progress & compress: A scalable framework for continual learning. In Proceedings of the International Conference on Machine Learning (ICML), pp. 4535–4544, 2018.
+
+David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Richard S. Sutton. Generalization in reinforcement learning: Successful examples using sparse coarse coding. In Advances in Neural Information Processing Systems (NIPS), pp. 1038–1044, 1995.
+
+Yee Whye Teh, Victor Bapst, Wojciech M. Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In Advances in Neural Information Processing Systems (NIPS), pp. 4499–4509, 2017.
+
+Christopher J. C. H. Watkins and Peter Dayan. Q-learning. Machine Learning, 8:279–292, 1992.
+
+Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in Neural Information Processing Systems (NIPS), pp. 3320–3328, 2014.
+
+Chiyuan Zhang, Oriol Vinyals, Rémi Munos, and Samy Bengio. A study on overfitting in deep reinforcement learning. CoRR, abs/1804.06893, 2018.
+
+# A GAME MODES
+
+FREEWAY
+
+![](images/2aa668386109e1d563a4da6e20e0e078eba773211110fae1c133a31561cb8b56.jpg)
+
+In FREEWAY a chicken must cross a road containing multiple lanes of moving traffic within a prespecified time limit. In all modes of FREEWAY, the agent gets rewarded for reaching the top of the screen and is subsequently teleported to the bottom of the screen. If the chicken collides with a vehicle in difficulty 0 it gets bumped down one lane of traffic, alternatively, in difficulty 1 the chicken gets teleported to its starting position on the bottom of the screen. Mode 1 changes some vehicle sprites to include buses, adds more vehicles to some lanes, and increases the velocity of all vehicles. Mode 4 is almost identical to Mode 1; the only difference being vehicles can oscillate between two speeds.
+
+HERO
+
+![](images/4e1f9a03b118e6622d46725b65ec6b4af8fc78827ef3902caea119a258c29bd2.jpg)
+
+In HERO you control a character who must navigate a maze in order to save a trapped miner within a cave system. The agent scores points for any forward progression such as clearing an obstacle or killing an enemy. Once the miner is rescued, the level is terminated and you continue to the next level with a different maze. Some levels have partially observable rooms, more enemies, and more difficult obstacles to traverse. Past the default mode, each subsequent mode starts off at increasingly harder levels denoted by a level number increasing by multiples of 5. The default mode starts you off at level 1, mode 1 starts at level 5, and so on.
+
+# BREAKOUT
+
+![](images/e8ada2c923eaae624bc3f7f54240fb348bfb0e049ff96bc5e858d6e1a93b1886.jpg)  
+(a) BREAKOUT m0d0
+
+![](images/643a9a7840f6a9949a8a04cfc9b540c6c0bc1614c1788137620af3ef28b207db.jpg)  
+(b) BREAKOUT m12d0
+
+In BREAKOUT you control a paddle which can move horizontally along the bottom of the screen. At the beginning of the game, or on loss of life a ball is set into motion and can bounce off the paddle and collide with bricks at the top of the screen. The objective of the game is to break all the bricks without having the ball fall below your paddles horizontal plane. Subsequently, mode 12 of breakout hides the bricks from the player until the ball collides with the bricks in which case the bricks flash for a brief moment before disappearing again.
+
+![](images/3e7939fc132f28db015a68af1959cea16ff790ca122e95820d85c1284032ce10.jpg)
+
+# SPACE INVADERS
+
+When playing SPACE INVADERS you control a spaceship which can move horizontally along the bottom of the screen. There is a grid of aliens which are above you and the objective of the game is to shoot-out all aliens. You are afforded some protection from the alien bullets with three barriers just above the spaceship. Difficulty 1 of space invaders widens your spaceships sprite making it harder to doge enemy bullets. Mode 1 of SPACE INVADERS causes the shields above you to oscillate horizontally. Mode 9 of SPACE INVADERS is similar to Mode 12 of BREAKOUT where the aliens are partially observable until struck with the players bullet.
+
+# B BASELINE RESULTS
+
+In all experiments performed in this paper we utilize the neural network architecture used by Mnih et al. (2015). That is, a convolutional neural network with three convolutional layers and two fully connected layers. A visualization of this network can be found in Figure 8. Hyperparametes are generally kept consistent with Machado et al. (2018). Below we provide a table of the key hyperparameters used in the baseline experiments.
+
+# NEURAL NETWORK ARCHITECTURE
+
+![](images/7dfe146f2c0eda06161f62b44568482e8f495d2ebf3fa310b9b75eaeb385bde9.jpg)  
+Figure 8: Neural network architecture used by DQN to predict state-action values.
+
+# HYPERPARAMETERS
+
+Learning rate $\alpha$   
+Minibatch size   
+Dropout rate convolutions   
+Dropout rate fully connected   
+Regularization term $\lambda$
+
+0.00025   
+32   
+0.05   
+0.1   
+0.0001   
+Replay buffer size 1, 000, 000   
+Target update frequency 4   
+ϵ decay horizon 1M frames   
+$\epsilon$ initial 1.0   
+ϵ final 0.01   
+Discount factor $\gamma$ 0.99
+
+# EVALUATION
+
+Each baseline run is trained for up to 100M frames in each game flavour. We decay epsilon linearly over the $\epsilon$ -decay period to allow for an exploratory period at the beginning of training. We use sticky-actions with a probability of $p = 0 . 2 5$ of executing $A _ { t - 1 }$ instead of action $A _ { t }$ (Machado et al., 2018). We allow the agent access to all 18 primitive actions in the ALE, we do not utilize the reduced action set nor the lives signal.
+
+Furthermore, as a crude measure for environment complexity, we measure the best greedy action an agent could take in a game flavour. Simply put, we iterate through every action in $\mathcal A$ , executing this action $\epsilon$ -greeidly, with $\epsilon = 0 . 0 1$ , at every time step for 100 episodes. These results were then averaged over 5 runs with the standard deviations between runs reported in parenthesis.
+
+Table 5: Baselines using vanilla DQN for all tested game variants.   
+
+<table><tr><td colspan="2">GAME VARIANT</td><td colspan="2">10M</td><td colspan="2">50M</td><td colspan="2">100M</td><td colspan="2">BEST ACTION</td></tr><tr><td rowspan="4">PAAAIAA</td><td>m0d0</td><td>3.0</td><td>(1.0)</td><td>31.4</td><td>(0.2)</td><td>32.1</td><td>(0.1)</td><td>23.0</td><td>(1.4)</td></tr><tr><td>m1d0</td><td>0.0</td><td>(0.1)</td><td>4.8</td><td>(9.3)</td><td>7.5</td><td>(11.5)</td><td>5.0</td><td>(1.5)</td></tr><tr><td>m1d1</td><td>0.0</td><td>(0.0)</td><td>0.0</td><td>(0.0)</td><td>2.5</td><td>(7.3)</td><td>4.2</td><td>(1.3)</td></tr><tr><td>m4d0</td><td>4.4</td><td>(1.4)</td><td>29.9</td><td>(0.7)</td><td>32.8</td><td>(0.2)</td><td>7.5</td><td>(2.8)</td></tr><tr><td rowspan="3">HREH</td><td>m0d0</td><td>3187.8</td><td>(78.3)</td><td>9034.4</td><td>(1610.9)</td><td>13961.0</td><td>(181.9)</td><td>150.0</td><td>(0.0)</td></tr><tr><td>m1d0</td><td>326.9</td><td>(40.3)</td><td>1425.2</td><td>(1755.1)</td><td>5026.8</td><td>(2174.6)</td><td>75.8</td><td>(7.5)</td></tr><tr><td>m2d0</td><td>116.3</td><td>(11.0)</td><td>326.1</td><td>(130.4)</td><td>323.5</td><td>(76.4)</td><td>12.0</td><td>(27.5)</td></tr><tr><td rowspan="2">BHARAIRI</td><td>m0d0</td><td>17.5</td><td>(2.0)</td><td>72.5</td><td>(7.7)</td><td>73.4</td><td>(13.5)</td><td>2.3</td><td>(1.3)</td></tr><tr><td>m12d0</td><td>17.7</td><td>(1.3)</td><td>67.6</td><td>(32.4)</td><td>55.2</td><td>(37.2)</td><td>1.8</td><td>(1.1)</td></tr><tr><td rowspan="4">SSIAAAII IIISSS</td><td>m0d0</td><td>250.3</td><td>(16.2)</td><td>698.8</td><td>(32.2)</td><td>927.1</td><td></td><td></td><td></td></tr><tr><td>m1d0</td><td>203.6</td><td></td><td>753.6</td><td></td><td>979.7</td><td>(85.3)</td><td>243.6</td><td>(95.9)</td></tr><tr><td>m1d1</td><td></td><td>(24.3)</td><td>698.5</td><td>(31.6)</td><td></td><td>(39.8)</td><td>192.6</td><td>(65.7)</td></tr><tr><td></td><td>193.6</td><td>(11.0)</td><td></td><td>(31.3)</td><td>906.9</td><td>(56.5)</td><td>180.9</td><td>(101.9)</td></tr><tr><td>m9d0</td><td></td><td>173.0</td><td>(17.8)</td><td>518.0</td><td>(16.7)</td><td>567.7</td><td>(40.1)</td><td>174.6</td><td>(65.9)</td></tr></table>
+
+Table 6: Baselines using dropout $+ \ell _ { 2 }$ regularization for each default flavour.   
+
+<table><tr><td colspan="2">GAME VARIANT</td><td colspan="2">10M</td><td colspan="2">50M</td><td colspan="2">100M</td><td colspan="2">BEST ACTION</td></tr><tr><td>FREEWAY</td><td>m0d0</td><td>4.6</td><td>(5.0)</td><td>25.9</td><td>(0.6)</td><td>29.0</td><td>(0.8)</td><td>23.0</td><td>(1.4)</td></tr><tr><td>HERO</td><td>m0d0</td><td>2466.5</td><td>(630.8)</td><td>6505.9</td><td>(1843.0)</td><td>12446.9</td><td>(397.4)</td><td>150.0</td><td>(0.0)</td></tr><tr><td>BREAKOUT</td><td>m0d0</td><td>6.1</td><td>(2.7)</td><td>34.1</td><td>(1.8)</td><td>66.4</td><td>(3.6)</td><td>2.3</td><td>(1.3)</td></tr><tr><td>SPACE INVADERS</td><td>m0d0</td><td>214.6</td><td>(13.8)</td><td>623.1</td><td>(16.3)</td><td>617.4</td><td>(29.6)</td><td>243.6</td><td>(95.9)</td></tr></table>
+
+<table><tr><td colspan="2" rowspan="2">GAME VARIANT</td><td colspan="6">BASELINE</td><td colspan="6">BASELINEW/REGULARIZATION</td></tr><tr><td colspan="2">10M</td><td colspan="2">50M</td><td colspan="2">100M</td><td colspan="2">10M</td><td colspan="2">50M</td><td colspan="2">100M</td></tr><tr><td>FREEWAY</td><td>m0d0</td><td>3.0</td><td>(1.0)</td><td>31.4</td><td>(0.2)</td><td>32.1</td><td>(0.1)</td><td>4.6(5.0)</td><td></td><td>25.9</td><td>(0.6)</td><td>29.0</td><td>(0.8)</td></tr><tr><td>HERO</td><td>m0do</td><td>3187.8</td><td>(78.3)</td><td>9034.4</td><td>(1610.9)</td><td>13961.0</td><td>(181.9)</td><td>2466.5</td><td>(630.8)</td><td>6505.9</td><td>(1843.0)</td><td>12446.9</td><td>(397.4)</td></tr><tr><td>BREAKOUT</td><td>m0do</td><td>17.5</td><td>(2.0)</td><td>72.5</td><td>(7.7)</td><td>73.4</td><td>(13.5)</td><td>6.1</td><td>(2.7)</td><td>34.1</td><td>(1.8)</td><td>66.4</td><td>(3.6)</td></tr><tr><td>SPACE INVADERS</td><td>m0do</td><td>250.3</td><td>(16.2)</td><td>698.8</td><td>(32.2)</td><td>927.1</td><td>(85.3)</td><td>214.6</td><td>(13.8)</td><td>623.1</td><td>(16.3)</td><td>617.4</td><td>(29.6)</td></tr></table>
+
+Table 7: Comparison of baseline results with and without regularization in the default flavour. The baseline agent with regularization was trained with dropout and $\ell _ { 2 }$ regularization.
+
+# C POLICY EVALUATION LEARNING CURVES
+
+We provide learning curves for evaluating a policy learned in the default flavour $( \mathrm { m o d 0 } )$ to each subsequent flavour of that game. Each subplot are the results of evaluating the policy from a representation trained with and without regularization.
+
+# EVALUATION
+
+Checkpoint of the network weights $\theta$ were taken during training every 500, 000 frames, up to 50M frames in total. Each checkpoint was then evaluated in the target mode for 100 episodes averaged over five runs. Hyperparameters are kept consistent with the baseline experiments in Appendix B.
+
+![](images/3cba99530b5376f020719509f7d2ca33575814279dd3657daa2501cbe9026204.jpg)  
+Figure 9: Performance curves for policy evaluation results. The $\mathbf { X }$ -axis is the number of frames before we evaluated the $\epsilon$ -greedy policy from the default flavour on the target flavour. The y-axis is the cumulative reward the agent incurred.

parse/train/HkGmDsR9YQ/HkGmDsR9YQ_content_list.json

@@ -0,0 +1,1508 @@
+[
+    {
+        "type": "text",
+        "text": "GENERALIZATION AND REGULARIZATION IN DQN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            782,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            148,
+            398,
+            176
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            213,
+            544,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep reinforcement learning (RL) algorithms have shown an impressive ability to learn complex control policies in high-dimensional environments. However, despite the ever-increasing performance on popular benchmarks like the Arcade Learning Environment (ALE), policies learned by deep RL algorithms can struggle to generalize when evaluated in remarkably similar environments. These results are unexpected given the fact that, in supervised learning, deep neural networks often learn robust features that generalize across tasks. In this paper, we study the generalization capabilities of DQN in order to aid in understanding this mismatch between generalization in deep RL and supervised learning methods. We provide evidence suggesting that DQN overspecializes to the domain it is trained on. We then comprehensively evaluate the impact of traditional methods of regularization from supervised learning, $\\ell _ { 2 }$ and dropout, and of reusing learned representations to improve the generalization capabilities of DQN. We perform this study using different game modes of Atari 2600 games, a recently introduced modification for the ALE which supports slight variations of the Atari 2600 games used for benchmarking in the field. Despite regularization being largely underutilized in deep RL, we show that it can, in fact, help DQN learn more general features. These features can then be reused and fine-tuned on similar tasks, considerably improving the sample efficiency of DQN. ",
+        "bbox": [
+            232,
+            242,
+            766,
+            506
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            531,
+            336,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, reinforcement learning (RL) has proven very successful on complex high-dimensional problems, in large part due to the increase in computational power and to the use of deep neural networks for function approximation (e.g., Mnih et al., 2015; Silver et al., 2016). Despite the generality of the proposed solutions, applying these algorithms to slightly different environments generally requires agents to learn the new task from scratch. Practitioners often realize that the learned policies rarely generalize to other domains, even when they are remarkably similar, and that the learned representations are seldom reusable. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks, though, are lauded for their generalization capabilities (e.g., LeCun et al., 1998). Some communities heavily rely on reusing representations learned by neural networks. In computer vision, classification and segmentation algorithms are rarely trained from scratch; instead they are initialized with pre-trained models from larger datasets like ImageNet (e.g., Razavian et al., 2014; Long et al., 2015). The field of natural language processing has also seen successes in reusing and refining weights from certain layers of neural networks using pre-trained word embeddings, with more recent techniques able to reuse all weights of the network (e.g., Howard & Ruder, 2018). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In light of the successes of traditional supervised learning methods, the current lack of generalization or reusable knowledge (e.g., policies, representation) acquired by current deep RL algorithms is somewhat surprising. In this paper we investigate whether the representation learned by deep RL methods can be generalized, or at the very least reused and refined on small variations to the task at hand. First, we evaluate the generalization capabilities of DQN (Mnih et al., 2015). We further explore whether the experience gained by the supervised learning community to improve generalization and to avoid overfitting could be used in deep RL. We employ conventional supervised learning techniques, albeit largely unexplored in deep RL, such as fine-tuning (i.e., reusing and refining the representation) and regularization. We show that a learned representation trained with regularization allows us to learn more general features capable of being reused and fine-tuned. Besides improving the generalization capabilities of the learned policies this fine-tuning procedure has the potential to greatly improve sample efficiency on settings in which an agent might face multiple variations of the same task. Finally, the results we present here also can be seen as paving a way towards novel curriculum learning approaches for deep RL. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We perform our experiments using different game modes and difficulties of Atari 2600 games, a newly introduced feature of the Arcade Learning Environment (ALE; Bellemare et al., 2013). These game modes allow agents to be trained in one environment while being evaluated in a slightly different environment that still captures key concepts of the original environment (e.g., game sprites, agent goals, dynamics). This use of game modes is itself a novel approach for measuring our progress toward a longstanding goal of agents that can learn to be generally competent and generalize across tasks (Bellemare et al., 2013; Machado et al., 2018; Nichol et al., 2018). This paper also introduces the first baselines for the different modes of Atari 2600 games. ",
+        "bbox": [
+            173,
+            152,
+            826,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            326,
+            303
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            319,
+            415,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning (RL) is a problem where an agent interacts with an environment with the goal of maximizing some form of cumulative long term reward. RL problems are often modeled as a Markov decision process (MDP), defined by a 5-tuple $\\langle \\mathcal { S } , \\mathcal { A } , p , r , \\gamma \\rangle$ . At a discrete time step $t$ the agent observes the current state $S _ { t } ~ \\in ~ \\mathcal { S }$ and chooses an action $A _ { t } \\in \\mathcal A$ to probabilistically transition to the next state $S _ { t + 1 } \\in \\mathcal S$ according to the transition dynamics function $p ( s ^ { \\prime } \\mid s , a ) \\ { \\stackrel { . } { = } }$ $P ( S _ { t + 1 } = s ^ { \\prime } | S _ { t } = s , A _ { t } = \\stackrel { . } { a } )$ . The agent receives a reward signal $R _ { t + 1 }$ according to the reward function $r : \\mathcal { S } \\times \\mathcal { A }  \\mathbb { R }$ . The agents goal is to learn a policy $\\pi : \\mathcal { S } \\times \\mathcal { A }$ defined as the conditional probability of taking action $a$ in state $s$ written as $\\pi ( a | s )$ . The learning agent refines its policy with the objective of maximizing the expected return, that is, the cumulative discounted reward incurred from time $t$ , defined by $\\begin{array} { r } { G _ { t } \\stackrel {  } { = } \\sum _ { k = 0 } ^ { \\infty ^ { \\bullet } } \\gamma ^ { k } R _ { t + k + 1 } } \\end{array}$ where $\\gamma \\in [ 0 , 1 )$ is the discount factor. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Q-learning (Watkins & Dayan, 1992) is a traditional approach to learning an optimal policy from samples obtained from interactions with the environment. It is used to learn an optimal state-action value function via a bootstrapped iterative method. For a given policy $\\pi$ we define the state-action value function as the expected return conditioned on a state and action $q _ { \\pi } ( s , a ) \\doteq \\mathbb { E } _ { \\pi } \\bigl [ G _ { t } | S _ { t } = s , A _ { t } = a \\bigr ]$ . The agent iteratively updates the state-action value function based on samples from the environment using the update rule ",
+        "bbox": [
+            174,
+            491,
+            825,
+            575
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d4e9e5e59c8a1978ea541af6cce1ac53103da70a5b41b8357c4e535e88307ba.jpg",
+        "text": "$$\nQ ( S _ { t } , A _ { t } )  Q ( S _ { t } , A _ { t } ) + \\alpha \\big [ R _ { t + 1 } + \\gamma \\operatorname* { m a x } _ { a ^ { \\prime } \\in A } Q ( S _ { t + 1 } , a ^ { \\prime } ) - Q ( S _ { t } , A _ { t } ) \\big ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            583,
+            733,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $t$ denotes the current timestep and $\\alpha$ the step size. Generally, due to the exploding size of the state space in many real-world problems, it is intractable to learn a state-action pairing for the entire MDP, with researchers and practitioners often resorting to learning an approximate to $q _ { \\pi }$ . ",
+        "bbox": [
+            174,
+            616,
+            825,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "DQN approximates the state-action value function such that $q _ { \\pi } ( s , a ) \\approx Q ( s , a ; \\theta )$ , where $\\theta$ denotes the weights of a neural network. The network takes as input some encoding of the current state $S _ { t }$ and outputs $| { \\cal A } |$ scalars corresponding to the state-action values for that given state. DQN is trained to minimize ",
+        "bbox": [
+            173,
+            665,
+            825,
+            720
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/437986770901d056907b9dfb8bcbacbfde5e12f3bf85acea3dd66a4f003ce6f5.jpg",
+        "text": "$$\nL ^ { \\mathrm { { D Q N } } } = \\underset { S _ { t } , A _ { t } , R _ { t + 1 } , S _ { t + 1 } \\sim U ( \\cdot ) } { \\mathbb { E } } \\left[ \\left( R _ { t + 1 } + \\underset { a ^ { \\prime } \\in A } { \\operatorname* { m a x } } Q ( S _ { t + 1 } , a ^ { \\prime } ; \\theta ^ { - } ) - Q ( S _ { t } , A _ { t } ; \\theta ) \\right) ^ { 2 } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            227,
+            727,
+            767,
+            757
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $( S _ { t } , A _ { t } , R _ { t + 1 } , S _ { t + 1 } )$ are uniformly sampled from $U ( \\cdot )$ , the experience replay buffer filled with experience collected by the agent. The weights $\\theta ^ { - }$ of a duplicate network are updated less frequently for stability purposes. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            809
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 SUPERVISED LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            827,
+            382,
+            842
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the supervised learning problem we are given a dataset of examples represented by a matrix $X \\in \\mathbb { R } ^ { m \\times n }$ with $m$ training examples of dimension $n$ , and a vector $\\mathbf { y } ^ { \\star } \\in \\mathbb { R } ^ { 1 \\times m }$ denoting the output target $y _ { i }$ for each training example $X _ { i }$ . We want to learn a function which maps each training example $X _ { i }$ to its predicted output label $\\hat { y } _ { i }$ . The goal is to learn a robust model that accurately predicts $y _ { i }$ from $X _ { i }$ while also being able to generalize to unseen training examples. In this paper we focus on using a neural network parameterized by the weights $\\theta$ to learn the function $f$ such that $\\hat { y } _ { i } = f ( X _ { i } ; \\theta )$ . We typically train these models by minimizing ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2555f8ee847a694f033eac0c640460548cff7c75f6108da3d9f8b7fca9e7751.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\ \\frac { \\lambda } { 2 } \\ \\| \\theta \\| _ { 2 } ^ { 2 } + \\frac { 1 } { m } \\sum _ { i = 1 } ^ { m } L ( y _ { i } , \\hat { y } _ { i } ) = \\operatorname* { m i n } _ { \\theta } \\ \\frac { \\lambda } { 2 } \\ \\| \\theta \\| _ { 2 } ^ { 2 } + \\frac { 1 } { m } \\sum _ { i = 1 } ^ { m } L ( y _ { i } , f ( X _ { i } ; \\theta ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            136,
+            745,
+            178
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $L$ is a differentiable loss function which outputs a scalar determining the quality of the prediction (e.g., squared error loss). The first term is a form of regularization, i.e., $\\ell _ { 2 }$ regularization, which encourages generalization. $\\ell _ { 2 }$ regularization imposes a penalty on large weight vectors with $\\lambda$ being the weighted importance of the regularization term. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another popular regularization technique is dropout (Srivastava et al., 2014). When using dropout, during forward propagation each neural unit has a chance of being set to zero according to a Bernoulli distribution with probability $p \\in [ 0 , 1 ]$ , referred to as the dropout rate. Dropout discourages the network from relying on a small number of neurons to make a prediction, making it hard for the network to memorize the dataset. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            314
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Prior to training, the network parameters are usually initialized through a stochastic process (e.g., Xavier initialization; Glorot & Bengio, 2010). We can also initialize the network using pre-trained weights from a different task. If we reuse one or more pre-trained layers we say the weights encoded by those layers will be fine-tuned during training (e.g., Razavian et al., 2014; Long et al., 2015). ",
+        "bbox": [
+            174,
+            320,
+            825,
+            377
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 THE ALE AS A PLATFORM FOR EVALUATING GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            397,
+            727,
+            412
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Arcade Learning Environment (ALE) is a platform used to evaluate agents across dozens of Atari 2600 games (Bellemare et al., 2013). It has become one of the standard evaluation platforms in the field and has led to a number of exciting algorithmic advances (e.g., Mnih et al., 2015). The ALE poses the problem of general competency by having agents use the same learning algorithm to perform well in as many games as possible, while learning without using game specific knowledge. Learning to play multiple games with the same agent, or learning to play a game faster by leveraging knowledge acquired in a different game is much harder, with fewer successes being known (e.g., Rusu et al., 2016; Kirkpatrick et al., 2016; Parisotto et al., 2016; Schwarz et al., 2018; Espeholt et al., 2018). ",
+        "bbox": [
+            174,
+            426,
+            825,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we use the different modes and difficulties of Atari 2600 games to evaluate a neural network’s ability to generalize in high-dimensional state spaces. Game modes, originally native to the Atari console, were recently added in the ALE (Machado et al., 2018). They give us modifications of the default environment dynamics and state space, often modifying sprites, velocities, and partial observability. These modes pose a tractable way to investigate generalization of RL agents in a high-dimensional environment. Instead of requiring an agent to play multiple games that are visually very different or even non-analogous, it requires agents to play games that are visually very similar and that can be played with policies that are very similar, at least from a human perspective. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use 13 flavours (combinations of a mode and a difficulty) obtained from 4 games: FREEWAY, HERO, BREAKOUT, and SPACE INVADERS. In FREEWAY, the different modes vary the speed and number of vehicles, while different difficulties change how the player is penalized for running into a vehicle. In HERO, subsequent modes start the player off at increasingly harder levels of the game. The mode we use in BREAKOUT makes the bricks partially observable. The used modes in SPACE INVADERS allow for oscillating shield barriers, increasing the width of the player sprite, and partially observable aliens. Full explanations of specific games, their modes, and their difficulties can be found in Appendix A. Figure 1 provides screenshots showing side by side comparisons of some of the modes explored in this paper. When reading the analyses of this paper it is important to keep in mind how remarkably similar these modes are. ",
+        "bbox": [
+            173,
+            678,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 GENERALIZATION OF THE LEARNED POLICIES AND OVERFITTING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            838,
+            745,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to test the generalization capabilities of DQN we first evaluate whether a policy learned in one flavour can perform well in a different flavour. As afformentioned, different modes and difficulties of a single game look very similar. If the representation encodes a robust policy we might expect it to be able to generalize to slight variations of the underlying reward signal, game dynamics, or observations. Evaluating the learned policy in a similar but different flavour can be seen as evaluating generalization in RL, similar to cross-validation in supervised learning. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e16ca4fc99a7529db72180bc5d0a6ac0bac1a6a9f7957b98bd044776a97649b.jpg",
+        "image_caption": [
+            "Figure 1: Each column shows variation between two selected flavours of each game. From left to right: FREEWAY, HERO, BREAKOUT, and SPACE INVADERS. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            99,
+            812,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            345,
+            823,
+            375
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To evaluate DQN’s ability to generalize across flavours we evaluate the learned $\\epsilon$ -greedy policy on a new flavour after being trained for 50M frames in the default flavour, $\\mathrm { m 0 d 0 }$ (mode 0, difficulty 0). We measure the cumulative reward averaged over 100 episodes in the new flavour, adhering to the evaluation protocol suggested by Machado et al. (2018). The results are summarized in Table 1. Baseline results where the agent is trained from scratch for 50M frames in the flavour we use for evaluation are summarized in the baseline column. Theoretically, this baseline can be seen as an upper bound on the performance DQN can achieve in that flavour, as it represents the agent’s performance when evaluated in the same flavour it was trained on. Full baseline results with the agent’s performance after different number of frames can be found in Appendix B. ",
+        "bbox": [
+            173,
+            381,
+            825,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can see in the results that the policies learned by DQN do not generalize well to different flavours, even when the flavours are remarkably similar. For example, in FREEWAY, a high-level policy applicable to all flavours is to go up while avoiding cars. Perhaps surprisingly, this does not seem to be what DQN learns. For example, the default flavour $\\mathrm { m 0 d 0 }$ and $\\scriptstyle \\mathrm { m 4 d 0 }$ have exactly the same sprites on the screen, the only difference is that in $\\mathrm { m 4 d 0 }$ some cars accelerate and decelerate over time. The close to optimal policy learned in $\\mathrm { m 0 d 0 }$ is only able to score 15.8 points when evaluated on $\\scriptstyle \\mathrm { m 4 d 0 }$ , which is approximately half of what the policy learned from scratch in that flavour achieves (29.9 points). The learned policy when evaluated on flavours that differ more from $\\mathrm { m 0 d 0 }$ perform even worse. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As previously mentioned, the different modes of HERO can be seen as giving the agent a curriculum or a natural progression. Interestingly, the agent trained in the default mode for 50M frames can progress to at least level 3 and sometimes level 4. Mode 1 starts the agent off at level 5, and performance in this mode suffers greatly during evaluation. There are very few game mechanics added to level 5, indicating that perhaps the agent is memorizing trajectories instead of learning a robust policy capable of solving each level. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The results in some flavours suggest that the agent is overfitting to the flavour it is trained on. We tested this hypothesis by periodically evaluating the policy being learned in each of the other flavours of that game. This process involved taking checkpoints of the network at every 500, 000 frames and evaluating the $\\epsilon$ -greedy policy in the prescribed flavour for 100 episodes, again further averaged over five runs. The obtained results in FREEWAY, the most pronounced game in which we see this overfitting trend, are depicted in Figure 2. Learning curves for all flavours can be found in Appendix C. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In FREEWAY, while we see the policy’s performance flattening out in $\\mathrm { m 4 d 0 }$ , we do see the traditional bell-shaped curve associated to overfitting in the other modes. At first, improvements in the original policy do correspond to improvements in the performance of that policy in other domains. With time, it seems that it starts to refine its policy for the specific flavour it is being trained on, overfitting to that flavour. With other game flavours being significantly more complex in their dynamics and gameplay, we do not observe this prominent bell-shaped curve though. For example, in BREAKOUT, we actually observe a monotonic increase in performance throughout the evaluation process. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/001606936357700631c1fc57f19c7a43cd6fb7d1a9a7d04fde6e85bda52a0114.jpg",
+        "table_caption": [
+            "Table 1: Direct policy evaluation. Each game was initially trained in the default mode for 50M frames then evaluated in each listed game flavour. Reported numbers are the average over 5 runs. Standard deviation is reported between parentheses. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">GAME VARIANT</td><td>EVALUATION</td><td>LEARN SCRATCH</td></tr><tr><td rowspan=\"3\">FREEWAY</td><td>m1d0</td><td>0.2 (0.2)</td><td>4.8 (9.3)</td></tr><tr><td>m1d1</td><td>0.1 (0.1)</td><td>0.0 (0.0)</td></tr><tr><td>m4d0</td><td>15.8 (1.0)</td><td>29.9 (0.7)</td></tr><tr><td rowspan=\"2\">HERO</td><td>m1d0</td><td>82.1 (89.3)</td><td>1425.2 (1755.1)</td></tr><tr><td>m2d0</td><td>33.9 (38.7)</td><td>326.1 (130.4)</td></tr><tr><td>BREAKOUT</td><td>m12d0</td><td>43.4 (11.1)</td><td>67.6 (32.4)</td></tr><tr><td rowspan=\"3\">SPACE INVADERS</td><td>m1d0</td><td>258.9 (88.3)</td><td>753.6 (31.6)</td></tr><tr><td>m1d1</td><td>140.4 (61.4)</td><td>698.5 (31.3)</td></tr><tr><td>m9d0</td><td>179.0 (75.1)</td><td>518.0 (16.7)</td></tr></table>",
+        "bbox": [
+            176,
+            99,
+            526,
+            251
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e32eeeaacc66511639a1e09440b8ebe1528f57a96c854659d6ffb8b951741981.jpg",
+        "image_caption": [
+            "Freeway Policy Evaluation ",
+            "Figure 2: Performance of an agent that was trained in the default mode of FREEWAY and evaluated at every 500, 000 frames in each corresponding mode. Results are averaged over five seeds. The y-axis is log scaled. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            545,
+            102,
+            794,
+            255
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In conclusion, when looking at Table 1, it seems that the policies learned by DQN struggle to generalize to even small variations encountered in game flavours. This lack of generalization is surprising, and results as seen in FREEWAY exhibit a troubling notion of overfitting. Based on these results we aim to evaluate whether deep RL could benefit from established methods from supervised learning promoting generalization and reducing overfitting. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 REGULARIZATION IN DEEP RL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            476,
+            459,
+            492
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to evaluate the hypothesis that the observed lack of generalization is due to overfitting, we revisit some popular regularization methods from the supervised learning literature. The two forms of regularization we test are dropout and $\\ell _ { 2 }$ regularization. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            555
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "First we want to understand the effect of regularization on evaluating the learned policy in a different flavour. We do so by applying dropout to the first four layers of the network during training, that is, the three convolutional layers and the first fully connected layer. We simultaneously apply $\\ell _ { 2 }$ regularization on all weights in the network based on preliminary experiments that showed an additive effect when combining dropout and $\\ell _ { 2 }$ regularization. This confirms, for example, Srivastava et al.’s (2014) result that these methods provide benefit in tandem. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            645
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We follow the same evaluation scheme described when evaluating the unregularized policy to different flavours. We evaluate the policy learned after 50M frames of the default mode of each game. A grid search was performed on FREEWAY to find reasonable hyperparameters for the dropout rate $p \\in$ $\\{ 0 . 0 5 , 0 . 1 , 0 . 2 , \\bar { 0 } . 3 , 0 . 4 , 0 . 5 \\}$ and the weighted regularization parameter $\\lambda \\in \\{ 1 0 ^ { - 2 } , \\dot { 1 } 0 ^ { - 3 } , 1 0 ^ { - 4 } \\}$ . These parameters were then used for each subsequent flavour. Notably, significantly smaller dropout values were required compared to heuristics used in supervised learning, although this could be due to the small size of the network in question. We ended up choosing $\\lambda \\stackrel { = } { = } 1 0 ^ { - 4 }$ , $p = 0 . 0 5$ for the first three convolutional layers, and $p = 0 . 1$ for the first fully connected layer. We contrast these results with the results presented in the previous section. This evaluation protocol allows us to directly evaluate the effect of regularization on the learned policy’s ability to generalize. A baseline agent trained from scratch for 50M frames in each flavour is also provided. The results are presented in Table 2 with the evaluation learning curves being available in the Appendix. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "When using regularization during training we sometimes observe a performance hit in the default flavour. Dropout generally requires increased training iterations to reach the same level of performance sans-dropout. Suprisingly, we did not observe this performance hit in all games. Nevertheless, maximal performance in one flavour is not our goal. We are interested in the setting where one may be willing to take lower performance on one task in order to obtain higher performance, or adaptability, on future tasks. Nevertheless, full baseline results using regularization in the default flavour can also be found in Table 7 in the Appendix. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f8b1798dc9372aa2f4d440f0777a995afb4cd37230d6c38714dee744dd1b1dde.jpg",
+        "table_caption": [
+            "Table 2: Policy evaluation using regularization. Each game was initially trained in the default mode for 50M frames with dropout and $\\ell _ { 2 }$ regularization then evaluated on each listed flavour. Reported numbers are the average over 5 runs. Standard deviation is reported between parentheses. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">GAME VARIANT</td><td>EVAL. WITH REGULARIZATION</td><td></td><td>EVAL.WITHOUT REGULARIZATION</td><td>LEARN SCRATCH</td><td></td></tr><tr><td rowspan=\"3\">FREEWAY</td><td>m1do</td><td>5.8</td><td>(3.5)</td><td>0.2 (0.2)</td><td>4.8</td><td>(9.3)</td></tr><tr><td>m1d1</td><td>4.4</td><td>(2.3)</td><td>0.1 (0.1)</td><td>0.0</td><td>(0.0)</td></tr><tr><td>m4d0</td><td>20.6</td><td>(0.7)</td><td>15.8 (1.0)</td><td>29.9</td><td>(0.7)</td></tr><tr><td rowspan=\"2\">HERO</td><td>m1d0o</td><td>116.8</td><td>(76.0)</td><td>82.1 (89.3)</td><td>1425.2</td><td>(1755.1)</td></tr><tr><td>m2d0</td><td>30.0</td><td>(36.7)</td><td>33.9 (38.7)</td><td>326.1</td><td>(130.4)</td></tr><tr><td>BREAKOUT</td><td>m12d0</td><td>31.0</td><td>(8.6)</td><td>43.4 (11.1)</td><td>67.6</td><td>(32.4)</td></tr><tr><td rowspan=\"3\">SPACE INVADERS</td><td>m1d0</td><td>456.0</td><td>(221.4)</td><td>258.9 (88.3)</td><td>753.6</td><td>(31.6)</td></tr><tr><td>m1d1</td><td>146.0</td><td>(84.5)</td><td>140.4 (61.4)</td><td>698.5</td><td>(31.3)</td></tr><tr><td>m9d0</td><td>290.0</td><td>(257.8)</td><td>179.0 (75.1)</td><td>518.0</td><td>(16.7)</td></tr></table>",
+        "bbox": [
+            176,
+            98,
+            560,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f5e5f10f47bd42958285ee27360663615f449cc18168450b5ef8d6803a3ade84.jpg",
+        "image_caption": [
+            "Freeway Policy Evaluation w/ Regularization ",
+            "Figure 3: Performance of an agent that was evaluated every 500, 000 frames after being trained in the default flavour of FREEWAY with dropout and $\\ell _ { 2 }$ regularization. Results are averaged over five seeds. The y-axis is log scaled. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            576,
+            106,
+            797,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In most flavours, evaluating the policy trained with regularization does not negatively impact performance when compared to the performance of the policy trained without regularization. In some flavours we even see an increase in performance. Interestingly, when using regularization the agent in FREEWAY improves for all flavours and even learns a policy capable of outperforming the baseline learned from scratch in two of the three flavours. Moreover, in FREEWAY we now observe increasing performance during evaluation throughout most of the learning procedure as depicted in Figure 3. These results seem to confirm the notion of overfitting observed in Figure 2. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            444
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Despite slight improvements from these techniques, regularization by itself does not seem sufficient to enable policies to generalize across flavours. As shown in the next section, perhaps the real benefit of regularization in deep RL comes from the ability to learn more general features. These features may lead to a more adaptable representation which can be reused and subsequently fine-tuned on other flavours, which is often the case in supervised learning. ",
+        "bbox": [
+            174,
+            450,
+            825,
+            521
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 VALUE FUNCTION FINE-TUNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            544,
+            470,
+            559
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We hypothesize that the benefit of regularizing deep RL algorithms may not come from improvements during evaluation, but instead in having a good parameter initialization that can be adapted to new tasks that are similar. We evaluate this hypothesis using two common practices in machine learning. First, we the use the weights trained with regularization as the initialization for the entire network. We subsequently fine-tune all weights in the network. This is similar to what is performed in computer vision with supervised classification methods (e.g., Razavian et al., 2014). Secondly, we evaluate reusing and fine-tuning only early layers of the network. This has been shown to improve generalization in some settings (e.g., Yosinski et al., 2014), and is sometimes used in natural language processing (e.g., Mou et al., 2016; Howard & Ruder, 2018). ",
+        "bbox": [
+            174,
+            575,
+            825,
+            702
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "When fine-tuning the entire network, we take the weights of the network trained in the default flavour for 50M frames and use them to initialize the network commencing training in the new flavour for 50M frames. We perform this set of experiments twice. Once for the weights trained without regularization, and again for the weights trained with regularization, as described in the previous section. Each run is averaged over five seeds. For comparison we provide a baseline trained from scratch for 50M and 100M frames in each flavour. Directly comparing the performance obtained after fine-tuning to the performance after 50M frames (SCRATCH) shows the benefit of re-using a representation learned in a different task instead of randomly initializing the network. Comparing the performance obtained after fine-tuning to the performance of 100M frames (SCRATCH) lets us take into consideration the whole learning process. The results are presented in Table 3. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fine-tuning from an unregularized representation yields conflicting conclusions. Although in FREEWAY we obtained positive fine-tuning results, we note that rewards are so sparse in m1d0 and m1d1 that this initialization is likely to be simply acting as a form of optimistic initialization, biasing the agent to go up. The agent observes rewards more often, therefore, it learns quicker about the new flavour. However, the agent is still unable to reach the maximum score in these flavours. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/656a7dc9931c51a1dd1833432cb1b28c58e1edf3fa87ad2683139d2a172cb2b2.jpg",
+        "table_caption": [
+            "Table 3: Experiments fine-tuning the entire network with and without regularization (dropout $+ \\ell _ { 2 } .$ ). An agent is trained with dropout $+ ~ \\ell _ { 2 }$ regularization in the default flavour of each game for 50M frames, then DQN’s parameters $\\theta$ were used to initialize the fine-tuning procedure on each new flavour for 50M frames. The baseline agent is trained from scratch up to 100M frames. Standard deviation reported between parenthesis. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\"></td><td colspan=\"4\">FINE-TUNING</td><td colspan=\"4\">REGULARIZED FINE-TUNING</td><td colspan=\"4\">SCRATCH</td></tr><tr><td colspan=\"2\">GAME VARIANT</td><td colspan=\"2\">10M</td><td colspan=\"2\">50M</td><td colspan=\"2\">10M</td><td colspan=\"2\">50M</td><td colspan=\"2\">50M</td><td colspan=\"2\">100M</td></tr><tr><td rowspan=\"3\">FREEWAY</td><td>m1d0</td><td>2.9</td><td>(3.7)</td><td>22.5</td><td>(7.5)</td><td>20.2</td><td>(1.9)</td><td>25.4</td><td>(0.2)</td><td>4.8</td><td>(9.3)</td><td>7.5</td><td>(11.5)</td></tr><tr><td>m1d1</td><td>0.1</td><td>(0.2)</td><td>17.4</td><td>(11.4)</td><td>18.5</td><td>(2.8)</td><td>25.4</td><td>(0.4)</td><td>0.0</td><td>(0.0)</td><td>2.5</td><td>(7.3)</td></tr><tr><td>m4d0</td><td>20.8</td><td>(1.1)</td><td>31.4</td><td>(0.5)</td><td>22.6</td><td>(0.7)</td><td>32.2</td><td>(0.5)</td><td>29.9</td><td>(0.7)</td><td>32.8</td><td>(0.2)</td></tr><tr><td rowspan=\"2\">HERO</td><td>m1d0</td><td>220.7</td><td>(98.2)</td><td>496.7</td><td>(362.8)</td><td>322.5</td><td>(39.3)</td><td>4104.6</td><td>(2192.8)</td><td>1425.2</td><td>(1755.1)</td><td>5026.8</td><td>(2174.6)</td></tr><tr><td>m2d0</td><td>74.4</td><td>(31.7)</td><td>92.5</td><td>(26.2)</td><td>84.8</td><td>(56.1)</td><td>211.0</td><td>(100.6)</td><td>326.1</td><td>(130.4)</td><td>323.5</td><td>(76.4)</td></tr><tr><td>BREAKOUT</td><td>m12d0</td><td>11.5</td><td>(10.7)</td><td>69.1</td><td>(14.9)</td><td>48.2</td><td>(4.1)</td><td>96.1</td><td>(11.2)</td><td>67.6</td><td>(32.4)</td><td>55.2</td><td>(37.2)</td></tr><tr><td rowspan=\"3\">SPACE INVADERS</td><td>m1d0</td><td>617.8</td><td>(55.9)</td><td>926.1</td><td>(56.6)</td><td>701.8</td><td>(28.5)</td><td>1033.5</td><td>(89.7)</td><td>753.6</td><td>(31.6)</td><td>979.7</td><td>(39.8)</td></tr><tr><td>m1d1</td><td>482.6</td><td>(63.4)</td><td>799.4</td><td>(52.5)</td><td>656.7</td><td>(25.5)</td><td>920.0</td><td>(83.5)</td><td>698.5</td><td>(31.3)</td><td>906.9</td><td>(56.5)</td></tr><tr><td>m9d0</td><td>354.8</td><td>(59.4)</td><td>574.1</td><td>(37.0)</td><td>519.0</td><td>(31.1)</td><td>583.0</td><td>(17.5)</td><td>518.0</td><td>(16.7)</td><td>567.7</td><td>(40.1)</td></tr></table>",
+        "bbox": [
+            176,
+            98,
+            820,
+            252
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The results of fine-tuning the regularized representation are more exciting. In FREEWAY we observe the highest scores on $\\mathrm { m l d 0 }$ and m1d1 throughout the whole paper. In HERO we vastly outperform fine-tuning from an unregularized representation. In SPACE INVADERS we obtain higher scores across the board on average when comparing to the same amount of experience. These results suggest that reusing a regularized representation in deep RL might allow us to learn more general features which can be more successfully fine-tuned. ",
+        "bbox": [
+            174,
+            357,
+            823,
+            441
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Moreover, initializing the network with a regularized representation has a big impact on the agent’s performance when compared to initializing the network randomly. These results are impressive when we consider the potential regularization has in reducing the sample complexity of deep RL algorithms. Such an observation also holds when we take the total number of frames seen between two flavours into consideration. When directly comparing one row of REGULARIZED FINE-TUNING to SCRATCH we are comparing two algorithms that observed 100M frames. However, to generate two rows of SCRATCH we used 200M frames while two rows of REGULARIZED FINE-TUNING used 150M frames (50M from scratch $\\mathbf { \\Gamma } + 5 0 \\mathbf { M }$ in each row). The distinction becomes bigger and bigger as more tasks are taken into consideration. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            574
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We further investigate which layers may encode general features able to be fine-tuned. Inspiration was taken from other studies that have shown that neural networks can re-learn co-adaptations when their final layers are randomly initialized, sometimes improving generalization (Yosinski et al., 2014). We conjectured DQN may benefit from re-learning the co-adaptations between early layers comprising general features and the randomly initialized layers which ultimately assign state-action values. We hypothesized that it might be beneficial to re-learn the final layers from scratch since state-action values are ultimately conditioned on the flavour at hand. Therefore, we also evaluated whether fine-tuning only the convolutional layers, or the convolutional layers and the first fully connected layer was more effective than fine-tuning the whole network. Suprisingly, this does not seem to be the case. The performance obtained when the whole network is fine-tuned (Table 3) is consistently better than when it is not (Table 4). We speculate that this might not be the case on more dissimilar tasks. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            747
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION AND CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            767,
+            465,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Many studies have tried to explain generalization of deep neural networks in supervised learning settings (e.g., Zhang et al., 2018; Dinh et al., 2017). Analyzing generalization and overfitting in deep RL has its own issues on top of the challenges posed in the supervised learning case. Actually, generalization in RL can be seen in different ways. We can talk about generalization in RL in terms of conditioned sub-goals within an environment (e.g., Andrychowicz et al., 2017; Sutton, 1995), learning multiple tasks at once (e.g., Teh et al., 2017; Parisotto et al., 2016), or sequential task learning as in a continual learning setting (e.g., Schwarz et al., 2018; Kirkpatrick et al., 2016). In this paper we evaluated generalization in terms of small variations of high-dimensional control tasks. This provides a candid evaluation method to study how well features and policies learned by deep neural networks in RL problems can generalize. The approach of studying generalization with respect to the representation learning problem intersects nicely with the aforementioned problems in RL where generalization is key. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/46b2176ad4b91669f0972b6078a883246a5b38f5a7d72d94bd1499935e16461f.jpg",
+        "table_caption": [
+            "REGULARIZED FINE-TUNING 3CONV ",
+            "REGULARIZED FINE-TUNING REGULARIZED 3CONV+1FC FINE-TUNING ",
+            "Table 4: Experiments fine-tuning early layers of the network trained with regularization. An agent is trained with dropout $+ \\ell _ { 2 }$ regularization in the default flavour of each game for 50M frames, then DQN’s parameters $\\theta$ were used to initialize the corresponding layers to be further fine-tuned on each new flavour. Remaining layers were randomly initialized. Compared against fine-tuning the entire network from Table 3. Standard deviation reported between parenthesis. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">GAME VARIANT</td><td colspan=\"2\">10M</td><td colspan=\"2\">50M</td><td colspan=\"2\">10M</td><td colspan=\"2\">50M</td><td colspan=\"2\">50M</td></tr><tr><td rowspan=\"3\">FREEWAY</td><td>m1d0</td><td>0.0</td><td>(0.0)</td><td>0.7</td><td>(1.4)</td><td>0.1</td><td>(0.1)</td><td>4.9 (9.9)</td><td></td><td>25.4 (0.2)</td></tr><tr><td>m1d1</td><td>0.0</td><td>(0.0)</td><td>0.0</td><td>(0.0)</td><td>0.1</td><td>(0.1)</td><td>10.0 (12.3)</td><td></td><td>25.4 (0.4)</td></tr><tr><td>m4d0</td><td>7.3</td><td>(3.5)</td><td>30.4</td><td>(0.6)</td><td>4.9</td><td>(4.8)</td><td>30.7 (1.7)</td><td></td><td>32.2 （0.5)</td></tr><tr><td rowspan=\"2\">HERO</td><td>m1d0</td><td>405.1</td><td>(82.0)</td><td>1949.1</td><td>(2076.4)</td><td>350.3</td><td>(52.1)</td><td>3085.3 (2055.6)</td><td></td><td>4104.6 (2192.8)</td></tr><tr><td>m2d0</td><td>232.1</td><td>(30.1)</td><td>455.2</td><td>(170.4)</td><td>150.4</td><td>(38.5)</td><td>307.6 (64.8)</td><td>211.0</td><td>(100.6)</td></tr><tr><td>BREAKOUT</td><td>m12d0</td><td>4.3</td><td>(1.7)</td><td>63.7</td><td>(26.6)</td><td>5.4</td><td>(0.8)</td><td>89.1 (16.7)</td><td></td><td>96.1 (11.2)</td></tr><tr><td rowspan=\"3\">SPACE INVADERS</td><td>m1d0</td><td>669.3</td><td>(29.1)</td><td>998.1</td><td>(78.8)</td><td>681.3</td><td>(17.2) 989.6</td><td>(39.4)</td><td>1033.5</td><td>(89.7)</td></tr><tr><td>m1d1</td><td>609.8</td><td>(16.6)</td><td>836.3</td><td>(55.9)</td><td>638.7</td><td>(19.1)</td><td>883.4 (38.1)</td><td></td><td>920.0 (83.5)</td></tr><tr><td>m9d0</td><td>436.1</td><td>(18.9)</td><td>581.0</td><td>(12.2)</td><td>439.9</td><td>(40.3) 586.7</td><td>(39.7)</td><td>583.0</td><td>(17.5)</td></tr></table>",
+        "bbox": [
+            176,
+            116,
+            820,
+            270
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            388,
+            823,
+            430
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The empirical evaluation presented in this paper has shown that traditional DQN seems to generalize poorly even between very similar high-dimensional control tasks. Given this lack of generality we investigated how dropout and $\\ell _ { 2 }$ regularization can be used to improve generalization in deep RL. Other forms of regularization in RL that have been explored in the past are sticky-actions, random initial states, entropy regularization (Zhang et al., 2018), and procedural generation of environments (Justesen et al., 2018). More related to our work, regularization in the form of weight constraints has been applied in the continual learning setting in order to reduce the catastrophic forgetting exhibited by fine-tuning on many sequential tasks (Kirkpatrick et al., 2016; Schwarz et al., 2018). Similar weight constraint methods have been explored in multitask learning (Teh et al., 2017). ",
+        "bbox": [
+            174,
+            438,
+            825,
+            563
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Evaluation practices in RL often focuses on training and evaluating agents on exactly the same task. Consequently, regularization has traditionally been underutilized in deep RL. With a renewed emphasis on generalization in RL, regularization applied to the representation learning problem can be a feasible method to improving generalization on closely related tasks. Our results suggest that dropout and $\\ell _ { 2 }$ regularization seem to be able to learn more general purpose features which can be adapted to similar problems. Although other communities relying on deep neural networks have shown similar successes, this is of particular importance for the deep RL community which struggles with sample efficiency (Henderson et al., 2018). This work is also related to recent metalearning procedures like MAML (Finn et al., 2017) which aim to find a parameter initialization that can be quickly adapted to new tasks. In fact, some of the results here can also be seen under the light of curriculum learning. The regularization techniques we’ve evaluated here seem to be effective in leveraging situations where an easier task is presented first, sometimes leading to unseen performance levels (e.g., FREEWAY). ",
+        "bbox": [
+            174,
+            570,
+            825,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we believe it would be extremely beneficial for the field if we were able to develop algorithms that can generalize across tasks. Ultimately we want agents that can keep learning as they interact with the world in a continual learning fashion. The ability to generalize is essential. Throughout this paper we often avoided the expression transfer learning because we believe that succeeding in slightly different environments should be actually seen as a problem of generalization. Our results suggested that regularizing and fine-tuning representations in deep RL might be a viable approach towards improving sample efficiency and generalization on multiple tasks. It is particularly interesting that fine-tuning a regularized network was the most successful approach because this might also be applicable in the continual learning settings where the environment changes without the agent being told so, and re-initializing layers of a network is obviously not an option. In this setting, the work from Kirkpatrick et al. (2016), and Schwarz et al. (2018) might be a great starting point as they provide a more thorough discussion of generalization in continual learning. ",
+        "bbox": [
+            174,
+            757,
+            826,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Dwight Crow, Alex Ray, Jonas Schneider, Rachel Fong, Peter Welinder, Bob McGrew, Josh Tobin, Pieter Abbeel, and Wojciech Zaremba. Hindsight experience replay. In Advances in Neural Information Processing Systems (NIPS), pp. 5055–5065, 2017. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            169
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc G. Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The Arcade Learning Environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research, 47:253–279, 2013. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            220
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. In Proceedings of the International Conference on Machine Learning (ICML), pp. 1019–1028, 2017. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lasse Espeholt, Hubert Soyer, Rémi Munos, Karen Simonyan, Volodymyr Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, Shane Legg, and Koray Kavukcuoglu. IMPALA: Scalable distributed deep-RL with importance weighted actor-learner architectures. In Proceedings of the International Conference on Machine Learning (ICML), pp. 1406–1415, 2018. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            338
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the International Conference on Machine Learning (ICML), pp. 1126–1135, 2017. ",
+        "bbox": [
+            174,
+            347,
+            826,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the International Conference on Artificial Intelligence and Statistics (AISTATS), pp. 249–256, 2010. ",
+        "bbox": [
+            173,
+            398,
+            826,
+            443
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. In Proceedings of the AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            174,
+            450,
+            823,
+            494
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jeremy Howard and Sebastian Ruder. Fine-tuned language models for text classification. CoRR, abs/1801.06146, 2018. ",
+        "bbox": [
+            169,
+            503,
+            825,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Niels Justesen, Ruben Rodriguez Torrado, Philip Bontrager, Ahmed Khalifa, Julian Togelius, and Sebastian Risi. Procedural level generation improves generality of deep reinforcement learning. CoRR, abs/1806.10729, 2018. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            584
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James Kirkpatrick, Razvan Pascanu, Neil C. Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, Demis Hassabis, Claudia Clopath, Dharshan Kumaran, and Raia Hadsell. Overcoming catastrophic forgetting in neural networks. CoRR, abs/1612.00796, 2016. ",
+        "bbox": [
+            173,
+            593,
+            826,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            173,
+            659,
+            823,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pp. 3431–3440, 2015. ",
+        "bbox": [
+            173,
+            696,
+            826,
+            739
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marlos C. Machado, Marc G. Bellemare, Erik Talvitie, Joel Veness, Matthew J. Hausknecht, and Michael Bowling. Revisiting the Arcade Learning Environment: Evaluation protocols and open problems for general agents. Journal of Artificial Intelligence Research, 61:523–562, 2018. ",
+        "bbox": [
+            173,
+            750,
+            826,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin A. Riedmiller, Andreas Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            174,
+            801,
+            826,
+            871
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lili Mou, Zhao Meng, Rui Yan, Ge Li, Yan Xu, Lu Zhang, and Zhi Jin. How transferable are neural networks in NLP applications? In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 479–489, 2016. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Nichol, Vicki Pfau, Christopher Hesse, Oleg Klimov, and John Schulman. Gotta learn fast: A new benchmark for generalization in RL. CoRR, abs/1804.03720, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto, Lei Jimmy Ba, and Ruslan Salakhutdinov. Actor-mimic: Deep multitask and transfer reinforcement learning. In Proceedings of the International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Sharif Razavian, Hossein Azizpour, Josephine Sullivan, and Stefan Carlsson. CNN features offthe-shelf: An astounding baseline for recognition. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR) Workshops, pp. 512–519, 2014. ",
+        "bbox": [
+            174,
+            193,
+            823,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "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. CoRR, abs/1606.04671, 2016. ",
+        "bbox": [
+            173,
+            244,
+            825,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Schwarz, Wojciech Czarnecki, Jelena Luketina, Agnieszka Grabska-Barwinska, Yee Whye Teh, Razvan Pascanu, and Raia Hadsell. Progress & compress: A scalable framework for continual learning. In Proceedings of the International Conference on Machine Learning (ICML), pp. 4535–4544, 2018. ",
+        "bbox": [
+            173,
+            295,
+            826,
+            352
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            173,
+            361,
+            826,
+            431
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            176,
+            440,
+            823,
+            483
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton. Generalization in reinforcement learning: Successful examples using sparse coarse coding. In Advances in Neural Information Processing Systems (NIPS), pp. 1038–1044, 1995. ",
+        "bbox": [
+            174,
+            492,
+            823,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yee Whye Teh, Victor Bapst, Wojciech M. Czarnecki, John Quan, James Kirkpatrick, Raia Hadsell, Nicolas Heess, and Razvan Pascanu. Distral: Robust multitask reinforcement learning. In Advances in Neural Information Processing Systems (NIPS), pp. 4499–4509, 2017. ",
+        "bbox": [
+            173,
+            542,
+            826,
+            587
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher J. C. H. Watkins and Peter Dayan. Q-learning. Machine Learning, 8:279–292, 1992. ",
+        "bbox": [
+            171,
+            594,
+            808,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jason Yosinski, Jeff Clune, Yoshua Bengio, and Hod Lipson. How transferable are features in deep neural networks? In Advances in Neural Information Processing Systems (NIPS), pp. 3320–3328, 2014. ",
+        "bbox": [
+            173,
+            619,
+            823,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chiyuan Zhang, Oriol Vinyals, Rémi Munos, and Samy Bengio. A study on overfitting in deep reinforcement learning. CoRR, abs/1804.06893, 2018. ",
+        "bbox": [
+            173,
+            670,
+            821,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A GAME MODES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            331,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "FREEWAY ",
+        "bbox": [
+            174,
+            136,
+            243,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/2aa668386109e1d563a4da6e20e0e078eba773211110fae1c133a31561cb8b56.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            166,
+            772,
+            268
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In FREEWAY a chicken must cross a road containing multiple lanes of moving traffic within a prespecified time limit. In all modes of FREEWAY, the agent gets rewarded for reaching the top of the screen and is subsequently teleported to the bottom of the screen. If the chicken collides with a vehicle in difficulty 0 it gets bumped down one lane of traffic, alternatively, in difficulty 1 the chicken gets teleported to its starting position on the bottom of the screen. Mode 1 changes some vehicle sprites to include buses, adds more vehicles to some lanes, and increases the velocity of all vehicles. Mode 4 is almost identical to Mode 1; the only difference being vehicles can oscillate between two speeds. ",
+        "bbox": [
+            173,
+            286,
+            826,
+            400
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "HERO ",
+        "bbox": [
+            174,
+            417,
+            217,
+            431
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/4e1f9a03b118e6622d46725b65ec6b4af8fc78827ef3902caea119a258c29bd2.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            449,
+            774,
+            551
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In HERO you control a character who must navigate a maze in order to save a trapped miner within a cave system. The agent scores points for any forward progression such as clearing an obstacle or killing an enemy. Once the miner is rescued, the level is terminated and you continue to the next level with a different maze. Some levels have partially observable rooms, more enemies, and more difficult obstacles to traverse. Past the default mode, each subsequent mode starts off at increasingly harder levels denoted by a level number increasing by multiples of 5. The default mode starts you off at level 1, mode 1 starts at level 5, and so on. ",
+        "bbox": [
+            173,
+            570,
+            826,
+            667
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "BREAKOUT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            688,
+            254,
+            702
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/e8ada2c923eaae624bc3f7f54240fb348bfb0e049ff96bc5e858d6e1a93b1886.jpg",
+        "image_caption": [
+            "(a) BREAKOUT m0d0 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            261,
+            723,
+            406,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/643a9a7840f6a9949a8a04cfc9b540c6c0bc1614c1788137620af3ef28b207db.jpg",
+        "image_caption": [
+            "(b) BREAKOUT m12d0 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            583,
+            720,
+            727,
+            801
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In BREAKOUT you control a paddle which can move horizontally along the bottom of the screen. At the beginning of the game, or on loss of life a ball is set into motion and can bounce off the paddle and collide with bricks at the top of the screen. The objective of the game is to break all the bricks without having the ball fall below your paddles horizontal plane. Subsequently, mode 12 of breakout hides the bricks from the player until the ball collides with the bricks in which case the bricks flash for a brief moment before disappearing again. ",
+        "bbox": [
+            173,
+            840,
+            826,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e7939fc132f28db015a68af1959cea16ff790ca122e95820d85c1284032ce10.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            99,
+            787,
+            203
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "SPACE INVADERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            229,
+            297,
+            243
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "When playing SPACE INVADERS you control a spaceship which can move horizontally along the bottom of the screen. There is a grid of aliens which are above you and the objective of the game is to shoot-out all aliens. You are afforded some protection from the alien bullets with three barriers just above the spaceship. Difficulty 1 of space invaders widens your spaceships sprite making it harder to doge enemy bullets. Mode 1 of SPACE INVADERS causes the shields above you to oscillate horizontally. Mode 9 of SPACE INVADERS is similar to Mode 12 of BREAKOUT where the aliens are partially observable until struck with the players bullet. ",
+        "bbox": [
+            173,
+            255,
+            825,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B BASELINE RESULTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            375,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In all experiments performed in this paper we utilize the neural network architecture used by Mnih et al. (2015). That is, a convolutional neural network with three convolutional layers and two fully connected layers. A visualization of this network can be found in Figure 8. Hyperparametes are generally kept consistent with Machado et al. (2018). Below we provide a table of the key hyperparameters used in the baseline experiments. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            476
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "NEURAL NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            494,
+            423,
+            507
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/7dfe146f2c0eda06161f62b44568482e8f495d2ebf3fa310b9b75eaeb385bde9.jpg",
+        "image_caption": [
+            "Figure 8: Neural network architecture used by DQN to predict state-action values. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            536,
+            743,
+            604
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            684,
+            318,
+            698
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Learning rate $\\alpha$   \nMinibatch size   \nDropout rate convolutions   \nDropout rate fully connected   \nRegularization term $\\lambda$ ",
+        "bbox": [
+            183,
+            720,
+            375,
+            791
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "0.00025   \n32   \n0.05   \n0.1   \n0.0001   \nReplay buffer size 1, 000, 000   \nTarget update frequency 4   \nϵ decay horizon 1M frames   \n$\\epsilon$ initial 1.0   \nϵ final 0.01   \nDiscount factor $\\gamma$ 0.99 ",
+        "bbox": [
+            388,
+            720,
+            446,
+            790
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            509,
+            713,
+            761,
+            799
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            266,
+            842
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Each baseline run is trained for up to 100M frames in each game flavour. We decay epsilon linearly over the $\\epsilon$ -decay period to allow for an exploratory period at the beginning of training. We use sticky-actions with a probability of $p = 0 . 2 5$ of executing $A _ { t - 1 }$ instead of action $A _ { t }$ (Machado et al., 2018). We allow the agent access to all 18 primitive actions in the ALE, we do not utilize the reduced action set nor the lives signal. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, as a crude measure for environment complexity, we measure the best greedy action an agent could take in a game flavour. Simply put, we iterate through every action in $\\mathcal A$ , executing this action $\\epsilon$ -greeidly, with $\\epsilon = 0 . 0 1$ , at every time step for 100 episodes. These results were then averaged over 5 runs with the standard deviations between runs reported in parenthesis. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/ea9c26f4281137ae38ced71e512d33b3b5a3406c3663c89089b3d0e783ed19da.jpg",
+        "table_caption": [
+            "Table 5: Baselines using vanilla DQN for all tested game variants. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">GAME VARIANT</td><td colspan=\"2\">10M</td><td colspan=\"2\">50M</td><td colspan=\"2\">100M</td><td colspan=\"2\">BEST ACTION</td></tr><tr><td rowspan=\"4\">PAAAIAA</td><td>m0d0</td><td>3.0</td><td>(1.0)</td><td>31.4</td><td>(0.2)</td><td>32.1</td><td>(0.1)</td><td>23.0</td><td>(1.4)</td></tr><tr><td>m1d0</td><td>0.0</td><td>(0.1)</td><td>4.8</td><td>(9.3)</td><td>7.5</td><td>(11.5)</td><td>5.0</td><td>(1.5)</td></tr><tr><td>m1d1</td><td>0.0</td><td>(0.0)</td><td>0.0</td><td>(0.0)</td><td>2.5</td><td>(7.3)</td><td>4.2</td><td>(1.3)</td></tr><tr><td>m4d0</td><td>4.4</td><td>(1.4)</td><td>29.9</td><td>(0.7)</td><td>32.8</td><td>(0.2)</td><td>7.5</td><td>(2.8)</td></tr><tr><td rowspan=\"3\">HREH</td><td>m0d0</td><td>3187.8</td><td>(78.3)</td><td>9034.4</td><td>(1610.9)</td><td>13961.0</td><td>(181.9)</td><td>150.0</td><td>(0.0)</td></tr><tr><td>m1d0</td><td>326.9</td><td>(40.3)</td><td>1425.2</td><td>(1755.1)</td><td>5026.8</td><td>(2174.6)</td><td>75.8</td><td>(7.5)</td></tr><tr><td>m2d0</td><td>116.3</td><td>(11.0)</td><td>326.1</td><td>(130.4)</td><td>323.5</td><td>(76.4)</td><td>12.0</td><td>(27.5)</td></tr><tr><td rowspan=\"2\">BHARAIRI</td><td>m0d0</td><td>17.5</td><td>(2.0)</td><td>72.5</td><td>(7.7)</td><td>73.4</td><td>(13.5)</td><td>2.3</td><td>(1.3)</td></tr><tr><td>m12d0</td><td>17.7</td><td>(1.3)</td><td>67.6</td><td>(32.4)</td><td>55.2</td><td>(37.2)</td><td>1.8</td><td>(1.1)</td></tr><tr><td rowspan=\"4\">SSIAAAII IIISSS</td><td>m0d0</td><td>250.3</td><td>(16.2)</td><td>698.8</td><td>(32.2)</td><td>927.1</td><td></td><td></td><td></td></tr><tr><td>m1d0</td><td>203.6</td><td></td><td>753.6</td><td></td><td>979.7</td><td>(85.3)</td><td>243.6</td><td>(95.9)</td></tr><tr><td>m1d1</td><td></td><td>(24.3)</td><td>698.5</td><td>(31.6)</td><td></td><td>(39.8)</td><td>192.6</td><td>(65.7)</td></tr><tr><td></td><td>193.6</td><td>(11.0)</td><td></td><td>(31.3)</td><td>906.9</td><td>(56.5)</td><td>180.9</td><td>(101.9)</td></tr><tr><td>m9d0</td><td></td><td>173.0</td><td>(17.8)</td><td>518.0</td><td>(16.7)</td><td>567.7</td><td>(40.1)</td><td>174.6</td><td>(65.9)</td></tr></table>",
+        "bbox": [
+            176,
+            172,
+            818,
+            511
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/62a2dad07d9f0570c490c723a579d75f8f084fa40612f81285f7c68ed107b064.jpg",
+        "table_caption": [
+            "Table 6: Baselines using dropout $+ \\ell _ { 2 }$ regularization for each default flavour. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">GAME VARIANT</td><td colspan=\"2\">10M</td><td colspan=\"2\">50M</td><td colspan=\"2\">100M</td><td colspan=\"2\">BEST ACTION</td></tr><tr><td>FREEWAY</td><td>m0d0</td><td>4.6</td><td>(5.0)</td><td>25.9</td><td>(0.6)</td><td>29.0</td><td>(0.8)</td><td>23.0</td><td>(1.4)</td></tr><tr><td>HERO</td><td>m0d0</td><td>2466.5</td><td>(630.8)</td><td>6505.9</td><td>(1843.0)</td><td>12446.9</td><td>(397.4)</td><td>150.0</td><td>(0.0)</td></tr><tr><td>BREAKOUT</td><td>m0d0</td><td>6.1</td><td>(2.7)</td><td>34.1</td><td>(1.8)</td><td>66.4</td><td>(3.6)</td><td>2.3</td><td>(1.3)</td></tr><tr><td>SPACE INVADERS</td><td>m0d0</td><td>214.6</td><td>(13.8)</td><td>623.1</td><td>(16.3)</td><td>617.4</td><td>(29.6)</td><td>243.6</td><td>(95.9)</td></tr></table>",
+        "bbox": [
+            176,
+            568,
+            818,
+            657
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b1373f9ea64b48a8fc40e2f03e592f16ae564922b0eb239b01307c4c76250c5.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\" rowspan=\"2\">GAME VARIANT</td><td colspan=\"6\">BASELINE</td><td colspan=\"6\">BASELINEW/REGULARIZATION</td></tr><tr><td colspan=\"2\">10M</td><td colspan=\"2\">50M</td><td colspan=\"2\">100M</td><td colspan=\"2\">10M</td><td colspan=\"2\">50M</td><td colspan=\"2\">100M</td></tr><tr><td>FREEWAY</td><td>m0d0</td><td>3.0</td><td>(1.0)</td><td>31.4</td><td>(0.2)</td><td>32.1</td><td>(0.1)</td><td>4.6(5.0)</td><td></td><td>25.9</td><td>(0.6)</td><td>29.0</td><td>(0.8)</td></tr><tr><td>HERO</td><td>m0do</td><td>3187.8</td><td>(78.3)</td><td>9034.4</td><td>(1610.9)</td><td>13961.0</td><td>(181.9)</td><td>2466.5</td><td>(630.8)</td><td>6505.9</td><td>(1843.0)</td><td>12446.9</td><td>(397.4)</td></tr><tr><td>BREAKOUT</td><td>m0do</td><td>17.5</td><td>(2.0)</td><td>72.5</td><td>(7.7)</td><td>73.4</td><td>(13.5)</td><td>6.1</td><td>(2.7)</td><td>34.1</td><td>(1.8)</td><td>66.4</td><td>(3.6)</td></tr><tr><td>SPACE INVADERS</td><td>m0do</td><td>250.3</td><td>(16.2)</td><td>698.8</td><td>(32.2)</td><td>927.1</td><td>(85.3)</td><td>214.6</td><td>(13.8)</td><td>623.1</td><td>(16.3)</td><td>617.4</td><td>(29.6)</td></tr></table>",
+        "bbox": [
+            174,
+            723,
+            820,
+            809
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 7: Comparison of baseline results with and without regularization in the default flavour. The baseline agent with regularization was trained with dropout and $\\ell _ { 2 }$ regularization. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            858
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C POLICY EVALUATION LEARNING CURVES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            557,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We provide learning curves for evaluating a policy learned in the default flavour $( \\mathrm { m o d 0 } )$ to each subsequent flavour of that game. Each subplot are the results of evaluating the policy from a representation trained with and without regularization. ",
+        "bbox": [
+            174,
+            133,
+            826,
+            176
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            193,
+            266,
+            207
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Checkpoint of the network weights $\\theta$ were taken during training every 500, 000 frames, up to 50M frames in total. Each checkpoint was then evaluated in the target mode for 100 episodes averaged over five runs. Hyperparameters are kept consistent with the baseline experiments in Appendix B. ",
+        "bbox": [
+            174,
+            218,
+            826,
+            261
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/3cba99530b5376f020719509f7d2ca33575814279dd3657daa2501cbe9026204.jpg",
+        "image_caption": [
+            "Figure 9: Performance curves for policy evaluation results. The $\\mathbf { X }$ -axis is the number of frames before we evaluated the $\\epsilon$ -greedy policy from the default flavour on the target flavour. The y-axis is the cumulative reward the agent incurred. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            262,
+            777,
+            813
+        ],
+        "page_idx": 13
+    }
+]

parse/train/NGPmH3vbAA_/NGPmH3vbAA_.md

@@ -0,0 +1,281 @@
+# Scaling Vision with Sparse Mixture of Experts
+
+Carlos Riquelme ∗ Google Brain
+
+Joan Puigcerver \* Google Brain
+
+Basil Mustafa \* Google Brain
+
+Maxim Neumann Google Brain
+
+Rodolphe Jenatton Google Brain
+
+André Susano Pinto Google Brain
+
+Daniel Keysers Google Brain
+
+Neil Houlsby Google Brain
+
+# Abstract
+
+Sparsely-gated Mixture of Experts networks (MoEs) have demonstrated excellent scalability in Natural Language Processing. In Computer Vision, however, almost all performant networks are “dense”, that is, every input is processed by every parameter. We present a Vision MoE (V-MoE), a sparse version of the Vision Transformer, that is scalable and competitive with the largest dense networks. When applied to image recognition, V-MoE matches the performance of state-ofthe-art networks, while requiring as little as half of the compute at inference time. Further, we propose an extension to the routing algorithm that can prioritize subsets of each input across the entire batch, leading to adaptive per-image compute. This allows V-MoE to trade-off performance and compute smoothly at test-time. Finally, we demonstrate the potential of V-MoE to scale vision models, and train a 15B parameter model that attains $9 0 . 3 5 \%$ on ImageNet.
+
+# 1 Introduction
+
+Deep learning historically shows that increasing network capacity and dataset size generally improves performance. In computer vision, large models pre-trained on large datasets often achieve the state of the art [57, 50, 36, 20, 3]. This approach has had even more success in Natural Language Processing (NLP), where large pre-trained models are ubiquitous, and perform very well on many tasks [48, 18]. Text Transformers [61] are the largest models to date, some with over 100B parameters [9]. However, training and serving such models is expensive [56, 46]. This is partially because these deep networks are typically “dense”– every example is processed using every parameter –thus, scale comes at high computational cost. In contrast, conditional computation [5] aims to increase model capacity while keeping the training and inference cost roughly constant by applying only a subset of parameters to each example. In NLP, sparse Mixture of Experts (MoEs) are gaining popularity [54, 39, 22], enabling training and inference with fewer resources while unlocking trillion parameter models.
+
+In this work, we explore conditional computation for vision at scale. We introduce the Vision MoE (V-MoE), a sparse variant of the recent Vision Transformer (ViT) architecture [20] for image classification. The V-MoE replaces a subset of the dense feedforward layers in ViT with sparse MoE layers, where each image patch is “routed” to a subset of “experts” (MLPs). Due to unique failure modes and non-differentiability, routing in deep sparse models is challenging. We explore various design choices, and present an effective recipe for the pre-training and transfer of V-MoE, notably outperforming their dense counterparts. We further show that V-MoE models are remarkably flexible. The performance vs. inference-cost trade-off of already trained models can be smoothly adjusted during inference by modulating the sparsity level with respect to the input and/or the model weights. Also, we open-source our implementation and a number of V-MoE models trained on ImageNet-21k.2
+
+![](images/248567e4274ec5c9f1a7fffd719389cf4c09bbe4388e9bb269069f3eda3ebd0c.jpg)  
+Figure 1: Overview of the architecture. V-MoE is composed of $L$ ViT blocks. In some, we replace the MLP with a sparsely activated mixture of MLPs. Each MLP (the expert) is stored on a separate device, and processes a fixed number of tokens. The communication of these tokens between devices =  expert uses a capacity ratio C = 43 : the sparse MoE layer receives 12 tokens per device, but each is shown in this example, which depicts the case when $k = 1$ expert is selected per token. Here each expert has capacity for 16 ( $\textstyle \frac { 1 6 \cdot 1 } { 1 2 } = \frac { 4 } { 3 }$ ; see Section 2.4). Non-expert components of V-MoE such as routers, attention layers and normal MLP blocks are replicated identically across devices.
+
+With V-MoE, we can scale to model sizes of 15B parameters, the largest vision models to date. We match the performance of state-of-the-art dense models, while requiring fewer time to train. Alternatively, V-MoE can match the cost of ViT while achieving better performance. To help control this tradeoff, we propose Batch Prioritized Routing, a routing algorithm that repurposes model sparsity to skip the computation of some patches, reducing compute on uninformative image regions.
+
+We summarize our main contributions as follows:
+
+Vision models at scale. We present the Vision Mixture of Experts, a distributed sparsely-activated Transformer model for vision. We train models with up to $2 4 \mathrm { M o E }$ layers, 32 experts per layer, and almost 15B parameters. We show that these models can be stably trained, seamlessly used for transfer, and successfully fine-tuned with as few as 1 000 datapoints. Moreover, our largest model achieves $9 0 . 3 5 \%$ test accuracy on ImageNet when fine-tuned.
+
+Performance and inference. We show V-MoEs strongly outperform their dense counterparts on upstream, few-shot and full fine-tuning metrics in absolute terms. Moreover, at inference time, the V-MoE models can be adjusted to either (i) match the largest dense model’s performance while using as little as half the compute, or actual runtime, or (ii) significantly outperform it at the same cost.
+
+Batch Prioritized Routing. We propose a new priority-based routing algorithm that allows V-MoEs to discard the least useful patches. Thus, we devote less compute to each image. In particular, we show V-MoEs match the performance of the dense models while saving $20 \%$ of the training FLOPs. Analysis. We provide some visualization of the routing decisions, revealing patterns and conclusions which helped motivate design decisions and may further improve understanding in the field.
+
+# 2 The Vision Mixture of Experts
+
+We first describe MoEs and sparse MoEs. We then present how we apply this methodology to vision, before explaining our design choices for the routing algorithm and the implementation of V-MoEs.
+
+# 2.1 Conditional Computation with MoEs
+
+Conditional computation aims at activating different subsets of a network for different inputs [5]. A mixture-of-experts model is a specific instantiation whereby different model “experts” are responsible for different regions of the input space [31].
+
+We follow the setting of [54], who present for deep learning a mixture of experts layer with $E$ experts as $\begin{array} { r } { \mathrm { M o E } ( \mathbf { x } ) = \sum _ { i = 1 } ^ { E } g ( \mathbf { x } ) _ { i } e _ { i } ( \mathbf { x } ) } \end{array}$ where $\mathbf { x } \in \mathbb { R } ^ { D }$ is the input to the layer, $\boldsymbol { e } _ { i } : \mathbb { R } ^ { \boldsymbol { \bar { D } } } \mapsto \mathbb { R } ^ { D }$ the function computed by expert $i$ , and $g : \mathbb { R } ^ { D } \mapsto \mathbb { R } ^ { E }$ is the “routing” function which prescribes the input-conditioned weight for the experts. Both $e _ { i }$ and $g$ are parameterized by neural networks. As defined, this is still a dense network. However, if $g$ is sparse, i.e., restricted to assign only $k \ll E$ non-zero weights, then unused experts need not be computed. This unlocks super-linear scaling of the number of model parameters with respect to inference and training compute.
+
+# 2.2 MoEs for Vision
+
+We explore the application of sparsity to vision in the context of the Vision Transformer (ViT) [20]. ViT has been shown to scale well in the transfer learning setting, attaining better accuracies than CNNs with less pre-training compute. ViT processes images as a sequence of patches. An input image is first divided into a grid of equal-sized patches. These are linearly projected to the Transformer’s [61] hidden size. After adding positional embeddings, the patch embeddings (tokens) are processed by a Transformer, which consists predominately of alternating self-attention and MLP layers.
+
+The MLPs have two layers and a GeLU [29] non-linearity: $\mathrm { M L P } ( \mathbf { x } ) = \mathbf { W } _ { \mathrm { 2 } } \ \sigma _ { \mathrm { g e l u } } ( \mathbf { W } _ { \mathrm { 1 } } \mathbf { x } )$ . For Vision MoE, we replace a subset of these with MoE layers, where each expert is an MLP; see Figure 1. The experts have the same architecture $e _ { i } ( { \bf x } ) = \mathrm { M L P } _ { \theta _ { i } } ( { \bf x } )$ but with different weights $\theta _ { i } = \left( \mathbf { W } _ { 1 } ^ { i } , \mathbf { W } _ { 2 } ^ { i } \right)$ . =This follows a similar design pattern as the M4 machine translation model [39].
+
+# 2.3 Routing
+
+For each MoE layer in V-MoE, we use the routing function $g ( \mathbf { x } ) \mathbf { \Psi } = \mathrm { T O P } _ { k }$ softmax $\left( \mathbf { W } \mathbf { x } + \epsilon \right)$ , where $\mathrm { T O P } _ { k }$ is an operation that sets all elements of the vector to zero except the elements with the largest $k$ values, and $\epsilon$ is sampled independently $\epsilon \sim \mathcal { N } ( 0 , \frac { 1 } { E ^ { 2 } } )$ entry-wise. In practice, we use $k = 1$ or $k = 2$ . In the context of the Vision Transformer, $\mathbf { x }$ =is a representation of an image token at some =layer of the network. Therefore, V-MoE routes patch representations, not entire images.
+
+The difference between previous formulations [54] is that we apply $\mathrm { T O P } _ { k }$ after the softmax over experts weights [39], instead of before. This allows us to train with $k = 1$ (otherwise gradients with respect to routings are zero almost everywhere) and also performs better for $k > 1$ (see Appendix A).
+
+Finally, we add a small amount of noise with standard deviation $\frac { 1 } { E }$ to the activations $\mathbf { W } \mathbf { x }$ . We empirically found this performed well but that the setup was robust to this parameter. The noise typically altered routing decisions ${ \sim } 1 5 \%$ of the time in earlier layers, and ${ \sim } 2 { - } 3 \%$ in deeper layers.
+
+# 2.4 Expert’s Buffer Capacity
+
+During training, sparse models may favor only a small set of experts [26, 52]. This common failure mode can cause two problems. First, statistical inefficiency: in the limit of collapse to a single expert, the model is no more powerful than a dense model. Second, computational inefficiency: imbalanced assignment of items to experts may lead to a poor hardware utilization.
+
+To combat imbalance and simplify our implementation, we fix the buffer capacity of each expert (i.e. the number of tokens that each expert processes), and train our model with auxiliary losses that encourage load balancing. This is essentially the same approach as followed by [54, 39, 22]. In our case, we use slight variants of two of the auxiliary losses proposed in [54], as described in Appendix A.
+
+We define the buffer capacity of an expert $( B _ { e } )$ as a function of the number of images in the batch number of experts $( N )$ , the number of tokens per image $( E )$ , and the capacity ratio $( P )$ , the number of selected experts per token $( C )$ : $B _ { e } =$ round $\textstyle \left( { \frac { k N P C } { E } } \right)$ . $( k )$ , the total
+
+If the router assigns more than $B _ { e }$ tokens to a given expert, only $B _ { e }$ of them are processed. The remaining tokens are not entirely ‘lost’ as their information is preserved by residual connections (the top diagram of Figure 1). Also, if $k > 1$ , several experts try to process each token. Tokens are never >fully discarded. If an expert is assigned fewer than $B _ { e }$ tokens, the rest of its buffer is zero-padded.
+
+We use the capacity ratio to adjust the capacity of the experts. With $C > 1$ , a slack capacity is added to account for a potential routing imbalance. This is typically useful for fine-tuning when the new data might come from a very different distribution than during upstream training. With $C < 1$ , the router is forced to ignore some assignments. In Section 4 we propose a new algorithm that takes advantage of setting $C \ll 1$ to discard the least useful tokens and save compute during inference.
+
+# 3 Transfer Learning
+
+In this section, we first present training different variants of V-MoE on a large dataset (Section 3.2) in order to be used for Transfer Learning afterwards. The ability to easily adapt our massive models to new tasks, using a small amount of data from the new task, is extremely valuable: it allows to amortize the cost of pre-training across multiple tasks. We consider two different approaches to Transfer Learning: linear few-shot learning on fixed representations and full fine-tuning of the model.
+
+# 3.1 Models
+
+We build V-MoE on different variants of ViT [20]: ViT-S(mall), ViT-B(ase), ViT-L(arge) and ViTH(uge), the hyperparameters of which are described in Appendix B.5. There are three additional major design decisions that affect the cost (and potentially the quality) of our model:
+
+Number of MoE layers. Following [39], we place the MoEs on every other layer (we refer to these as V-MoE Every-2). In addition, we experimented with using fewer MoE layers, by placing them on the last- $\boldsymbol { n }$ even blocks (thus we dub these V-MoE Last-n). In Appendix E.1 we observe that, although using fewer MoE layers decreases the number of parameters of the model, it has typically little impact on quality and can speed-up the models significantly, since less communication overhead is incurred.
+
+Number of selected experts $k$ : The cost of our model does not depend on the total number of experts but the number of selected ones per token. Concurrent works in NLP fix $k = 1$ [22] or $k = 2$ [54, 39]. In our case, we use by default $k = 2$ (see Figure 10 in Appendix B for the exploration of different values of $k$ ), while we found the total number of experts $E = 3 2$ to be the sweet spot in our setting.
+
+Buffer capacity $C$ : As mentioned in Section 2.4, we use a fixed buffer capacity. While this is typically regarded as a downside or engineering difficulty to implement these models, we can adjust the capacity ratio to control different trade-offs. We can intentionally set it to a low ratio to save compute, using Batch Prioritized Routing (see Section 4). During upstream training, we set $C = 1 . 0 5$ by default to give a small amount of slack without increasing the cost noticeably.
+
+Note that for a given trained model, the latter two— $k$ and $C$ —can be adjusted without further training, whereas the positioning and quantity of expert layers is effectively fixed to match pre-training.
+
+# 3.2 Data
+
+We pre-train our models on JFT-300M [57], a semi-automatically noisy-labeled dataset. It has $\sim 3 0 5 \mathrm { M }$ training and 50 000 validation images, organised in a hierarchy of 18 291 classes (average 1.89 labels per image). We deduplicate it with respect to all our validation/test sets as in previous efforts [36].3
+
+Our few-shot experiments on ImageNet (i.e. ILSVRC2012) use only 1, 5, or 10 shots per class to adapt the upstream model, evaluating the resulting model on the validation set.
+
+We also fine-tuned the pre-trained models on the full training set (ca. 1M images). We report performance in a similar regime for four other datasets in Appendix B.5. Lastly, we explore the ability to fine-tune our large models in the low-data regime by evaluating them on the Visual Task Adaptation Benchmark (VTAB) [69], a diverse suite of 19 tasks with only 1 000 data points per task. As well as natural image classification, VTAB includes specialized tasks (e.g. medical or satellite imagery) and structured tasks (e.g. counting or assessing rotation/distance).
+
+# 3.3 Upstream results
+
+JFT is a multilabel dataset, so we measure model performance via precision $@ 1$ (see Appendix B.6 for details). Note that as in previous works [20], hyperparameters were tuned for transfer performance, and JFT precision could be improved at the expense of downstream tasks e.g. by reducing weight decay. Figure 2a shows the quality of different V-MoE and ViT variants with respect to total training compute and time. It shows models that select $k = 2$ experts and place MoEs in the last $n$ even blocks $\hslash = 5$ for V-MoE-H, $n = 2$ otherwise), but the best results are achieved by V-MoE-H/14 Every-2 (see Table 2, 14 is the patch size). L/16’s are trained for 7 or 14 epochs. See Appendix B.5 for all results.
+
+![](images/c9583ef8573f88b5ab52bb6cdc466f3a72778204fe31d121cb2429ff9c12592a.jpg)  
+Figure 2: JFT-300M Precision $@ 1$ and ImageNet 5-shot accuracy. Colors represent different ViT variants, markers represent either standard ViT or V-MoEs on the last $n$ even blocks. The lines represent the Pareto frontier of ViT (dashed) and V-MoE (solid) variants.
+
+![](images/40e9744cbeb03d4891d930be558dc399a68ae80031ccc224b2837d477dced43f.jpg)  
+Figure 3: ImageNet Fine-Tuning Accuracy. Colors represent different VIT variants, markers represent either standard ViT or V-MoEs on the last $n$ even blocks. Lines show the Pareto frontier of VIT (dashed) and V-MoE (solid).
+
+Table 1: VTAB. Scores and $9 5 \%$ confidence intervals for ViT and V-MoE.   
+
+<table><tr><td>ViT</td><td>V-MoE</td></tr><tr><td>L/16 76.3±0.5</td><td>77.2±0.4</td></tr><tr><td>H/14 77.6±0.2</td><td>77.8±0.4</td></tr></table>
+
+Expert models provide notable gains across all model sizes, for only a mild increase in FLOPs, establishing a new Pareto frontier (gray lines). Alternatively, we can match or improve performance of ViT models at lower cost (e.g. V-MoE-L/16 improves upon ViT-H/14). Similar conclusions hold for training time, which includes communication overhead of dispatching data across devices.
+
+# 3.4 Linear few-shot results
+
+We evaluate the quality of the representations learned using few-shot linear transfer. Given training examples from the new dataset $\{ ( X , Y ) _ { i } \}$ , we use the pre-trained model $\mathcal { M }$ to extract a fixed representation $\mathcal { M } ( x _ { i } )$ of each image. We fit a linear regression model mapping $\mathcal { M } ( x _ { i } )$ to the one-hot encoding of the target labels $Y _ { i }$ , following [20] (see [27, Chapter 5] for background).
+
+Figure 2b shows that the upstream gains are preserved under 5-shot ImageNet evaluation, considering both compute and time; in other words, the quality of the representations learned by V-MoE also outperforms ViT models when looking at a new task. Table 2 further shows the results on $\{ 1 , 1 0 \}$ -shot for some selected models, and the full detailed results are available in Appendix B.5.
+
+# 3.5 Full fine-tuning results
+
+The typically most performant approach for Transfer Learning [19] consists of replacing the upstream classification head with a new task-specific one and fine-tuning the whole model. Though one may expect that massive models like V-MoEs require special handling for fine-tuning, we broadly follow the standard fine-tuning protocol for Vision Transformers. We use the auxiliary loss during fine-tuning as well, although we observe that it is often not needed in this step, as the router is already well trained. We explore the two sets of tasks considered therein:
+
+![](images/50ec35f7ecf28e9c0130e04ba518b414285354dcdb6207d834c1ac8587a7979a.jpg)  
+Figure 4: White patches are discarded tokens in the first layer of experts, for different capacities, using Batch Prioritized Routing (Section 4.1) with a V-MoE-H/14. See Appendix D for more examples.
+
+Full data. We follow the setup of [20], except that we apply a dropout rate of 0.1 on the expert MLPs (as done in [22]), and we halve the number of fine-tuning steps for all datasets other than ImageNet. Figure 3 shows the results on ImageNet (averaged over three runs). Here, V-MoE also performs better than dense counterparts, though we suspect the fine-tuning protocol could be further improved and tailored to the sparse models. See Table 8 for all details, including results on other datasets.
+
+Low-data regime. On the VTAB benchmark, we use a similar setup and hyperparameter budget as [20] (but fine-tune with half the schedule length). Table 1 shows that, while performance is similar for V-MoE-H/14, experts provide significant gains at the ViT-L/16 level, indicating that despite the large size of these models, they can still be fine-tuned with small amounts of data and no further tricks.
+
+# 3.6 Scaling up V-MoE
+
+Finally, we test how well V-MoE can scale vision models to a very large number of parameters, while continuing to improve performance. For this, we increase the size of the model and use a larger pre-training dataset: JFT-3B is a larger version of JFT-300M, it contains almost 3B images and is noisily annotated with 30k classes. Inspired by [68], we apply the changes detailed in Appendix B.3, and train a 48-block V-MoE model, with every-2 expert placement (32 experts and $k = 2$ ), resulting in a model with 14.7B parameters, which we denote by V-MoE-15B.
+
+We successfully train V-MoE-15B, which is, as far as we are aware, the largest vision model to date. It has an impressive $8 2 . 7 8 \%$ accuracy on 5-shot ImageNet and $9 0 . 3 5 \%$ when fully fine-tuned, as shown in Appendix B.5, which also includes more details about the model. Training this model required $1 6 . 8 \mathrm { k }$ TPUv3-core-days. To contextualize this result, the current state of the art on ImageNet is Meta Pseudo-Labelling (MPL) [49]. MPL trains an EfficientNet-based model on unlabelled JFT-300M using ImageNet pseudo-labelling, achieving $9 0 . 2 \%$ while requiring $2 2 . 5 \mathrm { k }$ TPUv3-core-days.
+
+# 4 Skipping Tokens with Batch Prioritized Routing
+
+We present a new routing algorithm that allows the model to prioritize important tokens (corresp. patches). By simultaneously reducing the capacity of each expert, we can discard the least useful tokens. Intuitively, not every patch is equally important to classify a given image, e.g., most background patches can be dropped to let the model only focus on the ones with the relevant entities.
+
+# 4.1 From Vanilla Routing to Batch Prioritized Routing
+
+With the notation from Section 2, the routing function $\mathbf { X } \in \mathbb { R } ^ { N \cdot P \times D }$ . A batch contains $N$ images composed of $P$ $g$ is applied row-wise to a batch of inputs tokens each; each row of $\mathbf { X }$ corresponds to the $D$ -dimensional representation of a particular token of an image. Accordingly, $g ( \mathbf { X } ) _ { t , i } \in \mathbb { R }$ denotes the routing weight for the $t$ -th token and the $i$ -th expert.
+
+![](images/29e4a2dc24e77688a20381ca0a9a9204e095cf85146fd91910e17ceb4adf02f7.jpg)  
+Figure 5: Reducing compute with priority routing. Performance vs. inference FLOPs for large models. V-MoEs with the original vanilla routing are represented by $\bullet$ , while $\mid$ shows V-MoEs where BPR and a mix of $C \in \{ 0 . 6 , 0 . 7 , 0 . 8 \}$ and $k \in \{ 1 , 2 \}$ are used to reduce compute. ViT models shown as $\mathbf { x }$ .
+
+![](images/a7de5765086bcdc5f0b366171e8b6331b7af94a05b53a7eba6ce847b523b20bc.jpg)  
+Figure 6: Priority routing works where vanilla fails. Performance vs. inference capacity ratio for a V-MoE-H/14 model with $k = 2$ . Even for large $C$ ’s BPR outperforms vanilla; at low $C$ the difference is stark. BPR is competitive with dense by processing only $1 5 { - } 3 0 \%$ of the tokens.
+
+In all routing algorithms considered, for $i < j$ , every TOP- $i$ assignment has priority over any TOP- $j$ <assignment. The router first tries to dispatch all $i ^ { \mathrm { { t h } } }$ expert choices before assigning any $j ^ { \mathrm { t h } }$ choice4.
+
+Given the TOP- $\cdot i$ position, the default—or vanilla—routing, as used in [54, 39, 22], assigns tokens to experts as follows. It sequentially goes over the rows of $g ( \mathbf { X } )$ and assigns each token to its TOP- $i$ expert when the expert’s buffer is not full. As a result, priority is given to tokens depending on the rank of their corresponding row. While images in a batch are randomly ordered, tokens within an image follow a pre-defined fixed order. The algorithm is detailed in Algorithm 1 of Appendix C.
+
+Batch Prioritized Routing (BPR). To favour the “most important” tokens, we propose to compute a priority score $s ( \mathbf { x } )$ on each token, and sort $g ( \mathbf { X } )$ accordingly before proceeding with the allocation. We sort tokens based on their maximum routing weight, formally $s ( \mathbf { \bar { X } } ) _ { t } = \operatorname* { m a x } _ { i } g ( \mathbf { X } ) _ { t , i }$ . The sum of TOP- $k$ weights, i.e. $s ( \mathbf { X } ) _ { t } = \sum _ { i } g ( \mathbf { X } ) _ { t , i }$ =, worked equally well. These two simple approaches =outperformed other options we explored, e.g., directly parameterising and learning the function $s$ .
+
+We reuse the router outputs as a proxy for the priority of allocation. Our experiments show this preserves the performant predictive behaviour of the model, even though the router outputs primarily encode how well tokens and experts can be paired, not the token’s “importance” for the final classification task. Figure 4 visualizes token prioritisation with Batch Prioritized Routing for increasingly small capacities. Since all tokens across all images in the batch $\mathbf { X }$ compete with each other, different images may receive different amounts of compute. We summarize BPR in Algorithm 2, in Appendix C.
+
+# 4.2 Skip tokens with low capacity $C$
+
+Batch Prioritized Routing opens the door to reducing the buffer size by smartly selecting which tokens to favor. This can have a dramatic impact in the computational cost of the overall sparse model. We discuss now inference and training results with $C$ defined in Section 2.4 in the regime $C \ll 1$ .
+
+At inference time. Prioritized routing is agnostic to how the model was originally trained. Figure 6 shows the effect of reducing compute at inference time by using BPR versus vanilla routing, on a V-MoE-H/14 model trained using vanilla routing. The difference in performance between both methods is remarkable —especially for $C \leq 0 . 5$ , where the model truly starts fully dropping tokens, as $k = 2$ . Also, BPR allows the model to be competitive with the dense one even at quite low capacities. =As shown in Figure 5 for V-MoE-L/16 and V-MoE-H/14, Batch Prioritized Routing and low $C$ allow V-MoE to smoothly trade-off performance and FLOPS at inference time, quite a unique model feature. More concretely, Table 10 shows V-MoE models can beat the dense VIT-H performance by using less than half the FLOPs and less than $60 \%$ of the runtime. Conversely, we can match the inference FLOPs cost and preserve a one-point accuracy gain in ImageNet/5shot and almost three-point in JFT precision at one (Table 11). Dense models generally require less runtime for the same amount of FLOPs due to the data transfer involved in the V-MoE implementation.
+
+![](images/640deb97f79b2375225dd1090af5f85b4d407bb4a860255dc9270e4de0ca5a73.jpg)  
+Figure 7: Deeper routing decisions correlate with image classes. We show $4 ~ \mathrm { M o E }$ layers of a V-MoE-H/14. The $x$ -axis corresponds to the 32 experts in a layer. The $y$ -axis are the 1 000 ImageNet classes; orderings for both axes are different across plots. For each pair (expert $e$ , class $c$ ) we show the average routing weight for the tokens corresponding to all images with class $c$ for that particular expert $e$ . Figure 29 includes all the remaining layers; see Appendix E.2 for details.
+
+At training time. Batch Prioritized Routing can also be leveraged during training. In Appendix C we show how expert models with max-weight routing can match the dense performance while saving around $20 \%$ of the total training FLOPs, and strongly outperform vanilla with a similar FLOP budget.
+
+# 5 Model Analysis
+
+Although large-scale sparse MoEs have led to strong performance [22, 39, 54], little is known and understood about how the internals of those complex models work. We argue that such exploratory experiments can inform the design of new algorithms. In this section, we provide the first such analysis at this scale, which guided the development of the algorithms presented in the paper.
+
+Specialized experts. Intuitively, routers should learn to distribute images across experts based on their similarity. For instance, if the model had three experts, and the task mainly involved three categories—say animals, cars, and buildings—one would expect an expert to specialize in each of those. We test this intuition, with some obvious caveats: (a) experts are placed at several network depths, (b) $k$ experts are combined, and (c) routing happens at the token rather than the image level.
+
+Figure 7 illustrates how many images of a given ImageNet class use each expert. The plots were produced by running a fine-tuned V-MoE-H Every-2 model. Interestingly, we saw similar patterns with the upstream model without fine-tuning. Experts specialize in discriminating between small sets of classes (those primarily routed through the expert). In earlier MoE layers we do not observe this. Experts may instead focus on aspects common to all classes (background, basic shapes, colours) - for example, Figure 30 (Appendix E) shows correlations with patch location in earlier layers.
+
+The value of routers. After training a sparse MoE, it is natural to study the usefulness of the learned routers, in the light of several pitfalls. For example, the routers may just act as a load balancer if experts end up learning very similar functions, or the routers may simply choose poor assignments. In Appendix E.1, we replace, after training, one router at a time with a uniformly random router. The models are robust to early routing changes while more sensitive to the decisions in the last layers.
+
+Routing weights distributions. We analyse the router outputs in Appendix E.3, and observe the distribution of selected weights varies wildly across different mixture of experts layers.
+
+Changing $k$ at inference time. We have observed expert models are remarkably flexible. Somewhat surprisingly, sparse models are fairly robust to mismatches between their training and inference configurations. In Appendix E.4, we explore the effect of training with some original value of $k$ while applying the model at inference time with a different $\boldsymbol { k } ^ { \prime } \neq \boldsymbol { k }$ . This can be handy to control (decrease ≠or increase) the amount of FLOPs per input in a particular production system.
+
+# 6 Related work
+
+Conditional Computation. To grow the number of model parameters without proportionally increasing the computational cost, conditional computation [5, 15, 12] only activates some relevant parts of the model in an input-dependent fashion, like in decision trees [7]. In deep learning, the activation of portions of the model can use stochastic neurons [6] or reinforcement learning [4, 17, 53].
+
+Mixture of Experts. MoEs [31, 34, 10, 66] combine the outputs of sub-models known as experts via a router in an input-dependent way. MoEs have successfully used this form of conditional computation in a range of applications [23, 30, 58, 55, 67]. An input can select either all experts [21] or only a sparse mixture thereof as in recent massive language models [54, 39, 22].
+
+MoEs for Language. MoEs have recently scaled language models up to trillions of parameters. Our approach is inspired by [54] who proposed a top- $k$ gating in LSTMs, with auxiliary losses ensuring the expert balance [26]. [39] further scaled up this approach for transformers, showing strong gains for neural machine translation. With over one trillion parameters and one expert per input, [22] sped up pre-training compared to a dense baseline [50] while showing gains thanks to transfer and distillation. [40] alternatively enforced a balanced routing by solving a linear assignment problem.
+
+MoEs for Vision. For computer vision, previous work on MoEs [21, 2, 25, 1, 63, 47, 64] focused on architectures whose scale is considerably smaller than that of both language models and our model. In DeepMoE [63], the “experts” are the channels of convolutional layers that are adaptively selected by a multi-headed sparse gate. This is similar to [64] where the kernels of convolutional layers are activated on a per-example basis. Other approaches use shallow MoEs, learning a single router, either disjointly [25] or jointly [2], together with CNNs playing the role of experts. [1] further have a cost-aware procedure to bias the assignments of inputs across the experts. Unlike shallow MoEs, we operate with up to several tens of routing decisions per token along the depth of the model. Scaling up routing depth was marked as a major challenge in [51], which we successfully tackle in our work.
+
+# 7 Conclusions
+
+We have employed sparse conditional computation to train some of the largest vision models to date, showing significant improvements in representation learning and transfer learning. Alongside V-MoE, we have proposed Batch Prioritized Routing, which allows successful repurposing of model sparsity to introduce sparsity with respect to the inputs. This can be done without further adapting the model, allowing the re-use of trained models with sparse conditional computation.
+
+This has interesting connotations for recent work in NLP using sparse models; recent analysis shows model sparsity is the most promising way to reduce model $\mathrm { C O } _ { 2 }$ emissions [46] and that $90 \%$ of the footprint stems from inference costs — we present an algorithm which takes the most efficient models and makes them even more efficient without any further model adaptation.
+
+This is just the beginning of conditional computation at scale for vision; extensions include scaling up the expert count, reducing dependency on data and improving transfer of the representations produced by sparse models. Directions relating to heterogeneous expert architectures and conditional variable-length routes should also be fruitful. We expect increasing importance of sparse model scaling, especially in data rich domains such as large scale multimodal or video modeling.
+
+# Acknowledgments and Disclosure of Funding
+
+We thank Alex Kolesnikov, Lucas Beyer and Xiaohua Zhai for providing continuous help and details about scaling ViT models; Alexey Dosovitskiy, who provided some of the pre-trained ViT models; Ilya Tolstikhin, who suggested placing experts only in the last layers; Josip Djolonga for his early review of the manuscript; Dmitry Lepikhin for providing details about the original GShard implementation; Barret Zoph and Liam Fedus for insightful comments and feedback; James Bradbury, Blake Hechtman and the rest of JAX and TPU team who helped us running our models efficiently, and many others from Google Brain for their support.
+
+# References
+
+[1] A. Abbas and Y. Andreopoulos. Biased mixtures of experts: Enabling computer vision inference under data transfer limitations. IEEE Trans. Image Processing, 29:7656–7667, 2020.   
+[2] K. Ahmed, M. H. Baig, and L. Torresani. Network of experts for large-scale image categorization. In ECCV, 2016.   
+[3] A. Arnab, M. Dehghani, G. Heigold, C. Sun, M. Luciˇ c, and C. Schmid. ViViT: A video vision ´ transformer. arXiv preprint arXiv:2103.15691, 2021.   
+[4] E. Bengio, P.-L. Bacon, J. Pineau, and D. Precup. Conditional computation in neural networks for faster models. arXiv preprint arXiv:1511.06297, 2015.   
+[5] Y. Bengio. Deep learning of representations: Looking forward. In International Conference on Statistical Language and Speech Processing, pages 1–37, 2013.   
+[6] Y. Bengio, N. Léonard, and A. Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.   
+[7] L. Breiman, J. Friedman, C. J. Stone, and R. A. Olshen. Classification and regression trees. CRC press, 1984.   
+[8] A. Brock, S. De, S. L. Smith, and K. Simonyan. High-performance large-scale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   
+[9] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   
+[10] K. Chen, L. Xu, and H. Chi. Improved learning algorithms for mixture of experts in multiclass classification. Neural networks, 12(9):1229–1252, 1999.   
+[11] G. Cheng, J. Han, and X. Lu. Remote sensing image scene classification: Benchmark and state of the art. Proceedings of the IEEE, 105(10):1865–1883, Oct 2017.   
+[12] K. Cho and Y. Bengio. Exponentially increasing the capacity-to-computation ratio for conditional computation in deep learning. arXiv preprint arXiv:1406.7362, 2014.   
+[13] M. Cimpoi, S. Maji, I. Kokkinos, S. Mohamed, and A. Vedaldi. Describing textures in the wild. In Computer Vision and Pattern Recognition (CVPR), 2014.   
+[14] E. D. Cubuk, B. Zoph, J. Shlens, and Q. Le. Randaugment: Practical automated data augmentation with a reduced search space. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, 2020.   
+[15] A. Davis and I. Arel. Low-rank approximations for conditional feedforward computation in deep neural networks. arXiv preprint arXiv:1312.4461, 2013.   
+[16] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.   
+[17] L. Denoyer and P. Gallinari. Deep sequential neural network. arXiv preprint arXiv:1410.0510, 2014.   
+[18] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019.   
+[19] G. S. Dhillon, P. Chaudhari, A. Ravichandran, and S. Soatto. A baseline for few-shot image classification. In ICLR, 2020.   
+[20] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR, 2021.   
+[21] D. Eigen, M. Ranzato, and I. Sutskever. Learning factored representations in a deep mixture of experts. arXiv preprint arXiv:1312.4314, 2013.   
+[22] W. Fedus, B. Zoph, and N. Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. arXiv preprint arXiv:2101.03961, 2021.   
+[23] D. M. Gavrila and S. Munder. Multi-cue pedestrian detection and tracking from a moving vehicle. International journal of computer vision, 73(1):41–59, 2007.   
+[24] A. Geiger, P. Lenz, and R. Urtasun. Are we ready for autonomous driving? The KITTI vision benchmark suite. In Computer Vision and Pattern Recognition (CVPR), 2012.   
+[25] S. Gross, M. Ranzato, and A. Szlam. Hard mixtures of experts for large scale weakly supervised vision. In CVPR, 2017.   
+[26] J. V. Hansen. Combining predictors: comparison of five meta machine learning methods. Information Sciences, 119(1-2):91–105, 1999.   
+[27] T. Hastie, R. Tibshirani, and J. Friedman. The elements of statistical learning: data mining, inference, and prediction. Springer, 2017.   
+[28] P. Helber, B. Bischke, A. Dengel, and D. Borth. EuroSAT: A novel dataset and deep learning benchmark for land use and land cover classification. IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing, 12(7):2217–2226, 2019.   
+[29] D. Hendrycks and K. Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415, 2016.   
+[30] Y. H. Hu, S. Palreddy, and W. J. Tompkins. A patient-adaptable ECG beat classifier using a mixture of experts approach. IEEE Trans. Biomedical Engineering, 44(9):891–900, 1997.   
+[31] R. A. Jacobs, M. I. Jordan, S. J. Nowlan, and G. E. Hinton. Adaptive mixtures of local experts. Neural Computation, 3(1):79–87, 1991.   
+[32] Z. Jiang, Q. Hou, L. Yuan, D. Zhou, X. Jin, A. Wang, and J. Feng. Token labeling: Training a $8 5 . 5 \%$ top-1 accuracy vision transformer with 56m parameters on imagenet. arXiv preprint arXiv:2104.10858, 2021.   
+[33] J. Johnson, B. Hariharan, L. van der Maaten, F.-F. Li, C. Lawrence Zitnick, and R. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In Computer Vision and Pattern Recognition (CVPR), 2017.   
+[34] M. I. Jordan and R. A. Jacobs. Hierarchical mixtures of experts and the EM algorithm. Neural computation, 6(2):181–214, 1994.   
+[35] Kaggle and EyePacs. Kaggle diabetic retinopathy detection, 2015.   
+[36] A. Kolesnikov, L. Beyer, X. Zhai, J. Puigcerver, J. Yung, S. Gelly, and N. Houlsby. Big transfer (BiT): General visual representation learning. In ECCV, 2020.   
+[37] A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   
+[38] Y. LeCun, F. J. Huang, and L. Bottou. Learning methods for generic object recognition with invariance to pose and lighting. In Computer Vision and Pattern Recognition (CVPR), 2004.   
+[39] D. Lepikhin, H. Lee, Y. Xu, D. Chen, O. Firat, Y. Huang, M. Krikun, N. Shazeer, and Z. Chen. GShard: Scaling giant models with conditional computation and automatic sharding. In ICLR, 2021.   
+[40] M. Lewis, S. Bhosale, T. Dettmers, N. Goyal, and L. Zettlemoyer. Base layers: Simplifying training of large, sparse models. arXiv preprint arXiv:2103.16716, 2021.   
+[41] F.-F. Li, R. Fergus, and P. Perona. Learning generative visual models from few training examples: An incremental Bayesian approach tested on 101 object categories. Computer Vision and Pattern Recognition Workshop, 2004.   
+[42] L. Matthey, I. Higgins, D. Hassabis, and A. Lerchner. dSprites: Disentanglement testing sprites dataset, 2017.   
+[43] Y. Netzer, T. Wang, A. Coates, A. Bissacco, and A. Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011.   
+[44] M.-E. Nilsback and A. Zisserman. Automated flower classification over a large number of classes. In Sixth Indian Conf. on Computer Vision, Graphics & Image Processing, 2008.   
+[45] O. M. Parkhi, A. Vedaldi, A. Zisserman, and C. Jawahar. Cats and dogs. In CVPR, 2012.   
+[46] D. Patterson, J. Gonzalez, Q. Le, C. Liang, L.-M. Munguia, D. Rothchild, D. So, M. Texier, and J. Dean. Carbon emissions and large neural network training. arXiv preprint arXiv:2104.10350, 2021.   
+[47] S. Pavlitskaya, C. Hubschneider, M. Weber, R. Moritz, F. Huger, P. Schlicht, and M. Zollner. Using mixture of expert models to gain insights into semantic segmentation. In CVPR Workshops, 2020.   
+[48] M. E. Peters, M. Neumann, M. Iyyer, M. Gardner, C. Clark, K. Lee, and L. Zettlemoyer. Deep contextualized word representations. In NAACL, 2018.   
+[49] H. Pham, Z. Dai, Q. Xie, M.-T. Luong, and Q. V. Le. Meta pseudo labels. arXiv preprint arXiv:2003.10580, 2020.   
+[50] C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y. Zhou, W. Li, and P. J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019.   
+[51] P. Ramachandran and Q. V. Le. Diversity and depth in per-example routing models. In ICLR, 2018.   
+[52] C. Rosenbaum, I. Cases, M. Riemer, and T. Klinger. Routing networks and the challenges of modular and compositional computation. arXiv preprint arXiv:1904.12774, 2019.   
+[53] C. Rosenbaum, T. Klinger, and M. Riemer. Routing networks: Adaptive selection of non-linear functions for multi-task learning. arXiv preprint arXiv:1711.01239, 2017.   
+[54] N. Shazeer, A. Mirhoseini, K. Maziarz, A. Davis, Q. Le, G. Hinton, and J. Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. In ICLR, 2017.   
+[55] C. Sminchisescu, A. Kanaujia, Z. Li, and D. Metaxas. Learning to reconstruct 3D human motion from Bayesian mixtures of experts. A probabilistic discriminative approach. Dept. Comput. Sci., Univ. Toronto, Tech. Rep. CSRG-502, 2004.   
+[56] E. Strubell, A. Ganesh, and A. McCallum. Energy and policy considerations for deep learning in NLP. arXiv preprint arXiv:1906.02243, 2019.   
+[57] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In ICCV, 2017.   
+[58] J. Tani and S. Nolfi. Learning to perceive the world as articulated: an approach for hierarchical learning in sensory-motor systems. Neural Networks, 12(7-8):1131–1141, 1999.   
+[59] H. Touvron, M. Cord, M. Douze, F. Massa, A. Sablayrolles, and H. Jégou. Training data-efficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   
+[60] H. Touvron, M. Cord, A. Sablayrolles, G. Synnaeve, and H. Jégou. Going deeper with image transformers. arXiv preprint arXiv:2103.17239, 2021.   
+[61] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In NeurIPS, 2017.   
+[62] B. S. Veeling, J. Linmans, J. Winkens, T. Cohen, and M. Welling. Rotation equivariant CNNs for digital pathology. In Medical Image Computing and Computer Assisted Intervention (MICCAI), 2018.   
+[63] X. Wang, F. Yu, L. Dunlap, Y.-A. Ma, R. Wang, A. Mirhoseini, T. Darrell, and J. E. Gonzalez. Deep mixture of experts via shallow embedding. In Uncertainty in Artificial Intelligence, 2020.   
+[64] B. Yang, G. Bender, Q. V. Le, and J. Ngiam. Condconv: Conditionally parameterized convolutions for efficient inference. arXiv preprint arXiv:1904.04971, 2019.   
+[65] L. Yuan, Y. Chen, T. Wang, W. Yu, Y. Shi, F. E. Tay, J. Feng, and S. Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. arXiv preprint arXiv:2101.11986, 2021.   
+[66] S. E. Yuksel, J. N. Wilson, and P. D. Gader. Twenty years of mixture of experts. IEEE transactions on neural networks and learning systems, 23(8):1177–1193, 2012.   
+[67] A. J. Zeevi, R. Meir, and R. J. Adler. Time series prediction using mixtures of experts. In NeurIPS, 1997.   
+[68] X. Zhai, A. Kolesnikov, N. Houlsby, and L. Beyer. Scaling vision transformers, 2021.   
+[69] X. Zhai, J. Puigcerver, A. Kolesnikov, P. Ruyssen, C. Riquelme, M. Lucic, J. Djolonga, A. S. Pinto, M. Neumann, A. Dosovitskiy, L. Beyer, O. Bachem, M. Tschannen, M. Michalski, O. Bousquet, S. Gelly, and N. Houlsby. A large-scale study of representation learning with the visual task adaptation benchmark. arXiv preprint arXiv:1910.04867, 2019.   
+[70] X. Zhai, J. Puigcerver, A. Kolesnikov, P. Ruyssen, C. Riquelme, M. Lucic, J. Djolonga, A. S. Pinto, M. Neumann, A. Dosovitskiy, et al. A large-scale study of representation learning with the visual task adaptation benchmark. arXiv preprint arXiv:1910.04867, 2019.

parse/train/NGPmH3vbAA_/NGPmH3vbAA__content_list.json

@@ -0,0 +1,1257 @@
+[
+    {
+        "type": "text",
+        "text": "Scaling Vision with Sparse Mixture of Experts ",
+        "text_level": 1,
+        "bbox": [
+            217,
+            122,
+            779,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Carlos Riquelme ∗ Google Brain ",
+        "bbox": [
+            207,
+            200,
+            334,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Joan Puigcerver \\* Google Brain ",
+        "bbox": [
+            364,
+            202,
+            490,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Basil Mustafa \\* Google Brain ",
+        "bbox": [
+            526,
+            200,
+            635,
+            228
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Maxim Neumann Google Brain ",
+        "bbox": [
+            671,
+            202,
+            795,
+            229
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rodolphe Jenatton Google Brain ",
+        "bbox": [
+            204,
+            251,
+            339,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "André Susano Pinto Google Brain ",
+        "bbox": [
+            375,
+            250,
+            517,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Daniel Keysers Google Brain ",
+        "bbox": [
+            553,
+            251,
+            663,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neil Houlsby Google Brain ",
+        "bbox": [
+            699,
+            250,
+            792,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            314,
+            535,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Sparsely-gated Mixture of Experts networks (MoEs) have demonstrated excellent scalability in Natural Language Processing. In Computer Vision, however, almost all performant networks are “dense”, that is, every input is processed by every parameter. We present a Vision MoE (V-MoE), a sparse version of the Vision Transformer, that is scalable and competitive with the largest dense networks. When applied to image recognition, V-MoE matches the performance of state-ofthe-art networks, while requiring as little as half of the compute at inference time. Further, we propose an extension to the routing algorithm that can prioritize subsets of each input across the entire batch, leading to adaptive per-image compute. This allows V-MoE to trade-off performance and compute smoothly at test-time. Finally, we demonstrate the potential of V-MoE to scale vision models, and train a 15B parameter model that attains $9 0 . 3 5 \\%$ on ImageNet. ",
+        "bbox": [
+            232,
+            345,
+            766,
+            511
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            535,
+            310,
+            553
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning historically shows that increasing network capacity and dataset size generally improves performance. In computer vision, large models pre-trained on large datasets often achieve the state of the art [57, 50, 36, 20, 3]. This approach has had even more success in Natural Language Processing (NLP), where large pre-trained models are ubiquitous, and perform very well on many tasks [48, 18]. Text Transformers [61] are the largest models to date, some with over 100B parameters [9]. However, training and serving such models is expensive [56, 46]. This is partially because these deep networks are typically “dense”– every example is processed using every parameter –thus, scale comes at high computational cost. In contrast, conditional computation [5] aims to increase model capacity while keeping the training and inference cost roughly constant by applying only a subset of parameters to each example. In NLP, sparse Mixture of Experts (MoEs) are gaining popularity [54, 39, 22], enabling training and inference with fewer resources while unlocking trillion parameter models. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            719
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we explore conditional computation for vision at scale. We introduce the Vision MoE (V-MoE), a sparse variant of the recent Vision Transformer (ViT) architecture [20] for image classification. The V-MoE replaces a subset of the dense feedforward layers in ViT with sparse MoE layers, where each image patch is “routed” to a subset of “experts” (MLPs). Due to unique failure modes and non-differentiability, routing in deep sparse models is challenging. We explore various design choices, and present an effective recipe for the pre-training and transfer of V-MoE, notably outperforming their dense counterparts. We further show that V-MoE models are remarkably flexible. The performance vs. inference-cost trade-off of already trained models can be smoothly adjusted during inference by modulating the sparsity level with respect to the input and/or the model weights. Also, we open-source our implementation and a number of V-MoE models trained on ImageNet-21k.2 ",
+        "bbox": [
+            174,
+            724,
+            825,
+            863
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/248567e4274ec5c9f1a7fffd719389cf4c09bbe4388e9bb269069f3eda3ebd0c.jpg",
+        "image_caption": [
+            "Figure 1: Overview of the architecture. V-MoE is composed of $L$ ViT blocks. In some, we replace the MLP with a sparsely activated mixture of MLPs. Each MLP (the expert) is stored on a separate device, and processes a fixed number of tokens. The communication of these tokens between devices =  expert uses a capacity ratio C = 43 : the sparse MoE layer receives 12 tokens per device, but each is shown in this example, which depicts the case when $k = 1$ expert is selected per token. Here each expert has capacity for 16 ( $\\textstyle \\frac { 1 6 \\cdot 1 } { 1 2 } = \\frac { 4 } { 3 }$ ; see Section 2.4). Non-expert components of V-MoE such as routers, attention layers and normal MLP blocks are replicated identically across devices. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            823,
+            289
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "With V-MoE, we can scale to model sizes of 15B parameters, the largest vision models to date. We match the performance of state-of-the-art dense models, while requiring fewer time to train. Alternatively, V-MoE can match the cost of ViT while achieving better performance. To help control this tradeoff, we propose Batch Prioritized Routing, a routing algorithm that repurposes model sparsity to skip the computation of some patches, reducing compute on uninformative image regions. ",
+        "bbox": [
+            173,
+            428,
+            826,
+            497
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We summarize our main contributions as follows: ",
+        "bbox": [
+            176,
+            503,
+            496,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Vision models at scale. We present the Vision Mixture of Experts, a distributed sparsely-activated Transformer model for vision. We train models with up to $2 4 \\mathrm { M o E }$ layers, 32 experts per layer, and almost 15B parameters. We show that these models can be stably trained, seamlessly used for transfer, and successfully fine-tuned with as few as 1 000 datapoints. Moreover, our largest model achieves $9 0 . 3 5 \\%$ test accuracy on ImageNet when fine-tuned. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Performance and inference. We show V-MoEs strongly outperform their dense counterparts on upstream, few-shot and full fine-tuning metrics in absolute terms. Moreover, at inference time, the V-MoE models can be adjusted to either (i) match the largest dense model’s performance while using as little as half the compute, or actual runtime, or (ii) significantly outperform it at the same cost. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            642
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Batch Prioritized Routing. We propose a new priority-based routing algorithm that allows V-MoEs to discard the least useful patches. Thus, we devote less compute to each image. In particular, we show V-MoEs match the performance of the dense models while saving $20 \\%$ of the training FLOPs. Analysis. We provide some visualization of the routing decisions, revealing patterns and conclusions which helped motivate design decisions and may further improve understanding in the field. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 The Vision Mixture of Experts ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            460,
+            748
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first describe MoEs and sparse MoEs. We then present how we apply this methodology to vision, before explaining our design choices for the routing algorithm and the implementation of V-MoEs. ",
+        "bbox": [
+            174,
+            762,
+            826,
+            791
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Conditional Computation with MoEs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            472,
+            823
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Conditional computation aims at activating different subsets of a network for different inputs [5]. A mixture-of-experts model is a specific instantiation whereby different model “experts” are responsible for different regions of the input space [31]. ",
+        "bbox": [
+            176,
+            833,
+            825,
+            876
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We follow the setting of [54], who present for deep learning a mixture of experts layer with $E$ experts as $\\begin{array} { r } { \\mathrm { M o E } ( \\mathbf { x } ) = \\sum _ { i = 1 } ^ { E } g ( \\mathbf { x } ) _ { i } e _ { i } ( \\mathbf { x } ) } \\end{array}$ where $\\mathbf { x } \\in \\mathbb { R } ^ { D }$ is the input to the layer, $\\boldsymbol { e } _ { i } : \\mathbb { R } ^ { \\boldsymbol { \\bar { D } } } \\mapsto \\mathbb { R } ^ { D }$ the function computed by expert $i$ , and $g : \\mathbb { R } ^ { D } \\mapsto \\mathbb { R } ^ { E }$ is the “routing” function which prescribes the input-conditioned weight for the experts. Both $e _ { i }$ and $g$ are parameterized by neural networks. As defined, this is still a dense network. However, if $g$ is sparse, i.e., restricted to assign only $k \\ll E$ non-zero weights, then unused experts need not be computed. This unlocks super-linear scaling of the number of model parameters with respect to inference and training compute. ",
+        "bbox": [
+            174,
+            881,
+            821,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            89,
+            825,
+            161
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 MoEs for Vision ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            179,
+            326,
+            193
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We explore the application of sparsity to vision in the context of the Vision Transformer (ViT) [20]. ViT has been shown to scale well in the transfer learning setting, attaining better accuracies than CNNs with less pre-training compute. ViT processes images as a sequence of patches. An input image is first divided into a grid of equal-sized patches. These are linearly projected to the Transformer’s [61] hidden size. After adding positional embeddings, the patch embeddings (tokens) are processed by a Transformer, which consists predominately of alternating self-attention and MLP layers. ",
+        "bbox": [
+            174,
+            204,
+            825,
+            289
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The MLPs have two layers and a GeLU [29] non-linearity: $\\mathrm { M L P } ( \\mathbf { x } ) = \\mathbf { W } _ { \\mathrm { 2 } } \\ \\sigma _ { \\mathrm { g e l u } } ( \\mathbf { W } _ { \\mathrm { 1 } } \\mathbf { x } )$ . For Vision MoE, we replace a subset of these with MoE layers, where each expert is an MLP; see Figure 1. The experts have the same architecture $e _ { i } ( { \\bf x } ) = \\mathrm { M L P } _ { \\theta _ { i } } ( { \\bf x } )$ but with different weights $\\theta _ { i } = \\left( \\mathbf { W } _ { 1 } ^ { i } , \\mathbf { W } _ { 2 } ^ { i } \\right)$ . =This follows a similar design pattern as the M4 machine translation model [39]. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            351
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 Routing ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            368,
+            269,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For each MoE layer in V-MoE, we use the routing function $g ( \\mathbf { x } ) \\mathbf { \\Psi } = \\mathrm { T O P } _ { k }$ softmax $\\left( \\mathbf { W } \\mathbf { x } + \\epsilon \\right)$ , where $\\mathrm { T O P } _ { k }$ is an operation that sets all elements of the vector to zero except the elements with the largest $k$ values, and $\\epsilon$ is sampled independently $\\epsilon \\sim \\mathcal { N } ( 0 , \\frac { 1 } { E ^ { 2 } } )$ entry-wise. In practice, we use $k = 1$ or $k = 2$ . In the context of the Vision Transformer, $\\mathbf { x }$ =is a representation of an image token at some =layer of the network. Therefore, V-MoE routes patch representations, not entire images. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The difference between previous formulations [54] is that we apply $\\mathrm { T O P } _ { k }$ after the softmax over experts weights [39], instead of before. This allows us to train with $k = 1$ (otherwise gradients with respect to routings are zero almost everywhere) and also performs better for $k > 1$ (see Appendix A). ",
+        "bbox": [
+            174,
+            470,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Finally, we add a small amount of noise with standard deviation $\\frac { 1 } { E }$ to the activations $\\mathbf { W } \\mathbf { x }$ . We empirically found this performed well but that the setup was robust to this parameter. The noise typically altered routing decisions ${ \\sim } 1 5 \\%$ of the time in earlier layers, and ${ \\sim } 2 { - } 3 \\%$ in deeper layers. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 Expert’s Buffer Capacity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            387,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "During training, sparse models may favor only a small set of experts [26, 52]. This common failure mode can cause two problems. First, statistical inefficiency: in the limit of collapse to a single expert, the model is no more powerful than a dense model. Second, computational inefficiency: imbalanced assignment of items to experts may lead to a poor hardware utilization. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            661
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To combat imbalance and simplify our implementation, we fix the buffer capacity of each expert (i.e. the number of tokens that each expert processes), and train our model with auxiliary losses that encourage load balancing. This is essentially the same approach as followed by [54, 39, 22]. In our case, we use slight variants of two of the auxiliary losses proposed in [54], as described in Appendix A. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We define the buffer capacity of an expert $( B _ { e } )$ as a function of the number of images in the batch number of experts $( N )$ , the number of tokens per image $( E )$ , and the capacity ratio $( P )$ , the number of selected experts per token $( C )$ : $B _ { e } =$ round $\\textstyle \\left( { \\frac { k N P C } { E } } \\right)$ . $( k )$ , the total ",
+        "bbox": [
+            174,
+            729,
+            825,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If the router assigns more than $B _ { e }$ tokens to a given expert, only $B _ { e }$ of them are processed. The remaining tokens are not entirely ‘lost’ as their information is preserved by residual connections (the top diagram of Figure 1). Also, if $k > 1$ , several experts try to process each token. Tokens are never >fully discarded. If an expert is assigned fewer than $B _ { e }$ tokens, the rest of its buffer is zero-padded. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use the capacity ratio to adjust the capacity of the experts. With $C > 1$ , a slack capacity is added to account for a potential routing imbalance. This is typically useful for fine-tuning when the new data might come from a very different distribution than during upstream training. With $C < 1$ , the router is forced to ignore some assignments. In Section 4 we propose a new algorithm that takes advantage of setting $C \\ll 1$ to discard the least useful tokens and save compute during inference. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Transfer Learning ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            359,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first present training different variants of V-MoE on a large dataset (Section 3.2) in order to be used for Transfer Learning afterwards. The ability to easily adapt our massive models to new tasks, using a small amount of data from the new task, is extremely valuable: it allows to amortize the cost of pre-training across multiple tasks. We consider two different approaches to Transfer Learning: linear few-shot learning on fixed representations and full fine-tuning of the model. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            190
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Models ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            207,
+            264,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We build V-MoE on different variants of ViT [20]: ViT-S(mall), ViT-B(ase), ViT-L(arge) and ViTH(uge), the hyperparameters of which are described in Appendix B.5. There are three additional major design decisions that affect the cost (and potentially the quality) of our model: ",
+        "bbox": [
+            174,
+            233,
+            825,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Number of MoE layers. Following [39], we place the MoEs on every other layer (we refer to these as V-MoE Every-2). In addition, we experimented with using fewer MoE layers, by placing them on the last- $\\boldsymbol { n }$ even blocks (thus we dub these V-MoE Last-n). In Appendix E.1 we observe that, although using fewer MoE layers decreases the number of parameters of the model, it has typically little impact on quality and can speed-up the models significantly, since less communication overhead is incurred. ",
+        "bbox": [
+            174,
+            281,
+            825,
+            352
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Number of selected experts $k$ : The cost of our model does not depend on the total number of experts but the number of selected ones per token. Concurrent works in NLP fix $k = 1$ [22] or $k = 2$ [54, 39]. In our case, we use by default $k = 2$ (see Figure 10 in Appendix B for the exploration of different values of $k$ ), while we found the total number of experts $E = 3 2$ to be the sweet spot in our setting. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Buffer capacity $C$ : As mentioned in Section 2.4, we use a fixed buffer capacity. While this is typically regarded as a downside or engineering difficulty to implement these models, we can adjust the capacity ratio to control different trade-offs. We can intentionally set it to a low ratio to save compute, using Batch Prioritized Routing (see Section 4). During upstream training, we set $C = 1 . 0 5$ by default to give a small amount of slack without increasing the cost noticeably. ",
+        "bbox": [
+            174,
+            419,
+            825,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that for a given trained model, the latter two— $k$ and $C$ —can be adjusted without further training, whereas the positioning and quantity of expert layers is effectively fixed to match pre-training. ",
+        "bbox": [
+            176,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Data ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            540,
+            246,
+            555
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We pre-train our models on JFT-300M [57], a semi-automatically noisy-labeled dataset. It has $\\sim 3 0 5 \\mathrm { M }$ training and 50 000 validation images, organised in a hierarchy of 18 291 classes (average 1.89 labels per image). We deduplicate it with respect to all our validation/test sets as in previous efforts [36].3 ",
+        "bbox": [
+            176,
+            566,
+            823,
+            608
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our few-shot experiments on ImageNet (i.e. ILSVRC2012) use only 1, 5, or 10 shots per class to adapt the upstream model, evaluating the resulting model on the validation set. ",
+        "bbox": [
+            173,
+            614,
+            821,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We also fine-tuned the pre-trained models on the full training set (ca. 1M images). We report performance in a similar regime for four other datasets in Appendix B.5. Lastly, we explore the ability to fine-tune our large models in the low-data regime by evaluating them on the Visual Task Adaptation Benchmark (VTAB) [69], a diverse suite of 19 tasks with only 1 000 data points per task. As well as natural image classification, VTAB includes specialized tasks (e.g. medical or satellite imagery) and structured tasks (e.g. counting or assessing rotation/distance). ",
+        "bbox": [
+            174,
+            650,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Upstream results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            331,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "JFT is a multilabel dataset, so we measure model performance via precision $@ 1$ (see Appendix B.6 for details). Note that as in previous works [20], hyperparameters were tuned for transfer performance, and JFT precision could be improved at the expense of downstream tasks e.g. by reducing weight decay. Figure 2a shows the quality of different V-MoE and ViT variants with respect to total training compute and time. It shows models that select $k = 2$ experts and place MoEs in the last $n$ even blocks $\\hslash = 5$ for V-MoE-H, $n = 2$ otherwise), but the best results are achieved by V-MoE-H/14 Every-2 (see Table 2, 14 is the patch size). L/16’s are trained for 7 or 14 epochs. See Appendix B.5 for all results. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9583ef8573f88b5ab52bb6cdc466f3a72778204fe31d121cb2429ff9c12592a.jpg",
+        "image_caption": [
+            "Figure 2: JFT-300M Precision $@ 1$ and ImageNet 5-shot accuracy. Colors represent different ViT variants, markers represent either standard ViT or V-MoEs on the last $n$ even blocks. The lines represent the Pareto frontier of ViT (dashed) and V-MoE (solid) variants. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            88,
+            812,
+            290
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/40e9744cbeb03d4891d930be558dc399a68ae80031ccc224b2837d477dced43f.jpg",
+        "image_caption": [
+            "Figure 3: ImageNet Fine-Tuning Accuracy. Colors represent different VIT variants, markers represent either standard ViT or V-MoEs on the last $n$ even blocks. Lines show the Pareto frontier of VIT (dashed) and V-MoE (solid). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            359,
+            485,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f4640af04c8dd45ba58858379b5fca7caf4214ec75ce47e59bac0305765ba3b4.jpg",
+        "table_caption": [
+            "Table 1: VTAB. Scores and $9 5 \\%$ confidence intervals for ViT and V-MoE. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>ViT</td><td>V-MoE</td></tr><tr><td>L/16 76.3±0.5</td><td>77.2±0.4</td></tr><tr><td>H/14 77.6±0.2</td><td>77.8±0.4</td></tr></table>",
+        "bbox": [
+            503,
+            445,
+            676,
+            503
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Expert models provide notable gains across all model sizes, for only a mild increase in FLOPs, establishing a new Pareto frontier (gray lines). Alternatively, we can match or improve performance of ViT models at lower cost (e.g. V-MoE-L/16 improves upon ViT-H/14). Similar conclusions hold for training time, which includes communication overhead of dispatching data across devices. ",
+        "bbox": [
+            173,
+            570,
+            826,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Linear few-shot results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            642,
+            372,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the quality of the representations learned using few-shot linear transfer. Given training examples from the new dataset $\\{ ( X , Y ) _ { i } \\}$ , we use the pre-trained model $\\mathcal { M }$ to extract a fixed representation $\\mathcal { M } ( x _ { i } )$ of each image. We fit a linear regression model mapping $\\mathcal { M } ( x _ { i } )$ to the one-hot encoding of the target labels $Y _ { i }$ , following [20] (see [27, Chapter 5] for background). ",
+        "bbox": [
+            174,
+            667,
+            825,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 2b shows that the upstream gains are preserved under 5-shot ImageNet evaluation, considering both compute and time; in other words, the quality of the representations learned by V-MoE also outperforms ViT models when looking at a new task. Table 2 further shows the results on $\\{ 1 , 1 0 \\}$ -shot for some selected models, and the full detailed results are available in Appendix B.5. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 Full fine-tuning results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            803,
+            370,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The typically most performant approach for Transfer Learning [19] consists of replacing the upstream classification head with a new task-specific one and fine-tuning the whole model. Though one may expect that massive models like V-MoEs require special handling for fine-tuning, we broadly follow the standard fine-tuning protocol for Vision Transformers. We use the auxiliary loss during fine-tuning as well, although we observe that it is often not needed in this step, as the router is already well trained. We explore the two sets of tasks considered therein: ",
+        "bbox": [
+            174,
+            827,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/50ec35f7ecf28e9c0130e04ba518b414285354dcdb6207d834c1ac8587a7979a.jpg",
+        "image_caption": [
+            "Figure 4: White patches are discarded tokens in the first layer of experts, for different capacities, using Batch Prioritized Routing (Section 4.1) with a V-MoE-H/14. See Appendix D for more examples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            111,
+            825,
+            325
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Full data. We follow the setup of [20], except that we apply a dropout rate of 0.1 on the expert MLPs (as done in [22]), and we halve the number of fine-tuning steps for all datasets other than ImageNet. Figure 3 shows the results on ImageNet (averaged over three runs). Here, V-MoE also performs better than dense counterparts, though we suspect the fine-tuning protocol could be further improved and tailored to the sparse models. See Table 8 for all details, including results on other datasets. ",
+        "bbox": [
+            174,
+            390,
+            825,
+            459
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Low-data regime. On the VTAB benchmark, we use a similar setup and hyperparameter budget as [20] (but fine-tune with half the schedule length). Table 1 shows that, while performance is similar for V-MoE-H/14, experts provide significant gains at the ViT-L/16 level, indicating that despite the large size of these models, they can still be fine-tuned with small amounts of data and no further tricks. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.6 Scaling up V-MoE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            537,
+            339,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, we test how well V-MoE can scale vision models to a very large number of parameters, while continuing to improve performance. For this, we increase the size of the model and use a larger pre-training dataset: JFT-3B is a larger version of JFT-300M, it contains almost 3B images and is noisily annotated with 30k classes. Inspired by [68], we apply the changes detailed in Appendix B.3, and train a 48-block V-MoE model, with every-2 expert placement (32 experts and $k = 2$ ), resulting in a model with 14.7B parameters, which we denote by V-MoE-15B. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            646
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We successfully train V-MoE-15B, which is, as far as we are aware, the largest vision model to date. It has an impressive $8 2 . 7 8 \\%$ accuracy on 5-shot ImageNet and $9 0 . 3 5 \\%$ when fully fine-tuned, as shown in Appendix B.5, which also includes more details about the model. Training this model required $1 6 . 8 \\mathrm { k }$ TPUv3-core-days. To contextualize this result, the current state of the art on ImageNet is Meta Pseudo-Labelling (MPL) [49]. MPL trains an EfficientNet-based model on unlabelled JFT-300M using ImageNet pseudo-labelling, achieving $9 0 . 2 \\%$ while requiring $2 2 . 5 \\mathrm { k }$ TPUv3-core-days. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            736
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Skipping Tokens with Batch Prioritized Routing ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            753,
+            607,
+            772
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We present a new routing algorithm that allows the model to prioritize important tokens (corresp. patches). By simultaneously reducing the capacity of each expert, we can discard the least useful tokens. Intuitively, not every patch is equally important to classify a given image, e.g., most background patches can be dropped to let the model only focus on the ones with the relevant entities. ",
+        "bbox": [
+            174,
+            786,
+            826,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 From Vanilla Routing to Batch Prioritized Routing ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            857,
+            566,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With the notation from Section 2, the routing function $\\mathbf { X } \\in \\mathbb { R } ^ { N \\cdot P \\times D }$ . A batch contains $N$ images composed of $P$ $g$ is applied row-wise to a batch of inputs tokens each; each row of $\\mathbf { X }$ corresponds to the $D$ -dimensional representation of a particular token of an image. Accordingly, $g ( \\mathbf { X } ) _ { t , i } \\in \\mathbb { R }$ denotes the routing weight for the $t$ -th token and the $i$ -th expert. ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/29e4a2dc24e77688a20381ca0a9a9204e095cf85146fd91910e17ceb4adf02f7.jpg",
+        "image_caption": [
+            "Figure 5: Reducing compute with priority routing. Performance vs. inference FLOPs for large models. V-MoEs with the original vanilla routing are represented by $\\bullet$ , while $\\mid$ shows V-MoEs where BPR and a mix of $C \\in \\{ 0 . 6 , 0 . 7 , 0 . 8 \\}$ and $k \\in \\{ 1 , 2 \\}$ are used to reduce compute. ViT models shown as $\\mathbf { x }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            93,
+            482,
+            297
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7de5765086bcdc5f0b366171e8b6331b7af94a05b53a7eba6ce847b523b20bc.jpg",
+        "image_caption": [
+            "Figure 6: Priority routing works where vanilla fails. Performance vs. inference capacity ratio for a V-MoE-H/14 model with $k = 2$ . Even for large $C$ ’s BPR outperforms vanilla; at low $C$ the difference is stark. BPR is competitive with dense by processing only $1 5 { - } 3 0 \\%$ of the tokens. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            503,
+            93,
+            828,
+            309
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            421,
+            823,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In all routing algorithms considered, for $i < j$ , every TOP- $i$ assignment has priority over any TOP- $j$ <assignment. The router first tries to dispatch all $i ^ { \\mathrm { { t h } } }$ expert choices before assigning any $j ^ { \\mathrm { t h } }$ choice4. ",
+        "bbox": [
+            173,
+            455,
+            821,
+            483
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Given the TOP- $\\cdot i$ position, the default—or vanilla—routing, as used in [54, 39, 22], assigns tokens to experts as follows. It sequentially goes over the rows of $g ( \\mathbf { X } )$ and assigns each token to its TOP- $i$ expert when the expert’s buffer is not full. As a result, priority is given to tokens depending on the rank of their corresponding row. While images in a batch are randomly ordered, tokens within an image follow a pre-defined fixed order. The algorithm is detailed in Algorithm 1 of Appendix C. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            559
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Batch Prioritized Routing (BPR). To favour the “most important” tokens, we propose to compute a priority score $s ( \\mathbf { x } )$ on each token, and sort $g ( \\mathbf { X } )$ accordingly before proceeding with the allocation. We sort tokens based on their maximum routing weight, formally $s ( \\mathbf { \\bar { X } } ) _ { t } = \\operatorname* { m a x } _ { i } g ( \\mathbf { X } ) _ { t , i }$ . The sum of TOP- $k$ weights, i.e. $s ( \\mathbf { X } ) _ { t } = \\sum _ { i } g ( \\mathbf { X } ) _ { t , i }$ =, worked equally well. These two simple approaches =outperformed other options we explored, e.g., directly parameterising and learning the function $s$ . ",
+        "bbox": [
+            173,
+            565,
+            825,
+            636
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We reuse the router outputs as a proxy for the priority of allocation. Our experiments show this preserves the performant predictive behaviour of the model, even though the router outputs primarily encode how well tokens and experts can be paired, not the token’s “importance” for the final classification task. Figure 4 visualizes token prioritisation with Batch Prioritized Routing for increasingly small capacities. Since all tokens across all images in the batch $\\mathbf { X }$ compete with each other, different images may receive different amounts of compute. We summarize BPR in Algorithm 2, in Appendix C. ",
+        "bbox": [
+            174,
+            641,
+            825,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Skip tokens with low capacity $C$ ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            742,
+            434,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Batch Prioritized Routing opens the door to reducing the buffer size by smartly selecting which tokens to favor. This can have a dramatic impact in the computational cost of the overall sparse model. We discuss now inference and training results with $C$ defined in Section 2.4 in the regime $C \\ll 1$ . ",
+        "bbox": [
+            174,
+            768,
+            825,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "At inference time. Prioritized routing is agnostic to how the model was originally trained. Figure 6 shows the effect of reducing compute at inference time by using BPR versus vanilla routing, on a V-MoE-H/14 model trained using vanilla routing. The difference in performance between both methods is remarkable —especially for $C \\leq 0 . 5$ , where the model truly starts fully dropping tokens, as $k = 2$ . Also, BPR allows the model to be competitive with the dense one even at quite low capacities. =As shown in Figure 5 for V-MoE-L/16 and V-MoE-H/14, Batch Prioritized Routing and low $C$ allow V-MoE to smoothly trade-off performance and FLOPS at inference time, quite a unique model feature. More concretely, Table 10 shows V-MoE models can beat the dense VIT-H performance by using less than half the FLOPs and less than $60 \\%$ of the runtime. Conversely, we can match the inference FLOPs cost and preserve a one-point accuracy gain in ImageNet/5shot and almost three-point in JFT precision at one (Table 11). Dense models generally require less runtime for the same amount of FLOPs due to the data transfer involved in the V-MoE implementation. ",
+        "bbox": [
+            174,
+            816,
+            825,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/640deb97f79b2375225dd1090af5f85b4d407bb4a860255dc9270e4de0ca5a73.jpg",
+        "image_caption": [
+            "Figure 7: Deeper routing decisions correlate with image classes. We show $4 ~ \\mathrm { M o E }$ layers of a V-MoE-H/14. The $x$ -axis corresponds to the 32 experts in a layer. The $y$ -axis are the 1 000 ImageNet classes; orderings for both axes are different across plots. For each pair (expert $e$ , class $c$ ) we show the average routing weight for the tokens corresponding to all images with class $c$ for that particular expert $e$ . Figure 29 includes all the remaining layers; see Appendix E.2 for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            90,
+            818,
+            212
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            321,
+            825,
+            433
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "At training time. Batch Prioritized Routing can also be leveraged during training. In Appendix C we show how expert models with max-weight routing can match the dense performance while saving around $20 \\%$ of the total training FLOPs, and strongly outperform vanilla with a similar FLOP budget. ",
+        "bbox": [
+            174,
+            439,
+            823,
+            481
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Model Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            334,
+            517
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Although large-scale sparse MoEs have led to strong performance [22, 39, 54], little is known and understood about how the internals of those complex models work. We argue that such exploratory experiments can inform the design of new algorithms. In this section, we provide the first such analysis at this scale, which guided the development of the algorithms presented in the paper. ",
+        "bbox": [
+            174,
+            531,
+            823,
+            587
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Specialized experts. Intuitively, routers should learn to distribute images across experts based on their similarity. For instance, if the model had three experts, and the task mainly involved three categories—say animals, cars, and buildings—one would expect an expert to specialize in each of those. We test this intuition, with some obvious caveats: (a) experts are placed at several network depths, (b) $k$ experts are combined, and (c) routing happens at the token rather than the image level. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            662
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 7 illustrates how many images of a given ImageNet class use each expert. The plots were produced by running a fine-tuned V-MoE-H Every-2 model. Interestingly, we saw similar patterns with the upstream model without fine-tuning. Experts specialize in discriminating between small sets of classes (those primarily routed through the expert). In earlier MoE layers we do not observe this. Experts may instead focus on aspects common to all classes (background, basic shapes, colours) - for example, Figure 30 (Appendix E) shows correlations with patch location in earlier layers. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The value of routers. After training a sparse MoE, it is natural to study the usefulness of the learned routers, in the light of several pitfalls. For example, the routers may just act as a load balancer if experts end up learning very similar functions, or the routers may simply choose poor assignments. In Appendix E.1, we replace, after training, one router at a time with a uniformly random router. The models are robust to early routing changes while more sensitive to the decisions in the last layers. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            829
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Routing weights distributions. We analyse the router outputs in Appendix E.3, and observe the distribution of selected weights varies wildly across different mixture of experts layers. ",
+        "bbox": [
+            174,
+            835,
+            821,
+            863
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Changing $k$ at inference time. We have observed expert models are remarkably flexible. Somewhat surprisingly, sparse models are fairly robust to mismatches between their training and inference configurations. In Appendix E.4, we explore the effect of training with some original value of $k$ while applying the model at inference time with a different $\\boldsymbol { k } ^ { \\prime } \\neq \\boldsymbol { k }$ . This can be handy to control (decrease ≠or increase) the amount of FLOPs per input in a particular production system. ",
+        "bbox": [
+            176,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            316,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Conditional Computation. To grow the number of model parameters without proportionally increasing the computational cost, conditional computation [5, 15, 12] only activates some relevant parts of the model in an input-dependent fashion, like in decision trees [7]. In deep learning, the activation of portions of the model can use stochastic neurons [6] or reinforcement learning [4, 17, 53]. ",
+        "bbox": [
+            174,
+            170,
+            825,
+            226
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mixture of Experts. MoEs [31, 34, 10, 66] combine the outputs of sub-models known as experts via a router in an input-dependent way. MoEs have successfully used this form of conditional computation in a range of applications [23, 30, 58, 55, 67]. An input can select either all experts [21] or only a sparse mixture thereof as in recent massive language models [54, 39, 22]. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            287
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MoEs for Language. MoEs have recently scaled language models up to trillions of parameters. Our approach is inspired by [54] who proposed a top- $k$ gating in LSTMs, with auxiliary losses ensuring the expert balance [26]. [39] further scaled up this approach for transformers, showing strong gains for neural machine translation. With over one trillion parameters and one expert per input, [22] sped up pre-training compared to a dense baseline [50] while showing gains thanks to transfer and distillation. [40] alternatively enforced a balanced routing by solving a linear assignment problem. ",
+        "bbox": [
+            174,
+            294,
+            825,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "MoEs for Vision. For computer vision, previous work on MoEs [21, 2, 25, 1, 63, 47, 64] focused on architectures whose scale is considerably smaller than that of both language models and our model. In DeepMoE [63], the “experts” are the channels of convolutional layers that are adaptively selected by a multi-headed sparse gate. This is similar to [64] where the kernels of convolutional layers are activated on a per-example basis. Other approaches use shallow MoEs, learning a single router, either disjointly [25] or jointly [2], together with CNNs playing the role of experts. [1] further have a cost-aware procedure to bias the assignments of inputs across the experts. Unlike shallow MoEs, we operate with up to several tens of routing decisions per token along the depth of the model. Scaling up routing depth was marked as a major challenge in [51], which we successfully tackle in our work. ",
+        "bbox": [
+            174,
+            383,
+            826,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            307,
+            545
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have employed sparse conditional computation to train some of the largest vision models to date, showing significant improvements in representation learning and transfer learning. Alongside V-MoE, we have proposed Batch Prioritized Routing, which allows successful repurposing of model sparsity to introduce sparsity with respect to the inputs. This can be done without further adapting the model, allowing the re-use of trained models with sparse conditional computation. ",
+        "bbox": [
+            174,
+            558,
+            825,
+            628
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This has interesting connotations for recent work in NLP using sparse models; recent analysis shows model sparsity is the most promising way to reduce model $\\mathrm { C O } _ { 2 }$ emissions [46] and that $90 \\%$ of the footprint stems from inference costs — we present an algorithm which takes the most efficient models and makes them even more efficient without any further model adaptation. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This is just the beginning of conditional computation at scale for vision; extensions include scaling up the expert count, reducing dependency on data and improving transfer of the representations produced by sparse models. Directions relating to heterogeneous expert architectures and conditional variable-length routes should also be fruitful. We expect increasing importance of sparse model scaling, especially in data rich domains such as large scale multimodal or video modeling. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            766
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Alex Kolesnikov, Lucas Beyer and Xiaohua Zhai for providing continuous help and details about scaling ViT models; Alexey Dosovitskiy, who provided some of the pre-trained ViT models; Ilya Tolstikhin, who suggested placing experts only in the last layers; Josip Djolonga for his early review of the manuscript; Dmitry Lepikhin for providing details about the original GShard implementation; Barret Zoph and Liam Fedus for insightful comments and feedback; James Bradbury, Blake Hechtman and the rest of JAX and TPU team who helped us running our models efficiently, and many others from Google Brain for their support. ",
+        "bbox": [
+            173,
+            119,
+            826,
+            218
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            266,
+            253
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] A. Abbas and Y. Andreopoulos. Biased mixtures of experts: Enabling computer vision inference under data transfer limitations. IEEE Trans. Image Processing, 29:7656–7667, 2020.   \n[2] K. Ahmed, M. H. Baig, and L. Torresani. Network of experts for large-scale image categorization. In ECCV, 2016.   \n[3] A. Arnab, M. Dehghani, G. Heigold, C. Sun, M. Luciˇ c, and C. Schmid. ViViT: A video vision ´ transformer. arXiv preprint arXiv:2103.15691, 2021.   \n[4] E. Bengio, P.-L. Bacon, J. Pineau, and D. Precup. Conditional computation in neural networks for faster models. arXiv preprint arXiv:1511.06297, 2015.   \n[5] Y. Bengio. Deep learning of representations: Looking forward. In International Conference on Statistical Language and Speech Processing, pages 1–37, 2013.   \n[6] Y. Bengio, N. Léonard, and A. Courville. Estimating or propagating gradients through stochastic neurons for conditional computation. arXiv preprint arXiv:1308.3432, 2013.   \n[7] L. Breiman, J. Friedman, C. J. Stone, and R. A. Olshen. Classification and regression trees. CRC press, 1984.   \n[8] A. Brock, S. De, S. L. Smith, and K. Simonyan. High-performance large-scale image recognition without normalization. arXiv preprint arXiv:2102.06171, 2021.   \n[9] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al. Language models are few-shot learners. arXiv preprint arXiv:2005.14165, 2020.   \n[10] K. Chen, L. Xu, and H. Chi. Improved learning algorithms for mixture of experts in multiclass classification. Neural networks, 12(9):1229–1252, 1999.   \n[11] G. Cheng, J. Han, and X. Lu. Remote sensing image scene classification: Benchmark and state of the art. Proceedings of the IEEE, 105(10):1865–1883, Oct 2017.   \n[12] K. Cho and Y. Bengio. Exponentially increasing the capacity-to-computation ratio for conditional computation in deep learning. arXiv preprint arXiv:1406.7362, 2014.   \n[13] M. Cimpoi, S. Maji, I. Kokkinos, S. Mohamed, and A. Vedaldi. Describing textures in the wild. In Computer Vision and Pattern Recognition (CVPR), 2014.   \n[14] E. D. Cubuk, B. Zoph, J. Shlens, and Q. Le. Randaugment: Practical automated data augmentation with a reduced search space. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, 2020.   \n[15] A. Davis and I. Arel. Low-rank approximations for conditional feedforward computation in deep neural networks. arXiv preprint arXiv:1312.4461, 2013.   \n[16] J. Deng, W. Dong, R. Socher, L.-J. Li, K. Li, and L. Fei-Fei. ImageNet: A large-scale hierarchical image database. In CVPR, 2009.   \n[17] L. Denoyer and P. Gallinari. Deep sequential neural network. arXiv preprint arXiv:1410.0510, 2014.   \n[18] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. BERT: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019.   \n[19] G. S. Dhillon, P. Chaudhari, A. Ravichandran, and S. Soatto. A baseline for few-shot image classification. In ICLR, 2020.   \n[20] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In ICLR, 2021.   \n[21] D. Eigen, M. Ranzato, and I. Sutskever. Learning factored representations in a deep mixture of experts. arXiv preprint arXiv:1312.4314, 2013.   \n[22] W. Fedus, B. Zoph, and N. Shazeer. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. arXiv preprint arXiv:2101.03961, 2021.   \n[23] D. M. Gavrila and S. Munder. Multi-cue pedestrian detection and tracking from a moving vehicle. International journal of computer vision, 73(1):41–59, 2007.   \n[24] A. Geiger, P. Lenz, and R. Urtasun. Are we ready for autonomous driving? The KITTI vision benchmark suite. In Computer Vision and Pattern Recognition (CVPR), 2012.   \n[25] S. Gross, M. Ranzato, and A. Szlam. Hard mixtures of experts for large scale weakly supervised vision. In CVPR, 2017.   \n[26] J. V. Hansen. Combining predictors: comparison of five meta machine learning methods. Information Sciences, 119(1-2):91–105, 1999.   \n[27] T. Hastie, R. Tibshirani, and J. Friedman. The elements of statistical learning: data mining, inference, and prediction. Springer, 2017.   \n[28] P. Helber, B. Bischke, A. Dengel, and D. Borth. EuroSAT: A novel dataset and deep learning benchmark for land use and land cover classification. IEEE Journal of Selected Topics in Applied Earth Observations and Remote Sensing, 12(7):2217–2226, 2019.   \n[29] D. Hendrycks and K. Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415, 2016.   \n[30] Y. H. Hu, S. Palreddy, and W. J. Tompkins. A patient-adaptable ECG beat classifier using a mixture of experts approach. IEEE Trans. Biomedical Engineering, 44(9):891–900, 1997.   \n[31] R. A. Jacobs, M. I. Jordan, S. J. Nowlan, and G. E. Hinton. Adaptive mixtures of local experts. Neural Computation, 3(1):79–87, 1991.   \n[32] Z. Jiang, Q. Hou, L. Yuan, D. Zhou, X. Jin, A. Wang, and J. Feng. Token labeling: Training a $8 5 . 5 \\%$ top-1 accuracy vision transformer with 56m parameters on imagenet. arXiv preprint arXiv:2104.10858, 2021.   \n[33] J. Johnson, B. Hariharan, L. van der Maaten, F.-F. Li, C. Lawrence Zitnick, and R. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In Computer Vision and Pattern Recognition (CVPR), 2017.   \n[34] M. I. Jordan and R. A. Jacobs. Hierarchical mixtures of experts and the EM algorithm. Neural computation, 6(2):181–214, 1994.   \n[35] Kaggle and EyePacs. Kaggle diabetic retinopathy detection, 2015.   \n[36] A. Kolesnikov, L. Beyer, X. Zhai, J. Puigcerver, J. Yung, S. Gelly, and N. Houlsby. Big transfer (BiT): General visual representation learning. In ECCV, 2020.   \n[37] A. Krizhevsky. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   \n[38] Y. LeCun, F. J. Huang, and L. Bottou. Learning methods for generic object recognition with invariance to pose and lighting. In Computer Vision and Pattern Recognition (CVPR), 2004.   \n[39] D. Lepikhin, H. Lee, Y. Xu, D. Chen, O. Firat, Y. Huang, M. Krikun, N. Shazeer, and Z. Chen. GShard: Scaling giant models with conditional computation and automatic sharding. In ICLR, 2021.   \n[40] M. Lewis, S. Bhosale, T. Dettmers, N. Goyal, and L. Zettlemoyer. Base layers: Simplifying training of large, sparse models. arXiv preprint arXiv:2103.16716, 2021.   \n[41] F.-F. Li, R. Fergus, and P. Perona. Learning generative visual models from few training examples: An incremental Bayesian approach tested on 101 object categories. Computer Vision and Pattern Recognition Workshop, 2004.   \n[42] L. Matthey, I. Higgins, D. Hassabis, and A. Lerchner. dSprites: Disentanglement testing sprites dataset, 2017.   \n[43] Y. Netzer, T. Wang, A. Coates, A. Bissacco, and A. Y. Ng. Reading digits in natural images with unsupervised feature learning. In NIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011.   \n[44] M.-E. Nilsback and A. Zisserman. Automated flower classification over a large number of classes. In Sixth Indian Conf. on Computer Vision, Graphics & Image Processing, 2008.   \n[45] O. M. Parkhi, A. Vedaldi, A. Zisserman, and C. Jawahar. Cats and dogs. In CVPR, 2012.   \n[46] D. Patterson, J. Gonzalez, Q. Le, C. Liang, L.-M. Munguia, D. Rothchild, D. So, M. Texier, and J. Dean. Carbon emissions and large neural network training. arXiv preprint arXiv:2104.10350, 2021.   \n[47] S. Pavlitskaya, C. Hubschneider, M. Weber, R. Moritz, F. Huger, P. Schlicht, and M. Zollner. Using mixture of expert models to gain insights into semantic segmentation. In CVPR Workshops, 2020.   \n[48] M. E. Peters, M. Neumann, M. Iyyer, M. Gardner, C. Clark, K. Lee, and L. Zettlemoyer. Deep contextualized word representations. In NAACL, 2018.   \n[49] H. Pham, Z. Dai, Q. Xie, M.-T. Luong, and Q. V. Le. Meta pseudo labels. arXiv preprint arXiv:2003.10580, 2020.   \n[50] C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y. Zhou, W. Li, and P. J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. arXiv preprint arXiv:1910.10683, 2019.   \n[51] P. Ramachandran and Q. V. Le. Diversity and depth in per-example routing models. In ICLR, 2018.   \n[52] C. Rosenbaum, I. Cases, M. Riemer, and T. Klinger. Routing networks and the challenges of modular and compositional computation. arXiv preprint arXiv:1904.12774, 2019.   \n[53] C. Rosenbaum, T. Klinger, and M. Riemer. Routing networks: Adaptive selection of non-linear functions for multi-task learning. arXiv preprint arXiv:1711.01239, 2017.   \n[54] N. Shazeer, A. Mirhoseini, K. Maziarz, A. Davis, Q. Le, G. Hinton, and J. Dean. Outrageously large neural networks: The sparsely-gated mixture-of-experts layer. In ICLR, 2017.   \n[55] C. Sminchisescu, A. Kanaujia, Z. Li, and D. Metaxas. Learning to reconstruct 3D human motion from Bayesian mixtures of experts. A probabilistic discriminative approach. Dept. Comput. Sci., Univ. Toronto, Tech. Rep. CSRG-502, 2004.   \n[56] E. Strubell, A. Ganesh, and A. McCallum. Energy and policy considerations for deep learning in NLP. arXiv preprint arXiv:1906.02243, 2019.   \n[57] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In ICCV, 2017.   \n[58] J. Tani and S. Nolfi. Learning to perceive the world as articulated: an approach for hierarchical learning in sensory-motor systems. Neural Networks, 12(7-8):1131–1141, 1999.   \n[59] H. Touvron, M. Cord, M. Douze, F. Massa, A. Sablayrolles, and H. Jégou. Training data-efficient image transformers & distillation through attention. arXiv preprint arXiv:2012.12877, 2020.   \n[60] H. Touvron, M. Cord, A. Sablayrolles, G. Synnaeve, and H. Jégou. Going deeper with image transformers. arXiv preprint arXiv:2103.17239, 2021.   \n[61] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In NeurIPS, 2017.   \n[62] B. S. Veeling, J. Linmans, J. Winkens, T. Cohen, and M. Welling. Rotation equivariant CNNs for digital pathology. In Medical Image Computing and Computer Assisted Intervention (MICCAI), 2018.   \n[63] X. Wang, F. Yu, L. Dunlap, Y.-A. Ma, R. Wang, A. Mirhoseini, T. Darrell, and J. E. Gonzalez. Deep mixture of experts via shallow embedding. In Uncertainty in Artificial Intelligence, 2020.   \n[64] B. Yang, G. Bender, Q. V. Le, and J. Ngiam. Condconv: Conditionally parameterized convolutions for efficient inference. arXiv preprint arXiv:1904.04971, 2019.   \n[65] L. Yuan, Y. Chen, T. Wang, W. Yu, Y. Shi, F. E. Tay, J. Feng, and S. Yan. Tokens-to-token vit: Training vision transformers from scratch on imagenet. arXiv preprint arXiv:2101.11986, 2021.   \n[66] S. E. Yuksel, J. N. Wilson, and P. D. Gader. Twenty years of mixture of experts. IEEE transactions on neural networks and learning systems, 23(8):1177–1193, 2012.   \n[67] A. J. Zeevi, R. Meir, and R. J. Adler. Time series prediction using mixtures of experts. In NeurIPS, 1997.   \n[68] X. Zhai, A. Kolesnikov, N. Houlsby, and L. Beyer. Scaling vision transformers, 2021.   \n[69] X. Zhai, J. Puigcerver, A. Kolesnikov, P. Ruyssen, C. Riquelme, M. Lucic, J. Djolonga, A. S. Pinto, M. Neumann, A. Dosovitskiy, L. Beyer, O. Bachem, M. Tschannen, M. Michalski, O. Bousquet, S. Gelly, and N. Houlsby. A large-scale study of representation learning with the visual task adaptation benchmark. arXiv preprint arXiv:1910.04867, 2019.   \n[70] X. Zhai, J. Puigcerver, A. Kolesnikov, P. Ruyssen, C. Riquelme, M. Lucic, J. Djolonga, A. S. Pinto, M. Neumann, A. Dosovitskiy, et al. A large-scale study of representation learning with the visual task adaptation benchmark. arXiv preprint arXiv:1910.04867, 2019. ",
+        "bbox": [
+            174,
+            263,
+            826,
+            916
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            95,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            79,
+            828,
+            914
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            279
+        ],
+        "page_idx": 12
+    }
+]

parse/train/SVsLxTfHa1/SVsLxTfHa1.md

@@ -0,0 +1,385 @@
+# TOWARDS MULTI-SENSE CROSS-LINGUAL ALIGNMENT OF CONTEXTUAL EMBEDDINGS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Cross-lingual word embeddings (CLWE) have been proven useful in many crosslingual tasks. However, most existing approaches to learn CLWE including the ones with contextual embeddings are sense agnostic. In this work, we propose a novel framework to align contextual embeddings at the sense level by leveraging cross-lingual signal from bilingual dictionaries only. We operationalize our framework by first proposing a novel sense-aware cross entropy loss to model word senses explicitly. The monolingual ELMo and BERT models pretrained with our sense-aware cross entropy loss demonstrate significant performance improvement for word sense disambiguation tasks. We then propose a sense alignment objective on top of the sense-aware cross entropy loss for cross-lingual model pretraining, and pretrain cross-lingual models for several language pairs (English to German/Spanish/Japanese/Chinese). Compared with the best baseline results, our cross-lingual models achieve $0 . 5 2 \%$ , $2 . 0 9 \%$ and $1 . 2 9 \%$ average performance improvements on zero-shot cross-lingual NER, sentiment classification and XNLI tasks, respectively. We will release our code.
+
+# 1 INTRODUCTION
+
+Cross-lingual word embeddings (CLWE) provide a shared representation space for knowledge transfer between languages, yielding state-of-the-art performance in many cross-lingual natural language processing (NLP) tasks. Most of the previous works have focused on aligning static embeddings. To utilize the richer information captured by the pre-trained language model, more recent approaches attempt to extend previous methods to align contextual representations.
+
+Aligning the dynamic and complex contextual spaces poses significant challenges, so most of the existing approaches only perform coarse-grained alignment. Schuster et al. (2019) compute the average of contextual embeddings for each word as an anchor, and then learn to align the static anchors using a bilingual dictionary. In another work, Aldarmaki & Diab (2019) use parallel sentences in their approach, where they compute sentence representations by taking the average of contextual word embeddings, and then they learn a projection matrix to align sentence representations. They find that the learned projection matrix also works well for word-level NLP tasks. Besides, unsupervised multilingual language models (Devlin et al., 2018; Artetxe & Schwenk, 2019; Conneau et al., 2019; Liu et al., 2020) pretrained on multilingual corpora have also demonstrated strong cross-lingual transfer performance. Cao et al. (2020) and Wang et al. (2020) show that unsupervised multilingual language model can be further aligned with parallel sentences.
+
+Though contextual word embeddings are intended to provide different representations of the same word in distinct contexts, Schuster et al. (2019) find that the contextual embeddings of different senses of one word are much closer compared with that of different words. This contributes to the anisomorphic embedding distribution of different languages and causes problems for cross-lingual alignment. For example, it will be difficult to align the English word bank and its Japanese translations 銀行 and 岸 that correspond to its two different senses, since the contextual embeddings of different senses of bank are close to each other while those of 銀行 and 岸 are far. Recently, Zhang et al. (2019) propose two solutions to handle multi-sense words: 1) remove multi-sense words and then align anchors in the same way as Schuster et al. (2019); 2) generate cluster level average anchor for contextual embeddings of multi-sense words and then learn a projection matrix in an unsupervised way with MUSE (Conneau et al., 2017). They do not make good use of the bilingual dictionaries, which are usually easy to obtain, even in low-resource scenarios. Moreover, their projection-based approach still cannot handle the anisomorphic embedding distribution problem.
+
+In this work, we propose a novel sense-aware cross entropy loss to model multiple word senses explicitly, and then leverage a sense level translation task on top of it for cross-lingual model pretraining. The proposed sense level translation task enables our models to provide more isomorphic and better aligned cross-lingual embeddings. We only use the cross-lingual signal from bilingual dictionaries for supervision. Our pretrained models demonstrate consistent performance improvements on zero-shot cross-lingual NER, sentiment classification and XNLI tasks. Though pretrained on less data, our model achieves the state-of-the-art result on zero-shot cross-lingual German NER task. To the best of our knowledge, we are the first to perform sense-level contextual embedding alignment with only bilingual dictionaries.
+
+# 2 BACKGROUND: PREDICTION TASKS OF LANGUAGE MODELS
+
+Next token prediction and masked token prediction are two common tasks in neural language model pretraining. We take two well-known language models, ELMo (Peters et al., 2018) and BERT (Devlin et al., 2018), as examples to illustrate these two tasks (architectures are shown in Appendix A).
+
+Next token prediction ELMo uses next token prediction tasks in a bidirectional language model. Given a sequence of $N$ tokens $( t _ { 1 } , t _ { 2 } , \ldots , t _ { N } )$ , it first prepares a context independent representation for each token by using a convolutional neural network over the characters or by word embedding lookup (a.k.a. input embeddings). These representations are then fed into $L$ layers of LSTMs to generate the contextual representations: $h _ { i , j }$ for token $t _ { i }$ at layer $j$ . The model assigns a learnable output embedding $\pmb { w }$ for each token in the vocabulary, which has the same dimension as $h _ { i , L }$ . Then, the forward language model predicts the token at position $k$ with:
+
+$$
+p ( t _ { k } | t _ { 1 } , t _ { 2 } , \dots , t _ { k - 1 } ) = \mathrm { s o f t m a x } ( h _ { k - 1 , L } ^ { \mathsf { T } } w _ { k ^ { \prime } } ) = \frac { \exp ( h _ { k - 1 , L } ^ { \mathsf { T } } w _ { k ^ { \prime } } ) } { \sum _ { i = 1 } ^ { V } \exp ( h _ { k - 1 , L } ^ { \mathsf { T } } w _ { i } ) }
+$$
+
+where $k ^ { \prime }$ is the index of token $t _ { k }$ in the vocabulary, $V$ is the size of the vocabulary, and $( \pmb { w } _ { 1 } , \dots , \pmb { w } _ { V } )$ are the output embeddings for the tokens in the vocabulary. The backward language model is similar to the forward one, except that tokens are predicted in the reverse order. Since the forward and backward language models are very similar, we will only describe our proposed approach in the context of the forward language model in the subsequent sections.
+
+Masked token prediction The Masked Language Model (MLM) in BERT is a typical example of masked token prediction. Given a sequence $( t _ { 1 } , t _ { 2 } , \ldots , t _ { N } )$ , this approach randomly masks a certain percentage $( 1 5 \% )$ of the tokens and generates a masked sequence $( m _ { 1 } , m _ { 2 } , \ldots , m _ { N } )$ , where $m _ { k } = [ m a s k ]$ if the token at position $k$ is masked, otherwise $m _ { k } = t _ { k }$ . BERT first prepares the context independent representations $( \pmb { x } _ { 1 } , \pmb { x } _ { 2 } , \dots , \pmb { x } _ { N } )$ of the masked sequence via token embeddings. It is then fed into $L$ layers of transformer encoder (Vaswani et al., 2017) to generate “bidirectional” contextual token representations. The final layer representations are then used to predict the masked token at position $k$ as follows:
+
+$$
+p ( m _ { k } = t _ { k } | m _ { 1 } , \dots , m _ { N } ) = \mathrm { s o f t m a x } ( h _ { k , L } ^ { \top } w _ { k ^ { \prime } } ) = \frac { \exp ( h _ { k , L } ^ { \top } w _ { k ^ { \prime } } ) } { \sum _ { i = 1 } ^ { V } \exp ( h _ { k , L } ^ { \top } w _ { i } ) }
+$$
+
+where $k ^ { \prime } , V ,$ $^ { h }$ and $\textbf { \em w }$ are similarly defined as in Eq. 1. Unlike ELMo, BERT ties the input and output embeddings.
+
+# 3 PROPOSED FRAMEWORK
+
+We first describe our proposed sense-aware cross entropy loss to model multiple word senses explicitly in language model pretraining. Then, we present our joint training approach with sense alignment objective for cross-lingual mapping of contextual word embeddings. The proposed framework can be applied to most of the recent neural language models, such as ELMo, BERT and their variants. See Table 1 for a summary of the main notations used in this paper.
+
+# 3.1 SENSE-AWARE CROSS ENTROPY LOSS
+
+Limitations of original training objectives The training tasks with Eq. 1 and 2 maximize the normalized dot product of contextual representations $( h _ { k - 1 , L }$ or $\displaystyle h _ { k , L } )$ ) with a weight vector $\pmb { w } _ { k ^ { \prime } }$ . The only difference is that $h _ { k - 1 , L }$ in Eq. 1 encodes the information of previous tokens in the sequence, while $h _ { k , L }$ in Eq. 2 encodes the information of the masked sequence. Therefore, without loss of generality, we use $h _ { k ^ { * } , L }$ to denote the contextual representation for predicting the next or masked token $t _ { k }$ .
+
+Even though contextual language models like ELMo and BERT provide a different token representation for each distinct context, the learned representations are not guaranteed to be sense separated. For example, Schuster et al. (2019) computed the average of ELMo embeddings for each word as an anchor, and found that the average cosine distance between contextual em
+
+Table 1: Summary of the main notations   
+
+<table><tr><td>Notation</td><td>Description</td></tr><tr><td>tk</td><td>k-th token in sentence</td></tr><tr><td>tk,s</td><td>s-th sense of tk</td></tr><tr><td>k&#x27;</td><td>index of token tk in vocabulary</td></tr><tr><td>L</td><td>number ofLSTM/Transformer layers</td></tr><tr><td>V</td><td>size of vocabulary</td></tr><tr><td>S</td><td>maximum number of senses per token</td></tr><tr><td>hk,j</td><td>contextual representation of token tk in layer j</td></tr><tr><td>hk*,L</td><td>contextual representation used in softmax function for predicting tk</td></tr><tr><td>Ui</td><td>i-th word in vocabulary</td></tr><tr><td>Ui,s</td><td>s-th sense of Ui</td></tr><tr><td>Wi</td><td>output embedding of Ui</td></tr><tr><td>Wi,s</td><td>context-dependent output embedding (i.e. sense vector) of Ui,s</td></tr><tr><td>Ci,s</td><td>sense cluster center of Ui,s</td></tr><tr><td>C</td><td>sense cluster centers of Ui</td></tr><tr><td>d</td><td>dimension of contextual representations</td></tr><tr><td>P</td><td>projection matrix for dimension reduction</td></tr></table>
+
+beddings of multi-sense words and their corresponding anchors are much smaller than the average distance between anchors, which mean that the embeddings of different senses of one word are relatively near to each other comparing to that of different words. We also observed the same with BERT embeddings. This finding suggests that sense clusters of a multi-sense word’s appearances are not well separated in the embedding space, and the current contextual language models still have room for improvement by considering finer-grained word sense disambiguation.
+
+Notice that there is only one weight vector $\pmb { w } _ { k ^ { \prime } }$ for predicting the token $t _ { k }$ in the original training tasks. Ideally, we should treat the appearances of a multi-sense word in different contexts as different tokens, and train the language models to predict different senses of the word. In the following, we propose a novel sense-aware cross entropy loss to explicitly model different senses of a word in different contexts.
+
+Sense-aware cross entropy loss Given a sequence $( t _ { 1 } , t _ { 2 } , \ldots , t _ { N } )$ , our proposed framework generates contextual representations $( h _ { k , j }$ for token $t _ { k }$ in layer $j \in \{ 1 , \dots , L \} )$ in the same way as the standard LMs. Different from existing methods, our approach maintains multiple context-dependent output embeddings (henceforth, sense vectors) for each token. Specifically, let $S$ be the maximum number of senses per token. Each word $v _ { i }$ in the vocabulary contains $S$ separate sense vectors $( \pmb { w } _ { i , 1 } , \pmb { w } _ { i , 2 } , \ldots , \pmb { w } _ { i , S } )$ , where each $w _ { i , s }$ corresponds to a different sense (see Appendix for some interesting visualization examples). Following the notation in Section 2, we use $k ^ { \prime }$ to denote the index of the output token $t _ { k }$ in the vocabulary. Therefore, the sense vectors of $t _ { k }$ can be represented by $( { \pmb w } _ { k ^ { \prime } , 1 } , { \pmb w } _ { k ^ { \prime } , 2 } , \dots , { \pmb w } _ { k ^ { \prime } , S } )$ , which are randomly initialized and of the same dimension as $h _ { k ^ { * } , L }$ Note that we untie the input and output embeddings in our framework.
+
+We propose a word sense selection method shown in Algorithm 1 to select the most likely sense vector when training with sense-level cross entropy loss. Figure 1 shows the architecture of our proposed models. Assuming sense $s ^ { \prime }$ is selected for token $t _ { k }$ (which means sense vector $_ { w _ { k ^ { \prime } , s ^ { \prime } } }$ should be used), we have the following new prediction task:
+
+$$
+p ( t _ { k , s ^ { \prime } } | c o n t e x t ) = \mathrm { s o f t m a x } ( h _ { k ^ { * } , L } ^ { \top } w _ { k ^ { \prime } , s ^ { \prime } } ) = \frac { \exp ( h _ { k ^ { * } , L } ^ { \top } w _ { k ^ { \prime } , s ^ { \prime } } ) } { \sum _ { i = 1 } ^ { V } \sum _ { s = 1 } ^ { S } \exp ( h _ { k ^ { * } , L } ^ { \top } w _ { i , s } ) }
+$$
+
+The sense-aware cross entropy loss for word sense prediction is defined as follows:
+
+$$
+\mathcal { L } _ { \mathrm { S E N S E } } = - \log ( p ( t _ { k , s ^ { \prime } } | c o n t e x t ) )
+$$
+
+Word sense selection algorithm Word sense selection when training the language model can be handled as a non-stationary data stream clustering problem (Aggarwal et al., 2004; Khalilian & Mustapha, 2010; Abdullatif et al., 2018). The most intuitive way to select the corresponding sense
+
+(a) Sense-aware next token prediction
+
+![](images/c7c9157133e4d02e33b2d7ac65b7323b9150cb1b31614ca73f6cbf9722087bb7.jpg)  
+(b) Sense-aware masked token prediction   
+(c) Word sense selection   
+Figure 1: Our proposed framework for sense-aware next token1and masked token prediction tasks. Figure (c) shows an example of word sense selection, where the two sense clusters of $t _ { k }$ (assume its vocabulary index is $k ^ { \prime }$ ) are shifting in space. Center vectors $\pmb { c } _ { k ^ { \prime } , 1 }$ and $\mathbf { c } _ { k ^ { \prime } , 2 }$ are used to locate cluster centers. Given $h _ { k , L }$ , the algorithm performs dimension reduction on both $h _ { k , L }$ and center vectors, and then finds the most close cluster center $\mathbf { c } _ { k ^ { \prime } , 2 }$ , so we know the output embedding corresponding to sense 2 $( w _ { k ^ { \prime } , 2 } )$ should be used in the loss function. $\mathbf { c } _ { k ^ { \prime } , 2 }$ also makes a small step towards $h _ { k , L }$ .
+
+vector for $h _ { k ^ { * } , L }$ is to select the vector $w _ { k ^ { \prime } , s }$ with the maximum dot product value $h _ { k ^ { * } , L } ^ { \top } w _ { k ^ { \prime } , s }$ , or cosine similarity value $c o s s i m ( h _ { k ^ { * } , L } , { \pmb w } _ { k ^ { \prime } , s } )$ . However, our experiments show that these methods do not work well due to curse of dimensionality, suboptimal learning rate and noisy $h _ { k ^ { * } , L }$ . We apply an online $\mathbf { k }$ -means algorithm to cluster different senses of a word in Algorithm 1. For each sense vector $w _ { i , s }$ , we maintain a cluster center $\mathbf { } _ { c _ { i , s } }$ which is of the same dimension as $_ { w _ { i , s } }$ . Therefore, each token $v _ { i }$ in the vocabulary has $S$ such cluster center vectors, denoted by $\boldsymbol { C } _ { i } = ( c _ { i , 1 } , c _ { i , 2 } , \ldots , c _ { i , S } )$ . When predicting token $t _ { k }$ in a given sequence, we apply Algorithm 1 to select the best sense vector based on $h _ { k , L }$ (see Figure 1). Notice that $h _ { k , L }$ is different from $h _ { k ^ { * } , L }$ for next token prediction (Figure 1a) for which $h _ { k ^ { * } , L } = h _ { k - 1 , L }$ . The cluster centers $C _ { i }$ are not neural network parameters; instead, they are randomly initialized using a normal distribution ${ \mathcal { N } } ( 0 , \sigma ^ { 2 } )$ and updated through Algorithm 1. In addition, we also maintain a projection matrix $_ { P }$ for dimension reduction to facilitate effective sense clustering. $P \in \mathbb { R } ^ { d \times d ^ { \prime } }$ projects $h _ { k , L }$ and $\mathbf { { c } } _ { i , s }$ from dimension $d$ to $d ^ { \prime }$ , and is shared by all tokens in vocabulary. Similar to $C$ , $_ { P }$ is also randomly initialized with normal distribution $\mathcal { N } ( 0 , 1 )$ , and then updated through Algorithm 2. Both Algorithm 1 and 2 run in parallel, and are interrupted when the language model stops training.
+
+Some rationales behind our algorithm design are the following:
+
+# Algorithm 1 Word sense selection
+
+# Algorithm 2 Projection matrix $_ { r }$ update
+
+1: Hyper-parameters: number of senses $S$ , sense learning rate $\alpha$   
+2: Initialize the set of all sense cluster centers $_ { C }$   
+3: repeat   
+4: input: ${ h } _ { k , L }$ , vocabulary index $k ^ { \prime }$ of the token to predict   
+5: Lookup sense cluster centers for $k ^ { \prime } \colon C _ { k ^ { \prime } } =$ $\{ c _ { k ^ { \prime } , 1 } , \bar { c } _ { k ^ { \prime } , 2 } , \ldots , c _ { k ^ { \prime } , S } \}$   
+6: ${ \pmb P } =$ updated projection matrix from Alg. 2   
+7: if cosine similarity between $\pmb { c } _ { k ^ { \prime } , s ^ { \prime } } \pmb { P }$ and $\pmb { h } _ { k } ^ { \prime } \pmb { P }$ is the largest among the vectors in $C _ { k ^ { \prime } }$ then   
+8: $\mathbf { c } _ { k ^ { \prime } , s ^ { \prime } } = ( 1 - \alpha ) \mathbf { c } _ { k ^ { \prime } , s ^ { \prime } } + \alpha \mathbf { h } _ { k , L }$   
+9: output: $s ^ { \prime } ( \boldsymbol { w } _ { k ^ { \prime } , s ^ { \prime } }$ should be selected)   
+10: end if   
+11: until interrupted
+
+1: Hyper-parameters: projection dimension $d ^ { \prime }$ , up  
+date interval $M$ , queue size $Q$   
+2: Initialize $_ { r }$ with $\mathcal { N } ( 0 , 1 )$ , queue $H = \emptyset , m = 0$   
+3: repeat   
+4: input: ${ h } _ { k , L }$   
+5: $m = m + 1$   
+6: Add ${ h } _ { k , L }$ to queue $H$   
+7: if $s i z e ( H ) > Q$ then   
+8: Pop the oldest element from queue $H$ .   
+9: end if   
+10: if $m > = M$ then   
+11: ${ \pmb { P } } =$ the first $d ^ { \prime }$ PCA components of $H$   
+12: $m = 0$   
+13: end if   
+14: output: $_ { r }$   
+15: until interrupted
+
+• Directly computing cosine similarity between $\boldsymbol { c } _ { \boldsymbol { k } ^ { \prime } , s }$ and $h _ { k , L }$ suffers from the curse of dimensionality. We maintain $_ { r }$ for dimension reduction. Although many algorithms use random projection for dimension reduction, we find using PCA components can help improve clustering accuracy. Since the neural model parameters keep being updated during training, the sense clusters become non-stationary, i.e., their locations keep changing. Experiments shows that when using $_ { r }$ for dimension reduction, a slightly larger projection dimension $d ^ { \prime }$ will make the clustering algorithm less sensitive to cluster location change. We use $d ^ { \prime } = 1 6$ for ELMo, and $d ^ { \prime } = 1 4$ for BERT. We also notice that the sense clustering works well even if $_ { P }$ is updated sporadically. We can set a relatively large update interval in Algorithm 2 to reduce computation cost. • A separate sense learning rate $\alpha$ should be set for the clustering algorithm. A large $\alpha$ makes the algorithm less robust to noise, while a small $\alpha$ leads to slow convergence. • It is essential to use the current token’s contextual representation $h _ { k , L }$ for sense selection even though we use $h _ { k ^ { * } , L } = h _ { k - 1 , L }$ in the next token prediction task. If we use $h _ { k - 1 , L }$ for sense selection, experiments show that most of the variance comes from input embedding ${ \bf { \mathcal { x } } } _ { k - 1 }$ . This introduces too much noise for word sense clustering.
+
+Dynamic pruning of redundant word senses To make the training more efficient, we keep track of relative sense selection frequency for each token in the vocabulary. Assume token $v _ { i }$ has initial senses $( v _ { i , 1 } , v _ { i , 2 } , \ldots , v _ { i , S } )$ , for which we compute the relative frequency $\rho ( v _ { i , s } )$ such that $0 \leq \rho ( v _ { i , s } ) \leq 1$ and $\begin{array} { r } { \sum _ { s } \rho ( v _ { i , s } ) = 1 } \end{array}$ . A lower $\rho ( v _ { i , s } )$ means the sense is less frequently selected compared with others. We check the relative frequencies after every $E$ training steps, and if $\rho ( v _ { i , s } ) < \beta$ (a threshold hyper-parameter), $v _ { i , s }$ is removed from the list of senses of $v _ { i }$ .
+
+Remark on model size and parameters The sense cluster centers $C$ and the projection matrix $_ { r }$ are only used to facilitate sense selection during model pretraining, which are not neural model parameters. The sense vectors $w _ { i , s }$ will no longer be used after pretraining, which can also be discarded. Therefore, our models and the original models have exactly the same number of parameters when transferred to downstream tasks.
+
+Remark on model complexity The computational complexity of our algorithm is linear with respect to the size of data, so our method is scalable to train on very large datasets.
+
+# 3.2 JOINT TRAINING WITH SENSE LEVEL TRANSLATION
+
+Training language model with sense-aware cross entropy loss helps to learn contextual token representations that are sufficiently distinct for different senses $( \ S 4 . 1 )$ . In this subsection, we extend it to cross-lingual settings and present a novel approach to learn cross-lingual contextual word embeddings at the sense level. Our approach uses a bilingual seed dictionary,2 and can be applied to both next and masked token prediction tasks.
+
+For training the cross-lingual LM, we concatenate the (non-parallel) corpora of two languages, $L _ { 1 }$ and $L _ { 2 }$ , and construct a joint vocabulary $O = O ^ { L _ { 1 } } \cup O ^ { L _ { 2 } }$ , where $O ^ { { \cal L } _ { 1 } }$ and $O ^ { L _ { 2 } }$ are the vocabularies of $L _ { 1 }$ and $L _ { 2 }$ , respectively. Algorithm 1 is used to model the senses of tokens in the joint vocabulary. In addition to predicting the correct monolingual sense $p ( t _ { k , s ^ { \prime } } | c o n t e x t )$ in Eq. 3, we also train the model to predict its sense level translation. Let $v _ { j }$ be the translation of $t _ { k }$ and sense $v _ { j , s ^ { * } }$ of $v _ { j }$ be the best sense level translation under the given context, we add the following sense-level translation prediction task to maximize probability of $v _ { j , s ^ { * } }$ .
+
+$$
+p ( v _ { j , s ^ { * } } | c o n t e x t ) = \mathrm { s o f t m a x } ( h _ { k ^ { * } , L } ^ { \top } w _ { j , s ^ { * } } ) = \frac { \exp ( h _ { k ^ { * } , L } ^ { \top } w _ { j , s ^ { * } } ) } { \sum _ { i = 1 } ^ { V } \sum _ { s = 1 } ^ { S } \exp ( h _ { k ^ { * } , L } ^ { \top } w _ { i , s } ) }
+$$
+
+where ${ \pmb w } _ { j , s ^ { * } }$ is the corresponding sense vector of $v _ { j , s ^ { * } }$
+
+Similar to the previous subsection, we maintain sense cluster centers $C _ { i }$ for each token $v _ { i } \in O$ and the shared projection matrix $_ { r }$ to select the best translation sense. Assume $t _ { k }$ has $T$ translations in dictionary, and each translation has $S$ senses, then there are $T \times S$ possible sense level translations for $t _ { k }$ in the given context. If the $c o s s i m ( h _ { k , L } P , c _ { j , s ^ { * } } P )$ value is the largest among the $T \times S$ sense cluster centers, then we select $v _ { j , s ^ { * } }$ as the closest translation. An example is shown in Figure 2.
+
+![](images/b2b5a5f36085b898f341dcb4127a33a5d05b65edf01fc849169fa5850587187c.jpg)  
+Figure 2: An example of English-Japanese sense-level joint training, which shows two possible Japanese translations (銀行 and 岸) of the English word bank. $h _ { k , L }$ is a contextual representation of bank in finance context and $\mathbf { c } _ { k ^ { \prime } , 2 }$ is the cluster center for this sense. $c _ { a , 1 } , c _ { a , 2 } , c _ { b , 1 } , c _ { b , 2 }$ are different sense cluster centers of the two Japanese translations, among which $^ { c _ { b , 2 } }$ is the closest to $h _ { k , L }$ after dimension reduction through PCA. Our sense level objective (Eq. 6) moves sense clusters for bank (organization) and 銀行(organization) closer to each other.
+
+If token $t _ { k }$ has at least one translation in the dictionary, the translation cross entropy loss can be computed as:
+
+$$
+\mathcal { L } _ { \mathrm { T R A N } } = - \log ( p ( v _ { j , s ^ { * } } | c o n t e x t ) )
+$$
+
+If token $t _ { k }$ has no translation in the seed dictionary, we use Eq. 4 as the only loss. The joint training loss is defined as follows:
+
+$$
+\mathcal { L } _ { \mathrm { J O I N T } } = \left\{ \begin{array} { l l } { \frac { \mathcal { L } _ { \mathrm { S E N S E } } + \mathcal { L } _ { \mathrm { T R A N } } } { 2 } , } & { \mathrm { i f ~ } t _ { k } \mathrm { ~ h a s ~ t r a n s l a t i o n s } } \\ { \mathcal { L } _ { \mathrm { S E N S E } } , } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+Further alignment (optional) Our sense-aware pretraining tries to move similar senses of two different languages close to each other as illustrated in Figure 2. This process makes the sense distributions of the two languages more isomorphic (some sense vector visualization examples are shown in Appendix C). Applying the linear projection approach proposed by Schuster et al. (2019) on top of the language model pretrained with our framework can further improve cross-lingual transfer on some tasks. See Appendix B for more details of our implementation.
+
+# 4 EXPERIMENTS
+
+# 4.1 EXPERIMENTS USING MONOLINGUAL MODELS
+
+To verify the effectiveness of our proposed sense-aware cross entropy loss, we implement the monolingual models on top of ELMo and BERT with the changes described in $\ S 3 . 1$ , which are named SaELMo (Sense-aware ELMo) and SaBERT (Sense-aware BERT) respectively. The algorithm for dynamic pruning of redundant word senses is optional, which is implemented on SaELMo only.
+
+Pretraining settings We use the one billion word language modeling benchmark data (Chelba et al., 2013) to pretrain all the monolingual models. The corpus is preprocessed with the provided scripts, and then converted to lowercase. We do not apply any subword tokenization. We use similar hyper-parameters as Peters et al. (2018) to train the ELMo and SaELMo models, and similar hyperparameters as Devlin et al. (2018) to train 4-layer BERT-Tiny and SaBERT-Tiny. Next sentence prediction task is disabled in BERT-Tiny and SaBERT-Tiny, since this task is irrelevant to our proposed changes. See Appendix D.1 for a complete list of hyper-parameters.
+
+Word sense disambiguation (WSD) Since our context-aware cross entropy loss is designed to learn word senses better in the context, we first conduct experiments to compare our monolingual model with the original models on the WSD task (Raganato et al., 2017), which is a task to associate words in context with the most suitable entry in a pre-defined sense inventory. We use a similar framework as Peters et al. (2018) to evaluate the monolingual models.3 We use SemCor 3.0 (Miller et al., 1993) as training data, and Senseval/SemEval series (Edmonds & Cotton, 2001; Moro & Navigli, 2015; Navigli et al., 2013; Pradhan et al., 2007; Snyder & Palmer, 2004) as test data. We use the pretrained models to compute the average of contextual representations for each sense in training data, and then classify the senses of the target words in test sentences by finding the nearest neighbour.
+
+WSD results are presented in Table 2. SaELMo shows significant performance improvements over the baseline ELMo model in all of the five test sets. SaBERT-Tiny also outperforms BERT-Tiny except on SE07, which is the smallest among the five test sets.
+
+Table 2: Word sense disambiguation (F1 scores)   
+
+<table><tr><td>Model</td><td>SE2</td><td>SE3</td><td>SE07</td><td>SE13</td><td>SE15</td></tr><tr><td>ELMo</td><td>0.555</td><td>0.576</td><td>0.446</td><td>0.544</td><td>0.538</td></tr><tr><td>SaELMo (ours)</td><td>0.575</td><td>0.586</td><td>0.470</td><td>0.560</td><td>0.583</td></tr><tr><td>BERT-Tiny</td><td>0.596</td><td>0.539</td><td>0.466</td><td>0.536</td><td>0.572</td></tr><tr><td>SaBERT-Tiny (ours)</td><td>0.611</td><td>0.546</td><td>0.446</td><td>0.550</td><td>0.579</td></tr></table>
+
+# 4.2 EXPERIMENTS USING BILINGUAL MODELS
+
+To verify the effectiveness of our cross-lingual framework, we implement the bilingual models on top of ELMo, named Bi-SaELMo that does not use linear projection for further alignment and Bi-SaELMo $^ +$ Proj that uses the linear projection. Sense vectors and cluster center vectors are not shared between the forward and backward language models. We use ELMo+Proj and Joint$\mathbf { E L M o + P r o j }$ as our baseline models, where ELMo+Proj is proposed by Schuster et al. (2019) and Joint-ELMo $^ +$ Proj is implemented following the framework recently proposed by Wang et al. (2020). Wang et al. (2020) combine joint training and projection, and claim their framework is applicable to any projection method, so we implement the same projection method as Schuster et al. (2019) did for Joint-ELMo $+$ Proj. We also report results of ELMo and Joint-ELMo, which are the counterparts of ELMo+Proj and Joint-ELMo $^ +$ Proj without using linear projection.
+
+Pretraining settings To pretrain language models, we sample a 500-million-token corpus for each language from the English, German, Spanish, Japanese and Chinese Wikipedia dump. The dictionaries used for pretraining models and learning the projection matrix were downloaded from the MUSE (Conneau et al., 2017) GitHub page4. We also add JMDict (Breen, 2004) to the en-jp MUSE dictionary. Bilingual models were pretrained on en-de, en-es, en-jp and en-zh concatenated data with similar parameters as the monolingual models. ELMo and ELMo+Proj were pretrained on monolingual data, while the projection matrix of ELMo $+$ Proj was learned using bilingual data. See Appendix D.2 for a complete list of hyper-parameters.
+
+Zero-shot cross-lingual NER A BiLSTM-CRF model implemented with the Flair framework (Akbik et al., 2018) is used for this task. For the CoNLL-2002 (Tjong Kim Sang, 2002) and CoNLL-2003 (Sang & De Meulder, 2003) datasets, the NER model was trained on English data, and evaluated on Spanish and German test data. For the OntoNotes 5.0 (Weischedel et al., 2013) dataset, the NER model was trained on all English data and evaluated on all Chinese data. We report the average F1 of 5 runs in Table 3. The results show that all of the models using linear projection outperform their counterparts (not using linear projection), since minimizing token level distance is more important for cross-lingual
+
+Table 3: Zero-shot cross-lingual NER (F1)   
+
+<table><tr><td>Model</td><td>de</td><td>es</td><td>zh</td></tr><tr><td>ELMo</td><td>16.30</td><td>16.14</td><td>0.28</td></tr><tr><td>Joint-ELMo</td><td>56.49</td><td>58.91</td><td>53.47</td></tr><tr><td>ELMo+Proj (Schuster et al.,2019)</td><td>69.57</td><td>60.02</td><td>63.15</td></tr><tr><td>Joint-ELMo+Proj (Wang et al.,2020)</td><td>71.59</td><td>65.19</td><td>59.08</td></tr><tr><td>Bi-SaELMo (ours)</td><td>63.83</td><td>60.65</td><td>55.83</td></tr><tr><td>Bi-SaELMo+Proj (ours)</td><td>72.19</td><td>65.86</td><td>63.44</td></tr><tr><td colspan="4">For references, but not our baselines,since they are t trainedon1 1much larger datasets and/or parallel sentences.</td></tr><tr><td>XLM Finetune (Conneau &amp; Lample, 2019)</td><td>67.55</td><td>63.18</td><td>-</td></tr><tr><td>XLM-R Finetune (Conneau et al.,2019)</td><td>71.40</td><td>78.64</td><td>-</td></tr><tr><td>M-BERT Finetune (Pires et al., 2019)</td><td>69.74</td><td>73.59</td><td>-</td></tr><tr><td>M-BERT Finetune (Wu &amp; Dredze,2019)</td><td>69.56</td><td>74.96</td><td>-</td></tr><tr><td>M-BERT Finetune+Adv (Keung et al., 2019)</td><td>71.90</td><td>74.30</td><td>-</td></tr><tr><td>M-BERT Feature+Proj (Wang et al.,2020)</td><td>70.54</td><td>75.77</td><td>-</td></tr></table>
+
+NER tasks. Our sense-aware pretraining makes sense distributions of two languages more isomorphic, which further improves linear projection performance. Our model Bi-SaELMo+Proj demonstrates consistent performance improvement in all the three languages. Moreover, our model outperforms finetuned XLM/XLM-R and Multilingual BERT on German data, and achieves state of the art even though it is pretrained on less data.
+
+Zero-shot cross-lingual sentiment classification We use the multi-lingual multi-domain Amazon review data (Prettenhofer & Stein, 2010) for evaluation on cross-lingual sentiment classification. The ratings in review data are converted into binary labels. The average of contextual word representations is used as the document/sentence representation for each review text/summary, which is then fed into a two-dense-layer model for sentiment classification. All the models are trained on English, and evaluated on German and Japanese test data in the same domain. We report the average accuracy of 5 runs in Table 4. Different from the NER task, the linear projection approach for cross-lingual alignment does not work for this task, since it may add noise to embedding features. Our model Bi-SaELMo demonstrates consistent improvements in all of the 6 evaluation tasks. The performance of Bi-SaELMo is significantly better than Joint-ELMo, which shows that our sense-level translation pretraining objective improves cross-lingual embedding alignment.
+
+Table 4: Zero-shot sentiment classification accuracy   
+
+<table><tr><td>Model</td><td colspan="3">de</td><td colspan="3">jp</td></tr><tr><td></td><td>books</td><td>music</td><td>dvd</td><td>books</td><td>music</td><td>dvd</td></tr><tr><td>ELMo</td><td>52.94</td><td>63.61</td><td>57.78</td><td>50.37</td><td>51.59</td><td>54.32</td></tr><tr><td>Joint-ELMo</td><td>71.72</td><td>75.22</td><td>64.25</td><td>66.64</td><td>68.50</td><td>58.54</td></tr><tr><td>ELMo+Proj (Schuster et al., 2019)</td><td>49.92</td><td>50.29</td><td>49.94</td><td>50.57</td><td>49.59</td><td>50.65</td></tr><tr><td>Joint-ELMo+Proj (Wang et al.,2020)</td><td>75.74</td><td>72.25</td><td>72.25</td><td>62.50</td><td>59.77</td><td>57.65</td></tr><tr><td>Bi-SaELMo (ours)</td><td>77.46</td><td>75.32</td><td>74.97</td><td>68.16</td><td>69.48</td><td>64.04</td></tr><tr><td>Bi-SaELMo+Proj (ours)</td><td>70.84</td><td>66.25</td><td>68.99</td><td>62.17</td><td>55.91</td><td>61.57</td></tr></table>
+
+Table 5: Zero-shot XNLI accuracy   
+
+<table><tr><td>Model</td><td>de</td><td>es</td><td>zh</td></tr><tr><td>ELMo</td><td>34.07</td><td>33.41</td><td>35.77</td></tr><tr><td>Joint-ELMo</td><td>60.12</td><td>63.73</td><td>57.82</td></tr><tr><td>ELMo+Proj (Schuster et al.,2019)</td><td>55.51</td><td>58.92</td><td>53.17</td></tr><tr><td>Joint-ELMo+Proj (Wang et al.,2020)</td><td>63.33</td><td>64.71</td><td>58.34</td></tr><tr><td>Bi-SaELMo (ours)</td><td>60.98</td><td>62.75</td><td>60.40</td></tr><tr><td>Bi-SaELMo+Proj (ours)</td><td>64.77</td><td>65.05</td><td>60.44</td></tr></table>
+
+Zero-shot cross-lingual natural language inference (XNLI) We use XNLI (Conneau et al., 2018) and MultiNLI (Williams et al., 2018) data for evaluation on this task. The Bi-LSTM baseline model5 was trained on MultiNLI English training data, and then evaluated on XNLI German, Spanish, Chinese test data. We report the average zero-shot XNLI accuracy of 2 runs in Table 5. Our models show consistent improvements over the baselines on all of the three data sets. For zero-shot transfer to Chinese, both of our models outperform the best baseline by more than 2 points, which again demonstrates the effectiveness of our framework on distant language pairs.
+
+# 5 RELATED WORK
+
+Cross-lingual word embedding demonstrates strong performance in many cross-lingual transfer tasks. The projection-based approach has a long line of research on aligning static embeddings (Mikolov et al., 2013; Xing et al., 2015; Smith et al., 2017; Joulin et al., 2018). It assumes that the embedding spaces of different languages have an isomorphic structure, and fit an orthogonal matrix to project multiple monolingual embedding spaces to a shared space. Recent studies (Schuster et al., 2019; Aldarmaki & Diab, 2019) have extended this approach to contextual representation alignment. Besides, there are also many discussions on the limitations of the projection-based approach, arguing that the isomorphic assumption is not true in general (Nakashole & Flauger, 2018; Patra et al., 2018; Søgaard et al., 2018; Ormazabal et al., 2019). Joint training is another line of research and early methods (Gouws et al., 2015; Luong et al., 2015; Ammar et al., 2016) learn static word embeddings of multiple languages simultaneously. Extending joint training to cross- or multi-lingual language model pretraining has gained more attention recently. As discussed above, unsupervised multilingual language models (Devlin et al., 2018; Artetxe & Schwenk, 2019; Conneau & Lample, 2019; Conneau et al., 2019; Liu et al., 2020) also demonstrate strong cross-lingual transfer performance.
+
+There has been some work on sense-aware language models/embeddings (Rothe & Schutze, 2015; ¨ Pilehvar & Collier, 2016; Hedderich et al., 2019), and most of them require WordNet (Miller, 1998) or other additional resource for supervision. Suster et al. (2016) utilize both monolingual and bilingual ˇ information from parallel corpora to learn multi-sense word embeddings. Peters et al. (2019) embed WordNet knowledge into BERT with attention mechanism. Levine et al. (2019) pretrain SenseBERT to predict both the masked words and their WordNet supersenses. Similar to our framework, there are also some unsupervised approaches, but most of them are used to learn static embeddings. Huang et al. (2012) learn word representations with both local and global context, and then apply a clustering algorithm to learn multi-prototype vectors. Neelakantan et al. (2014) propose an extension to the Skip-gram model that leverage $\mathbf { k }$ -means clustering algorithm learns multiple embeddings per word type. Lee & Chen (2017) leverage reinforcement learning for modularized unsupervised sense level embedding learning. Boyd-Graber et al. (2020) use Gumbel softmax for sense disambiguation when learning sense embeddings.
+
+# 6 CONCLUSIONS
+
+In this paper, we have introduced a novel sense-aware cross entropy loss to model word senses explicitly, then we have further proposed a sense-level alignment objective for cross-lingual model pretraining using only bilingual dictionaries. The results of the experiments show the effectiveness of our monolingual and bilingual models on WSD, zero-shot cross-lingual NER, sentiment classification and XNLI tasks. In future work, we will study how to effectively extend our method to multilingual models. In addition, using the sense cluster centers to learn the linear projection matrix would be another promising direction to further improve cross-lingual alignment.
+
+# REFERENCES
+
+Amr Abdullatif, Francesco Masulli, and Stefano Rovetta. Clustering of nonstationary data streams: A survey of fuzzy partitional methods. Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery, 8(4):e1258, 2018.
+
+Charu C Aggarwal, Jiawei Han, Jianyong Wang, and Philip S Yu. A framework for projected clustering of high dimensional data streams. In Proceedings of the Thirtieth international conference on Very large data bases-Volume 30, pp. 852–863, 2004.
+
+Alan Akbik, Duncan Blythe, and Roland Vollgraf. Contextual string embeddings for sequence labeling. In COLING 2018, 27th International Conference on Computational Linguistics, pp. 1638–1649, 2018.
+
+Hanan Aldarmaki and Mona Diab. Context-aware crosslingual mapping. arXiv preprint arXiv:1903.03243, 2019.
+
+Waleed Ammar, George Mulcaire, Yulia Tsvetkov, Guillaume Lample, Chris Dyer, and Noah A Smith. Massively multilingual word embeddings. arXiv preprint arXiv:1602.01925, 2016.
+
+Mikel Artetxe and Holger Schwenk. Massively multilingual sentence embeddings for zero-shot cross-lingual transfer and beyond. Transactions of the Association for Computational Linguistics, 7:597–610, Mar 2019. ISSN 2307-387X. doi: 10.1162/tacl a 00288. URL http://dx.doi. org/10.1162/tacl_a_00288.
+
+Jordan Boyd-Graber, Fenfei Guo, Leah Findlater, and Mohit Iyyer. Which evaluations uncover sense representations that actually make sense? In Proceedings of the 12th Language Resources and Evaluation Conference, pp. 1727–1738, Marseille, France, May 2020. European Language Resources Association. ISBN 979-10-95546-34-4. URL https://www.aclweb.org/anthology/ 2020.lrec-1.214.
+
+Jim Breen. Jmdict: a japanese-multilingual dictionary. In Proceedings of the workshop on multilingual linguistic resources, pp. 65–72, 2004.
+
+Steven Cao, Nikita Kitaev, and Dan Klein. Multilingual alignment of contextual word representations. arXiv preprint arXiv:2002.03518, 2020.
+
+Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling, 2013.
+
+Alexis Conneau and Guillaume Lample. Cross-lingual language model pretraining. In Advances in Neural Information Processing Systems, pp. 7057–7067, 2019.
+
+Alexis Conneau, Guillaume Lample, Marc’Aurelio Ranzato, Ludovic Denoyer, and Herve J ´ egou. ´ Word translation without parallel data. arXiv preprint arXiv:1710.04087, 2017.
+
+Alexis Conneau, Ruty Rinott, Guillaume Lample, Adina Williams, Samuel R. Bowman, Holger Schwenk, and Veselin Stoyanov. Xnli: Evaluating cross-lingual sentence representations. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, 2018.
+
+Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzman, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Unsupervised ´ cross-lingual representation learning at scale. arXiv preprint arXiv:1911.02116, 2019.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Philip Edmonds and Scott Cotton. Senseval-2: overview. In Proceedings of SENSEVAL-2 Second International Workshop on Evaluating Word Sense Disambiguation Systems, pp. 1–5, 2001.
+
+Stephan Gouws, Yoshua Bengio, and Greg Corrado. Bilbowa: Fast bilingual distributed representations without word alignments. In Proceedings of the 32nd International Conference on Machine Learning, 2015.
+
+Michael A. Hedderich, Andrew Yates, Dietrich Klakow, and Gerard de Melo. Using multi-sense vector embeddings for reverse dictionaries. In Proceedings of the 13th International Conference on Computational Semantics - Long Papers, pp. 247–258, Gothenburg, Sweden, May 2019. Association for Computational Linguistics. doi: 10.18653/v1/W19-0421. URL https://www. aclweb.org/anthology/W19-0421.
+
+Eric Huang, Richard Socher, Christopher Manning, and Andrew Ng. Improving word representations via global context and multiple word prototypes. In Proceedings of the 50th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 873–882, Jeju Island, Korea, July 2012. Association for Computational Linguistics. URL https://www.aclweb. org/anthology/P12-1092.
+
+Armand Joulin, Piotr Bojanowski, Tomas Mikolov, Herve J ´ egou, and Edouard Grave. Loss in transla- ´ tion: Learning bilingual word mapping with a retrieval criterion. arXiv preprint arXiv:1804.07745, 2018.
+
+Phillip Keung, Yichao Lu, and Vikas Bhardwaj. Adversarial learning with contextual embeddings for zero-resource cross-lingual classification and ner. arXiv preprint arXiv:1909.00153, 2019.
+
+Madjid Khalilian and Norwati Mustapha. Data stream clustering: Challenges and issues. arXiv preprint arXiv:1006.5261, 2010.
+
+Guang-He Lee and Yun-Nung Chen. MUSE: Modularizing unsupervised sense embeddings. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 327–337, Copenhagen, Denmark, September 2017. Association for Computational Linguistics. doi: 10.18653/v1/D17-1034. URL https://www.aclweb.org/anthology/D17-1034.
+
+Yoav Levine, Barak Lenz, Or Dagan, Dan Padnos, Or Sharir, Shai Shalev-Shwartz, Amnon Shashua, and Yoav Shoham. Sensebert: Driving some sense into bert. arXiv preprint arXiv:1908.05646, 2019.
+
+Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, and Luke Zettlemoyer. Multilingual denoising pre-training for neural machine translation, 2020.
+
+Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Bilingual word representations with monolingual quality in mind. In Proceedings of the 1st Workshop on Vector Space Modeling for Natural Language Processing, pp. 151–159, 2015.
+
+Christopher D. Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven J. Bethard, and David McClosky. The Stanford CoreNLP natural language processing toolkit. In Association for Computational Linguistics (ACL) System Demonstrations, pp. 55–60, 2014. URL http://www. aclweb.org/anthology/P/P14/P14-5010.
+
+Tomas Mikolov, Quoc V Le, and Ilya Sutskever. Exploiting similarities among languages for machine translation. arXiv preprint arXiv:1309.4168, 2013.
+
+George A Miller. WordNet: An electronic lexical database. MIT press, 1998.
+
+George A Miller, Claudia Leacock, Randee Tengi, and Ross T Bunker. A semantic concordance. In Proceedings of the workshop on Human Language Technology, pp. 303–308. Association for Computational Linguistics, 1993.
+
+Andrea Moro and Roberto Navigli. Semeval-2015 task 13: Multilingual all-words sense disambiguation and entity linking. In Proceedings of the 9th international workshop on semantic evaluation (SemEval 2015), pp. 288–297, 2015.
+
+Ndapa Nakashole and Raphael Flauger. Characterizing departures from linearity in word translation. arXiv preprint arXiv:1806.04508, 2018.
+
+Roberto Navigli, David Jurgens, and Daniele Vannella. Semeval-2013 task 12: Multilingual word sense disambiguation. In Second Joint Conference on Lexical and Computational Semantics (\* SEM), Volume 2: Proceedings of the Seventh International Workshop on Semantic Evaluation (SemEval 2013), pp. 222–231, 2013.
+
+Arvind Neelakantan, Jeevan Shankar, Alexandre Passos, and Andrew McCallum. Efficient nonparametric estimation of multiple embeddings per word in vector space. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1059–1069, Doha, Qatar, October 2014. Association for Computational Linguistics. doi: 10.3115/v1/D14-1113. URL https://www.aclweb.org/anthology/D14-1113.
+
+Aitor Ormazabal, Mikel Artetxe, Gorka Labaka, Aitor Soroa, and Eneko Agirre. Analyzing the limitations of cross-lingual word embedding mappings. arXiv preprint arXiv:1906.05407, 2019.
+
+Barun Patra, Joel Ruben Antony Moniz, Sarthak Garg, Matthew R Gormley, and Graham Neubig. Bliss in non-isometric embedding spaces. 2018.
+
+Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proc. of NAACL, 2018.
+
+Matthew E Peters, Mark Neumann, Robert L Logan IV, Roy Schwartz, Vidur Joshi, Sameer Singh, and Noah A Smith. Knowledge enhanced contextual word representations. arXiv preprint arXiv:1909.04164, 2019.
+
+Mohammad Taher Pilehvar and Nigel Collier. De-conflated semantic representations. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 1680–1690, Austin, Texas, November 2016. Association for Computational Linguistics. doi: 10.18653/v1/ D16-1174. URL https://www.aclweb.org/anthology/D16-1174.
+
+Telmo Pires, Eva Schlinger, and Dan Garrette. How multilingual is multilingual bert? arXiv preprint arXiv:1906.01502, 2019.
+
+Sameer Pradhan, Edward Loper, Dmitriy Dligach, and Martha Palmer. Semeval-2007 task-17: English lexical sample, srl and all words. In Proceedings of the fourth international workshop on semantic evaluations (SemEval-2007), pp. 87–92, 2007.
+
+Peter Prettenhofer and Benno Stein. Cross-language text classification using structural correspondence learning. In Proceedings of the 48th Annual Meeting of the Association for Computational Linguistics, pp. 1118–1127, Uppsala, Sweden, July 2010. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/P10-1114.
+
+Alessandro Raganato, Jose Camacho-Collados, and Roberto Navigli. Word sense disambiguation: A unified evaluation framework and empirical comparison. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, pp. 99–110, Valencia, Spain, April 2017. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/E17-1010.
+
+Sascha Rothe and Hinrich Schutze. AutoExtend: Extending word embeddings to embeddings ¨ for synsets and lexemes. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), pp. 1793–1803, Beijing, China, July 2015. Association for Computational Linguistics. doi: 10.3115/v1/P15-1173. URL https://www.aclweb.org/ anthology/P15-1173.
+
+Erik F Sang and Fien De Meulder. Introduction to the conll-2003 shared task: Language-independent named entity recognition. arXiv preprint cs/0306050, 2003.
+
+Tal Schuster, Ori Ram, Regina Barzilay, and Amir Globerson. Cross-lingual alignment of contextual word embeddings, with applications to zero-shot dependency parsing. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 1599–1613, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1162. URL https://www.aclweb.org/anthology/N19-1162.
+
+Samuel L Smith, David HP Turban, Steven Hamblin, and Nils Y Hammerla. Offline bilingual word vectors, orthogonal transformations and the inverted softmax. arXiv preprint arXiv:1702.03859, 2017.
+
+Benjamin Snyder and Martha Palmer. The english all-words task. In Proceedings of SENSEVAL-3, the Third International Workshop on the Evaluation of Systems for the Semantic Analysis of Text, pp. 41–43, 2004.
+
+Anders Søgaard, Sebastian Ruder, and Ivan Vulic. On the limitations of unsupervised bilingual ´ dictionary induction. arXiv preprint arXiv:1805.03620, 2018.
+
+Simon Suster, Ivan Titov, and Gertjan Van Noord. Bilingual learning of multi-sense embeddings with ˇ discrete autoencoders. arXiv preprint arXiv:1603.09128, 2016.
+
+Erik F. Tjong Kim Sang. Introduction to the CoNLL-2002 shared task: Language-independent named entity recognition. In COLING-02: The 6th Conference on Natural Language Learning 2002 (CoNLL-2002), 2002. URL https://www.aclweb.org/anthology/W02-2024.
+
+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, pp. 5998–6008, 2017.
+
+Zirui Wang, Jiateng Xie, Ruochen Xu, Yiming Yang, Graham Neubig, and Jaime G. Carbonell. Cross-lingual alignment vs joint training: A comparative study and a simple unified framework. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id ${ . } = { }$ S1l-C0NtwS.
+
+Ralph Weischedel, Martha Palmer, Mitchell Marcus, Eduard Hovy, Sameer Pradhan, Lance Ramshaw, Nianwen Xue, Ann Taylor, Jeff Kaufman, Michelle Franchini, et al. Ontonotes release 5.0 ldc2013t19. Linguistic Data Consortium, Philadelphia, PA, 23, 2013.
+
+Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 1112–1122. Association for Computational Linguistics, 2018. URL http://aclweb.org/anthology/N18-1101.
+
+Shijie Wu and Mark Dredze. Beto, bentz, becas: The surprising cross-lingual effectiveness of bert. arXiv preprint arXiv:1904.09077, 2019.
+
+Chao Xing, Dong Wang, Chao Liu, and Yiye Lin. Normalized word embedding and orthogonal transform for bilingual word translation. In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 1006–1011, 2015.
+
+Zheng Zhang, Ruiqing Yin, Jun Zhu, and Pierre Zweigenbaum. Cross-lingual contextual word embeddings mapping with multi-sense words in mind. arXiv preprint arXiv:1909.08681, 2019.
+
+# APPENDIX
+
+# A PREDICTION TASKS OF LANGUAGE MODELS
+
+Next token prediction and masked token prediction are two common tasks in neural language model (LM) pretraining. We take two well-known language models, ELMo and BERT, as examples to illustrate these two tasks, which are shown in Figure 3.
+
+![](images/00c5c4d80d28c12209dbf25a1b889ebd01eb5da62cbb3e8da14388f601fba4d2.jpg)  
+Figure 3: Next token and masked token prediction tasks of language models. For simplicity, we only show the forward language model in next token prediction.
+
+# B FURTHER ALIGNMENT (OPTIONAL)
+
+Applying the linear projection approach proposed by Schuster et al. (2019) on top of our framework can further improve cross-lingual transfer on some tasks. After our cross-lingual model is finished training on the concatenated corpora of two languages, $L _ { 1 }$ and $L _ { 2 }$ , it is used to generate contextual token embeddings for the word pairs in the seed dictionary $\mathcal { D } = \{ ( t _ { i } ^ { L _ { 1 } } , t _ { i } ^ { L _ { 2 } } ) \} _ { i = 1 } ^ { | \mathcal { D } | }$ 6. Then, we compute the average of all contextual embeddings for each token tLji , denoted by aLji . Finally, a
+
+$$
+W = \underset { W } { \arg \operatorname* { m i n } } \sum _ { i = 1 } ^ { | \mathcal { D } | } | | W \pmb { a } _ { i } ^ { L _ { 1 } } - \pmb { a } _ { i } ^ { L _ { 2 } } | | ^ { 2 }
+$$
+
+# C VISUALIZATION OF SENSE VECTORS
+
+We visualize7 the sense vectors of each model in a two dimensional PCA, and show some examples in Figures 4 to 7. For our English monolingual model (SaELMo), the vectors close to two different sense vectors of the word may are shown in (a) and (b) of Figure 4, respectively. We observe that senses are well clustered in these two subfigures, where cluster (a) corresponds to “month”, and cluster (b) corresponds to “auxiliary verb”.
+
+We do the same for the English-Japanese bilingual model (Bi-SaELMo, without projection), and show the vectors close to two different sense vectors of the English word bank in (c) and (d) of Figure 5. We can see both English and Japanese sense vectors (trade, 銀行, 証券, etc.) in (c), most of which correspond to the sense “organization”, though there are some noises. Similarly, most of the sense vectors in (d) correspond to sense “river bank”.
+
+Another two examples are shown in Figures 6 and 7. Our framework exhibits good sense clustering and sense level cross-lingual alignment behaviour in these examples. All sense vectors are dumped at training step 200,000, which is before pretraining complete.
+
+![](images/c5ef53a2f6367d3995ef4f1d101b386d70403c0364a54f3e0e4c48bea4f8447d.jpg)  
+Figure 4: We visualize sense vectors of English monolingual model (SaELMo) in a two dimensional PCA, and show the vectors close to two different sense vectors of word may in (a) and (b).
+
+![](images/6ce22bb1b8cf9d7652ee916c0d8ace4d0db5084f9650fe1d1584796f9005d86e.jpg)  
+Figure 5: We visualize all sense vectors of en-jp bilingual model (Bi-SaELMo) in a two dimensional PCA, and show the vectors close to two different sense vectors of word bank.
+
+![](images/1d2f78dedd801317944b6c6f7dfdedee9a448441ba90652425d0a25e1e8aa9d3.jpg)  
+Figure 6: We visualize sense vectors of English monolingual model (SaELMo) in a two dimensional PCA, and show the vectors close to two different sense vectors of word us in (a) and (b).
+
+![](images/68946afbd8f5c48486a50a9127da5b0f1dce5405a0622b44feac86f59c80fd4c.jpg)  
+Figure 7: We visualize all sense vectors of en-de bilingual model (Bi-SaELMo) in a two dimensional PCA, and show the vectors close to two different sense vectors of word may.
+
+# D PRETRAINING DETAILS
+
+# D.1 MONOLINGUAL MODEL
+
+All the monolingual models were trained for one million steps. For better sense clustering performance, the maximum number of senses $S$ in word sense selection algorithm) was set to 1 for the first 20,000 steps to quickly get a reasonable initial model, and then increased to 5 afterwards when pretraining SaELMo and SaBERT-Tiny, which is controlled by hyperparameter n context in our implementation. For SaELMo, we set n context to 6, so that the model initialize 6 senses for each token, but only use the first sense in the 20,000 steps, and then use the other 5 senses (the first sense will be disabled) afterwards. We implement this for SaBERT-Tiny in a slightly different way, where n context can be set to 5 directly to achieve the same effect. We use two NVIDIA V100 GPUs to pretrain SaELMo, which takes about 15 days to complete training. We use one NVIDIA V100 GPU to pretrain SaBERT-Tiny, which takes about 5 days. See Tables 6 and 7 for the hyperparameters used to pretrain SaELMo and SaBERT-Tiny respectively.
+
+Table 6: Monolingual model hyperparameters: SaELMo   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>max_word_length</td><td>50</td></tr><tr><td>batch_size</td><td>256</td></tr><tr><td>n-gpus</td><td>2</td></tr><tr><td>bidirectional</td><td>True</td></tr><tr><td>char_cnn:embedding:dim</td><td>16</td></tr><tr><td>char_cnn:max_characters-per_token</td><td>50</td></tr><tr><td>char_cnn:n_characters</td><td>261</td></tr><tr><td>char_cnn:n_highway</td><td>2</td></tr><tr><td>dropout</td><td>0.1</td></tr><tr><td>lstm:cell_clip</td><td>3</td></tr><tr><td>lstm:dim</td><td>4096</td></tr><tr><td>lstm:n_layers</td><td>2</td></tr><tr><td>lstm:proj_clip</td><td>3</td></tr><tr><td>lstm:projection_dim</td><td>512</td></tr><tr><td>lstm:use_skip_connections</td><td>True</td></tr><tr><td>all_clip_norm_val</td><td>10.0</td></tr><tr><td>n_epochs</td><td>10</td></tr><tr><td>unroll_steps</td><td>16</td></tr><tr><td>n_negative_samples_batch</td><td>8192</td></tr><tr><td>n_context</td><td>6</td></tr><tr><td>cluster_proj_dim</td><td>16</td></tr><tr><td>pca_sample</td><td>20.000</td></tr><tr><td>remove_less_freqent_contexts</td><td>0.1</td></tr><tr><td>learning_rate</td><td>0.2</td></tr><tr><td>sense_learning_rate</td><td>0.01</td></tr></table>
+
+Table 7: Monolingual model hyperparameters: SaBERT-Tiny   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>attention-probs_dropout_prob</td><td>50</td></tr><tr><td>directionality</td><td>bidi</td></tr><tr><td>hidden_act</td><td>gelu</td></tr><tr><td>hidden_dropout_prob</td><td>0.1</td></tr><tr><td>hidden_size</td><td>512</td></tr><tr><td>initializer_range</td><td>0.02</td></tr><tr><td>intermediate_size</td><td>2048</td></tr><tr><td>max-position_embeddings</td><td>512</td></tr><tr><td>num_attention_heads</td><td>8</td></tr><tr><td>num_hidden_layers</td><td>4</td></tr><tr><td>pooler_fc_size</td><td>512</td></tr><tr><td>pooler_num_attention_heads</td><td>8</td></tr><tr><td>pooler_num_fc_layers</td><td>3</td></tr><tr><td>pooler_size-per_head</td><td>128</td></tr><tr><td>pooler_type</td><td>first_token_transform</td></tr><tr><td>type_vocab_size</td><td>2</td></tr><tr><td>vocab_size</td><td>27654</td></tr><tr><td>n_context</td><td>5</td></tr><tr><td>context_rep_lr</td><td>0.01</td></tr><tr><td>pca_dim</td><td>14</td></tr><tr><td>contextual_warmup</td><td>20.000</td></tr></table>
+
+# D.2 BILINGUAL MODEL
+
+As metioned in the paper, we use Wikipedia dump to pretrain the bilingual models. The Stanford CoreNLP tokenizer (Manning et al., 2014) is used to tokenize English, German, Spanish and Chinese data. And the spaCy tokenizer is used to tokenize Japanese data. All data are converted to lowercase. We convert Chinese data to simplified font to make it consistent with evaluation task datasets.
+
+All the language models used in cross-lingual experiments were pretrained for 600,000 steps from scratch. Similar to our monolingual models, maximum number of senses $S$ in word sense selection algorithm) was set to 1 for the first 20,000 steps, and the increased to 3 afterwards when pretraining Bi-SaELMo and Bi-SaELMo $+$ Proj.8 We use two NVIDIA V100 GPUs to pretrain each Bi-SaELMo model, which takes about 10 days to complete the training. See Table 8 for the hyperparameters used to pretrain Bi-SaELMo/Bi-SaELMo+Proj.
+
+Table 8: Bilingual model hyperparameters: Bi-SaELMo/Bi-SaELMo+Proj   
+
+<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>max_word_length</td><td>50</td></tr><tr><td>batch_size</td><td>256</td></tr><tr><td>n-gpus</td><td>2</td></tr><tr><td>bidirectional</td><td>True</td></tr><tr><td>char_cnn:embedding:dim</td><td>16</td></tr><tr><td>char_cnn:max_characters_per_token</td><td>50</td></tr><tr><td>char_cnn:n_characters</td><td>261</td></tr><tr><td>char_cnn:n_highway</td><td>2</td></tr><tr><td>dropout</td><td>0.1</td></tr><tr><td>lstm:cell_clip</td><td>3</td></tr><tr><td>lstm:dim</td><td>4096</td></tr><tr><td>lstm:n_layers</td><td>2</td></tr><tr><td>lstm:proj_clip</td><td>3</td></tr><tr><td>lstm:projection_dim</td><td>512</td></tr><tr><td>lstm:use_skip_connections</td><td>True</td></tr><tr><td>all_clip_norm_val</td><td>10.0</td></tr><tr><td>n_epochs</td><td>6</td></tr><tr><td>unroll_steps</td><td>12</td></tr><tr><td>n_negative_samples_batch</td><td>8192</td></tr><tr><td>n_context</td><td>4</td></tr><tr><td>cluster_proj-dim</td><td>16</td></tr><tr><td>pca_sample</td><td>20,000</td></tr><tr><td>remove_less_freqent_contexts</td><td>0.1</td></tr><tr><td>learning_rate</td><td>0.2</td></tr><tr><td>sense_learning_rate</td><td>0.01</td></tr></table>

parse/train/SVsLxTfHa1/SVsLxTfHa1_content_list.json

@@ -0,0 +1,1881 @@
+[
+    {
+        "type": "text",
+        "text": "TOWARDS MULTI-SENSE CROSS-LINGUAL ALIGNMENT OF CONTEXTUAL EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            710,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Cross-lingual word embeddings (CLWE) have been proven useful in many crosslingual tasks. However, most existing approaches to learn CLWE including the ones with contextual embeddings are sense agnostic. In this work, we propose a novel framework to align contextual embeddings at the sense level by leveraging cross-lingual signal from bilingual dictionaries only. We operationalize our framework by first proposing a novel sense-aware cross entropy loss to model word senses explicitly. The monolingual ELMo and BERT models pretrained with our sense-aware cross entropy loss demonstrate significant performance improvement for word sense disambiguation tasks. We then propose a sense alignment objective on top of the sense-aware cross entropy loss for cross-lingual model pretraining, and pretrain cross-lingual models for several language pairs (English to German/Spanish/Japanese/Chinese). Compared with the best baseline results, our cross-lingual models achieve $0 . 5 2 \\%$ , $2 . 0 9 \\%$ and $1 . 2 9 \\%$ average performance improvements on zero-shot cross-lingual NER, sentiment classification and XNLI tasks, respectively. We will release our code. ",
+        "bbox": [
+            233,
+            266,
+            766,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            336,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Cross-lingual word embeddings (CLWE) provide a shared representation space for knowledge transfer between languages, yielding state-of-the-art performance in many cross-lingual natural language processing (NLP) tasks. Most of the previous works have focused on aligning static embeddings. To utilize the richer information captured by the pre-trained language model, more recent approaches attempt to extend previous methods to align contextual representations. ",
+        "bbox": [
+            174,
+            534,
+            823,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Aligning the dynamic and complex contextual spaces poses significant challenges, so most of the existing approaches only perform coarse-grained alignment. Schuster et al. (2019) compute the average of contextual embeddings for each word as an anchor, and then learn to align the static anchors using a bilingual dictionary. In another work, Aldarmaki & Diab (2019) use parallel sentences in their approach, where they compute sentence representations by taking the average of contextual word embeddings, and then they learn a projection matrix to align sentence representations. They find that the learned projection matrix also works well for word-level NLP tasks. Besides, unsupervised multilingual language models (Devlin et al., 2018; Artetxe & Schwenk, 2019; Conneau et al., 2019; Liu et al., 2020) pretrained on multilingual corpora have also demonstrated strong cross-lingual transfer performance. Cao et al. (2020) and Wang et al. (2020) show that unsupervised multilingual language model can be further aligned with parallel sentences. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Though contextual word embeddings are intended to provide different representations of the same word in distinct contexts, Schuster et al. (2019) find that the contextual embeddings of different senses of one word are much closer compared with that of different words. This contributes to the anisomorphic embedding distribution of different languages and causes problems for cross-lingual alignment. For example, it will be difficult to align the English word bank and its Japanese translations 銀行 and 岸 that correspond to its two different senses, since the contextual embeddings of different senses of bank are close to each other while those of 銀行 and 岸 are far. Recently, Zhang et al. (2019) propose two solutions to handle multi-sense words: 1) remove multi-sense words and then align anchors in the same way as Schuster et al. (2019); 2) generate cluster level average anchor for contextual embeddings of multi-sense words and then learn a projection matrix in an unsupervised way with MUSE (Conneau et al., 2017). They do not make good use of the bilingual dictionaries, which are usually easy to obtain, even in low-resource scenarios. Moreover, their projection-based approach still cannot handle the anisomorphic embedding distribution problem. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a novel sense-aware cross entropy loss to model multiple word senses explicitly, and then leverage a sense level translation task on top of it for cross-lingual model pretraining. The proposed sense level translation task enables our models to provide more isomorphic and better aligned cross-lingual embeddings. We only use the cross-lingual signal from bilingual dictionaries for supervision. Our pretrained models demonstrate consistent performance improvements on zero-shot cross-lingual NER, sentiment classification and XNLI tasks. Though pretrained on less data, our model achieves the state-of-the-art result on zero-shot cross-lingual German NER task. To the best of our knowledge, we are the first to perform sense-level contextual embedding alignment with only bilingual dictionaries. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND: PREDICTION TASKS OF LANGUAGE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            279,
+            699,
+            295
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Next token prediction and masked token prediction are two common tasks in neural language model pretraining. We take two well-known language models, ELMo (Peters et al., 2018) and BERT (Devlin et al., 2018), as examples to illustrate these two tasks (architectures are shown in Appendix A). ",
+        "bbox": [
+            176,
+            304,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Next token prediction ELMo uses next token prediction tasks in a bidirectional language model. Given a sequence of $N$ tokens $( t _ { 1 } , t _ { 2 } , \\ldots , t _ { N } )$ , it first prepares a context independent representation for each token by using a convolutional neural network over the characters or by word embedding lookup (a.k.a. input embeddings). These representations are then fed into $L$ layers of LSTMs to generate the contextual representations: $h _ { i , j }$ for token $t _ { i }$ at layer $j$ . The model assigns a learnable output embedding $\\pmb { w }$ for each token in the vocabulary, which has the same dimension as $h _ { i , L }$ . Then, the forward language model predicts the token at position $k$ with: ",
+        "bbox": [
+            173,
+            354,
+            826,
+            454
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91dd7404e2f67e88378b989e5200fb54d04335970d667f9152f41825a4c65689.jpg",
+        "text": "$$\np ( t _ { k } | t _ { 1 } , t _ { 2 } , \\dots , t _ { k - 1 } ) = \\mathrm { s o f t m a x } ( h _ { k - 1 , L } ^ { \\mathsf { T } } w _ { k ^ { \\prime } } ) = \\frac { \\exp ( h _ { k - 1 , L } ^ { \\mathsf { T } } w _ { k ^ { \\prime } } ) } { \\sum _ { i = 1 } ^ { V } \\exp ( h _ { k - 1 , L } ^ { \\mathsf { T } } w _ { i } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            256,
+            459,
+            740,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $k ^ { \\prime }$ is the index of token $t _ { k }$ in the vocabulary, $V$ is the size of the vocabulary, and $( \\pmb { w } _ { 1 } , \\dots , \\pmb { w } _ { V } )$ are the output embeddings for the tokens in the vocabulary. The backward language model is similar to the forward one, except that tokens are predicted in the reverse order. Since the forward and backward language models are very similar, we will only describe our proposed approach in the context of the forward language model in the subsequent sections. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Masked token prediction The Masked Language Model (MLM) in BERT is a typical example of masked token prediction. Given a sequence $( t _ { 1 } , t _ { 2 } , \\ldots , t _ { N } )$ , this approach randomly masks a certain percentage $( 1 5 \\% )$ of the tokens and generates a masked sequence $( m _ { 1 } , m _ { 2 } , \\ldots , m _ { N } )$ , where $m _ { k } = [ m a s k ]$ if the token at position $k$ is masked, otherwise $m _ { k } = t _ { k }$ . BERT first prepares the context independent representations $( \\pmb { x } _ { 1 } , \\pmb { x } _ { 2 } , \\dots , \\pmb { x } _ { N } )$ of the masked sequence via token embeddings. It is then fed into $L$ layers of transformer encoder (Vaswani et al., 2017) to generate “bidirectional” contextual token representations. The final layer representations are then used to predict the masked token at position $k$ as follows: ",
+        "bbox": [
+            173,
+            587,
+            826,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64a7106ba0deb32c25a75c73745344d9242ca725f15baf18a14ba19c3bdfd7f0.jpg",
+        "text": "$$\np ( m _ { k } = t _ { k } | m _ { 1 } , \\dots , m _ { N } ) = \\mathrm { s o f t m a x } ( h _ { k , L } ^ { \\top } w _ { k ^ { \\prime } } ) = \\frac { \\exp ( h _ { k , L } ^ { \\top } w _ { k ^ { \\prime } } ) } { \\sum _ { i = 1 } ^ { V } \\exp ( h _ { k , L } ^ { \\top } w _ { i } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            705,
+            736,
+            748
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $k ^ { \\prime } , V ,$ $^ { h }$ and $\\textbf { \\em w }$ are similarly defined as in Eq. 1. Unlike ELMo, BERT ties the input and output embeddings. ",
+        "bbox": [
+            173,
+            755,
+            823,
+            785
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 PROPOSED FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            797,
+            410,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We first describe our proposed sense-aware cross entropy loss to model multiple word senses explicitly in language model pretraining. Then, we present our joint training approach with sense alignment objective for cross-lingual mapping of contextual word embeddings. The proposed framework can be applied to most of the recent neural language models, such as ELMo, BERT and their variants. See Table 1 for a summary of the main notations used in this paper. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 SENSE-AWARE CROSS ENTROPY LOSS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            911,
+            472,
+            925
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Limitations of original training objectives The training tasks with Eq. 1 and 2 maximize the normalized dot product of contextual representations $( h _ { k - 1 , L }$ or $\\displaystyle h _ { k , L } )$ ) with a weight vector $\\pmb { w } _ { k ^ { \\prime } }$ . The only difference is that $h _ { k - 1 , L }$ in Eq. 1 encodes the information of previous tokens in the sequence, while $h _ { k , L }$ in Eq. 2 encodes the information of the masked sequence. Therefore, without loss of generality, we use $h _ { k ^ { * } , L }$ to denote the contextual representation for predicting the next or masked token $t _ { k }$ . ",
+        "bbox": [
+            174,
+            104,
+            485,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Even though contextual language models like ELMo and BERT provide a different token representation for each distinct context, the learned representations are not guaranteed to be sense separated. For example, Schuster et al. (2019) computed the average of ELMo embeddings for each word as an anchor, and found that the average cosine distance between contextual em",
+        "bbox": [
+            174,
+            263,
+            485,
+            375
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/81c5e4160f9696fde4d2c74368d85660b7941e7ff060b7b9a1a8a978fb994663.jpg",
+        "table_caption": [
+            "Table 1: Summary of the main notations "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Notation</td><td>Description</td></tr><tr><td>tk</td><td>k-th token in sentence</td></tr><tr><td>tk,s</td><td>s-th sense of tk</td></tr><tr><td>k&#x27;</td><td>index of token tk in vocabulary</td></tr><tr><td>L</td><td>number ofLSTM/Transformer layers</td></tr><tr><td>V</td><td>size of vocabulary</td></tr><tr><td>S</td><td>maximum number of senses per token</td></tr><tr><td>hk,j</td><td>contextual representation of token tk in layer j</td></tr><tr><td>hk*,L</td><td>contextual representation used in softmax function for predicting tk</td></tr><tr><td>Ui</td><td>i-th word in vocabulary</td></tr><tr><td>Ui,s</td><td>s-th sense of Ui</td></tr><tr><td>Wi</td><td>output embedding of Ui</td></tr><tr><td>Wi,s</td><td>context-dependent output embedding (i.e. sense vector) of Ui,s</td></tr><tr><td>Ci,s</td><td>sense cluster center of Ui,s</td></tr><tr><td>C</td><td>sense cluster centers of Ui</td></tr><tr><td>d</td><td>dimension of contextual representations</td></tr><tr><td>P</td><td>projection matrix for dimension reduction</td></tr></table>",
+        "bbox": [
+            496,
+            119,
+            828,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "beddings of multi-sense words and their corresponding anchors are much smaller than the average distance between anchors, which mean that the embeddings of different senses of one word are relatively near to each other comparing to that of different words. We also observed the same with BERT embeddings. This finding suggests that sense clusters of a multi-sense word’s appearances are not well separated in the embedding space, and the current contextual language models still have room for improvement by considering finer-grained word sense disambiguation. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notice that there is only one weight vector $\\pmb { w } _ { k ^ { \\prime } }$ for predicting the token $t _ { k }$ in the original training tasks. Ideally, we should treat the appearances of a multi-sense word in different contexts as different tokens, and train the language models to predict different senses of the word. In the following, we propose a novel sense-aware cross entropy loss to explicitly model different senses of a word in different contexts. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Sense-aware cross entropy loss Given a sequence $( t _ { 1 } , t _ { 2 } , \\ldots , t _ { N } )$ , our proposed framework generates contextual representations $( h _ { k , j }$ for token $t _ { k }$ in layer $j \\in \\{ 1 , \\dots , L \\} )$ in the same way as the standard LMs. Different from existing methods, our approach maintains multiple context-dependent output embeddings (henceforth, sense vectors) for each token. Specifically, let $S$ be the maximum number of senses per token. Each word $v _ { i }$ in the vocabulary contains $S$ separate sense vectors $( \\pmb { w } _ { i , 1 } , \\pmb { w } _ { i , 2 } , \\ldots , \\pmb { w } _ { i , S } )$ , where each $w _ { i , s }$ corresponds to a different sense (see Appendix for some interesting visualization examples). Following the notation in Section 2, we use $k ^ { \\prime }$ to denote the index of the output token $t _ { k }$ in the vocabulary. Therefore, the sense vectors of $t _ { k }$ can be represented by $( { \\pmb w } _ { k ^ { \\prime } , 1 } , { \\pmb w } _ { k ^ { \\prime } , 2 } , \\dots , { \\pmb w } _ { k ^ { \\prime } , S } )$ , which are randomly initialized and of the same dimension as $h _ { k ^ { * } , L }$ Note that we untie the input and output embeddings in our framework. ",
+        "bbox": [
+            173,
+            544,
+            825,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a word sense selection method shown in Algorithm 1 to select the most likely sense vector when training with sense-level cross entropy loss. Figure 1 shows the architecture of our proposed models. Assuming sense $s ^ { \\prime }$ is selected for token $t _ { k }$ (which means sense vector $_ { w _ { k ^ { \\prime } , s ^ { \\prime } } }$ should be used), we have the following new prediction task: ",
+        "bbox": [
+            173,
+            690,
+            825,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e39cb66579ff1e4a898e7c6fb8652033f5d63fc390f514ae70b32f8ff5091bb.jpg",
+        "text": "$$\np ( t _ { k , s ^ { \\prime } } | c o n t e x t ) = \\mathrm { s o f t m a x } ( h _ { k ^ { * } , L } ^ { \\top } w _ { k ^ { \\prime } , s ^ { \\prime } } ) = \\frac { \\exp ( h _ { k ^ { * } , L } ^ { \\top } w _ { k ^ { \\prime } , s ^ { \\prime } } ) } { \\sum _ { i = 1 } ^ { V } \\sum _ { s = 1 } ^ { S } \\exp ( h _ { k ^ { * } , L } ^ { \\top } w _ { i , s } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            753,
+            746,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The sense-aware cross entropy loss for word sense prediction is defined as follows: ",
+        "bbox": [
+            169,
+            801,
+            717,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e09d581824e858d5fc832d1c75b9d6f0c1ced799e80a187fc3d06708b603f770.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { S E N S E } } = - \\log ( p ( t _ { k , s ^ { \\prime } } | c o n t e x t ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            824,
+            614,
+            842
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Word sense selection algorithm Word sense selection when training the language model can be handled as a non-stationary data stream clustering problem (Aggarwal et al., 2004; Khalilian & Mustapha, 2010; Abdullatif et al., 2018). The most intuitive way to select the corresponding sense ",
+        "bbox": [
+            176,
+            856,
+            825,
+            898
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(a) Sense-aware next token prediction ",
+        "bbox": [
+            176,
+            273,
+            398,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7c9157133e4d02e33b2d7ac65b7323b9150cb1b31614ca73f6cbf9722087bb7.jpg",
+        "image_caption": [
+            "(b) Sense-aware masked token prediction ",
+            "(c) Word sense selection ",
+            "Figure 1: Our proposed framework for sense-aware next token1and masked token prediction tasks. Figure (c) shows an example of word sense selection, where the two sense clusters of $t _ { k }$ (assume its vocabulary index is $k ^ { \\prime }$ ) are shifting in space. Center vectors $\\pmb { c } _ { k ^ { \\prime } , 1 }$ and $\\mathbf { c } _ { k ^ { \\prime } , 2 }$ are used to locate cluster centers. Given $h _ { k , L }$ , the algorithm performs dimension reduction on both $h _ { k , L }$ and center vectors, and then finds the most close cluster center $\\mathbf { c } _ { k ^ { \\prime } , 2 }$ , so we know the output embedding corresponding to sense 2 $( w _ { k ^ { \\prime } , 2 } )$ should be used in the loss function. $\\mathbf { c } _ { k ^ { \\prime } , 2 }$ also makes a small step towards $h _ { k , L }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            107,
+            821,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "vector for $h _ { k ^ { * } , L }$ is to select the vector $w _ { k ^ { \\prime } , s }$ with the maximum dot product value $h _ { k ^ { * } , L } ^ { \\top } w _ { k ^ { \\prime } , s }$ , or cosine similarity value $c o s s i m ( h _ { k ^ { * } , L } , { \\pmb w } _ { k ^ { \\prime } , s } )$ . However, our experiments show that these methods do not work well due to curse of dimensionality, suboptimal learning rate and noisy $h _ { k ^ { * } , L }$ . We apply an online $\\mathbf { k }$ -means algorithm to cluster different senses of a word in Algorithm 1. For each sense vector $w _ { i , s }$ , we maintain a cluster center $\\mathbf { } _ { c _ { i , s } }$ which is of the same dimension as $_ { w _ { i , s } }$ . Therefore, each token $v _ { i }$ in the vocabulary has $S$ such cluster center vectors, denoted by $\\boldsymbol { C } _ { i } = ( c _ { i , 1 } , c _ { i , 2 } , \\ldots , c _ { i , S } )$ . When predicting token $t _ { k }$ in a given sequence, we apply Algorithm 1 to select the best sense vector based on $h _ { k , L }$ (see Figure 1). Notice that $h _ { k , L }$ is different from $h _ { k ^ { * } , L }$ for next token prediction (Figure 1a) for which $h _ { k ^ { * } , L } = h _ { k - 1 , L }$ . The cluster centers $C _ { i }$ are not neural network parameters; instead, they are randomly initialized using a normal distribution ${ \\mathcal { N } } ( 0 , \\sigma ^ { 2 } )$ and updated through Algorithm 1. In addition, we also maintain a projection matrix $_ { P }$ for dimension reduction to facilitate effective sense clustering. $P \\in \\mathbb { R } ^ { d \\times d ^ { \\prime } }$ projects $h _ { k , L }$ and $\\mathbf { { c } } _ { i , s }$ from dimension $d$ to $d ^ { \\prime }$ , and is shared by all tokens in vocabulary. Similar to $C$ , $_ { P }$ is also randomly initialized with normal distribution $\\mathcal { N } ( 0 , 1 )$ , and then updated through Algorithm 2. Both Algorithm 1 and 2 run in parallel, and are interrupted when the language model stops training. ",
+        "bbox": [
+            173,
+            434,
+            825,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Some rationales behind our algorithm design are the following: ",
+        "bbox": [
+            174,
+            655,
+            588,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Word sense selection ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            691,
+            403,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Projection matrix $_ { r }$ update ",
+        "text_level": 1,
+        "bbox": [
+            500,
+            690,
+            766,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Hyper-parameters: number of senses $S$ , sense learning rate $\\alpha$   \n2: Initialize the set of all sense cluster centers $_ { C }$   \n3: repeat   \n4: input: ${ h } _ { k , L }$ , vocabulary index $k ^ { \\prime }$ of the token to predict   \n5: Lookup sense cluster centers for $k ^ { \\prime } \\colon C _ { k ^ { \\prime } } =$ $\\{ c _ { k ^ { \\prime } , 1 } , \\bar { c } _ { k ^ { \\prime } , 2 } , \\ldots , c _ { k ^ { \\prime } , S } \\}$   \n6: ${ \\pmb P } =$ updated projection matrix from Alg. 2   \n7: if cosine similarity between $\\pmb { c } _ { k ^ { \\prime } , s ^ { \\prime } } \\pmb { P }$ and $\\pmb { h } _ { k } ^ { \\prime } \\pmb { P }$ is the largest among the vectors in $C _ { k ^ { \\prime } }$ then   \n8: $\\mathbf { c } _ { k ^ { \\prime } , s ^ { \\prime } } = ( 1 - \\alpha ) \\mathbf { c } _ { k ^ { \\prime } , s ^ { \\prime } } + \\alpha \\mathbf { h } _ { k , L }$   \n9: output: $s ^ { \\prime } ( \\boldsymbol { w } _ { k ^ { \\prime } , s ^ { \\prime } }$ should be selected)   \n10: end if   \n11: until interrupted ",
+        "bbox": [
+            178,
+            710,
+            475,
+            915
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1: Hyper-parameters: projection dimension $d ^ { \\prime }$ , up  \ndate interval $M$ , queue size $Q$   \n2: Initialize $_ { r }$ with $\\mathcal { N } ( 0 , 1 )$ , queue $H = \\emptyset , m = 0$   \n3: repeat   \n4: input: ${ h } _ { k , L }$   \n5: $m = m + 1$   \n6: Add ${ h } _ { k , L }$ to queue $H$   \n7: if $s i z e ( H ) > Q$ then   \n8: Pop the oldest element from queue $H$ .   \n9: end if   \n10: if $m > = M$ then   \n11: ${ \\pmb { P } } =$ the first $d ^ { \\prime }$ PCA components of $H$   \n12: $m = 0$   \n13: end if   \n14: output: $_ { r }$   \n15: until interrupted ",
+        "bbox": [
+            501,
+            712,
+            823,
+            916
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Directly computing cosine similarity between $\\boldsymbol { c } _ { \\boldsymbol { k } ^ { \\prime } , s }$ and $h _ { k , L }$ suffers from the curse of dimensionality. We maintain $_ { r }$ for dimension reduction. Although many algorithms use random projection for dimension reduction, we find using PCA components can help improve clustering accuracy. Since the neural model parameters keep being updated during training, the sense clusters become non-stationary, i.e., their locations keep changing. Experiments shows that when using $_ { r }$ for dimension reduction, a slightly larger projection dimension $d ^ { \\prime }$ will make the clustering algorithm less sensitive to cluster location change. We use $d ^ { \\prime } = 1 6$ for ELMo, and $d ^ { \\prime } = 1 4$ for BERT. We also notice that the sense clustering works well even if $_ { P }$ is updated sporadically. We can set a relatively large update interval in Algorithm 2 to reduce computation cost. • A separate sense learning rate $\\alpha$ should be set for the clustering algorithm. A large $\\alpha$ makes the algorithm less robust to noise, while a small $\\alpha$ leads to slow convergence. • It is essential to use the current token’s contextual representation $h _ { k , L }$ for sense selection even though we use $h _ { k ^ { * } , L } = h _ { k - 1 , L }$ in the next token prediction task. If we use $h _ { k - 1 , L }$ for sense selection, experiments show that most of the variance comes from input embedding ${ \\bf { \\mathcal { x } } } _ { k - 1 }$ . This introduces too much noise for word sense clustering. ",
+        "bbox": [
+            173,
+            103,
+            826,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Dynamic pruning of redundant word senses To make the training more efficient, we keep track of relative sense selection frequency for each token in the vocabulary. Assume token $v _ { i }$ has initial senses $( v _ { i , 1 } , v _ { i , 2 } , \\ldots , v _ { i , S } )$ , for which we compute the relative frequency $\\rho ( v _ { i , s } )$ such that $0 \\leq \\rho ( v _ { i , s } ) \\leq 1$ and $\\begin{array} { r } { \\sum _ { s } \\rho ( v _ { i , s } ) = 1 } \\end{array}$ . A lower $\\rho ( v _ { i , s } )$ means the sense is less frequently selected compared with others. We check the relative frequencies after every $E$ training steps, and if $\\rho ( v _ { i , s } ) < \\beta$ (a threshold hyper-parameter), $v _ { i , s }$ is removed from the list of senses of $v _ { i }$ . ",
+        "bbox": [
+            173,
+            337,
+            825,
+            420
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark on model size and parameters The sense cluster centers $C$ and the projection matrix $_ { r }$ are only used to facilitate sense selection during model pretraining, which are not neural model parameters. The sense vectors $w _ { i , s }$ will no longer be used after pretraining, which can also be discarded. Therefore, our models and the original models have exactly the same number of parameters when transferred to downstream tasks. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            498
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark on model complexity The computational complexity of our algorithm is linear with respect to the size of data, so our method is scalable to train on very large datasets. ",
+        "bbox": [
+            173,
+            513,
+            823,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 JOINT TRAINING WITH SENSE LEVEL TRANSLATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            553,
+            571,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training language model with sense-aware cross entropy loss helps to learn contextual token representations that are sufficiently distinct for different senses $( \\ S 4 . 1 )$ . In this subsection, we extend it to cross-lingual settings and present a novel approach to learn cross-lingual contextual word embeddings at the sense level. Our approach uses a bilingual seed dictionary,2 and can be applied to both next and masked token prediction tasks. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            648
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For training the cross-lingual LM, we concatenate the (non-parallel) corpora of two languages, $L _ { 1 }$ and $L _ { 2 }$ , and construct a joint vocabulary $O = O ^ { L _ { 1 } } \\cup O ^ { L _ { 2 } }$ , where $O ^ { { \\cal L } _ { 1 } }$ and $O ^ { L _ { 2 } }$ are the vocabularies of $L _ { 1 }$ and $L _ { 2 }$ , respectively. Algorithm 1 is used to model the senses of tokens in the joint vocabulary. In addition to predicting the correct monolingual sense $p ( t _ { k , s ^ { \\prime } } | c o n t e x t )$ in Eq. 3, we also train the model to predict its sense level translation. Let $v _ { j }$ be the translation of $t _ { k }$ and sense $v _ { j , s ^ { * } }$ of $v _ { j }$ be the best sense level translation under the given context, we add the following sense-level translation prediction task to maximize probability of $v _ { j , s ^ { * } }$ . ",
+        "bbox": [
+            173,
+            655,
+            826,
+            755
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9412c1cec35b3103667c7e6437f5035f91e37f1869efef78d1caa80b7ba37630.jpg",
+        "text": "$$\np ( v _ { j , s ^ { * } } | c o n t e x t ) = \\mathrm { s o f t m a x } ( h _ { k ^ { * } , L } ^ { \\top } w _ { j , s ^ { * } } ) = \\frac { \\exp ( h _ { k ^ { * } , L } ^ { \\top } w _ { j , s ^ { * } } ) } { \\sum _ { i = 1 } ^ { V } \\sum _ { s = 1 } ^ { S } \\exp ( h _ { k ^ { * } , L } ^ { \\top } w _ { i , s } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            761,
+            745,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\pmb w } _ { j , s ^ { * } }$ is the corresponding sense vector of $v _ { j , s ^ { * } }$ ",
+        "bbox": [
+            174,
+            808,
+            532,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar to the previous subsection, we maintain sense cluster centers $C _ { i }$ for each token $v _ { i } \\in O$ and the shared projection matrix $_ { r }$ to select the best translation sense. Assume $t _ { k }$ has $T$ translations in dictionary, and each translation has $S$ senses, then there are $T \\times S$ possible sense level translations for $t _ { k }$ in the given context. If the $c o s s i m ( h _ { k , L } P , c _ { j , s ^ { * } } P )$ value is the largest among the $T \\times S$ sense cluster centers, then we select $v _ { j , s ^ { * } }$ as the closest translation. An example is shown in Figure 2. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            900
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b2b5a5f36085b898f341dcb4127a33a5d05b65edf01fc849169fa5850587187c.jpg",
+        "image_caption": [
+            "Figure 2: An example of English-Japanese sense-level joint training, which shows two possible Japanese translations (銀行 and 岸) of the English word bank. $h _ { k , L }$ is a contextual representation of bank in finance context and $\\mathbf { c } _ { k ^ { \\prime } , 2 }$ is the cluster center for this sense. $c _ { a , 1 } , c _ { a , 2 } , c _ { b , 1 } , c _ { b , 2 }$ are different sense cluster centers of the two Japanese translations, among which $^ { c _ { b , 2 } }$ is the closest to $h _ { k , L }$ after dimension reduction through PCA. Our sense level objective (Eq. 6) moves sense clusters for bank (organization) and 銀行(organization) closer to each other. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            102,
+            676,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If token $t _ { k }$ has at least one translation in the dictionary, the translation cross entropy loss can be computed as: ",
+        "bbox": [
+            169,
+            315,
+            823,
+            344
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21d0a9e36a3ac98a858136c54cbe54f82614ca8cb8374242e311e8db1d27ed58.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { T R A N } } = - \\log ( p ( v _ { j , s ^ { * } } | c o n t e x t ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            343,
+            614,
+            361
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "If token $t _ { k }$ has no translation in the seed dictionary, we use Eq. 4 as the only loss. The joint training loss is defined as follows: ",
+        "bbox": [
+            174,
+            369,
+            826,
+            398
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3082b958580dcded4bf9cfac2a1915475994e04e0736f13c84c353454c0b00a4.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { J O I N T } } = \\left\\{ \\begin{array} { l l } { \\frac { \\mathcal { L } _ { \\mathrm { S E N S E } } + \\mathcal { L } _ { \\mathrm { T R A N } } } { 2 } , } & { \\mathrm { i f ~ } t _ { k } \\mathrm { ~ h a s ~ t r a n s l a t i o n s } } \\\\ { \\mathcal { L } _ { \\mathrm { S E N S E } } , } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            402,
+            658,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Further alignment (optional) Our sense-aware pretraining tries to move similar senses of two different languages close to each other as illustrated in Figure 2. This process makes the sense distributions of the two languages more isomorphic (some sense vector visualization examples are shown in Appendix C). Applying the linear projection approach proposed by Schuster et al. (2019) on top of the language model pretrained with our framework can further improve cross-lingual transfer on some tasks. See Appendix B for more details of our implementation. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            540
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            554,
+            326,
+            570
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTS USING MONOLINGUAL MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            537,
+            599
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To verify the effectiveness of our proposed sense-aware cross entropy loss, we implement the monolingual models on top of ELMo and BERT with the changes described in $\\ S 3 . 1$ , which are named SaELMo (Sense-aware ELMo) and SaBERT (Sense-aware BERT) respectively. The algorithm for dynamic pruning of redundant word senses is optional, which is implemented on SaELMo only. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            661
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Pretraining settings We use the one billion word language modeling benchmark data (Chelba et al., 2013) to pretrain all the monolingual models. The corpus is preprocessed with the provided scripts, and then converted to lowercase. We do not apply any subword tokenization. We use similar hyper-parameters as Peters et al. (2018) to train the ELMo and SaELMo models, and similar hyperparameters as Devlin et al. (2018) to train 4-layer BERT-Tiny and SaBERT-Tiny. Next sentence prediction task is disabled in BERT-Tiny and SaBERT-Tiny, since this task is irrelevant to our proposed changes. See Appendix D.1 for a complete list of hyper-parameters. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Word sense disambiguation (WSD) Since our context-aware cross entropy loss is designed to learn word senses better in the context, we first conduct experiments to compare our monolingual model with the original models on the WSD task (Raganato et al., 2017), which is a task to associate words in context with the most suitable entry in a pre-defined sense inventory. We use a similar framework as Peters et al. (2018) to evaluate the monolingual models.3 We use SemCor 3.0 (Miller et al., 1993) as training data, and Senseval/SemEval series (Edmonds & Cotton, 2001; Moro & Navigli, 2015; Navigli et al., 2013; Pradhan et al., 2007; Snyder & Palmer, 2004) as test data. We use the pretrained models to compute the average of contextual representations for each sense in training data, and then classify the senses of the target words in test sentences by finding the nearest neighbour. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            900
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "WSD results are presented in Table 2. SaELMo shows significant performance improvements over the baseline ELMo model in all of the five test sets. SaBERT-Tiny also outperforms BERT-Tiny except on SE07, which is the smallest among the five test sets. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b6f89916e9d36eeb77077f8c34dda5e33e26b7d600d8713db9a5c064ce12c04b.jpg",
+        "table_caption": [
+            "Table 2: Word sense disambiguation (F1 scores) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>SE2</td><td>SE3</td><td>SE07</td><td>SE13</td><td>SE15</td></tr><tr><td>ELMo</td><td>0.555</td><td>0.576</td><td>0.446</td><td>0.544</td><td>0.538</td></tr><tr><td>SaELMo (ours)</td><td>0.575</td><td>0.586</td><td>0.470</td><td>0.560</td><td>0.583</td></tr><tr><td>BERT-Tiny</td><td>0.596</td><td>0.539</td><td>0.466</td><td>0.536</td><td>0.572</td></tr><tr><td>SaBERT-Tiny (ours)</td><td>0.611</td><td>0.546</td><td>0.446</td><td>0.550</td><td>0.579</td></tr></table>",
+        "bbox": [
+            308,
+            181,
+            684,
+            261
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTS USING BILINGUAL MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            280,
+            508,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To verify the effectiveness of our cross-lingual framework, we implement the bilingual models on top of ELMo, named Bi-SaELMo that does not use linear projection for further alignment and Bi-SaELMo $^ +$ Proj that uses the linear projection. Sense vectors and cluster center vectors are not shared between the forward and backward language models. We use ELMo+Proj and Joint$\\mathbf { E L M o + P r o j }$ as our baseline models, where ELMo+Proj is proposed by Schuster et al. (2019) and Joint-ELMo $^ +$ Proj is implemented following the framework recently proposed by Wang et al. (2020). Wang et al. (2020) combine joint training and projection, and claim their framework is applicable to any projection method, so we implement the same projection method as Schuster et al. (2019) did for Joint-ELMo $+$ Proj. We also report results of ELMo and Joint-ELMo, which are the counterparts of ELMo+Proj and Joint-ELMo $^ +$ Proj without using linear projection. ",
+        "bbox": [
+            173,
+            306,
+            826,
+            445
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Pretraining settings To pretrain language models, we sample a 500-million-token corpus for each language from the English, German, Spanish, Japanese and Chinese Wikipedia dump. The dictionaries used for pretraining models and learning the projection matrix were downloaded from the MUSE (Conneau et al., 2017) GitHub page4. We also add JMDict (Breen, 2004) to the en-jp MUSE dictionary. Bilingual models were pretrained on en-de, en-es, en-jp and en-zh concatenated data with similar parameters as the monolingual models. ELMo and ELMo+Proj were pretrained on monolingual data, while the projection matrix of ELMo $+$ Proj was learned using bilingual data. See Appendix D.2 for a complete list of hyper-parameters. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot cross-lingual NER A BiLSTM-CRF model implemented with the Flair framework (Akbik et al., 2018) is used for this task. For the CoNLL-2002 (Tjong Kim Sang, 2002) and CoNLL-2003 (Sang & De Meulder, 2003) datasets, the NER model was trained on English data, and evaluated on Spanish and German test data. For the OntoNotes 5.0 (Weischedel et al., 2013) dataset, the NER model was trained on all English data and evaluated on all Chinese data. We report the average F1 of 5 runs in Table 3. The results show that all of the models using linear projection outperform their counterparts (not using linear projection), since minimizing token level distance is more important for cross-lingual ",
+        "bbox": [
+            174,
+            588,
+            452,
+            824
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/4cb7d32336e1dd6ad34b1ad9ab0ff30c64197fc59a8aac19bd89ffe55f889300.jpg",
+        "table_caption": [
+            "Table 3: Zero-shot cross-lingual NER (F1) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>de</td><td>es</td><td>zh</td></tr><tr><td>ELMo</td><td>16.30</td><td>16.14</td><td>0.28</td></tr><tr><td>Joint-ELMo</td><td>56.49</td><td>58.91</td><td>53.47</td></tr><tr><td>ELMo+Proj (Schuster et al.,2019)</td><td>69.57</td><td>60.02</td><td>63.15</td></tr><tr><td>Joint-ELMo+Proj (Wang et al.,2020)</td><td>71.59</td><td>65.19</td><td>59.08</td></tr><tr><td>Bi-SaELMo (ours)</td><td>63.83</td><td>60.65</td><td>55.83</td></tr><tr><td>Bi-SaELMo+Proj (ours)</td><td>72.19</td><td>65.86</td><td>63.44</td></tr><tr><td colspan=\"4\">For references, but not our baselines,since they are t trainedon1 1much larger datasets and/or parallel sentences.</td></tr><tr><td>XLM Finetune (Conneau &amp; Lample, 2019)</td><td>67.55</td><td>63.18</td><td>-</td></tr><tr><td>XLM-R Finetune (Conneau et al.,2019)</td><td>71.40</td><td>78.64</td><td>-</td></tr><tr><td>M-BERT Finetune (Pires et al., 2019)</td><td>69.74</td><td>73.59</td><td>-</td></tr><tr><td>M-BERT Finetune (Wu &amp; Dredze,2019)</td><td>69.56</td><td>74.96</td><td>-</td></tr><tr><td>M-BERT Finetune+Adv (Keung et al., 2019)</td><td>71.90</td><td>74.30</td><td>-</td></tr><tr><td>M-BERT Feature+Proj (Wang et al.,2020)</td><td>70.54</td><td>75.77</td><td>-</td></tr></table>",
+        "bbox": [
+            464,
+            631,
+            825,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "NER tasks. Our sense-aware pretraining makes sense distributions of two languages more isomorphic, which further improves linear projection performance. Our model Bi-SaELMo+Proj demonstrates consistent performance improvement in all the three languages. Moreover, our model outperforms finetuned XLM/XLM-R and Multilingual BERT on German data, and achieves state of the art even though it is pretrained on less data. ",
+        "bbox": [
+            174,
+            824,
+            826,
+            893
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot cross-lingual sentiment classification We use the multi-lingual multi-domain Amazon review data (Prettenhofer & Stein, 2010) for evaluation on cross-lingual sentiment classification. The ratings in review data are converted into binary labels. The average of contextual word representations is used as the document/sentence representation for each review text/summary, which is then fed into a two-dense-layer model for sentiment classification. All the models are trained on English, and evaluated on German and Japanese test data in the same domain. We report the average accuracy of 5 runs in Table 4. Different from the NER task, the linear projection approach for cross-lingual alignment does not work for this task, since it may add noise to embedding features. Our model Bi-SaELMo demonstrates consistent improvements in all of the 6 evaluation tasks. The performance of Bi-SaELMo is significantly better than Joint-ELMo, which shows that our sense-level translation pretraining objective improves cross-lingual embedding alignment. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/63624d86f25150c5982773b2b6f3a7e288195c862f977bba6c23655b96b614ce.jpg",
+        "table_caption": [
+            "Table 4: Zero-shot sentiment classification accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td colspan=\"3\">de</td><td colspan=\"3\">jp</td></tr><tr><td></td><td>books</td><td>music</td><td>dvd</td><td>books</td><td>music</td><td>dvd</td></tr><tr><td>ELMo</td><td>52.94</td><td>63.61</td><td>57.78</td><td>50.37</td><td>51.59</td><td>54.32</td></tr><tr><td>Joint-ELMo</td><td>71.72</td><td>75.22</td><td>64.25</td><td>66.64</td><td>68.50</td><td>58.54</td></tr><tr><td>ELMo+Proj (Schuster et al., 2019)</td><td>49.92</td><td>50.29</td><td>49.94</td><td>50.57</td><td>49.59</td><td>50.65</td></tr><tr><td>Joint-ELMo+Proj (Wang et al.,2020)</td><td>75.74</td><td>72.25</td><td>72.25</td><td>62.50</td><td>59.77</td><td>57.65</td></tr><tr><td>Bi-SaELMo (ours)</td><td>77.46</td><td>75.32</td><td>74.97</td><td>68.16</td><td>69.48</td><td>64.04</td></tr><tr><td>Bi-SaELMo+Proj (ours)</td><td>70.84</td><td>66.25</td><td>68.99</td><td>62.17</td><td>55.91</td><td>61.57</td></tr></table>",
+        "bbox": [
+            178,
+            299,
+            514,
+            375
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/950b34d87c5b68246a898f89d79f49ef1b21f0c0d4e0050da85f2ad10d9c1c85.jpg",
+        "table_caption": [
+            "Table 5: Zero-shot XNLI accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>de</td><td>es</td><td>zh</td></tr><tr><td>ELMo</td><td>34.07</td><td>33.41</td><td>35.77</td></tr><tr><td>Joint-ELMo</td><td>60.12</td><td>63.73</td><td>57.82</td></tr><tr><td>ELMo+Proj (Schuster et al.,2019)</td><td>55.51</td><td>58.92</td><td>53.17</td></tr><tr><td>Joint-ELMo+Proj (Wang et al.,2020)</td><td>63.33</td><td>64.71</td><td>58.34</td></tr><tr><td>Bi-SaELMo (ours)</td><td>60.98</td><td>62.75</td><td>60.40</td></tr><tr><td>Bi-SaELMo+Proj (ours)</td><td>64.77</td><td>65.05</td><td>60.44</td></tr></table>",
+        "bbox": [
+            550,
+            299,
+            810,
+            371
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot cross-lingual natural language inference (XNLI) We use XNLI (Conneau et al., 2018) and MultiNLI (Williams et al., 2018) data for evaluation on this task. The Bi-LSTM baseline model5 was trained on MultiNLI English training data, and then evaluated on XNLI German, Spanish, Chinese test data. We report the average zero-shot XNLI accuracy of 2 runs in Table 5. Our models show consistent improvements over the baselines on all of the three data sets. For zero-shot transfer to Chinese, both of our models outperform the best baseline by more than 2 points, which again demonstrates the effectiveness of our framework on distant language pairs. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            484
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            341,
+            511
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Cross-lingual word embedding demonstrates strong performance in many cross-lingual transfer tasks. The projection-based approach has a long line of research on aligning static embeddings (Mikolov et al., 2013; Xing et al., 2015; Smith et al., 2017; Joulin et al., 2018). It assumes that the embedding spaces of different languages have an isomorphic structure, and fit an orthogonal matrix to project multiple monolingual embedding spaces to a shared space. Recent studies (Schuster et al., 2019; Aldarmaki & Diab, 2019) have extended this approach to contextual representation alignment. Besides, there are also many discussions on the limitations of the projection-based approach, arguing that the isomorphic assumption is not true in general (Nakashole & Flauger, 2018; Patra et al., 2018; Søgaard et al., 2018; Ormazabal et al., 2019). Joint training is another line of research and early methods (Gouws et al., 2015; Luong et al., 2015; Ammar et al., 2016) learn static word embeddings of multiple languages simultaneously. Extending joint training to cross- or multi-lingual language model pretraining has gained more attention recently. As discussed above, unsupervised multilingual language models (Devlin et al., 2018; Artetxe & Schwenk, 2019; Conneau & Lample, 2019; Conneau et al., 2019; Liu et al., 2020) also demonstrate strong cross-lingual transfer performance. ",
+        "bbox": [
+            173,
+            522,
+            825,
+            717
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "There has been some work on sense-aware language models/embeddings (Rothe & Schutze, 2015; ¨ Pilehvar & Collier, 2016; Hedderich et al., 2019), and most of them require WordNet (Miller, 1998) or other additional resource for supervision. Suster et al. (2016) utilize both monolingual and bilingual ˇ information from parallel corpora to learn multi-sense word embeddings. Peters et al. (2019) embed WordNet knowledge into BERT with attention mechanism. Levine et al. (2019) pretrain SenseBERT to predict both the masked words and their WordNet supersenses. Similar to our framework, there are also some unsupervised approaches, but most of them are used to learn static embeddings. Huang et al. (2012) learn word representations with both local and global context, and then apply a clustering algorithm to learn multi-prototype vectors. Neelakantan et al. (2014) propose an extension to the Skip-gram model that leverage $\\mathbf { k }$ -means clustering algorithm learns multiple embeddings per word type. Lee & Chen (2017) leverage reinforcement learning for modularized unsupervised sense level embedding learning. Boyd-Graber et al. (2020) use Gumbel softmax for sense disambiguation when learning sense embeddings. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            905
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            328,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have introduced a novel sense-aware cross entropy loss to model word senses explicitly, then we have further proposed a sense-level alignment objective for cross-lingual model pretraining using only bilingual dictionaries. The results of the experiments show the effectiveness of our monolingual and bilingual models on WSD, zero-shot cross-lingual NER, sentiment classification and XNLI tasks. In future work, we will study how to effectively extend our method to multilingual models. In addition, using the sense cluster centers to learn the linear projection matrix would be another promising direction to further improve cross-lingual alignment. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            226
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            247,
+            285,
+            262
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Amr Abdullatif, Francesco Masulli, and Stefano Rovetta. Clustering of nonstationary data streams: A survey of fuzzy partitional methods. Wiley Interdisciplinary Reviews: Data Mining and Knowledge Discovery, 8(4):e1258, 2018. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            313
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Charu C Aggarwal, Jiawei Han, Jianyong Wang, and Philip S Yu. A framework for projected clustering of high dimensional data streams. In Proceedings of the Thirtieth international conference on Very large data bases-Volume 30, pp. 852–863, 2004. ",
+        "bbox": [
+            173,
+            324,
+            826,
+            367
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alan Akbik, Duncan Blythe, and Roland Vollgraf. Contextual string embeddings for sequence labeling. In COLING 2018, 27th International Conference on Computational Linguistics, pp. 1638–1649, 2018. ",
+        "bbox": [
+            174,
+            376,
+            823,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hanan Aldarmaki and Mona Diab. Context-aware crosslingual mapping. arXiv preprint arXiv:1903.03243, 2019. ",
+        "bbox": [
+            171,
+            430,
+            825,
+            459
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Waleed Ammar, George Mulcaire, Yulia Tsvetkov, Guillaume Lample, Chris Dyer, and Noah A Smith. Massively multilingual word embeddings. arXiv preprint arXiv:1602.01925, 2016. ",
+        "bbox": [
+            174,
+            469,
+            823,
+            498
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mikel Artetxe and Holger Schwenk. Massively multilingual sentence embeddings for zero-shot cross-lingual transfer and beyond. Transactions of the Association for Computational Linguistics, 7:597–610, Mar 2019. ISSN 2307-387X. doi: 10.1162/tacl a 00288. URL http://dx.doi. org/10.1162/tacl_a_00288. ",
+        "bbox": [
+            173,
+            508,
+            826,
+            565
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jordan Boyd-Graber, Fenfei Guo, Leah Findlater, and Mohit Iyyer. Which evaluations uncover sense representations that actually make sense? In Proceedings of the 12th Language Resources and Evaluation Conference, pp. 1727–1738, Marseille, France, May 2020. European Language Resources Association. ISBN 979-10-95546-34-4. URL https://www.aclweb.org/anthology/ 2020.lrec-1.214. ",
+        "bbox": [
+            173,
+            575,
+            826,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jim Breen. Jmdict: a japanese-multilingual dictionary. In Proceedings of the workshop on multilingual linguistic resources, pp. 65–72, 2004. ",
+        "bbox": [
+            173,
+            656,
+            823,
+            685
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Steven Cao, Nikita Kitaev, and Dan Klein. Multilingual alignment of contextual word representations. arXiv preprint arXiv:2002.03518, 2020. ",
+        "bbox": [
+            173,
+            695,
+            821,
+            726
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling, 2013. ",
+        "bbox": [
+            173,
+            734,
+            826,
+            779
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexis Conneau and Guillaume Lample. Cross-lingual language model pretraining. In Advances in Neural Information Processing Systems, pp. 7057–7067, 2019. ",
+        "bbox": [
+            171,
+            789,
+            823,
+            818
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexis Conneau, Guillaume Lample, Marc’Aurelio Ranzato, Ludovic Denoyer, and Herve J ´ egou. ´ Word translation without parallel data. arXiv preprint arXiv:1710.04087, 2017. ",
+        "bbox": [
+            169,
+            828,
+            825,
+            858
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexis Conneau, Ruty Rinott, Guillaume Lample, Adina Williams, Samuel R. Bowman, Holger Schwenk, and Veselin Stoyanov. Xnli: Evaluating cross-lingual sentence representations. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing. Association for Computational Linguistics, 2018. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexis Conneau, Kartikay Khandelwal, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzman, Edouard Grave, Myle Ott, Luke Zettlemoyer, and Veselin Stoyanov. Unsupervised ´ cross-lingual representation learning at scale. arXiv preprint arXiv:1911.02116, 2019. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            174,
+            156,
+            821,
+            186
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Philip Edmonds and Scott Cotton. Senseval-2: overview. In Proceedings of SENSEVAL-2 Second International Workshop on Evaluating Word Sense Disambiguation Systems, pp. 1–5, 2001. ",
+        "bbox": [
+            173,
+            196,
+            825,
+            226
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stephan Gouws, Yoshua Bengio, and Greg Corrado. Bilbowa: Fast bilingual distributed representations without word alignments. In Proceedings of the 32nd International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            173,
+            236,
+            826,
+            280
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael A. Hedderich, Andrew Yates, Dietrich Klakow, and Gerard de Melo. Using multi-sense vector embeddings for reverse dictionaries. In Proceedings of the 13th International Conference on Computational Semantics - Long Papers, pp. 247–258, Gothenburg, Sweden, May 2019. Association for Computational Linguistics. doi: 10.18653/v1/W19-0421. URL https://www. aclweb.org/anthology/W19-0421. ",
+        "bbox": [
+            173,
+            290,
+            826,
+            361
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eric Huang, Richard Socher, Christopher Manning, and Andrew Ng. Improving word representations via global context and multiple word prototypes. In Proceedings of the 50th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 873–882, Jeju Island, Korea, July 2012. Association for Computational Linguistics. URL https://www.aclweb. org/anthology/P12-1092. ",
+        "bbox": [
+            173,
+            372,
+            828,
+            443
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin, Piotr Bojanowski, Tomas Mikolov, Herve J ´ egou, and Edouard Grave. Loss in transla- ´ tion: Learning bilingual word mapping with a retrieval criterion. arXiv preprint arXiv:1804.07745, 2018. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            496
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Phillip Keung, Yichao Lu, and Vikas Bhardwaj. Adversarial learning with contextual embeddings for zero-resource cross-lingual classification and ner. arXiv preprint arXiv:1909.00153, 2019. ",
+        "bbox": [
+            171,
+            507,
+            823,
+            536
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Madjid Khalilian and Norwati Mustapha. Data stream clustering: Challenges and issues. arXiv preprint arXiv:1006.5261, 2010. ",
+        "bbox": [
+            173,
+            546,
+            825,
+            575
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Guang-He Lee and Yun-Nung Chen. MUSE: Modularizing unsupervised sense embeddings. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 327–337, Copenhagen, Denmark, September 2017. Association for Computational Linguistics. doi: 10.18653/v1/D17-1034. URL https://www.aclweb.org/anthology/D17-1034. ",
+        "bbox": [
+            173,
+            585,
+            826,
+            643
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yoav Levine, Barak Lenz, Or Dagan, Dan Padnos, Or Sharir, Shai Shalev-Shwartz, Amnon Shashua, and Yoav Shoham. Sensebert: Driving some sense into bert. arXiv preprint arXiv:1908.05646, 2019. ",
+        "bbox": [
+            176,
+            654,
+            826,
+            696
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, and Luke Zettlemoyer. Multilingual denoising pre-training for neural machine translation, 2020. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            738
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Minh-Thang Luong, Hieu Pham, and Christopher D Manning. Bilingual word representations with monolingual quality in mind. In Proceedings of the 1st Workshop on Vector Space Modeling for Natural Language Processing, pp. 151–159, 2015. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            791
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher D. Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven J. Bethard, and David McClosky. The Stanford CoreNLP natural language processing toolkit. In Association for Computational Linguistics (ACL) System Demonstrations, pp. 55–60, 2014. URL http://www. aclweb.org/anthology/P/P14/P14-5010. ",
+        "bbox": [
+            174,
+            801,
+            826,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Quoc V Le, and Ilya Sutskever. Exploiting similarities among languages for machine translation. arXiv preprint arXiv:1309.4168, 2013. ",
+        "bbox": [
+            171,
+            869,
+            823,
+            897
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George A Miller. WordNet: An electronic lexical database. MIT press, 1998. ",
+        "bbox": [
+            173,
+            909,
+            679,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "George A Miller, Claudia Leacock, Randee Tengi, and Ross T Bunker. A semantic concordance. In Proceedings of the workshop on Human Language Technology, pp. 303–308. Association for Computational Linguistics, 1993. ",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrea Moro and Roberto Navigli. Semeval-2015 task 13: Multilingual all-words sense disambiguation and entity linking. In Proceedings of the 9th international workshop on semantic evaluation (SemEval 2015), pp. 288–297, 2015. ",
+        "bbox": [
+            174,
+            154,
+            825,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ndapa Nakashole and Raphael Flauger. Characterizing departures from linearity in word translation. arXiv preprint arXiv:1806.04508, 2018. ",
+        "bbox": [
+            171,
+            204,
+            825,
+            233
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Roberto Navigli, David Jurgens, and Daniele Vannella. Semeval-2013 task 12: Multilingual word sense disambiguation. In Second Joint Conference on Lexical and Computational Semantics (\\* SEM), Volume 2: Proceedings of the Seventh International Workshop on Semantic Evaluation (SemEval 2013), pp. 222–231, 2013. ",
+        "bbox": [
+            173,
+            241,
+            826,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arvind Neelakantan, Jeevan Shankar, Alexandre Passos, and Andrew McCallum. Efficient nonparametric estimation of multiple embeddings per word in vector space. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1059–1069, Doha, Qatar, October 2014. Association for Computational Linguistics. doi: 10.3115/v1/D14-1113. URL https://www.aclweb.org/anthology/D14-1113. ",
+        "bbox": [
+            174,
+            306,
+            826,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aitor Ormazabal, Mikel Artetxe, Gorka Labaka, Aitor Soroa, and Eneko Agirre. Analyzing the limitations of cross-lingual word embedding mappings. arXiv preprint arXiv:1906.05407, 2019. ",
+        "bbox": [
+            174,
+            383,
+            823,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Barun Patra, Joel Ruben Antony Moniz, Sarthak Garg, Matthew R Gormley, and Graham Neubig. Bliss in non-isometric embedding spaces. 2018. ",
+        "bbox": [
+            173,
+            420,
+            823,
+            450
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proc. of NAACL, 2018. ",
+        "bbox": [
+            173,
+            457,
+            823,
+            487
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew E Peters, Mark Neumann, Robert L Logan IV, Roy Schwartz, Vidur Joshi, Sameer Singh, and Noah A Smith. Knowledge enhanced contextual word representations. arXiv preprint arXiv:1909.04164, 2019. ",
+        "bbox": [
+            174,
+            494,
+            826,
+            536
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Taher Pilehvar and Nigel Collier. De-conflated semantic representations. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, pp. 1680–1690, Austin, Texas, November 2016. Association for Computational Linguistics. doi: 10.18653/v1/ D16-1174. URL https://www.aclweb.org/anthology/D16-1174. ",
+        "bbox": [
+            173,
+            545,
+            826,
+            602
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Telmo Pires, Eva Schlinger, and Dan Garrette. How multilingual is multilingual bert? arXiv preprint arXiv:1906.01502, 2019. ",
+        "bbox": [
+            174,
+            609,
+            823,
+            638
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sameer Pradhan, Edward Loper, Dmitriy Dligach, and Martha Palmer. Semeval-2007 task-17: English lexical sample, srl and all words. In Proceedings of the fourth international workshop on semantic evaluations (SemEval-2007), pp. 87–92, 2007. ",
+        "bbox": [
+            174,
+            646,
+            826,
+            689
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Peter Prettenhofer and Benno Stein. Cross-language text classification using structural correspondence learning. In Proceedings of the 48th Annual Meeting of the Association for Computational Linguistics, pp. 1118–1127, Uppsala, Sweden, July 2010. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/P10-1114. ",
+        "bbox": [
+            174,
+            696,
+            826,
+            753
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alessandro Raganato, Jose Camacho-Collados, and Roberto Navigli. Word sense disambiguation: A unified evaluation framework and empirical comparison. In Proceedings of the 15th Conference of the European Chapter of the Association for Computational Linguistics: Volume 1, Long Papers, pp. 99–110, Valencia, Spain, April 2017. Association for Computational Linguistics. URL https://www.aclweb.org/anthology/E17-1010. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            832
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sascha Rothe and Hinrich Schutze. AutoExtend: Extending word embeddings to embeddings ¨ for synsets and lexemes. In Proceedings of the 53rd Annual Meeting of the Association for Computational Linguistics and the 7th International Joint Conference on Natural Language Processing (Volume 1: Long Papers), pp. 1793–1803, Beijing, China, July 2015. Association for Computational Linguistics. doi: 10.3115/v1/P15-1173. URL https://www.aclweb.org/ anthology/P15-1173. ",
+        "bbox": [
+            174,
+            839,
+            826,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Erik F Sang and Fien De Meulder. Introduction to the conll-2003 shared task: Language-independent named entity recognition. arXiv preprint cs/0306050, 2003. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tal Schuster, Ori Ram, Regina Barzilay, and Amir Globerson. Cross-lingual alignment of contextual word embeddings, with applications to zero-shot dependency parsing. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pp. 1599–1613, Minneapolis, Minnesota, June 2019. Association for Computational Linguistics. doi: 10.18653/v1/N19-1162. URL https://www.aclweb.org/anthology/N19-1162. ",
+        "bbox": [
+            174,
+            146,
+            826,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Samuel L Smith, David HP Turban, Steven Hamblin, and Nils Y Hammerla. Offline bilingual word vectors, orthogonal transformations and the inverted softmax. arXiv preprint arXiv:1702.03859, 2017. ",
+        "bbox": [
+            174,
+            244,
+            826,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Snyder and Martha Palmer. The english all-words task. In Proceedings of SENSEVAL-3, the Third International Workshop on the Evaluation of Systems for the Semantic Analysis of Text, pp. 41–43, 2004. ",
+        "bbox": [
+            173,
+            301,
+            823,
+            344
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Anders Søgaard, Sebastian Ruder, and Ivan Vulic. On the limitations of unsupervised bilingual ´ dictionary induction. arXiv preprint arXiv:1805.03620, 2018. ",
+        "bbox": [
+            173,
+            358,
+            823,
+            388
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Simon Suster, Ivan Titov, and Gertjan Van Noord. Bilingual learning of multi-sense embeddings with ˇ discrete autoencoders. arXiv preprint arXiv:1603.09128, 2016. ",
+        "bbox": [
+            173,
+            402,
+            823,
+            433
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Erik F. Tjong Kim Sang. Introduction to the CoNLL-2002 shared task: Language-independent named entity recognition. In COLING-02: The 6th Conference on Natural Language Learning 2002 (CoNLL-2002), 2002. URL https://www.aclweb.org/anthology/W02-2024. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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, pp. 5998–6008, 2017. ",
+        "bbox": [
+            174,
+            503,
+            825,
+            546
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zirui Wang, Jiateng Xie, Ruochen Xu, Yiming Yang, Graham Neubig, and Jaime G. Carbonell. Cross-lingual alignment vs joint training: A comparative study and a simple unified framework. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id ${ . } = { }$ S1l-C0NtwS. ",
+        "bbox": [
+            173,
+            560,
+            826,
+            616
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ralph Weischedel, Martha Palmer, Mitchell Marcus, Eduard Hovy, Sameer Pradhan, Lance Ramshaw, Nianwen Xue, Ann Taylor, Jeff Kaufman, Michelle Franchini, et al. Ontonotes release 5.0 ldc2013t19. Linguistic Data Consortium, Philadelphia, PA, 23, 2013. ",
+        "bbox": [
+            174,
+            631,
+            826,
+            674
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 1112–1122. Association for Computational Linguistics, 2018. URL http://aclweb.org/anthology/N18-1101. ",
+        "bbox": [
+            174,
+            688,
+            826,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shijie Wu and Mark Dredze. Beto, bentz, becas: The surprising cross-lingual effectiveness of bert. arXiv preprint arXiv:1904.09077, 2019. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            801
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chao Xing, Dong Wang, Chao Liu, and Yiye Lin. Normalized word embedding and orthogonal transform for bilingual word translation. In Proceedings of the 2015 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pp. 1006–1011, 2015. ",
+        "bbox": [
+            173,
+            815,
+            826,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zheng Zhang, Ruiqing Yin, Jun Zhu, and Pierre Zweigenbaum. Cross-lingual contextual word embeddings mapping with multi-sense words in mind. arXiv preprint arXiv:1909.08681, 2019. ",
+        "bbox": [
+            173,
+            887,
+            825,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            263,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A PREDICTION TASKS OF LANGUAGE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            137,
+            573,
+            152
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Next token prediction and masked token prediction are two common tasks in neural language model (LM) pretraining. We take two well-known language models, ELMo and BERT, as examples to illustrate these two tasks, which are shown in Figure 3. ",
+        "bbox": [
+            174,
+            167,
+            826,
+            210
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/00c5c4d80d28c12209dbf25a1b889ebd01eb5da62cbb3e8da14388f601fba4d2.jpg",
+        "image_caption": [
+            "Figure 3: Next token and masked token prediction tasks of language models. For simplicity, we only show the forward language model in next token prediction. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            232,
+            790,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B FURTHER ALIGNMENT (OPTIONAL) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            510,
+            501,
+            526
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Applying the linear projection approach proposed by Schuster et al. (2019) on top of our framework can further improve cross-lingual transfer on some tasks. After our cross-lingual model is finished training on the concatenated corpora of two languages, $L _ { 1 }$ and $L _ { 2 }$ , it is used to generate contextual token embeddings for the word pairs in the seed dictionary $\\mathcal { D } = \\{ ( t _ { i } ^ { L _ { 1 } } , t _ { i } ^ { L _ { 2 } } ) \\} _ { i = 1 } ^ { | \\mathcal { D } | }$ 6. Then, we compute the average of all contextual embeddings for each token tLji , denoted by aLji . Finally, a ",
+        "bbox": [
+            173,
+            541,
+            826,
+            636
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/471e5aa1f80dc7ba946444a57726d0212f65609ebaab5af8f52aec4b3d481d41.jpg",
+        "text": "$$\nW = \\underset { W } { \\arg \\operatorname* { m i n } } \\sum _ { i = 1 } ^ { | \\mathcal { D } | } | | W \\pmb { a } _ { i } ^ { L _ { 1 } } - \\pmb { a } _ { i } ^ { L _ { 2 } } | | ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            643,
+            622,
+            688
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C VISUALIZATION OF SENSE VECTORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            511,
+            722
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We visualize7 the sense vectors of each model in a two dimensional PCA, and show some examples in Figures 4 to 7. For our English monolingual model (SaELMo), the vectors close to two different sense vectors of the word may are shown in (a) and (b) of Figure 4, respectively. We observe that senses are well clustered in these two subfigures, where cluster (a) corresponds to “month”, and cluster (b) corresponds to “auxiliary verb”. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            808
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We do the same for the English-Japanese bilingual model (Bi-SaELMo, without projection), and show the vectors close to two different sense vectors of the English word bank in (c) and (d) of Figure 5. We can see both English and Japanese sense vectors (trade, 銀行, 証券, etc.) in (c), most of which correspond to the sense “organization”, though there are some noises. Similarly, most of the sense vectors in (d) correspond to sense “river bank”. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            883
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Another two examples are shown in Figures 6 and 7. Our framework exhibits good sense clustering and sense level cross-lingual alignment behaviour in these examples. All sense vectors are dumped at training step 200,000, which is before pretraining complete. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/c5ef53a2f6367d3995ef4f1d101b386d70403c0364a54f3e0e4c48bea4f8447d.jpg",
+        "image_caption": [
+            "Figure 4: We visualize sense vectors of English monolingual model (SaELMo) in a two dimensional PCA, and show the vectors close to two different sense vectors of word may in (a) and (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            162,
+            805,
+            411
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ce22bb1b8cf9d7652ee916c0d8ace4d0db5084f9650fe1d1584796f9005d86e.jpg",
+        "image_caption": [
+            "Figure 5: We visualize all sense vectors of en-jp bilingual model (Bi-SaELMo) in a two dimensional PCA, and show the vectors close to two different sense vectors of word bank. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            484,
+            794,
+            739
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d2f78dedd801317944b6c6f7dfdedee9a448441ba90652425d0a25e1e8aa9d3.jpg",
+        "image_caption": [
+            "Figure 6: We visualize sense vectors of English monolingual model (SaELMo) in a two dimensional PCA, and show the vectors close to two different sense vectors of word us in (a) and (b). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            145,
+            888,
+            430
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/68946afbd8f5c48486a50a9127da5b0f1dce5405a0622b44feac86f59c80fd4c.jpg",
+        "image_caption": [
+            "Figure 7: We visualize all sense vectors of en-de bilingual model (Bi-SaELMo) in a two dimensional PCA, and show the vectors close to two different sense vectors of word may. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            565,
+            843,
+            840
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "D PRETRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            401,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D.1 MONOLINGUAL MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            135,
+            382,
+            148
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "All the monolingual models were trained for one million steps. For better sense clustering performance, the maximum number of senses $S$ in word sense selection algorithm) was set to 1 for the first 20,000 steps to quickly get a reasonable initial model, and then increased to 5 afterwards when pretraining SaELMo and SaBERT-Tiny, which is controlled by hyperparameter n context in our implementation. For SaELMo, we set n context to 6, so that the model initialize 6 senses for each token, but only use the first sense in the 20,000 steps, and then use the other 5 senses (the first sense will be disabled) afterwards. We implement this for SaBERT-Tiny in a slightly different way, where n context can be set to 5 directly to achieve the same effect. We use two NVIDIA V100 GPUs to pretrain SaELMo, which takes about 15 days to complete training. We use one NVIDIA V100 GPU to pretrain SaBERT-Tiny, which takes about 5 days. See Tables 6 and 7 for the hyperparameters used to pretrain SaELMo and SaBERT-Tiny respectively. ",
+        "bbox": [
+            174,
+            161,
+            825,
+            314
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/e7ebfa8f669ac24b27461ff10c32ef8320f6f38afbb3b21856377dd5cd74202a.jpg",
+        "table_caption": [
+            "Table 6: Monolingual model hyperparameters: SaELMo "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>max_word_length</td><td>50</td></tr><tr><td>batch_size</td><td>256</td></tr><tr><td>n-gpus</td><td>2</td></tr><tr><td>bidirectional</td><td>True</td></tr><tr><td>char_cnn:embedding:dim</td><td>16</td></tr><tr><td>char_cnn:max_characters-per_token</td><td>50</td></tr><tr><td>char_cnn:n_characters</td><td>261</td></tr><tr><td>char_cnn:n_highway</td><td>2</td></tr><tr><td>dropout</td><td>0.1</td></tr><tr><td>lstm:cell_clip</td><td>3</td></tr><tr><td>lstm:dim</td><td>4096</td></tr><tr><td>lstm:n_layers</td><td>2</td></tr><tr><td>lstm:proj_clip</td><td>3</td></tr><tr><td>lstm:projection_dim</td><td>512</td></tr><tr><td>lstm:use_skip_connections</td><td>True</td></tr><tr><td>all_clip_norm_val</td><td>10.0</td></tr><tr><td>n_epochs</td><td>10</td></tr><tr><td>unroll_steps</td><td>16</td></tr><tr><td>n_negative_samples_batch</td><td>8192</td></tr><tr><td>n_context</td><td>6</td></tr><tr><td>cluster_proj_dim</td><td>16</td></tr><tr><td>pca_sample</td><td>20.000</td></tr><tr><td>remove_less_freqent_contexts</td><td>0.1</td></tr><tr><td>learning_rate</td><td>0.2</td></tr><tr><td>sense_learning_rate</td><td>0.01</td></tr></table>",
+        "bbox": [
+            377,
+            356,
+            616,
+            628
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/2e94d3158634b3e7f62a43037f291f156b4c7e4cdf84803c8045f5e124cd3ca7.jpg",
+        "table_caption": [
+            "Table 7: Monolingual model hyperparameters: SaBERT-Tiny "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>attention-probs_dropout_prob</td><td>50</td></tr><tr><td>directionality</td><td>bidi</td></tr><tr><td>hidden_act</td><td>gelu</td></tr><tr><td>hidden_dropout_prob</td><td>0.1</td></tr><tr><td>hidden_size</td><td>512</td></tr><tr><td>initializer_range</td><td>0.02</td></tr><tr><td>intermediate_size</td><td>2048</td></tr><tr><td>max-position_embeddings</td><td>512</td></tr><tr><td>num_attention_heads</td><td>8</td></tr><tr><td>num_hidden_layers</td><td>4</td></tr><tr><td>pooler_fc_size</td><td>512</td></tr><tr><td>pooler_num_attention_heads</td><td>8</td></tr><tr><td>pooler_num_fc_layers</td><td>3</td></tr><tr><td>pooler_size-per_head</td><td>128</td></tr><tr><td>pooler_type</td><td>first_token_transform</td></tr><tr><td>type_vocab_size</td><td>2</td></tr><tr><td>vocab_size</td><td>27654</td></tr><tr><td>n_context</td><td>5</td></tr><tr><td>context_rep_lr</td><td>0.01</td></tr><tr><td>pca_dim</td><td>14</td></tr><tr><td>contextual_warmup</td><td>20.000</td></tr></table>",
+        "bbox": [
+            364,
+            680,
+            632,
+            911
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D.2 BILINGUAL MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            352,
+            117
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "As metioned in the paper, we use Wikipedia dump to pretrain the bilingual models. The Stanford CoreNLP tokenizer (Manning et al., 2014) is used to tokenize English, German, Spanish and Chinese data. And the spaCy tokenizer is used to tokenize Japanese data. All data are converted to lowercase. We convert Chinese data to simplified font to make it consistent with evaluation task datasets. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            185
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "All the language models used in cross-lingual experiments were pretrained for 600,000 steps from scratch. Similar to our monolingual models, maximum number of senses $S$ in word sense selection algorithm) was set to 1 for the first 20,000 steps, and the increased to 3 afterwards when pretraining Bi-SaELMo and Bi-SaELMo $+$ Proj.8 We use two NVIDIA V100 GPUs to pretrain each Bi-SaELMo model, which takes about 10 days to complete the training. See Table 8 for the hyperparameters used to pretrain Bi-SaELMo/Bi-SaELMo+Proj. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            276
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/ede4dcc740833b9bc89f8731411499bc5dfab6a34579184fc8574bfe325cc542.jpg",
+        "table_caption": [
+            "Table 8: Bilingual model hyperparameters: Bi-SaELMo/Bi-SaELMo+Proj "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Hyperparameter</td><td>Value</td></tr><tr><td>max_word_length</td><td>50</td></tr><tr><td>batch_size</td><td>256</td></tr><tr><td>n-gpus</td><td>2</td></tr><tr><td>bidirectional</td><td>True</td></tr><tr><td>char_cnn:embedding:dim</td><td>16</td></tr><tr><td>char_cnn:max_characters_per_token</td><td>50</td></tr><tr><td>char_cnn:n_characters</td><td>261</td></tr><tr><td>char_cnn:n_highway</td><td>2</td></tr><tr><td>dropout</td><td>0.1</td></tr><tr><td>lstm:cell_clip</td><td>3</td></tr><tr><td>lstm:dim</td><td>4096</td></tr><tr><td>lstm:n_layers</td><td>2</td></tr><tr><td>lstm:proj_clip</td><td>3</td></tr><tr><td>lstm:projection_dim</td><td>512</td></tr><tr><td>lstm:use_skip_connections</td><td>True</td></tr><tr><td>all_clip_norm_val</td><td>10.0</td></tr><tr><td>n_epochs</td><td>6</td></tr><tr><td>unroll_steps</td><td>12</td></tr><tr><td>n_negative_samples_batch</td><td>8192</td></tr><tr><td>n_context</td><td>4</td></tr><tr><td>cluster_proj-dim</td><td>16</td></tr><tr><td>pca_sample</td><td>20,000</td></tr><tr><td>remove_less_freqent_contexts</td><td>0.1</td></tr><tr><td>learning_rate</td><td>0.2</td></tr><tr><td>sense_learning_rate</td><td>0.01</td></tr></table>",
+        "bbox": [
+            370,
+            314,
+            629,
+            616
+        ],
+        "page_idx": 16
+    }
+]

parse/train/ryl3ygHYDB/ryl3ygHYDB.md

@@ -0,0 +1,504 @@
+# LOOKAHEAD: A FAR-SIGHTED ALTERNATIVE OF MAGNITUDE-BASED PRUNING
+
+Sejun Park∗†, Jaeho Lee∗†‡, Sangwoo Mo† and Jinwoo Shin†‡ † KAIST EE ‡ KAIST AI {sejun.park,jaeho-lee,swmo,jinwoos}@kaist.ac.kr
+
+# ABSTRACT
+
+Magnitude-based pruning is one of the simplest methods for pruning neural networks. Despite its simplicity, magnitude-based pruning and its variants demonstrated remarkable performances for pruning modern architectures. Based on the observation that magnitude-based pruning indeed minimizes the Frobenius distortion of a linear operator corresponding to a single layer, we develop a simple pruning method, coined lookahead pruning, by extending the single layer optimization to a multi-layer optimization. Our experimental results demonstrate that the proposed method consistently outperforms magnitude-based pruning on various networks, including VGG and ResNet, particularly in the high-sparsity regime. See https://github.com/alinlab/lookahead_pruning for codes.
+
+# 1 INTRODUCTION
+
+The “magnitude-equals-saliency” approach has been long underlooked as an overly simplistic baseline among all imaginable techniques to eliminate unnecessary weights from over-parametrized neural networks. Since the early works of LeCun et al. (1989); Hassibi & Stork (1993) which provided more theoretically grounded alternatives of magnitude-based pruning (MP) based on second derivatives of the loss function, a wide range of methods including Bayesian / informationtheoretic approaches (Neal, 1996; Louizos et al., 2017; Molchanov et al., 2017; Dai et al., 2018), $\ell _ { p }$ -regularization (Wen et al., 2016; Liu et al., 2017; Louizos et al., 2018), sharing redundant channels (Zhang et al., 2018; Ding et al., 2019), and reinforcement learning approaches (Lin et al., 2017; Bellec et al., 2018; He et al., 2018) have been proposed as more sophisticated alternatives.
+
+On the other hand, the capabilities of MP heuristics are gaining attention once more. Combined with minimalistic techniques including iterative pruning (Han et al., 2015) and dynamic reestablishment of connections (Zhu & Gupta, 2017), a recent large-scale study by Gale et al. (2019) claims that MP can achieve a state-of-the-art trade-off between sparsity and accuracy on ResNet-50. The unreasonable effectiveness of magnitude scores often extends beyond the strict domain of network pruning; a recent experiment by Frankle & Carbin (2019) suggests the existence of an automatic subnetwork discovery mechanism underlying the standard gradient-based optimization procedures of deep, overparametrized neural networks by showing that the MP algorithm finds an efficient trainable subnetwork. These observations constitute a call to revisit the “magnitude-equals-saliency” approach for a better understanding of the deep neural network itself.
+
+As an attempt to better understand the nature of MP methods, we study a generalization of magnitude scores under a functional approximation framework; by viewing MP as a relaxed minimization of distortion in layerwise operators introduced by zeroing out parameters, we consider a multi-layer extension of the distortion minimization problem. Minimization of the newly suggested distortion measure, which ‘looks ahead’ the impact of pruning on neighboring layers, gives birth to a novel pruning strategy, coined lookahead pruning (LAP).
+
+In this paper, we focus on the comparison of the proposed LAP scheme to its MP counterpart. We empirically demonstrate that LAP consistently outperforms MP under various setups, including linear networks, fully-connected networks, and deep convolutional and residual networks. In particular, LAP consistently enables more than $\times 2$ gain in the compression rate of the considered models, with increasing benefits under the high-sparsity regime. Apart from its performance, lookahead pruning enjoys additional attractive properties:
+
+![](images/a1800b76bae0ab59832768ede01defd20eee3f7c1e77885fed68837210309243.jpg)  
+Figure 1: An illustration of magnitude-based pruning (MP) and lookahead pruning (LAP). MP only considers a single weight while LAP also considers the effects of neighboring edges.
+
+• Easy-to-use: Like magnitude-based pruning, the proposed LAP is a simple score-based approach agnostic to model and data, which can be implemented by computationally light elementary tensor operations. Unlike most Hessian-based methods, LAP does not rely on the availability of training data except for the retraining phase. It also has no hyper-parameter to tune, in contrast to other sophisticated training-based and optimization-based schemes. • Versatility: As our method simply replaces the “magnitude-as-saliency” criterion with a lookahead alternative, it can be deployed jointly with algorithmic tweaks developed for magnitudebased pruning, such as iterative pruning and retraining (Han et al., 2015) or joint pruning and training with dynamic reconnections (Zhu & Gupta, 2017; Gale et al., 2019).
+
+The remainder of this manuscript is structured as follows: In Section 2, we introduce a functional approximation perspective toward MP and motivate LAP and its variants as a generalization of MP for multiple layer setups; in Section 3 we explore the capabilities of LAP and its variants with simple models, then move on to apply LAP to larger-scale models.
+
+# 2 LOOKAHEAD: A FAR-SIGHTED LAYER APPROXIMATION
+
+We begin by a more formal description of the magnitude-based pruning (MP) algorithm (Han et al., 2015). Given an $L$ -layer neural network associated with weight tensors $W _ { 1 } , \dots , W _ { L }$ , the MP algorithm removes connections with the smallest absolute weights from each weight tensor until the desired level of sparsity has been achieved. This layerwise procedure is equivalent to finding a mask $M$ whose entries are either 0 or 1, incurring a smallest Frobenius distortion, measured by
+
+$$
+\operatorname* { m i n } _ { M : \| M \| _ { 0 } = s } \| W - M \odot W \| _ { F } ,
+$$
+
+where $\odot$ denotes the Hadamard product, $\| \cdot \| _ { 0 }$ denotes the entrywise $\ell _ { 0 }$ -norm, and $s$ is a sparsity constraint imposed by some operational criteria.
+
+Aiming to minimize the Frobenius distortion (Eq. (1)), the MP algorithm naturally admits a functional approximation interpretation. For the case of a fully-connected layer, the maximal difference between the output from a pruned and an unpruned layer can be bounded as
+
+$$
+\begin{array} { r } { \| W x - ( M \odot W ) x \| _ { 2 } \leq \| W - M \odot W \| _ { 2 } \cdot \| x \| _ { 2 } \leq \| W - M \odot W \| _ { F } \cdot \| x \| _ { 2 } . } \end{array}
+$$
+
+Namely, the product of the layerwise Frobenius distortion upper bounds the output distortion of the network incurred by pruning weights. Note that this perspective on MP as a worst-case distortion minimization was already made in Dong et al. (2017), which inspired an advent of the layerwise optimal brain surgery (L-OBS) procedure.
+
+A similar idea holds for convolutional layers. For the case of a two-dimensional convolution with a single input and a single output channel, the corresponding linear operator takes a form of a doubly block circulant matrix constructed from the associated kernel tensor (see, e.g., Goodfellow et al. (2016)). Here, the Frobenius distortion of doubly block circulant matrices can be controlled by the Frobenius distortion of the weight tensor of the convolutional layer.1
+
+# Algorithm 1 Lookahead Pruning (LAP)
+
+1: Input: Weight tensors $W _ { 1 } , \dots , W _ { L }$ of a trained network, desired sparsities $s _ { 1 } , \ldots , s _ { L }$   
+2: Output: Pruned weight tensors $\widetilde { W } _ { 1 } , \ldots , \widetilde { W } _ { L }$   
+3: for $i = 1 , \ldots , L$ do   
+4: Compute $\mathcal { L } _ { i } ( w )$ according to Eq. (4) for all entry $w$ of $W _ { i }$   
+5: Set $\tilde { w } _ { s _ { i } }$ as a $s _ { i }$ -th smallest element of $\{ \mathcal { L } _ { i } ( w ) : w$ is an entry of $W _ { i } \}$   
+6: Set $\tilde { M _ { i } } \gets \mathbb { 1 } \{ W _ { i } - \tilde { w } _ { s _ { i } } \geq 0 \}$   
+7: Set ${ \widetilde { W } } _ { i } \gets M _ { i } \odot W _ { i }$   
+8: end for
+
+# .1 LOOKAHEAD DISTORTION AS A BLOCK APPROXIMATION ERROR
+
+The myopic optimization (Eq. (1)) based on the per-layer Frobenius distortion falls short even in the simplest case of the two-layer linear neural network with one-dimensional output, where we consider predictors taking form $\widehat { Y } = u ^ { \top } W x$ and try to minimize the Frobenius distortion of $u ^ { \top } W$ (equivalent to $\ell _ { 2 }$ distortion in this case). Here, if $u _ { i }$ is extremely large, pruning any nonzero element in the $i$ -th row of $W$ may incur a significant Frobenius distortion.
+
+Motivated by this observation, we consider a block approximation analogue of the magnitude-based pruning objective Eq. (1). Consider an $L$ -layer neural network associated with weight tensors $W _ { 1 } , \dots , W _ { L }$ , and assume linear activation for simplicity (will be extended to nonlinear cases later in this section). Let $\mathcal { I } ( W _ { i } )$ denote the Jacobian matrix corresponding to the linear operator characterized by $W _ { i }$ . For pruning the $i$ -th layer, we take into account the weight tensors of adjacent layers $W _ { i - 1 } , W _ { i + 1 }$ in addition to the original weight tensor $W _ { i }$ . In particular, we propose to minimize the Frobenius distortion of the operator block $\mathcal { I } ( W _ { i + 1 } ) \mathcal { I } ( W _ { i } ) \mathcal { I } ( W _ { i - 1 } )$ , i.e.,
+
+$$
+\operatorname* { m i n } _ { M _ { i } : \| M _ { i } \| _ { 0 } = s _ { i } } \| \mathcal { I } ( W _ { i + 1 } ) \mathcal { I } ( W _ { i } ) \mathcal { I } ( W _ { i - 1 } ) - \mathcal { I } ( W _ { i + 1 } ) \mathcal { I } ( M _ { i } \odot W _ { i } ) \mathcal { I } ( W _ { i - 1 } ) \| _ { F } .
+$$
+
+An explicit minimization of the block distortion (Eq. (3)), however, is computationally intractable in general (see Appendix D for a more detailed discussion).
+
+To avoid an excessive computational overhead, we propose to use the following score-based pruning algorithm, coined lookahead pruning (LAP), for approximating Eq. (3): For each tensor $W _ { i }$ , we prune the weights $w$ with the smallest value of lookahead distortion (in a single step), defined as
+
+$$
+\mathcal { L } _ { i } ( w ) : = \| \mathcal { I } ( W _ { i + 1 } ) \mathcal { I } ( W _ { i } ) \mathcal { I } ( W _ { i - 1 } ) - \mathcal { I } ( W _ { i + 1 } ) \mathcal { I } ( W _ { i } | _ { w = 0 } ) \mathcal { I } ( W _ { i - 1 } ) \| _ { F }
+$$
+
+where $W _ { i } | _ { w = 0 }$ denotes the tensor whose entries are equal to the entries of $W _ { i }$ except for having zeroed out $w$ . We let both $W _ { 0 }$ and $W _ { L + 1 }$ to be tensors consisting of ones. In other words, lookahead distortion (Eq. (4)) measures the distortion (in Frobenius norm) induced by pruning $w$ while all other weights remain intact. For three-layer blocks consisting only of fully-connected layers and convolutional layers, Eq. (4) reduces to the following compact formula: for an edge $w$ connected to the $j$ -th input neuron/channel and the $k$ -th output neuron/channel of the $i$ -th layer, where its formal derivation is presented in Appendix E.
+
+$$
+\mathcal { L } _ { i } ( w ) = | w | \cdot \Big \| W _ { i - 1 } [ j , : ] \Big \| _ { F } \cdot \Big \| W _ { i + 1 } [ : , k ] \Big \| _ { F } ,
+$$
+
+where $| w |$ denotes the weight of $w$ , $W [ j , : ]$ denotes the slice of $W$ composed of weights connected to the $j$ -th output neuron/channel, and $W [ : , k ]$ denotes the same for the $k$ -th input neuron/channel.
+
+In LAP, we compute the lookahead distortion for all weights, and then remove weights with the smallest distortions in a single step (as done in MP). A formal description of LAP is presented in Algorithm 1. We also note the running time of LAP is comparable with that of MP (see Appendix G).
+
+LAP on linear networks. To illustrate the benefit of lookahead, we evaluate the performance of MP and LAP on a linear fully-connected network with a single hidden layer of 1,000 nodes, trained with the MNIST image classification dataset. Fig. 2a and Fig. 2b depict the test accuracy of models pruned with each method, before and after retraining steps.
+
+As can be expected from the discrepancy between the minimization objectives (Eqs. (1) and (3)), networks pruned with LAP outperform networks pruned with MP at every sparsity level, in terms of its performance before a retraining phase. Remarkably, we observe that test accuracy of models pruned with LAP monotonically increases from $9 1 . 2 \%$ to $9 2 . 3 \%$ as the sparsity level increases, until the fraction of surviving weights reaches $1 . 2 8 \%$ . At the same sparsity level, models pruned with MP achieves only $7 1 . 9 \%$ test accuracy. We also observe that LAP leads MP at every sparsity level even after a retraining phase, with an increasing margin as we consider a higher level of sparsity.
+
+![](images/e298a6f1505a0c521dab46a01082e1a8947ef782954c21fec507f2f3ada1742d.jpg)  
+Figure 2: Test accuracy of pruned linear network under varying levels of sparsity, (a) before and (b) after a retraining phase. MP denotes magnitude-based pruning and LAP denotes lookahead pruning. All reported points are averaged over 5 trials.
+
+Understanding LAP with nonlinear activations. Most neural network models in practice deploy nonlinear activation functions, e.g., rectified linear units (ReLU). Although the lookahead distortion has been initially derived using linear activation functions, LAP can also be used for nonlinear networks, as the quantity $\mathcal { L } _ { i } ( w )$ remains relevant to the original block approximation point of view. This is especially true when the network is severely over-parametrized. To see this, consider a case where one aims to prune a connection in the first layer of a two-layer fully-connected network with ReLU, i.e.,
+
+$$
+x \mapsto W _ { 2 } \sigma ( W _ { 1 } x ) ,
+$$
+
+where $\sigma ( x ) = \operatorname* { m a x } \{ 0 , x \}$ is applied entrywise. Under the over-parametrized scenario, zeroing out a single weight may alter the activation pattern of connected neurons with only negligible probability, which allows one to decouple the probability of activation of each neuron from the act of pruning each connection. This enables us to approximate the root mean square distortion of the network output introduced by pruning $w$ of $W _ { 1 }$ by $\sqrt { p _ { k } } \mathcal { L } _ { 1 } ( w )$ , where $k$ is the index of the output neuron that $w$ is connected to, and $p _ { k }$ denotes the probability of activation for the $k$ -th neuron. In this sense, LAP (Algorithm 1) can be understood as assuming i.i.d. activations of neurons, due to a lack of additional access to training data. In other words, LAP admits a natural extension to the regime where we assume additional access to training data during the pruning phase. This variant, coined LAP-act, will be formally described in Appendix F, with experimental comparisons to another datadependent baseline of optimal brain damage (OBD) (LeCun et al., 1989).
+
+Another theoretical justification of using the lookahead distortion (Eq. (5)) for neural networks with nonlinear activation functions comes from recent discoveries regarding the implicit bias imposed by training via stochastic gradient descent (Du et al., 2018). See Appendix M for a detailed discussion.
+
+As will be empirically shown in Section 3.1, LAP is an effective pruning strategy for sigmoids and tanh activations, that are not piece-wise linear as ReLU.
+
+# 2.2 LOOKAHEAD PRUNING WITH BATCH NORMALIZATION
+
+Batch normalization (BN), introduced by Ioffe & Szegedy (2015), aims to normalize the output of a layer per batch by scaling and shifting the outputs with trainable parameters. Based on our functional approximation perspective, having batch normalization layers in a neural network is not an issue for MP, which relies on the magnitudes of weights; batch normalization only affects the distribution of the input for each layer, not the layer itself. On the other hand, as the lookahead distortion (Eq. (3)) characterizes the distortion of the multi-layer block, one must take into account batch normalization when assessing the abstract importance of each connection.
+
+The revision of lookahead pruning under the presence of batch normalization can be done fairly simply. Note that such a normalization process can be expressed as
+
+$$
+x \mapsto a \odot x + b ,
+$$
+
+for some $a , b \in \mathbb { R } ^ { \mathsf { d i m } ( x ) }$ . Hence, we revise lookahead pruning to prune the connections with a minimum value of
+
+$$
+\mathcal { L } _ { i } ( w ) = | w | \cdot a _ { i - 1 } [ j ] a _ { i } [ k ] \cdot \Big \| { W _ { i - 1 } [ j , : ] } \Big \| _ { F } \cdot \Big \| { W _ { i + 1 } [ : , k ] } \Big \| _ { F } ,
+$$
+
+where $a _ { i } [ k ]$ denotes the $k$ -th index scaling factor for the BN layer placed at the output of the $i$ -th fully-connected or convolutional layer (if BN layer does not exist, let $a _ { i } [ k ] = 1 { \bmod { \frac { } { } } }$ ). This modification of LAP makes it an efficient pruning strategy, as will be empirically verified in Section 3.3.
+
+# 2.3 VARIANTS OF LOOKAHEAD PRUNING
+
+As the LAP algorithm (Algorithm 1) takes into account current states of the neighboring layers, LAP admits several variants in terms of lookahead direction, the order of pruning, and sequential pruning methods; these methods are extensively studied in Section 3.2. Along with “vanilla” LAP, we consider in total, six variants, which we now describe below:
+
+Mono-directional LAPs. To prune a layer, LAP considers both preceding and succeeding layers. Looking forward, i.e., only considering the succeeding layer, can be viewed as an educated modification of the internal representation the present layer produces. Looking backward, on the other hand, can be interpreted as only taking into account the expected structure of input coming into the current layer. The corresponding variants, coined LFP and LBP, are tested.
+
+Order of pruning. Instead of using the unpruned tensors of preceding/succeeding layers, we also consider performing LAP based on already-pruned layers. This observation brings up a question of the order of pruning; an option is to prune in a forward direction, i.e., prune the preceding layer first and use the pruned weight to prune the succeeding, and the other is to prune backward. Both methods are tested, which are referred to as LAP-forward and LAP-backward, respectively.
+
+Sequential pruning. We also consider a sequential version of LAP-forward/backward methods. More specifically, if we aim to prune total $p \%$ of weights from each layer, we divide the pruning budget into five pruning steps and gradually prune $( p / 5 ) \%$ of the weights per step in forward/backward direction. Sequential variants will be marked with a suffix “-seq”.
+
+# 3 EXPERIMENTS
+
+In this section, we compare the empirical performance of LAP with that of MP. More specifically, we validate the applicability of LAP to nonlinear activation functions in Section 3.1. In Section 3.2, we test LAP variants from Section 2.3. In Section 3.3, we test LAP on VGG (Simonyan & Zisserman, 2015), ResNet (He et al., 2016), and Wide ResNet (WRN, Zagoruyko & Komodakis (2016)).
+
+Experiment setup. We consider five neural network architectures: (1) The fully-connected network (FCN) under consideration is consist of four hidden layers, each with 500 neurons. (2) The convolutional network (Conv-6) consists of six convolutional layers, followed by a fully-connected classifier with two hidden layers with 256 neurons each; this model is identical to that appearing in the work of Frankle & Carbin (2019) suggested as a scaled-down variant of VGG.2 (3) VGG-19 is used, with an addition of batch normalization layers after each convolutional layers, and a reduced number of fully-connected layers from three to one.3 (4) ResNets of depths $\{ 1 8 , 5 0 \}$ are used. (5) WRN of 16 convolutional layers and widening factor 8 (WRN-16-8) is used. All networks used ReLU activation function, except for the experiments in Section 3.1. We mainly consider image classification tasks. In particular, FCN is trained on MNIST dataset (Lecun et al., 1998), Conv-6, VGG, and ResNet are trained on CIFAR-10 dataset (Krizhevsky & Hinton, 2009), and VGG, ResNet, and WRN are trained on Tiny-ImageNet.4 We focus on the one-shot pruning of MP and LAP, i.e., models are trained with a single training-pruning-retraining cycle. All results in this section are averaged over five independent trials. We provide more details on setups in Appendix A.
+
+![](images/82a376c79ec10cd22ec90814fc39358d830230ea00856db045158e1e67377168.jpg)  
+Figure 3: Test accuracy of FCN with (a) sigmoid, (b) tanh, (c) ReLU activations; (d) test accuracy of FCN with ReLU activation before retraining, for the MNIST dataset.
+
+# 3.1 NETWORKS WITH NONLINEAR ACTIVATION FUNCTIONS
+
+We first compare the performance of LAP with that of MP on FCN using three different types of activation functions: sigmoid, and tanh, and ReLU. Figs. 3a to 3c depict the performance of models pruned with LAP (Green) and MP (Red) under various levels of sparsity.
+
+Although LAP was motivated primarily from linear networks and partially justified for positivehomogenous activation functions such as ReLU, the experimental results show that LAP consistently outperforms MP even on networks using sigmoidal activation functions. We remark that LAP outperforms MP by a larger margin as fewer weights survive (less than $1 \%$ ). Such a pattern will be observed repeatedly in the remaining experiments of this paper.
+
+In addition, we also check whether LAP still exhibits better test accuracy before retraining under the usage of nonlinear activation functions, as in the linear network case (Fig. 2b). Fig. 3d illustrates the test accuracy of pruned FCN using ReLU on the MNIST dataset before retraining. We observe that the network pruned by LAP continues to perform better than MP in this case; the network pruned by LAP retains the original test accuracy until only $38 \%$ of the weights survive, and shows less than $1 \%$ performance drop with only $20 \%$ of the weights remaining. On the other hand, MP requires $54 \%$ and $30 \%$ to achieve the same level of performance, respectively. In other words, the models pruned with MP requires about $50 \%$ more survived parameters than the models pruned with LAP to achieve a similar level of performance before being retrained using additional training batches.
+
+# 3.2 EVALUATING LAP VARIANTS
+
+Now we evaluate LAP and its variants introduced in Section 2.3 on FCN and Conv-6, each trained on MNIST and CIFAR-10, respectively. Table 1 summarizes the experimental results on FCN and Table 2 summarizes the results on Conv-6. In addition to the baseline comparison with MP, we also compare with random pruning (RP), where the connection to be pruned was decided completely independently. We observe that LAP performs consistently better than MP and RP with similar or smaller variance in any case. In the case of an extreme sparsity, LAP enjoys a significant performance gain; over $7 5 \%$ gain on FCN and $14 \%$ on Conv-6. This performance gain comes from a better training accuracy, instead of a better generalization; see Appendix L for more information.
+
+Comparing mono-directional lookahead variants, we observe that LFP performs better than LBP in the low-sparsity regime, while LBP performs better in the high-sparsity regime; in any case, LAP performed better than both methods. Intriguingly, the same pattern appeared in the case of the ordered pruning. Here, LAP-forward can be considered an analogue of LBP in the sense that they both consider layers closer to the input to be more critical. Likewise, LAP-backward can be considered an analogue of LFP. We observe that LAP-forward performs better than LAP-backward in the high-sparsity regime, and vice versa in the low-sparsity regime. Our interpretation is as follows: Whenever the sparsity level is low, carefully curating the input signal is not important due to high redundancies in the natural image signal. This causes a relatively low margin of increment by looking backward in comparison to looking forward. When the sparsity level is high, the input signal is scarce, and the relative importance of preserving the input signal is higher.
+
+Finally, we observe that employing forward/backward ordering and sequential methods leads to better performance, especially in the high-sparsity regime. There is no clear benefit of adopting directional methods in the low-sparsity regime. The relative gain in performance with respect to LAP is either marginal or unreliable.
+
+Table 1: Test error rates of FCN on MNIST. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $1 . 9 8 \%$ error rate.   
+
+<table><tr><td></td><td>6.36%</td><td>3.21%</td><td>1.63%</td><td>0.84%</td><td>0.43%</td><td>0.23%</td><td>0.12%</td></tr><tr><td>MP (baseline) RP</td><td>1.75±0.11 2.36±0.13</td><td>2.11±0.14 2.72±0.16</td><td>2.53±0.09 3.64±0.17</td><td>3.32±0.27 17.54±7.07</td><td>4.77±0.22 82.48±4.03</td><td>19.85±8.67 88.65±0.00</td><td>67.62±9.91 88.65±0.00</td></tr><tr><td>LFP</td><td>1.63±0.08 (-6.41%)</td><td>1.89±0.11 (-10.60%)</td><td>2.43±0.10 (-3.95%)</td><td>3.32±0.13 (-0.12%)</td><td>4.23±0.38 (-11.40%)</td><td>9.59±1.70 (-51.70%)</td><td>50.11±12.99 (-25.91%)</td></tr><tr><td>LBP</td><td>1.75±0.17 (+0.69%)</td><td>2.04±0.12 (-3.31%)</td><td>2.61±0.15 (+3.00%)</td><td>3.62±0.17 (+8.97%)</td><td>4.19±0.31 (-12.23%)</td><td>9.09±1.41 (-54.21%)</td><td>28.51±14.85 (-57.84%)</td></tr><tr><td>LAP</td><td>1.67±0.11 (-4.24%)</td><td>1.89±0.12 (-10.61%)</td><td>2.48±0.13 (-2.05%)</td><td>3.29±0.06 (-1.08%)</td><td>3.93±0.26 (-17.72%)</td><td>6.72±0.44 (-66.15%)</td><td>16.45±5.61 (-75.68%)</td></tr><tr><td>LAP-forward</td><td>1.60±0.08 (-8.25%) 1.63±0.11</td><td>1.93±0.15 (-8.43%)</td><td>2.51±0.11 (-0.95%)</td><td>3.56±0.19 (+7.03%)</td><td>4.47±0.20 (-6.41%)</td><td>6.58±0.33 (-66.81%)</td><td>12.00±0.73 (-82.26%)</td></tr><tr><td>LAP-backward</td><td>(-6.64%) 1.68±0.11</td><td>1.88±0.07 (-10.80%)</td><td>2.35±0.02 (-7.03%)</td><td>3.12±0.08 (-6.08%)</td><td>3.87±0.18 (-19.02%)</td><td>5.62±0.17 (-71.71%)</td><td>13.00±3.30 (-80.78%)</td></tr><tr><td>LAP-forward-seq</td><td>(-3.66%)</td><td>1.92±0.10 (-9.09%)</td><td>2.49±0.14 (-1.42%)</td><td>3.39±0.24 (+1.93%)</td><td>4.21±0.06 (-11.86%)</td><td>6.20±0.32 (-68.73%)</td><td>10.98±1.03 (-83.76%)</td></tr><tr><td>LAP-backward-seq</td><td>1.57±0.08 (-10.08%)</td><td>1.84±0.10 (-12.41%)</td><td>2.20±0.10 (-13.27%)</td><td>3.13±0.16 (-5.90%)</td><td>3.62±0.14 (-24.13%)</td><td>5.42±0.27 (-72.71%)</td><td>11.92±4.61 (-82.36%)</td></tr></table>
+
+Table 2: Test error rates of Conv-6 on CIFAR-10. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $1 1 . 9 7 \%$ error rate.   
+
+<table><tr><td></td><td>10.62%</td><td>8.86%</td><td>7.39%</td><td>6.18%</td><td>5.17%</td><td>4.32%</td><td>3.62%</td></tr><tr><td>MP (baseline) RP</td><td>11.86±0.33 26.85±1.23</td><td>12.20±0.21 29.72±1.13</td><td>13.30±0.30 32.98±1.10</td><td>15.81±0.59 35.92±1.08</td><td>20.19±2.35 39.13±1.05</td><td>24.43±1.48 41.20±1.19</td><td>28.60±2.10 43.60±0.82</td></tr><tr><td>LFP</td><td>11.81±0.35</td><td>12.18±0.23</td><td>13.27±0.44</td><td>15.04±0.43</td><td>18.50±0.80</td><td>22.86±1.66</td><td>26.65±1.33</td></tr><tr><td>LBP</td><td>(-0.39%) 12.08±0.17</td><td>(-0.20%) 12.34±0.36</td><td>(-0.26%) 13.26±0.16</td><td>(-4.87%) 14.93±0.85</td><td>(-8.37%) 18.11±1.27</td><td>(-6.40%) 22.57±0.94</td><td>(-6.83%) 26.34±1.60</td></tr><tr><td>LAP</td><td>(+1.84%) 11.76±0.24 (-0.83%)</td><td>(-1.15%) 12.16±0.27</td><td>(-0.33%) 13.05±0.14</td><td>(-5.57%) 14.39±0.44</td><td>(-10.31%) 17.10±1.26</td><td>(-7.59%) 21.24±1.16</td><td>(-7.91%) 24.52±1.11</td></tr><tr><td>LAP-forward</td><td>11.82±0.16</td><td>(-0.34%) 12.35±0.34</td><td>(-1.86%) 13.09±0.36</td><td>(-8.99%) 14.42±0.45</td><td>(-15.30%) 17.05±1.30</td><td>(-13.04%) 20.28±1.40</td><td>(-14.29%) 22.80±0.51</td></tr><tr><td>LAP-backward</td><td>(-0.33%) 11.82±0.25 (-0.32%)</td><td>(+1.24%) 12.29±0.06 (+0.68%)</td><td>(-1.62%) 12.93±0.38</td><td>(-8.79%) 14.55±0.58</td><td>(-15.57%) 17.00±0.84</td><td>(-16.98%) 20.00±0.82</td><td>(-20.30%) 23.37±1.16</td></tr><tr><td>LAP-forward-seq</td><td>12.01±0.17</td><td>12.47±0.37</td><td>(-2.78%) 13.19±0.19</td><td>(-7.98%) 14.12±0.28</td><td>(-15.78%) 16.73±0.95</td><td>(-18.11%) 19.63±1.81</td><td>(-18.30%) 22.44±1.31</td></tr><tr><td>LAP-backward-seq</td><td>(+1.28%) 11.81±0.16 (-0.39%)</td><td>(+2.21%) 12.35±0.26</td><td>(-0.81%) 13.25±0.21</td><td>(-10.70%) 14.17±0.44</td><td>(-17.13%) 16.99±0.97</td><td>(-19.62%) 19.94±1.02</td><td>(-21.54%) 23.15±1.12</td></tr></table>
+
+# 3.3 DEEPER NETWORKS: VGG, RESNET, AND WRN
+
+We also compare empirical performances of MP with LAP on deeper networks. We trained VGG-19 and ResNet-18 on CIFAR-10 (Tables 3 and 4), and VGG-19, ResNet-50, and WRN-16-8 on TinyImageNet (Tables 5 to 7). For models trained on CIFAR-10, we also test LAP-forward to verify the observation that it outperforms LAP in the high-sparsity regime on such deeper models. We also report additional experimental results on VGG- $\lbrace 1 1 , 1 6 \rbrace$ trained on CIFAR-10 in Appendix B. For models trained on Tiny-ImageNet, top-1 error rates are reported in Appendix C.
+
+From Tables 3 to 7, we make the following two observations: First, as in Section 3.2, the models pruned with LAP consistently achieve a higher or similar level of accuracy compared to models pruned with MP, at all sparsity levels. In particular, test accuracies tend to decay at a much slower rate with LAP. In Table 3, for instance, we observe that the models pruned by LAP retain test accuracies of $70 \sim 8 0 \%$ even with less than $2 \%$ of weights remaining. In contrast, the performance of models pruned with MP falls drastically, to below $30 \%$ accuracy. This observation is consistent on both CIFAR-10 and Tiny-ImageNet datasets.
+
+Second, the advantages of considering an ordered pruning method (LAP-forward) over LAP is limited. While we observe from Table 3 that LAP-forward outperforms both MP and LAP in the highsparsity regime, the gain is marginal considering standard deviations. LAP-forward is consistently worse than LAP (by at most $1 \%$ in absolute scale) in the low-sparsity regime.
+
+Table 3: Test error rates of VGG-19 on CIFAR-10. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $9 . 0 2 \%$ error rate.   
+
+<table><tr><td></td><td>12.09%</td><td>8.74%</td><td>6.31%</td><td>4.56%</td><td>3.30%</td><td>2.38%</td><td>1.72%</td><td>1.24%</td></tr><tr><td>MP (baseline)</td><td>8.99±0.12</td><td>9.90±0.09</td><td>11.43±0.24</td><td>15.62±1.68</td><td>29.10±8.78</td><td>40.27±11.51</td><td>63.27±11.91</td><td>77.90±7.94</td></tr><tr><td>LAP</td><td>8.89±0.14 (-1.07%)</td><td>9.51±0.22 (-3.96%)</td><td>10.56±0.28 (-7.63%)</td><td>12.11±0.44 (-22.48%)</td><td>13.64±0.77 (-53.13%)</td><td>16.38±1.47 (-59.31%)</td><td>20.88±1.71 (-67.00%)</td><td>22.82±0.81 (-70.71%)</td></tr><tr><td>LAP-forward</td><td>9.63±0.25 (+7.16%)</td><td>10.31±0.23 (+4.12%)</td><td>11.10±0.22 (-2.89%)</td><td>12.24±0.33 (-21.66%)</td><td>13.54±0.28 (-53.46%)</td><td>16.03±0.46 (-60.18%)</td><td>19.33±1.14 (-69.44%)</td><td>21.59±0.32 (-72.29%)</td></tr></table>
+
+Table 4: Test error rates of ResNet-18 on CIFAR-10. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $8 . 6 8 \%$ error rate.   
+
+<table><tr><td></td><td>10.30%</td><td>6.33%</td><td>3.89%</td><td>2.40%</td><td>1.48%</td><td>0.92%</td><td>0.57%</td><td>0.36%</td></tr><tr><td>MP (baseline)</td><td>8.18±0.33</td><td>8.74±0.15</td><td>9.82±0.18</td><td>11.28±0.30</td><td>14.31±0.18</td><td>18.56±0.36</td><td>22.93±0.93</td><td>26.77±1.04</td></tr><tr><td>LAP</td><td>8.09±0.10 (-1.08%)</td><td>8.97±0.22 (+2.59%)</td><td>9.74±0.15 (-0.81%)</td><td>11.35±0.20 (+0.64%)</td><td>13.73±0.24 (-4.08%)</td><td>16.29±0.29 (-12.23%)</td><td>20.22±0.53 (-11.82%)</td><td>22.45±0.64 (-15.82%)</td></tr><tr><td>LAP-forward</td><td>8.19±0.15 (+0.12%)</td><td>9.17±0.07 (+4.85%)</td><td>10.32±0.27 (+5.09%)</td><td>12.38±0.30 (+9.79%)</td><td>15.31±0.62 (+6.96%)</td><td>18.56±0.88 (-0.02%)</td><td>21.09±0.53 (-8.04%)</td><td>23.89±0.46 (-10.44%)</td></tr></table>
+
+Table 5: Top-5 test error rates of VGG-19 on Tiny-ImageNet. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $3 6 . 8 9 \%$ error rate. Top-1 test error rates are presented in Table 10.   
+
+<table><tr><td></td><td>12.16%</td><td>10.34%</td><td>8.80%</td><td>7.48%</td><td>6.36%</td><td>5.41%</td><td>4.61%</td><td>3.92%</td></tr><tr><td>MP (baseline)</td><td>36.40±1.31</td><td>37.37±1.08</td><td>38.40±1.30</td><td>40.23±1.26</td><td>42.68±1.97</td><td>45.83±2.76</td><td>49.79±2.67</td><td>56.15±5.14</td></tr><tr><td>LAP</td><td>36.01±1.31 (-1.07%)</td><td>37.03±0.90 (-0.90%)</td><td>38.20±1.61 (-0.52%)</td><td>39.36±1.30 (-2.16%)</td><td>40.95±1.46 (-4.05%)</td><td>43.14±1.33 (-5.87%)</td><td>45.29±1.80 (-9.02%)</td><td>48.34±0.30 (-13.92%)</td></tr><tr><td>LAP-forward</td><td>36.98±1.04 (+1.58%)</td><td>37.35±0.90 (-0.04%)</td><td>38.49±1.10 (+0.24%)</td><td>39.57±0.97 (-1.65%)</td><td>40.94±1.49 (-4.06%)</td><td>43.30±1.57 (-5.53%)</td><td>45.76±1.37 (-8.08%)</td><td>48.95±1.70 (-12.84%)</td></tr></table>
+
+Table 6: Top-5 test error rates of ResNet-50 on Tiny-ImageNet. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $2 3 . 1 9 \%$ error rate. Top-1 test error rates are presented in Table 11.   
+
+<table><tr><td></td><td>6.52%</td><td>4.74%</td><td>3.45%</td><td>2.51%</td><td>1.83%</td><td>1.34%</td><td>0.98%</td><td>0.72%</td></tr><tr><td>MP (baseline)</td><td>23.88±0.27</td><td>24.99±0.34</td><td>26.84±0.39</td><td>29.54±0.58</td><td>34.04±0.48</td><td>40.19±0.36</td><td>45.13±0.57</td><td>59.18±16.31</td></tr><tr><td>LAP</td><td>23.64±0.40 (-1.00%)</td><td>24.91±0.25 (-0.34%)</td><td>26.52±0.38 (-1.17%)</td><td>28.84±0.43 (-2.38%)</td><td>33.71±0.58 (-0.98%)</td><td>39.07±0.45 (-2.79%)</td><td>43.05±0.97 (-4.61%)</td><td>46.16±1.04 (-22.00%)</td></tr><tr><td>LAP-forward</td><td>24.26±0.48 (+1.57%)</td><td>24.92±0.41 (-0.30%)</td><td>27.66±0.55 (+3.08%)</td><td>30.93±0.81 (+4.71%)</td><td>35.90±1.24 (+5.46%)</td><td>39.99±0.58 (-0.48%)</td><td>43.42±0.52 (-3.79%)</td><td>45.45±0.78 (-23.19%)</td></tr></table>
+
+Table 7: Top-5 test error rates of WRN-16-8 on Tiny-ImageNet. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $2 5 . 7 7 \%$ error rate. Top-1 test error rates are presented in Table 12.   
+
+<table><tr><td></td><td>12.22%</td><td>8.85%</td><td>6.41%</td><td>4.65%</td><td>3.37%</td><td>2.45%</td><td>1.77%</td><td>1.29%</td></tr><tr><td>MP (baseline)</td><td>25.27±0.73</td><td>26.79±0.87</td><td>28.84±1.04</td><td>31.91±0.80</td><td>37.01±1.42</td><td>42.89±2.43</td><td>51.10±2.59</td><td>59.73±2.85</td></tr><tr><td>LAP</td><td>24.99±0.85 (-1.12%)</td><td>26.55±1.45 (-0.87%)</td><td>28.68±1.17 (-0.58%)</td><td>32.22±2.51 (+0.98%)</td><td>35.82±2.06 (-3.22%)</td><td>41.37±3.07 (-3.55%)</td><td>45.43±4.48 (-11.10%)</td><td>51.83±1.91 (-13.22%)</td></tr><tr><td>LAP-forward</td><td>26.30±0.88 (+4.08%)</td><td>28.52±2.13 (+6.48%)</td><td>30.98±1.39 (+7.42%)</td><td>34.72±1.82 (+8.83%)</td><td>38.41±2.48 (+3.79%)</td><td>42.02±2.46 (-2.02%)</td><td>45.10±1.80 (-11.74%)</td><td>51.92±1.94 (-13.07%)</td></tr></table>
+
+# 4 CONCLUSION
+
+In this work, we interpret magnitude-based pruning as a solution to the minimization of the Frobenius distortion of a single layer operation incurred by pruning. Based on this framework, we consider the minimization of the Frobenius distortion of multi-layer operation, and propose a novel lookahead pruning (LAP) scheme as a computationally efficient algorithm to solve the optimization. Although LAP was motivated from linear networks, it extends to nonlinear networks which indeed minimizes the root mean square lookahead distortion assuming i.i.d. activations. We empirically show its effectiveness on networks with nonlinear activation functions, and test the algorithm on various network architectures including VGG, ResNet and WRN, where LAP consistently performs better than MP.
+
+Acknowledgments. We thank Seunghyun Lee for providing helpful feedbacks and suggestions in preparing the early version of the manuscript. JL also gratefully acknowledges Jungseul Ok and Phillip M. Long for enlightening discussions about theoretical natures of neural network pruning. This research was supported by the Engineering Research Center Program through the National Research Foundation of Korea (NRF), funded by the Korean Government MSIT (NRF2018R1A5A1059921).
+
+# REFERENCES
+
+S. Arora, N. Cohen, and E. Hazan. On the optimization of deep networks: Implicit acceleration by overparametrization. In Proceedings of the International Conference on Machine Learning, 2018.   
+G. Bellec, D. Kappel, W. Maass, and R. Legenstein. Deep rewiring: training very sparse deep networks. In International Conference on Learning Representations, 2018.   
+B. Dai, C. Zhu, B. Guo, and D. Wipf. Compressing neural networks using the variational information bottleneck. In Proceedings of the International Conference on Machine Learning, 2018.   
+F. Dangel, F. Kunstner, and P. Hennig. BackPACK: Packing more into backprop. In International Conference on Learning Representations, 2020.   
+X. Ding, G. Ding, Y. Guo, and J. Han. Centripetal SGD for pruning very deep convolutional networks with complicated structure. In IEEE Conference on Computer Vision and Pattern Recognition, 2019.   
+Xin Dong, Shangyu Chen, and Sinno Pan. Learning to prune deep neural networks via layer-wise optimal brain surgeon. In Advances in Neural Information Processing Systems, 2017.   
+S. S. Du, W. Hu, and J. D. Lee. Algorithmic regularization in learning deep homogeneous models: Layers are automatically balanced. In Advances in Neural Information Processing Systems, 2018.   
+J. Frankle and M. Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019.   
+T. Gale, E. Elsen, and S. Hooker. The state of sparsity in deep neural networks. arXiv preprint 1902.09574, 2019.   
+X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the International Conference on Artificial Intelligence and Statistics, 2010.   
+I. Goodfellow, Y. Bengio, and A. Courville. Deep Learning. MIT Press, 2016. http://www. deeplearningbook.org.   
+S. Han, J. Pool, J. Tran, and W. J. Dally. Learning both weights and connections for efficient neural networks. In Advances in Neural Information Processing Systems, 2015.   
+B. Hassibi and D. G. Stork. Second order derivatives for network pruning: Optimal brain surgeon. In Advances in Neural Information Processing Systems, 1993.   
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In IEEE Conference on Computer Vision and Pattern Recognition, 2016.   
+Y. He, J. Lin, Z. Liu, H. Wang, L. Li, and S. Han. AMC: AutoML for model compression and acceleration on mobile devices. In European Conference on Computer Vision, 2018.   
+S. Ioffe and C. Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the International Conference on Machine Learning, 2015.   
+D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations, 2015.   
+A. Krizhevsky and G. Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.   
+Y. LeCun, J. S. Denker, and S. A. Solla. Optimal brain damage. In Advances in Neural Information Processing Systems, 1989.   
+Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. In Proceedings of the IEEE, 1998.   
+J. Lin, Y. Rao, J. Lu, and J. Zhou. Runtime neural pruning. In Advances in Neural Information Processing Systems, 2017.   
+Z. Liu, J. Li, Z. Shen, G. Huang, S. Yan, and C. Zhang. Learning efficient convolutional networks through network slimming. In IEEE International Conference on Computer Vision, 2017.   
+Z. Liu, M. Sun, T. Zhou, G. Huang, and T. Darrell. Rethinking the value of network pruning. In International Conference on Learning Representations, 2019.   
+C. Louizos, K. Ullrich, and M. Welling. Bayesian compression for deep learning. In Advances in Neural Information Processing Systems, 2017.   
+C. Louizos, M. Welling, and D. P. Kingma. Learning sparse neural networks through $l _ { 0 }$ regularization. In International Conference on Learning Representations, 2018.   
+D. Molchanov, A. Ashukha, and D. Vetrov. Variational dropout sparsified deep neural networks. In Proceedings of the International Conference on Machine Learning, 2017.   
+K. G. Murty and S. N. Kabadi. Some NP-complete problems in quadratic and nonlinear programming. Mathematical programming, 39(2):117–129, 1987.   
+R. M. Neal. Bayesian learning for neural networks. Springer, 1996.   
+M. Sandler, A. Howard, M. Zhu, A. Zhmoginov, and L. Chen. MobileNetV2: Inverted residuals and linear bottlenecks. In IEEE Conference on Computer Vision and Pattern Recognition, 2018.   
+H. Sedghi, V. Gupta, and P. M. Long. The singular values of convolutional layers. In International Conference on Learning Representations, 2019.   
+K. Simonyan and A. Zisserman. Very deep convolutional networks for large-scale image recognition. In International Conference on Learning Representations, 2015.   
+W. Wen, C. Wu, Y. Wang, Y. Chen, and H. Li. Learning structured sparsity in deep networks. In Advances in Neural Information Processing Systems, 2016.   
+J. Ye, X. Lu, Z. Lin, and J. Z. Wang. Rethinking smaller-norm-less-informative assumption in channel pruning of convolutional layers. In International Conference on Learning Representations, 2018.   
+S. Zagoruyko and N. Komodakis. Wide residual networks. In Proceedings of British Machine Vision Conference, 2016.   
+D. Zhang, H. Wang, M. Figueiredo, and L. Balzano. Learning to share: simultaneous parameter tying and sparsification in deep learning. In International Conference on Learning Representations, 2018.   
+M. Zhu and S. Gupta. To prune, or not to prune: exploring the efficacy of pruning for model compression. arXiv preprint arXiv:1710.01878, 2017.
+
+# A EXPERIMENTAL SETUP
+
+Models and datasets. We consider four neural network architectures: (1) The fully-connected network (FCN) under consideration is composed of four hidden layers, each with 500 hidden neurons. (2) The convolutional network (Conv-6) consists of six convolutional layers, followed by a fully-connected classifier with two hidden layers with 256 hidden neurons each; this model is identical to that appearing in the work of Frankle & Carbin (2019) suggested as a scaled-down variant of VGG.5 (3) VGGs of depths $\{ 1 1 , 1 6 , 1 9 \}$ were used, with an addition of batch normalization layers after each convolutional layers, and a reduced number of fully-connected layers from three to one.6 (4) ResNets with depth $\{ 1 8 , 5 0 \}$ are used. (5) Wide ResNets with depth 16 and widening factor 8 is used. All networks are initialized via the method of Glorot & Bengio (2010), except for ResNets and WRN. We use the ReLU activation function except for the experiments in Section 3.1. We focus on image classification tasks. FCN is trained with MNIST dataset (Lecun et al., 1998), Conv-6, VGG- $\{ 1 1 , \bar { 1 } 6 , 1 9 \}$ and ResNet-18 are trained with CIFAR-10 dataset (Krizhevsky & Hinton, 2009), and VGG-19, ResNet-50, WRN-16-8 ware trained with Tiny-ImageNet dataset.
+
+Optimizers and hyperparameters. We use Adam optimizer (Kingma & Ba, 2015) with batch size 60. We use a learning rate of $1 . 2 \cdot 1 0 ^ { - 3 }$ for FCN and $3 \cdot 1 0 ^ { - 4 } $ for all other models. For FCN, we use [50k, 50k] for the initial training phase and retraining phase. For Conv-6, we use [30k, 20k] steps. For VGG-11 and ResNet-18, we use [35k, 25k] steps. For VGG-16, we use [50k, 35k]. For VGG-19, ResNet-50, and WRN-16-8 we use [60k, 40k]. We do not use any weight decay, learning rate scheduling, or regularization.
+
+Sparsity levels. To determine the layerwise pruning ratio, we largely follow the the guidelines of Han et al. (2015); Frankle & Carbin (2019): For integer values of $\tau$ , we keep $p ^ { \tau }$ fraction of weights in all convolutional layers and $q ^ { \tau }$ fraction in all fully-connected layers, except for the last layer where we use $( 1 + q ) / 2$ instead. For FCN, we use $( \dot { p , q } ) \ : = \ : ( 0 , 0 . 5 )$ . For Conv-6, VGGs ResNets, and WRN, we use (0.85, 0.8). For ResNet- $\{ 1 8 , 5 0 \}$ , we do not prune the first convolutional layer. The range of sparsity for reported figures in all tables is decided as follows: we start from $\tau$ where test error rate starts falling below that of an unpruned model and report the results at $\tau , \tau + 1 , \tau + 2 , \dots$ for FCN and Conv-6, $\tau , \tau + 2 , \tau + 4 , \dots$ for VGGs, ResNet-50, and WRN, and $\tau , \tau + 3 , \tau + 6 , \dots$ for ResNet-18.
+
+# B ADDITIONAL VGG EXPERIMENTS
+
+Table 8: Test error rates of VGG-11 on CIFAR-10. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $1 1 . 5 1 \%$ error rate.   
+
+<table><tr><td></td><td>16.74%</td><td>12.10%</td><td>8.74%</td><td>6.32%</td><td>4.56%</td><td>3.30%</td><td>2.38%</td><td>1.72%</td></tr><tr><td>MP (baseline)</td><td>11.41±0.24</td><td>12.38±0.14</td><td>13.54±0.35</td><td>16.08±1.13</td><td>19.76±1.67</td><td>28.12±3.45</td><td>45.38±11.69</td><td>55.97±15.99</td></tr><tr><td>LAP</td><td>11.19±0.15 (-1.96%)</td><td>11.79±0.44 (-4.78%)</td><td>12.95±0.14 (-4.39%)</td><td>13.95±0.17 (-13.25%)</td><td>15.59±0.35 (-21.13%)</td><td>20.96±6.02 (-25.47%)</td><td>22.00±1.09 (-51.52%)</td><td>28.96±3.30 (-48.25%)</td></tr><tr><td>LAP-forward</td><td>11.47±0.30 (+0.56%)</td><td>12.33±0.12 (-0.44%)</td><td>13.15±0.22 (-2.87%)</td><td>13.96±0.25 (-13.18%)</td><td>15.42±0.21 (-21.97%)</td><td>18.22±0.69 (-35.20%)</td><td>21.74±1.59 (-52.10%)</td><td>25.85±1.40 (-53.82%)</td></tr></table>
+
+Table 9: Test error rates of VGG-16 on CIFAR-10. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $9 . 3 3 \%$ error rate.   
+
+<table><tr><td></td><td>10.28%</td><td>7.43%</td><td>5.37%</td><td>3.88%</td><td>2.80%</td><td>2.03%</td><td>1.46%</td><td>1.06%</td></tr><tr><td>MP (baseline)</td><td>9.55±0.11</td><td>10.78±0.45</td><td>13.42±2.19</td><td>17.83±3.08</td><td>26.61±4.91</td><td>48.87±5.85</td><td>69.39±11.85</td><td>83.47±5.60</td></tr><tr><td>LAP</td><td>9.35±0.18 (-2.05%)</td><td>10.07±0.19 (-6.59%)</td><td>11.52±0.26 (-14.21%)</td><td>12.57±0.34 (-29.50%)</td><td>14.23±0.27 (-46.52%)</td><td>17.01±1.46 (-65.19%)</td><td>25.03±2.08 (-63.92%)</td><td>32.45±12.20 (-61.12%)</td></tr><tr><td>LAP-forward</td><td>9.45±0.17 (-1.03%)</td><td>10.40±0.20 (-3.49%)</td><td>11.33±0.15 (-15.60%)</td><td>13.09±0.21 (-26.56%)</td><td>14.61±0.25 (-45.08%)</td><td>17.10±0.19 (-65.02%)</td><td>22.39±0.74 (-67.74%)</td><td>24.99±0.49 (-70.06%)</td></tr></table>
+
+# C TOP-1 ERROR RATES FOR TINY-IMAGENET EXPERIMENTS
+
+Table 10: Top-1 test error rates of VGG-19 on Tiny-ImageNet. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $6 4 . 5 5 \%$ error rate.   
+
+<table><tr><td></td><td>12.16%</td><td>10.34%</td><td>8.80%</td><td>7.48%</td><td>6.36%</td><td>5.41%</td><td>4.61%</td><td>3.92%</td></tr><tr><td>MP (baseline)</td><td>63.35±1.44</td><td>64.43±1.05</td><td>65.44±1.31</td><td>67.09±1.04</td><td>69.40±1.40</td><td>72.36±2.09</td><td>75.35±1.75</td><td>79.98±3.28</td></tr><tr><td>LAP</td><td>63.15±1.52</td><td>63.91±1.38</td><td>65.56±1.42</td><td>66.56±0.93</td><td>68.40±1.08</td><td>70.45±0.67</td><td>72.16±1.62</td><td>75.05±0.29</td></tr><tr><td rowspan="3">LAP-forward</td><td>(-0.31%) 64.22±1.11</td><td>(-0.80%)</td><td>(+0.18%) 65.63±1.21</td><td>(-0.80%) 67.03±1.23</td><td>(-1.44%)</td><td>(-2.63%) 70.55±1.21</td><td>(-4.24%)</td><td>(-6.17%) 75.71±1.33</td></tr><tr><td>(+1.38%)</td><td>64.77±0.96 (+0.53%)</td><td>(+0.28%)</td><td>(-0.09%)</td><td>68.52±1.39 (-1.26%)</td><td>(-2.50%)</td><td>73.13±0.97</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td>(-2.95%)</td><td>(-5.34%)</td></tr></table>
+
+Table 11: Top-1 test error rates of ResNet-50 on Tiny-ImageNet. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $4 7 . 5 0 \%$ error rate.   
+
+<table><tr><td></td><td>6.52%</td><td>4.74%</td><td>3.45%</td><td>2.51%</td><td>1.83%</td><td>1.34%</td><td>0.98%</td><td>0.72%</td></tr><tr><td>MP (baseline)</td><td>48.18±0.39</td><td>49.85±0.30</td><td>52.28±0.24</td><td>55.46±0.57</td><td>60.51±0.39</td><td>66.60±0.42</td><td>70.75±0.33</td><td>80.02±8.94</td></tr><tr><td>LAP</td><td>48.27±0.13 (+0.20%)</td><td>49.96±0.26 (+0.22%)</td><td>51.92±0.21 (-0.69%)</td><td>54.91±0.45 (-0.99%)</td><td>60.31±0.18 (-0.34%)</td><td>65.46±0.27 (-1.71%)</td><td>69.13±0.91 (-2.29%)</td><td>71.81±0.84 (-10.26%)</td></tr><tr><td>LAP-forward</td><td>48.69±0.52 (+1.05%)</td><td>50.25±0.26 (+0.79%)</td><td>53.55±0.42 (+2.42%)</td><td>57.59±0.61 (+3.84%)</td><td>62.74±0.87 (+3.69%)</td><td>66.59±0.89 (-0.02%)</td><td>69.55±0.25 (-1.69%)</td><td>71.49±0.57 (-10.67%)</td></tr></table>
+
+Table 12: Top-1 test error rates of WRN-16-8 on Tiny-ImageNet. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP. Unpruned models have $5 1 . 8 5 \%$ error rate.   
+
+<table><tr><td></td><td>12.22%</td><td>8.85%</td><td>6.41%</td><td>4.65%</td><td>3.37%</td><td>2.45%</td><td>1.77%</td><td>1.29%</td></tr><tr><td>MP (baseline)</td><td>50.38±1.00</td><td>52.64±0.84</td><td>55.23±1.13</td><td>58.79±0.81</td><td>64.11±1.23</td><td>69.22±2.03</td><td>75.90±2.03</td><td>81.83±2.17</td></tr><tr><td>LAP</td><td>49.85±1.19 (-1.04%)</td><td>52.33±1.69 (-0.60%)</td><td>54.96±1.26</td><td>59.06±2.40</td><td>62.68±1.57</td><td>67.82±2.39 (-2.02%)</td><td>71.30±3.65</td><td>76.51±1.54 (-6.50%)</td></tr><tr><td>LAP-forward</td><td>51.86±1.14 (+2.95%)</td><td>54.77±2.37 (+4.05%)</td><td>(-0.49%) 57.65±1.75 (+4.38%)</td><td>(+0.46%) 61.84±1.39 (+5.18%)</td><td>(-2.23%) 65.30±2.16 (+1.85%)</td><td>69.03±2.46 (-0.27%)</td><td>(-6.06%) 71.75±1.66 (-5.46%)</td><td>77.00±1.23 (-5.91%)</td></tr></table>
+
+# D NP-HARDNESS OF EQ. (3)
+
+In this section, we show that the optimization in Eq. (3) is NP-hard by showing the reduction from the following binary quadratic programming which is NP-hard (Murty & Kabadi, 1987):
+
+$$
+\operatorname* { m i n } _ { x \in \{ 0 , 1 \} ^ { n } } x ^ { T } A x
+$$
+
+for some symmetric matrix $A \in \mathbb { R } ^ { n \times n }$ . Without loss of generality, we assume that the minimum eigenvalue of $A$ (denoted with $\lambda$ ) is negative; if not, Eq. (9) admits a trivial solution $x = ( 0 , \ldots , 0 )$ .
+
+Assuming $\lambda < 0$ , Eq. (9) can be reformulated as:
+
+$$
+\operatorname* { m i n } _ { x \in \{ 0 , 1 \} ^ { n } } x ^ { T } H x + \lambda \sum _ { i } x _ { i }
+$$
+
+where $H = A - \lambda I$ . Here, one can easily observe that the above optimization can be solved by solving the below optimization for $s = 1 , \ldots , n$
+
+$$
+\operatorname* { m i n } _ { x \in \{ 0 , 1 \} ^ { n } : \sum _ { i } x _ { i } = s } x ^ { T } H x
+$$
+
+Finally, we introduce the below equality
+
+$$
+\begin{array} { r l } & { { \boldsymbol x } ^ { \top } { \boldsymbol H } { \boldsymbol x } = { \boldsymbol x } ^ { \top } { \boldsymbol U } \Lambda { \boldsymbol U } ^ { \top } { \boldsymbol x } } \\ & { \qquad = \| \sqrt \Lambda { \boldsymbol U } ^ { \top } { \boldsymbol x } \| _ { F } ^ { 2 } } \\ & { \qquad = \| \sqrt \Lambda { \boldsymbol U } ^ { \top } { \boldsymbol x } \| _ { F } ^ { 2 } } \\ & { \qquad = \| \sqrt \Lambda { \boldsymbol U } ^ { \top } { \mathbf 1 } - \sqrt \Lambda { \boldsymbol U } ^ { \top } \big ( ( { \mathbf 1 } - { \boldsymbol x } ) \odot { \mathbf 1 } \big ) \| _ { F } ^ { 2 } } \end{array}
+$$
+
+where 1 denotes a vector of ones, $U$ is a matrix consisting of the eigenvectors of $H$ as its column vectors, and $\Lambda$ is a diagonal matrix with corresponding (positive) eigenvalues of $H$ as its diagonal elements. The above equality shows that Eq. (11) is a special case of Eq. (3) by choosing $W _ { 1 } =$ $\sqrt { \Lambda } U ^ { \top } , W _ { 2 } = { \bf 1 } , W _ { 3 } = 1$ and $M = { \bf 1 } - x$ . This completes the reduction from Eq. (9) to Eq. (3).
+
+# E DERIVATION OF EQ. (5)
+
+In this section, we provide a derivation of Eq. (5) for the fully-connected layers. The convolutional layers can be handled similarly by substituting the multiplications in Eqs. (16) and (17) by the convolutions.
+
+The Jacobian matrix of the linear operator correponding to a fully-connected layer is the weight matrix itself, i.e. $\mathcal { I } ( W _ { i } ) = W _ { i }$ . From this, lookahead distortion can be reformulated as
+
+$$
+\mathcal { L } _ { i } ( w ) = \Big | \Big | W _ { i + 1 } W _ { i } W _ { i - 1 } - W _ { i + 1 } W _ { i } \big | _ { w = 0 } W _ { i - 1 } \Big | \Big | _ { F } .
+$$
+
+Now, we decompose the matrix product $W _ { i + 1 } W _ { i } W _ { i - 1 }$ in terms of entries of $W _ { i }$ as below:
+
+$$
+W _ { i + 1 } W _ { i } W _ { i - 1 } = \sum _ { j , k } W _ { i } [ k , j ] W _ { i + 1 } [ : , k ] W _ { i - 1 } [ j , : ]
+$$
+
+where $W _ { i } [ k , j ] , W _ { i + 1 } [ : , k ]$ , and $W _ { i - 1 } [ j , : ]$ denote $( j , k )$ -th element of $W _ { i }$ , $k$ -th column of $W _ { i + 1 }$ , and $j$ -th row of $W _ { i - 1 }$ , respectively. The contribution of a single entry $w : = W _ { i } [ k , j ]$ to the product $W _ { i + 1 } W _ { i } W _ { i - 1 }$ is equivalent to $w \cdot W _ { i + 1 } [ : , k ] W _ { i - 1 } [ j , : ]$ . Therefore, in terms of the Frobenius distortion, we conclude that
+
+$$
+\mathcal { L } _ { i } ( w ) = \left. w \cdot W _ { i + 1 } [ : , k ] W _ { i - 1 } [ j , : ] \right. _ { F } = \left| w \right| \cdot \left. W _ { i - 1 } [ j , : ] \right. _ { F } \cdot \left. W _ { i + 1 } [ : , k ] \right. _ { F } ,
+$$
+
+which completes the derivation of Eq. (5) for fully-connected layers.
+
+# F LAP-ACT: IMPROVING LAP USING TRAINING DATA
+
+Recall two observations made from the example of two-layer fully connected network with ReLU activation appearing in Section 2.1: LAP is designed to reflect the lack of knowledge about the training data at the pruning phase; once the activation probability of each neuron can be estimated, it is possible to refine LAP to account for this information.
+
+In this section, we continue our discussion on the second observation. In particular, we study an extension of LAP called lookahead pruning with activation (LAP-act) which prunes the weight with smallest value of
+
+$$
+\widehat { \mathcal { L } } _ { i } ( w ) : = | \widehat { w } | \cdot \left\| \widehat { W } _ { i - 1 } [ j , : ] \right\| _ { F } \cdot \left\| \widehat { W } _ { i + 1 } [ : , k ] \right\| _ { F } .
+$$
+
+Here, $\widehat { W } _ { i }$ is a scaled version of $W _ { i }$ and $\widehat { w }$ is the corresponding scaled value of $w$ , defined by
+
+$$
+\widehat W _ { i } [ j , : ] : = \Big ( \sum _ { k \in I _ { i , j } } \sqrt { p _ { k } } \Big ) \cdot W _ { i } [ j , : ] ,
+$$
+
+where $I _ { i , j }$ denotes the set of ReLU indices in the $j$ -th output neuron/channel of $i$ -th layer. For example, $\mathbf { \check { \it I } } _ { i , j } = \{ j \}$ for fully connected layers and $I _ { i , j }$ is a set of ReLU indices in the $j$ -th channel for convolutional layers. Also, $p _ { k }$ denotes the $k$ -th ReLU’s probability of activation, which can be estimated by passing the training data.
+
+We derive LAP-act (Eq. (18)) in Appendix F.1 and perform preliminary empirical validations in Appendix F.2 with using optimal brain damage (OBD) as a baseline. We also evaluate a variant of LAP using Hessian scores of OBD instead of magnitude scores. It turns out that in the small networks (FCN, Conv-6), LAP-act outperforms OBD.
+
+# F.1 DERIVATION OF LAP-ACT
+
+Consider a case where one aims to prune a connection of a network with ReLU, i.e.,
+
+$$
+x \mapsto \mathcal { I } ( W _ { L } ) \sigma ( \mathcal { I } ( W _ { L - 1 } ) \cdot \cdot \cdot \sigma ( \mathcal { I } ( W _ { 1 } ) x ) \cdot \cdot \cdot ) ,
+$$
+
+where $\sigma ( x ) = \operatorname* { m a x } \{ 0 , x \}$ is applied entrywise. Under the over-parametrized scenario, zeroing out a single weight may alter the activation pattern of connected neurons with only negligible probability, which allows one to decouple the probability of activation of each neuron from the act of pruning each connection. From this observation, we first construct the below random distortion, following the philosophy of the linear lookahead distortion Eq. (4)
+
+$$
+\widetilde { \mathcal { L } } _ { i } ( w ) : = \| \widetilde { \mathcal { I } } ( W _ { i + 1 } ) ( \widetilde { \mathcal { I } } ( W _ { i } ) - \widetilde { \mathcal { I } } ( W _ { i } | _ { w = 0 } ) ) \widetilde { \mathcal { I } } ( W _ { i - 1 } ) \| _ { F }
+$$
+
+where $\widetilde { \mathcal { I } } ( W _ { i } )$ denotes a random matrix where $\begin{array} { r } { \widetilde { \mathcal { I } } ( W _ { i } ) [ k , : ] = g _ { i } [ k ] \cdot \mathcal { I } ( W _ { i } ) [ k , : ] } \end{array}$ and $g _ { i } [ k ]$ is a 0-1 random variable corresponding to the activation, i.e., $g _ { i } [ k ] = 1$ if and only if the $k$ -th output, i.e., ReLU, of the $i$ -th layer is activated. However, directly computing the expected distortion with respect to the real activation distribution might be computationally expensive. To resolve this issue, we approximate the root mean square lookahead distortion by applying the mean-field approximation to the activation probability of neurons, i.e., all activations are assumed to be independent, as
+
+$$
+\sqrt { \mathbb { E } _ { g \sim p ( g ) } [ \widetilde { \mathcal { L } } _ { i } ( w ) ^ { 2 } ] } \approx \sqrt { \mathbb { E } _ { g \sim \prod _ { i , k } p ( g _ { i } [ k ] ) } [ \widetilde { \mathcal { L } } _ { i } ( w ) ^ { 2 } ] } = : \widehat { \mathcal { L } } _ { i } ( w )
+$$
+
+where $g = [ g _ { i } ] _ { i } , p ( g )$ denotes the empirical activation distribution of all neurons and $\begin{array} { r } { \prod _ { i , k } p ( g _ { i } [ k ] ) } \end{array}$ denotes the mean-field approximation of $p ( g )$ . Indeed, the lookahead distortion with ReLU nonlinearity (Eq. (22)) or three-layer blocks consisting only of the fully-connected layers and the convolutional layers can be easily computed by using the rescaled weight matrix $\widehat { W } _ { i }$ :
+
+$$
+\widehat W _ { i } [ j , : ] : = \bigg ( \sum _ { k \in I _ { i , j } } \sqrt { p ( g _ { i } [ k ] = 1 ) } \bigg ) \cdot W _ { i } [ j , : ]
+$$
+
+where $I _ { i , j }$ denotes the set of ReLU indices in the $j$ -th output neuron/channel of $i$ -th layer. For example, $\boldsymbol { I } _ { i , j } = \{ j \}$ for fully connected layers and $I _ { i , j }$ is a set of ReLU indices in the $j$ -th channel
+
+for convolutional layers. Finally, for an edge $w$ connected to the $j$ -th input neuron/channel and the $k$ -th output neuron/channel of the $i$ -th layer, Eq. (22) reduces to
+
+$$
+\widehat { \mathcal { L } } _ { i } ( w ) = | \widehat { w } | \cdot \left\| \widehat { W } _ { i - 1 } [ j , : ] \right\| _ { F } \cdot \left\| \widehat { W } _ { i + 1 } [ : , k ] \right\| _ { F }
+$$
+
+where $\widehat { w }$ denotes the rescaled value of $w$ . This completes the derivation of Eq. (18).
+
+# F.2 EXPERIMENTS WITH LAP-ACT
+
+We compare the performance of three algorithms utilizing training data at the pruning phase: optimal brain damage (OBD) which approximates the loss via second order Taylor seris approximation with the Hessian diagonal (LeCun et al., 1989), LAP using OBD instead of weight magnitudes (OBD+LAP), and LAP-act as described in this section. We compare the performances of three algorithms under the same experimental setup as in Section 3.2. To compute the Hessian diagonal for OBD and OBD $^ +$ LAP, we use a recently introduced software package called “BackPACK,” (Dangel et al., 2020), which is the only open-source package supporting an efficient of Hessians, up to our knowledge. Note that the algorithms evaluated in this section are also evaluated for global pruning experiments in Appendix I.
+
+The experimental results for FCN and Conv-6 are presented in Tables 13 and 14. Comparing to algorithms relying solely on the model parameters for pruning (MP/LAP in Tables 1 and 2), we observe that OBD performs better in general, especially in the high sparsity regime. This observation is coherent to the findings of LeCun et al. (1989). Intriguingly, however, we observe that applying lookahead critertion to OBD (OBD $^ +$ LAP) significantly enhances to OBD significantly enhances the performance in the high sparsity regime. We hypothesize that LAP helps capturing a correlation among scores (magnitude or Hessian-based) of adjacent layers. Also, we observe that LAP-act consistently exhibits a better performance compared to OBD. This result is somewhat surprising, in the sense that LAP-act only utilizes (easier-to-estimate) information about activation probabilities of each neuron to correct lookahead distortion.
+
+The average running time of OBD, OBD $^ +$ LAP, and LAP-act is summarized in Table 15. We use Xeon E5-2630v4 2.20GHz for pruning edges, and additionally used a single NVidia GeForce GTX1080 for the computation of Hessian diagonals (used for OBD, OBD+LAP) and activation probabiility (for LAP-act). We observe that LAP-act runs in a significantly less running time than OBD/OBD+LAP, and the gap widens as the number of parameters and the dimensionality of the dataset increases (from MNIST to CIFAR-10).
+
+Table 13: Test error rates of FCN on MNIST. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to OBD. Unpruned models achieve $1 . 9 8 \%$ error rate.   
+
+<table><tr><td></td><td>6.36%</td><td>3.21%</td><td>1.63%</td><td>0.84%</td><td>0.43%</td><td>0.23%</td><td>0.12%</td></tr><tr><td>OBD (baseline)</td><td>1.87±0.05</td><td>2.07±0.13</td><td>2.51±0.10</td><td>3.07±0.12</td><td>4.08±0.14</td><td>5.66±0.39</td><td>11.01±1.71</td></tr><tr><td>OBD+LAP</td><td>1.81±0.05</td><td>2.18±0.13</td><td>2.52±0.14</td><td>3.48±0.14</td><td>4.16±0.35</td><td>5.88±0.51</td><td>8.65±0.56</td></tr><tr><td></td><td>(-3.42%)</td><td>(+5.31%)</td><td>(+0.48%)</td><td>(+13.35%)</td><td>(+1.91%)</td><td>(+3.81%)</td><td>(-21.41%)</td></tr><tr><td>LAP-act</td><td>1.78±0.07</td><td>1.85±0.09</td><td>2.21±0.13</td><td>2.73±0.04</td><td>3.50±0.35</td><td>4.74±0.21</td><td>7.99±0.19</td></tr><tr><td></td><td>(-4.60%)</td><td>(-10.63%)</td><td>(-12.11%)</td><td>(-11.13%)</td><td>(-14.31%)</td><td>(-16.21%)</td><td>(-27.48%)</td></tr></table>
+
+Table 14: Test error rates of Conv-6 on CIFAR-10. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to OBD. Unpruned models achieve $1 1 . 9 7 \%$ error rate.   
+
+<table><tr><td></td><td>10.62%</td><td>8.86%</td><td>7.39%</td><td>6.18%</td><td>5.17%</td><td>4.32%</td><td>3.62%</td></tr><tr><td>OBD (baseline)</td><td>12.10±0.21</td><td>12.81±0.61</td><td>13.18±0.26</td><td>14.28±0.55</td><td>15.54±0.40</td><td>16.83±0.27</td><td>19.14±0.32</td></tr><tr><td>OBD+LAP</td><td>12.51±0.21 (+3.41%)</td><td>13.22±0.48 (+3.20%)</td><td>13.68±0.57 (+2.23%)</td><td>14.31±0.36 (+0.18%)</td><td>15.09±0.36 (-2.90%)</td><td>16.31±0.51 (-3.13%)</td><td>17.29±0.47 (-9.65%)</td></tr><tr><td>LAP-act</td><td>12.11±0.12 (+0.12%)</td><td>12.72±0.11 (-0.69%)</td><td>12.92±0.48 (-3.47%)</td><td>13.45±0.25 (-5.87%)</td><td>14.86±0.13 (-4.40%)</td><td>16.47±0.36 (-2.13%)</td><td>18.48±0.33 (-3.46%)</td></tr></table>
+
+Table 15: Computation time of OBD, OBD+LAP and LAP-act (averaged over 100 trials).   
+
+<table><tr><td></td><td>FCN</td><td>Conv-6</td></tr><tr><td>OBD (baseline)</td><td>11.38 (s)</td><td>167.87 (s)</td></tr><tr><td>OBD+LAP</td><td>11.61 (s)</td><td>168.03 (s)</td></tr><tr><td>LAP-act</td><td>6.28 (s)</td><td>8.95 (s)</td></tr><tr><td># weight parameters</td><td>1.15M</td><td>2.26M</td></tr></table>
+
+# G COMPUTATIONAL COST OF LOOKING AHEAD
+
+In this section, we briefly describe how a computation of lookahead distortion Eq. (5) can be done efficiently, and provide experimental comparisons of average computation times for MP and LAP. It turns out that most of the computational load for LAP comes from the sorting procedure, and tensor operations introduce only a minimal overhead.
+
+MP comprises of three steps: (1) computing the absolute value of the tensor, (2) sorting the absolute values, and (3) selecting the cut-off threshold and zero-ing out the weights under the threshold. Steps (2) and (3) remain the same in LAP, and typically takes ${ \mathcal { O } } ( n \log n )$ steps $\dot { n }$ denotes the number of parameters in a layer). On the other hand, Step (1) is replaced by computing the lookahead distortion
+
+$$
+\mathcal { L } _ { i } ( w ) = | w | \cdot \left\| W _ { i - 1 } [ j , : ] \right\| _ { F } \left\| W _ { i + 1 } [ : , k ] \right\| _ { F }
+$$
+
+for each parameter $w$ . Fortunately, this need not be computed separately for each parameter. Indeed, one can perform tensor operations to compute the squared lookahead distortion, which has the same ordering with lookahead distortion. For fully-connected layers with 2-dimensional Jacobians, the squared lookahead distortion for $W _ { i + 1 } \in \mathbb { R } ^ { d _ { i + 1 } \times d _ { i } } , W _ { i } \in \bar { \mathbb { R } } ^ { d _ { i } \times d _ { i - 1 } } , W _ { i - 1 } \in \mathbb { R } ^ { d _ { i - 1 } \times d _ { i - 2 } }$ is
+
+$$
+\begin{array} { r } { \mathcal { L } ^ { 2 } ( W _ { i } ) = ( \mathbf { 1 } _ { i + 1 } W _ { i + 1 } ^ { \odot 2 } ) ^ { \top } \odot ( W _ { i } ^ { \odot 2 } ) \odot ( W _ { i - 1 } ^ { \odot 2 } \mathbf { 1 } _ { i } ) ^ { \top } , } \end{array}
+$$
+
+where $\mathbf { 1 } _ { i }$ denotes all-one matrix of size $d _ { i - 2 } \times d _ { i }$ ; multiplying ${ \bf 1 } _ { i }$ denotes summing operation along an axis and duplicating summed results into the axis, and $_ { \odot 2 }$ denotes the element-wise square operation. The case of convolutional layers can be handled similarly.
+
+We note that an implementation of Eq. (25) is very simple. Indeed, the following PyTorch code segment calculates a lookahead score matrix:
+
+<table><tr><td>def lookahead_score(W,W_prev,W_next):</td></tr><tr><td>W_prev_sq = (W_prev ** 2).sum(dim=1)</td></tr><tr><td>W_prev_mat = W_prev_sq.view(l,-1).repeat(W.size(0),1)</td></tr><tr><td></td></tr><tr><td>W_next_sq = (W_next ** 2).sum(dim=0)</td></tr><tr><td>W_next_mat = W_next_sq.view(-1,1).repeat(1,W.size(1))</td></tr><tr><td></td></tr><tr><td>return (W**2)*W_prev_mat*W_next_mat</td></tr></table>
+
+Combined with modern tensor computation frameworks, computing Eq. (25) does not introduce heavy overhead. To show this, we compare the computation time of MP and LAP for six neural networks in Table 16, where we fixed the layerwise pruning rate to be uniformly $90 \%$ . The codes are implemented with PyTorch, and the computations have taken place on 40 CPUs of Intel Xeon E5-2630v4 $@$ $) 2 . 2 0 \mathrm { G H z }$ . All figures are averaged over 100 trials.
+
+We make two observations from Table 16. First, the time required for LAP did not exceed $1 5 0 \%$ of the time required for MP, confirming our claim on the computational benefits of LAP. Second, most of the added computation comes from considering the factors from batch normalization, without which the added computation load is ${ \approx } 5 \%$ .
+
+Table 16: Computation time of MP and LAP on FCN, Conv-6, VGG-{11,16,19}, ResNet-18. All figures are averaged over 100 independent trials. Bracketed numbers denote relative increments. Number of weight parameters denote the number of parameters that are the target of pruning.   
+
+<table><tr><td></td><td>FCN</td><td>Conv-6</td><td>VGG-11</td><td>VGG-16</td><td>VGG-19</td><td>ResNet-18</td></tr><tr><td>MP (baseline)</td><td>46.23 (ms)</td><td>108.92 (ms)</td><td>542.95 (ms)</td><td>865.91 (ms)</td><td>1188.29 (ms)</td><td>641.59 (ms)</td></tr><tr><td>LAP (w/o batchnorm)</td><td>47.73 (ms)</td><td>116.74 (ms)</td><td>560.60 (ms)</td><td>912.47 (ms)</td><td>1241.55 (ms)</td><td>671.61 (ms)</td></tr><tr><td rowspan="2">LAP</td><td>(+3.14%)</td><td>(+7.18%) 1</td><td>(+3.25%) 805.98 (ms)</td><td>(+5.28%) 1213.24 (ms)</td><td>(+4.48%) 1653.02 (ms)</td><td>(+4.68%) 943.86 (ms)</td></tr><tr><td>- -</td><td>1</td><td>(+48.44%)</td><td>(+40.11%)</td><td>(+39.19%)</td><td>(+47.11%)</td></tr><tr><td># weight parameters</td><td>1.15M</td><td>2.26M</td><td>9.23M</td><td>14.72M</td><td>20.03M</td><td>10.99M</td></tr></table>
+
+# H LOOKAHEAD FOR CHANNEL PRUNING
+
+In the main text, LAP is compared to MP in the context of unstructured pruning, where we do not impose any structural constraints on the set of connections to be pruned together. On the other hand, the magnitude-based pruning methods are also being used popularly as a baseline for channel pruning (Ye et al., 2018), which falls under the category of structured pruning.
+
+MP in channel pruning is typically done by removing channels with smallest aggregated weight magnitudes; this aggregation can be done by either taking $\ell _ { 1 }$ -norm or $\ell _ { 2 }$ -norm of magnitudes. Similarly, we can consider channel pruning scheme based on an $\ell _ { 1 }$ or $\ell _ { 2 }$ aggregation of LAP distortions, which we will call LAP- $\ell _ { 1 }$ and LAP- $\ell _ { 2 }$ (as opposed to MP- $\cdot \ell _ { 1 }$ and MP- $\ell _ { 2 }$ ).
+
+We compare the performances of LAP-based channel pruning methods to MP-based channel pruning methods, along with another baseline of random channel pruning (denoted with RP). We test with Conv-6 (Table 17) and VGG-19 (Table 18) networks on CIFAR-10 dataset. All reported figures are averaged over five trials, experimental settings are identical to the unstructure pruning experiments unless noted otherwise.
+
+Similar to the case of unstructured pruning, we observe that LAP-based methods consistently outperform MP-based methods. Comparing $\ell _ { 1 }$ with $\ell _ { 2 }$ aggregation, we note that LAP- $\ell _ { 2 }$ performs better than LAP- $\cdot \ell _ { 1 }$ in both experiments, by a small margin. Among MP-based methods, we do not observe any similar dominance.
+
+Table 17: Test error rates of Conv-6 on CIFAR-10 for channel pruning. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to the best of MP- $\ell _ { 1 }$ and MP$\ell _ { 2 }$ . Unpruned models achieve $1 1 . 9 7 \%$ error rate.   
+
+<table><tr><td></td><td>34.40%</td><td>24.01%</td><td>16.81%</td><td>11.77%</td><td>8.24%</td><td>5.76%</td><td>4.04%</td><td>2.82%</td></tr><tr><td>MP-l1</td><td>12.11±0.38</td><td>12.55±0.44</td><td>13.62±0.44</td><td>16.85±1.14</td><td>20.05±0.61</td><td>23.98±0.92</td><td>27.75±0.89</td><td>37.56±2.16</td></tr><tr><td>MP-l2 RP</td><td>11.97±0.39 12.94±0.41</td><td>12.66±0.24 14.82±0.27</td><td>14.17±0.53 17.57±0.65</td><td>16.69±1.08</td><td>20.09±0.96 22.50±0.69</td><td>24.61±1.94 25.86±0.72</td><td>28.30±1.47 30.64±0.87</td><td>35.18±1.80</td></tr><tr><td></td><td></td><td></td><td></td><td>20.19±0.54</td><td></td><td></td><td></td><td>38.26±2.78</td></tr><tr><td>LAP-l1</td><td>12.08±0.28 (+0.87%)</td><td>12.57±0.26 (+0.16%)</td><td>13.37±0.29 (-1.85%)</td><td>15.46±0.71 (-7.42%)</td><td>18.30±0.53 (-8.76%)</td><td>21.40±0.66 (-10.75%)</td><td>24.88±1.10 (-10.37%)</td><td>30.43±1.07 (-13.50%)</td></tr><tr><td>LAP-l2</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>11.70±0.37</td><td>12.31±0.23</td><td>13.70±0.51</td><td>15.42±0.62</td><td>17.94±0.91</td><td>21.38±1.24</td><td>24.36±1.55</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>30.55±3.04</td></tr><tr><td></td><td>(-2.21%)</td><td>(-1.90%)</td><td>(+0.62%)</td><td>(-7.62%)</td><td>(-10.55%)</td><td>(-10.84%)</td><td>(-12.23%)</td><td>(-13.16%)</td></tr></table>
+
+Table 18: Test error rates of VGG-19 on CIFAR-10 for channel pruning. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to the best of MP- $\ell _ { 1 }$ and MP$\ell _ { 2 }$ . Unpruned models achieve $9 . 0 2 \%$ error rate.   
+
+<table><tr><td></td><td>34.30%</td><td>28.70%</td><td>24.01%</td><td>20.09%</td><td>16.81%</td><td>14.06%</td><td>11.76%</td><td>9.84%</td></tr><tr><td>MP-l1 MP-l2</td><td>9.25±0.23 9.40±0.23</td><td>9.81±0.36 9.73±0.52</td><td>10.12±0.15 10.27±0.18</td><td>10.77±0.73 10.61±0.74</td><td>14.28±1.57 12.26±1.79</td><td>14.53±1.48 13.74±1.96</td><td>18.84±3.53 17.70±3.46</td><td>23.71±4.94 33.27±15.72</td></tr><tr><td>RP LAP-l1</td><td>10.58±0.61 9.05±0.23</td><td>11.72±1.26 9.46±0.25</td><td>12.86±0.89 10.07±0.46</td><td>19.49±12.70 10.53±0.27</td><td>20.19±2.45 10.95±0.19</td><td>24.99±6.33 12.37±0.74</td><td>46.18±18.08 15.50±0.81</td><td>54.52±16.61 16.65±3.28</td></tr><tr><td>LAP-l2</td><td>(-2.23%) 9.06±0.20 (-2.10%)</td><td>(-2.75%) 9.42±0.36 (-3.21%)</td><td>(-0.47%) 9.74±0.37 (-3.77%)</td><td>(-0.81%) 10.53±0.40 (-0.79%)</td><td>(-10.73%) 10.74±0.22 (-12.39%)</td><td>(-9.99%) 11.87±0.33 (-13.61%)</td><td>(-12.43%) 13.51±0.27 (-23.66%)</td><td>(-29.77%) 15.67±2.78 (-33.92%)</td></tr></table>
+
+# I LOOKAHEAD FOR GLOBAL PRUNING
+
+In this section, we present global pruning results for MP, LAP, OBD, OBD+LAP and LAP-act in Table 19 and Table 20. In this methods, we prune a fraction of weights with smallest scores (e.g. weight magnitude, lookahead distortion, Hessian-based scores) among all weights in the whole network. The suffix “-normalize” in the tables denotes that the score is normalized by the Frobenius norm of the corresponding layer’s score. For MP, LAP, OBD+LAP and LAP-act, we only report the results for global pruning with normalization, as the normalized versions outperform the unnormalized ones. In the case of OBD, whose score is already globally designed, we report the results for both unnormalized and normalized versions.
+
+As demonstrated in Section 3.2 for fixed layerwise pruning rates, we observe that LAP and its variants perform better than their global pruning baselines, i.e. MP-normalize and OBD. We also note that LAP-normalize performs better than MP with pre-specified layerwise pruning rates (appeared in Section 3.2), with a larger gap for higher levels of sparsity.
+
+Table 19: Test error rates of FCN on MNIST for global pruning. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP-normalize (for data-agnostic algorithms) and OBD-normalize (for data-dependent algorithms), respectively. Unpruned models achieve $1 . 9 8 \%$ error rate.   
+
+<table><tr><td></td><td>6.36%</td><td>3.21%</td><td>1.63%</td><td>0.84%</td><td>0.43%</td><td>0.23%</td><td>0.12%</td></tr><tr><td rowspan="3">MP-normalize (baseline) LAP-normalize</td><td>1.82±0.08</td><td>2.16±0.06</td><td>2.72±0.17</td><td>3.54±0.09</td><td>6.54±0.35</td><td>59.59±16.23</td><td>88.65±0.00</td></tr><tr><td>1.71±0.09</td><td>2.07±0.10</td><td>2.69±0.09</td><td>3.42±0.22</td><td>4.15±0.07</td><td>6.68±0.55</td><td>19.18±3.81</td></tr><tr><td>(-6.16%)</td><td>(-4.26%)</td><td>(-1.03%)</td><td>(-3.33%)</td><td>(-36.57%)</td><td>(-88.79%)</td><td>(-78.36%)</td></tr><tr><td>OBD (baseline)</td><td>1.71±0.13</td><td>1.93±0.13</td><td>2.12±0.12</td><td>2.82±0.17</td><td>3.59±0.31</td><td>5.12±0.22</td><td>10.52±1.14</td></tr><tr><td rowspan="2">OBD-normalize</td><td>1.71±0.09</td><td>1.92±0.10</td><td>2.22±0.08</td><td>2.77±0.25</td><td>3.55±0.19</td><td>4.99±0.26</td><td>11.08±2.73</td></tr><tr><td>(-0.12%)</td><td>(-0.52%)</td><td>(+4.62%)</td><td>(-1.84%)</td><td>(-1.11%)</td><td>(-2.54%)</td><td>(+5.36%)</td></tr><tr><td rowspan="2">OBD+LAP-normalize</td><td>1.84±0.13</td><td>2.00±0.13</td><td>2.22±0.16</td><td>2.93±0.34</td><td>3.55±0.27</td><td>5.04±0.76</td><td>8.33±2.51</td></tr><tr><td>(+7.48%)</td><td>(+3.73%)</td><td>(+4.91%)</td><td>(+3.97%)</td><td>(-1.22%)</td><td>(-1.52%)</td><td>(-20.79%)</td></tr><tr><td rowspan="2">LAP-act-normalize</td><td>1.68±0.13</td><td>1.80±0.09</td><td>2.06±0.10</td><td>2.80±0.19</td><td>3.50±0.12</td><td>4.82±0.27</td><td>8.50±1.16</td></tr><tr><td>(-1.87%)</td><td>(-6.84%)</td><td>(-3.02%)</td><td>(-0.78%)</td><td>(-2.56%)</td><td>(-5.90%)</td><td>(-19.21%)</td></tr></table>
+
+Table 20: Test error rates of Conv-6 on CIFAR-10 for global pruning. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to MP-normalize (for dataagnostic algorithms) and OBD-normalize (for data-dependent algorithms), respectively. Unpruned models achieve $1 1 . 9 7 \%$ error rate.   
+
+<table><tr><td></td><td>10.62%</td><td>8.86%</td><td>7.39%</td><td>6.18%</td><td>5.17%</td><td>4.32%</td><td>3.62%</td></tr><tr><td rowspan="3">MP-normalize (baseline) LAP-normalize</td><td>12.42±0.17</td><td>13.14±0.35</td><td>14.17±0.40</td><td>15.39±0.40</td><td>17.57±0.46</td><td>21.04±0.42</td><td>24.40±1.57</td></tr><tr><td>11.81±0.32</td><td>12.23±0.25</td><td>12.44±0.22</td><td>13.02±0.12</td><td>13.73±0.16</td><td>14.81±0.34</td><td>15.97±0.30</td></tr><tr><td>(-4.91%)</td><td>(-6.87%)</td><td>(-12.19%)</td><td>(-15.42%)</td><td>(-21.86%)</td><td>(-29.61%)</td><td>(-34.54%)</td></tr><tr><td>OBD (baseline)</td><td>12.03±0.64</td><td>12.30±0.53</td><td>12.64±0.15</td><td>13.16±0.23</td><td>13.75±0.45</td><td>14.70±0.53</td><td>16.11±0.50</td></tr><tr><td rowspan="2">OBD-normalize</td><td>11.69±0.34</td><td>11.93±0.21</td><td>12.58±0.08</td><td>12.87±0.22</td><td>13.62±0.28</td><td>14.60±0.24</td><td>15.82±0.44</td></tr><tr><td>(-2.86%)</td><td>(-2.99%)</td><td>(-0.47%)</td><td>(-2.26%)</td><td>(-0.89%)</td><td>(-0.67%)</td><td>(-1.75%)</td></tr><tr><td rowspan="2">OBD+LAP-normalize</td><td>12.11±0.32</td><td>12.66±0.46</td><td>13.36±0.47</td><td>13.60±0.33</td><td>14.05±0.34</td><td>14.98±0.33</td><td>15.82±0.39</td></tr><tr><td>(+0.68%)</td><td>(+2.96%)</td><td>(+5.66%)</td><td>(+3.30%)</td><td>(+2.24%)</td><td>(+1.89%)</td><td>(-1.80%)</td></tr><tr><td rowspan="2">LAP-act-normalize</td><td>11.92±0.23</td><td>12.24±0.05</td><td>12.51±0.45</td><td>12.89±0.36</td><td>13.53±0.41</td><td>14.21±0.40</td><td>15.42±0.16</td></tr><tr><td>(-0.90%)</td><td>(-0.49%)</td><td>(-1.08%)</td><td>(-2.05%)</td><td>(-1.54%)</td><td>(-3.31%)</td><td>(-4.26%)</td></tr></table>
+
+# J LAP-ALL: LOOKING AHEAD THE WHOLE NETWORK
+
+We also report some experimental results on a variant of lookahead pruning, coined LAP-all, which treats (a linearized version of) the whole network as an operator block. More specifically, one attempts to minimize the Frobenius distortion of the operator block
+
+$$
+\operatorname* { m i n } _ { M _ { i } : \| M _ { i } \| _ { 0 } = s _ { i } } \| \mathcal { I } _ { d : i + 1 } \mathcal { I } ( W _ { i } ) \mathcal { I } _ { i - 1 : 1 } - \mathcal { I } _ { d : i + 1 } \mathcal { I } ( M _ { i } \odot W _ { i } ) \mathcal { I } _ { i - 1 : 1 } \| _ { F } ,
+$$
+
+where $\mathcal { I } _ { i + j : i } : = \mathcal { I } ( W _ { i + j } ) \mathcal { I } ( W _ { i + j - 1 } ) \cdot \cdot \cdot \mathcal { I } ( W _ { i } ) .$
+
+We test LAP-all on FCN under the same setup as in Section 3.2, and report the results in Table 21.   
+All figures are averaged over five trials.
+
+We observe that LAP-all achieves a similar level of performance to LAP, while LAP-all underperforms under a high-sparsity regime. We suspect that such shortfall originates from the accumulation of error terms incurred by ignoring the effect of activation functions, by which the benefits of looking further fades. An in-depth theoretical analysis for the determination of an optimal “sight range” of LAP would be an interesting future direction.
+
+Table 21: Test error rates of FCN on MNIST, with LAP-all variant. Subscripts denote standard deviations. Unpruned models achieve $1 . 9 8 \%$ error rate.   
+
+<table><tr><td></td><td>6.36%</td><td>3.21%</td><td>1.63%</td><td>0.84%</td><td>0.43%</td><td>0.23%</td><td>0.12%</td></tr><tr><td>MP (baseline)</td><td>1.75± 0.11</td><td>2.11± 0.14</td><td>2.53±0.09</td><td>3.32± 0.27</td><td>4.77± 0.22</td><td>19.85± 8.67</td><td>67.62± 9.91</td></tr><tr><td>RP</td><td>2.36± 0.13</td><td>2.72± 0.16</td><td>3.64± 0.17</td><td>17.54± 7.07</td><td>82.48± 4.03</td><td>88.65±0.00</td><td>88.65±0.00</td></tr><tr><td>LAP</td><td>1.67± 0.11</td><td>1.89± 0.12</td><td>2.48± 0.13</td><td>3.29±0.06</td><td>3.93± 0.26</td><td>6.72± 0.44</td><td>16.45± 5.61</td></tr><tr><td>LAP-all</td><td>1.64± 0.05</td><td>2.06± 0.17</td><td>2.53± 0.15</td><td>3.23± 0.13</td><td>4.01± 0.10</td><td>6.78± 0.44</td><td>25.64± 5.42</td></tr></table>
+
+# K COMPARISON WITH SMALLER NETWORKS
+
+As a sanity check, we compare the performance of large neural networks pruned via MP and LAP to the performance of a small network. In particular, we prune VGG-16, VGG-19, and ResNet18 trained on CIFAR-10 dataset, to have a similar number of parameters to MobileNetV2 (Sandler et al., 2018). For training and pruning VGGs and ResNet, we follows the prior setup in Appendix A while we use the same setup for training MobileNetV2 (Adam optimizer with learning rate of $3 \cdot 1 0 ^ { - 4 }$ with batch size 60, and trained $6 0 \mathrm { k }$ steps). We observe that models pruned via LAP (and MP) exhibit better performance compared to MobileNetV2, even when pruned to have a smaller number of parameters.
+
+Table 22: Test error rates of various networks on CIFAR-10. Subscripts denote standard deviations, and bracketed numbers denote relative gains with respect to the unpruned MobileNetV2.   
+
+<table><tr><td></td><td>VGG-16</td><td>VGG-19</td><td>ResNet-18</td><td>MobileNetV2</td></tr><tr><td>Unpruned</td><td>9.33±0.15</td><td>9.02±0.36</td><td>8.68±0.21</td><td>9.81±0.30</td></tr><tr><td>MP</td><td>8.92±0.18</td><td>9.46±0.25</td><td>7.70±0.23</td><td>1</td></tr><tr><td></td><td>(-9.07%)</td><td>(-3.57%)</td><td>(-21.51%)</td><td></td></tr><tr><td>LAP</td><td>8.77±0.20</td><td>9.30±0.25</td><td>7.73±0.29</td><td></td></tr><tr><td></td><td>(-10.60%)</td><td>(-5.20%)</td><td>(-21.20%)</td><td></td></tr><tr><td># weight parameters</td><td>2.09M/14.72M</td><td>2.06M/20.03M</td><td>2.17M/10.99M</td><td>2.20M</td></tr><tr><td></td><td>(14.23%)</td><td>(10.28%)</td><td>(19.17%)</td><td></td></tr></table>
+
+# L WHERE IS THE PERFORMANCE GAIN OF LAP COMING FROM?
+
+In this section, we briefly discuss where the benefits of the sub-network discovered by LAP comes from; does LAP subnetwork have a better generalizability or expressibility? For this purpose, we look into the generalization gap, i.e., the gap between the training and test accuracies, of the hypothesis learned via LAP procedure. Below we present a plot of test accuracies (Fig. 4a) and a plot of generalization gap (Fig. 4b) for FCN trained with MNIST dataset. The plot hints us that the network structure learned by LAP may not necessarily have a smaller generalizability. Remarkably, the generalization gap of the MP-pruned models and the LAP-pruned models are very similar to each other; the benefits of LAP subnetwork compared to MP would be that it can express a better-performing architecture with a network of similar sparsity and generalizability.
+
+![](images/e40da896e4b29971f888b394448af4d5544a2846daeb54978e42fd4a7d3a9631.jpg)  
+Figure 4: Test accuracy and generalization gap of FCN trained on MNIST.
+
+# M CONNECTIONS TO IMPLICIT BIAS OF SGD
+
+Another theoretical justification of using the lookahead distortion (Eq. (5)) for neural networks with nonlinear activation functions comes from recent discoveries regarding the implicit bias imposed by training procedures using stochastic gradient descent. More specifically, Du et al. (2018) proves the following result, generalizing the findings of Arora et al. (2018): For any two neighboring layers of fully-connected neural network using positive homogeneous activation functions, the quantity
+
+$$
+\| W _ { i + 1 } [ : , j ] \| _ { 2 } ^ { 2 } - \| W _ { i } [ j , : ] \| _ { 2 } ^ { 2 }
+$$
+
+remains constant for any hidden neuron $j$ over training via gradient flow. In other words, the total outward flow of weights is tied to the inward flow of weights for each neuron. This observation hints at the possibility of a relative undergrowth of weight magnitude of an ‘important’ connection, in the case where the connection shares the same input/output neuron with other ‘important’ connections. From this viewpoint, the multiplicative factors in Eq. (5) take into account the abstract notion of neuronal importance score, assigning significance to connections to the neuron through which more gradient signals have flowed through. Without considering such factors, LAP reduces to the ordinary magnitude-based pruning.