Add files using upload-large-folder tool

parse/train/B8fp0LVMHa/B8fp0LVMHa.md

@@ -0,0 +1,586 @@
+# EMAQ: EXPECTED-MAX Q-LEARNING OPERATORFOR SIMPLE YET EFFECTIVE OFFLINE AND ONLINERL
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Off-policy reinforcement learning (RL) holds the promise of sample-efficient learning of decision-making policies by leveraging past experience. However, in the offline RL setting – where a fixed collection of interactions are provided and no further interactions are allowed – it has been shown that standard off-policy RL methods can significantly underperform. Recently proposed methods often aim to address this shortcoming by constraining learned policies to remain close to the given dataset of interactions. In this work, we closely investigate an important simplification of BCQ (Fujimoto et al., 2018a) – a prior approach for offline RL – which removes a heuristic design choice and naturally restrict extracted policies to remain exactly within the support of a given behavior policy. Importantly, in contrast to their original theoretical considerations, we derive this simplified algorithm through the introduction of a novel backup operator, Expected-Max Q-Learning (EMaQ), which is more closely related to the resulting practical algorithm. Specifically, in addition to the distribution support, EMaQ explicitly considers the number of samples and the proposal distribution, allowing us to derive new sub-optimality bounds which can serve as a novel measure of complexity for offline RL problems. In the offline RL setting – the main focus of this work – EMaQ matches and outperforms prior state-of-the-art in the D4RL benchmarks (Fu et al., 2020a). In the online RL setting, we demonstrate that EMaQ is competitive with Soft Actor Critic (SAC). The key contributions of our empirical findings are demonstrating the importance of careful generative model design for estimating behavior policies, and an intuitive notion of complexity for offline RL problems. With its simple interpretation and fewer moving parts, such as no explicit function approximator representing the policy, EMaQ serves as a strong yet easy to implement baseline for future work.
+
+# 1 INTRODUCTION
+
+Leveraging past interactions in order to improve a decision-making process is the hallmark goal of off-policy reinforcement learning (RL) (Precup et al., 2001; Degris et al., 2012). Effectively learning from past experiences can significantly reduce the amount of online interaction required to learn a good policy, and is a particularly crucial ingredient in settings where interactions are costly or safety is of great importance, such as robotics Gu et al. (2017); Kalashnikov et al. (2018a), health Murphy et al. (2001), dialog agents (Jaques et al., 2019), and education Mandel et al. (2014). In recent years, with neural networks taking a more central role in the RL literature, there have been significant advances in developing off-policy RL algorithms for the function approximator setting, where policies and value functions are represented by neural networks (Mnih et al., 2015; Lillicrap et al., 2015; Gu et al., 2016b;a; Haarnoja et al., 2018; Fujimoto et al., 2018b). Such algorithms, while off-policy in nature, are typically trained in an online setting where algorithm updates are interleaved with additional online interactions. However, in purely offline RL settings, where a dataset of interactions are provided ahead of time and no additional interactions are allowed, the performance of these algorithms degrades drastically (Fujimoto et al., 2018a; Jaques et al., 2019).
+
+A number of recent methods have been developed to address this shortcoming of off-policy RL algorithms. A particular class of algorithms for offline RL that have enjoyed recent success are those based on dynamic programming and value estimation (Fujimoto et al., 2018a; Jaques et al., 2019; Kumar et al., 2019; Wu et al., 2019; Levine et al., 2020). Most proposed algorithms are designed with a key intuition that it is desirable to prevent policies from deviating too much from the provided collection of interactions. By moving far from the actions taken in the offline data, any subsequently learned policies or value functions may not generalize well and lead to the belief that certain actions will lead to better outcomes than they actually would. Furthermore, due to the dynamics of the MDP, taking out-of-distribution actions may lead to states not covered in the offline data, creating a snowball effect (Ross et al., 2011). In order to prevent learned policies from straying from the offline data, various methods have been introduced for regularizing the policy towards a base behavior policy (e.g. through a divergence penalty (Jaques et al., 2019; Wu et al., 2019; Kumar et al., 2019) or clipping actions (Fujimoto et al., 2018a)).
+
+Taking the above intuitions into consideration, in this work we investigate a simplifcation of the BCQ algorithm (Fujimoto et al., 2018a) (a notable prior work in offline RL), which removes a heuristic design choice and has the property that extracted policies remain exactly within the support of a given behavior policy. In contrast to the theoretical considerations in the original work, we derive this simplified algorithm in a theoretical setup that more closely reflects the resulting algorithm. We introduce the Expected-Max Q-Learning (EMaQ) operator, which interpolates between the standard Q-function evaluation and Q-learning backup operators. The EMaQ operator makes explicit the relation between the proposal distribution and number of samples used, and leads to sub-optimality bounds which introduce a novel notion of complexity for offline RL problems. In its practical implementation for the continuous control and function approximator setting, EMaQ has only two standard components (an estimate of the base behavior policy, and Q functions) and does not explicitly represent a policy, requiring fitting one less function approximator than prior approaches (Fujimoto et al., 2018a; Kumar et al., 2019; Wu et al., 2019).
+
+In online RL, EMaQ is competitive with Soft Actor Critic (SAC) (Haarnoja et al., 2018) and surpasses SAC in the deployment-efficient setting (Matsushima et al., 2020). In the offline RL setting – the main focus of this work – EMaQ matches and outperforms prior state-of-the-art in the D4RL (Fu et al., 2020a) benchmark tasks. Through our explorations with EMaQ we make two intriguing findings. First, due to the strong dependence of EMaQ on the quality of behavior policy used, our results demonstrate the significant impact of careful considerations in modeling the behavior policy that generate the offline interaction datasets. Second, relating to the introduced notion of complexity, in a diverse array of benchmark settings considered in this work we observe that surprisingly little modification to a base behavior policy is necessary to obtain a performant policy. As an example, we observe that while a HalfCheetah random policy obtains a return of 0, a policy that at each state uniformly samples only 5 actions and chooses the one with the best value obtains a return of 2000. The simplicity, intuitive interpretation, and strong empirical performance of EMaQ make it a great test-bed for further examination and theoretical analyses, and an easy to implement yet strong baseline for future work in offline RL.
+
+# 2 BACKGROUND
+
+Throughout this work, we represent Markov Decision Process (MDP) as $M = \langle S , \mathcal { A } , r , \mathcal { P } , \gamma \rangle$ , with state space $s$ , action space $\mathcal { A }$ , reward function $r : S { \times } A {  } \mathbb { R }$ , transition dynamics $\mathcal { P }$ , and discount $\gamma$ . In offline RL, we assume access to a dataset of interactions with the MDP, which we will represent as collection of tuples $D = \{ ( s , a , s ^ { \prime } , r , t ) \} ^ { N }$ , where $t$ is an indicator variable that is set to True when $s ^ { \prime }$ is a terminal state. We will use $\mu$ to represent the behavior policy used to collect $D$ , and depending on the context, we will overload this notation and use $\mu$ to represent an estimate of the true behavior policy. For a given policy $\pi$ , we will use the notation $d ^ { \pi } ( s ) , d ^ { \pi } ( s , a )$ to represent the state-visitation and state-action visitation distributions respectively.
+
+As alluded to above, a significant challenge of offline RL methods is the problem of distribution shift. At training-time, there is no distribution shift in states as a fixed dataset $D$ is used for training, and the policy and value functions are never evaluated on states outside of $d ^ { \mu } ( s )$ . However, a very significant challenge is the problem of distribution shift in actions. Consider the Bellman backup for obtaining the Q-function of a given policy $\pi$ ,
+
+$$
+\begin{array} { r } { \mathcal T _ { \pi } Q ( s , a ) : = r ( s , a ) + \gamma \cdot \mathbb E _ { s ^ { \prime } } \mathbb E _ { a ^ { \prime } \sim \pi ( a ^ { \prime } | s ^ { \prime } ) } \Big [ Q ( s ^ { \prime } , a ^ { \prime } ) \Big ] } \end{array}
+$$
+
+The target Q-values on the right hand side depend on action samples $a ^ { \prime } \sim \pi ( a ^ { \prime } | s ^ { \prime } )$ . If the sampled actions are outside the distribution of actions observed in $D$ , the estimated Q-values can be erroneous leading to incorrect target values. The effects of action distribution shift are further exacerbated in actor-critic algorithms; out of distribution (OOD) actions may incorrectly be assigned high values, in which case the policy will be updated to further sample OOD actions, leading to a hazardous loop.
+
+An important approach – with particular recent interest – to mitigate the effects of both kinds of distributional shift is to devise methods for constraining learned policies to remain close to the behavior policy $\mu$ : $d ^ { \pi } ( s , a ) \approx d ^ { \mu } ( s , a )$ . Below, we set the stage by reviewing a closely related prior work in offline RL.
+
+Batch Constrained Q-Learning (BCQ) In BCQ (Fujimoto et al., 2018a) the aim is to constrain a Q-Learning based algorithm such that it will be effective in the offline RL continuous control setting with function approximators. To do so, the trained policy is parameterized as:
+
+$$
+\begin{array} { r l } & { \pi _ { \theta } ( a | s ) = \underset { a _ { i } + \xi _ { \theta } ( s , a _ { i } ) } { \arg \operatorname* { m a x } } Q _ { \psi } ( s , a _ { i } + \xi _ { \theta } ( s , a _ { i } ) ) \qquad \mathrm { f o r } \qquad a _ { i } \sim \mu ( a | s ) , i = 1 , . . . , N } \\ & { } \\ & { y ( s , a , s ^ { \prime } , r , t ) = \bigg ( r + ( 1 - t ) \cdot \gamma \operatorname* { m a x } _ { a _ { i } ^ { \prime } } Q _ { \psi ^ { \prime } } ( s ^ { \prime } , a _ { i } ^ { \prime } ) \bigg ) \qquad \mathrm { f o r } \qquad a _ { i } ^ { \prime } \sim \pi _ { \theta } ( a ^ { \prime } | s ^ { \prime } ) , i = 1 , . . . , N } \\ & { } \\ & { \mathcal { L } _ { Q } = \left( y ( s , a , s ^ { \prime } , r , t ) - Q _ { \psi } ( s , a ) \right) ^ { 2 } } \end{array}
+$$
+
+where $y ( s , a )$ are target $\mathrm { Q }$ -values, $Q _ { \psi }$ is learned with the objective in equation 4, $\mu ( a | s )$ is an estimate of the base behavior policy (a generative model trained using the dataset $D$ ), and $\xi _ { \theta }$ is an action perturbation model trained to modify actions towards more optimal ones. Crucially, each component of the output of $\xi _ { \theta }$ is bounded to the range $[ - \Phi , \Phi ]$ . The key intuition is that because $a _ { i }$ are sampled from an estimate of the behavior policy, they should hopefully be within the distribution observed in $D$ . Thus, since the perturbation model is constrained by the hyperparameter $\Phi$ , the perturbed actions should not be too far from actions in the dataset. This should mitigate errors in value estimates, which should in turn lead to better updates for the perturbation model.
+
+# 3 EXPECTED-MAX Q-LEARNING
+
+We make the observation that, in the BCQ algorithm, if we could obtain a good estimate $\mu ( a | s )$ and sufficiently increased the number of samples $N$ , there would be no need for the perturbation network $\xi _ { \theta }$ . This simplification would remove one additional function approximator and the associated hyperparameter $\Phi$ . This is the driving intuition of our work, which we frame theoretically in a manner that encapsulates the key components: the behavior policy $\mu$ and number of samples $N$ . Below, we introduce the Expected-Max Q operator, illustrate its key properties for tabular MDPs, and obtain sub-optimality bounds which can serve as a novel measure of complexity of an offline RL problem for future theoretical work. We then provide an extension to the offline RL setting with function approximators, and then discuss the generative model used to approximate the behavior policy.
+
+# 3.1 EXPECTED-MAX Q OPERATOR
+
+Let $\mu ( a | s )$ be an arbitrary behavior policy, and let $\{ a _ { i } \} ^ { N } \sim \mu ( a | s )$ denote sampling $N$ iid actions from $\mu ( a | s )$ . Let $Q : { \mathcal { S } } \times { \mathcal { A } }  \mathbb { R }$ be an arbitrary function. For a given choice of $N$ , we define the Expected-Max Q-Learning operator (EMaQ) $\mathcal { T } _ { \mu } ^ { N } Q$ as follows:
+
+$$
+\begin{array} { r l } & { \mathcal { T } _ { \mu } ^ { N } Q ( s , a ) : = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { \{ a _ { i } ^ { \prime } \} ^ { N } \sim \mu ( \cdot \vert s ^ { \prime } ) } \left[ \underset { a ^ { \prime } \in \{ a _ { i } ^ { \prime } \} ^ { N } } { \operatorname* { m a x } } Q ( s ^ { \prime } , a ^ { \prime } ) \right] } \\ { \mathrm { Q . E v a l u a t i o n ~ f o r } \mu \quad } & { \mathcal { T } _ { \mu } Q ( s , a ) : = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { a ^ { \prime } \sim \mu ( \cdot \vert s ^ { \prime } ) } \left[ Q ( s ^ { \prime } , a ^ { \prime } ) \right] } \\ { \mathrm { Q . L e a r n i n g } \quad } & { \mathcal { T } ^ { \ast } Q ( s , a ) : = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \left[ \underset { a ^ { \prime } } { \operatorname* { m a x } } Q ( s ^ { \prime } , a ^ { \prime } ) \right] } \end{array}
+$$
+
+This operator provides a natural interpolant between the on-policy backup for $\mu$ (Eq. 6) when $N = 1$ , and the Q-learning backup (Eq. 7) as $N  \infty$ (if $\mu ( a | s )$ has full support over $\mathcal { A }$ ). We formalize these observations more precisely below when we articulate the key properties in the tabular MDP setting. We discuss how this relates to existing modified backup operators in the related work.
+
+# 3.2 DYNAMIC PROGRAMMING PROPERTIES IN THE TABULAR MDP SETTING
+
+To understand any novel backup operator it is useful to first characterize its key dynamic programming properties in the tabular MDP setting. First, we establish that EMaQ retains essential contraction and fixed-point existence properties, regardless of the choice of $N \in \mathbb { N }$ . In the interest of space, all missing proofs can be found in Appendix A.
+
+Theorem 3.1. In the tabular setting, for any $N \in \mathbb { N }$ , $\mathcal { T } _ { \mu } ^ { N }$ is a contraction operator in the $\mathcal { L } _ { \infty }$ norm. Hence, with repeated applications of the $\mathcal { T } _ { \mu } ^ { N }$ , any initial $Q$ function converges to a unique fixed point.
+
+Theorem 3.2. Let $Q _ { \mu } ^ { N }$ denote the unique fixed point achieved in Theorem 3.1, and let $\pi _ { \mu } ^ { N } ( a | s )$ denote the policy that samples $N$ actions from $\mu ( a | s ) , \{ a _ { i } \} ^ { N }$ , and chooses the action with the maximum $\bar { Q } _ { \mu } ^ { N }$ . Then $Q _ { \mu } ^ { N }$ is the $Q$ -value function corresponding to $\pi _ { \mu } ^ { N } ( a | s )$ .
+
+Proof. (Theorem 3.2) Rearranging the terms in equation 5 we have,
+
+$$
+\begin{array} { r } { \mathcal { T } _ { \mu } ^ { N } Q _ { \mu } ^ { N } ( s , a ) = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { a ^ { \prime } \sim \pi _ { \mu } ^ { N } ( a ^ { \prime } | s ^ { \prime } ) } [ Q _ { \mu } ^ { N } ( s ^ { \prime } , a ^ { \prime } ) ] } \end{array}
+$$
+
+Since by definition $Q _ { \mu } ^ { N }$ is the unique fixed point of $\mathcal { T } _ { \mu } ^ { N }$ , we have our result.
+
+From these results we can then rigorously establish the interpolation properties of the EMaQ family. Theorem 3.3. Let $\pi _ { \mu } ^ { \ast }$ denote the optimal policy from the class of policies whose actions are restricted to lie within the support of the policy $\mu ( a | s )$ . Let $Q _ { \mu } ^ { * }$ denote the $Q$ -value function corresponding to $\pi _ { \mu } ^ { \ast }$ . Furthermore, let $Q _ { \mu }$ denote the $Q$ -value function of the policy $\mu ( a | s )$ . Let $\begin{array} { r } { \mu ^ { * } ( s ) : = \int _ { S u p p o r t ( \pi _ { \mu } ^ { * } ( a \left| s ) ) \right|} \mu ( a  s ) } \end{array}$ denote the probability of optimal actions under $\mu ( a | s )$ . Under the assumption that $\operatorname* { i n f } _ { s } \mu ^ { * } ( s ) > 0$ and $r ( s , a )$ is bounded, we have that,
+
+$$
+Q _ { \mu } ^ { 1 } = Q _ { \mu } \qquad a n d \qquad \operatorname * { l i m } _ { N \to \infty } Q _ { \mu } ^ { N } = Q _ { \mu } ^ { * }
+$$
+
+That is, Theorem 3.3 shows that, given a base behavior policy $\mu ( a | s )$ , the choice of $N$ makes the EMaQ operator interpolate between evaluating the Q-value of $\mu$ on the one hand, and learning the optimal $\mathbf { Q }$ -value function on the other (optimal subject to the support constraint discussed in Theorem 3.3). In the special case where $\mu ( a | s )$ has full support over the action space $\mathcal { A }$ , EMaQ interpolates between the standard Q-Evaluation and Q-Learning operators in reinforcement learning.
+
+Intuitively, as we increase $N$ , the fixed-points $Q _ { \mu } ^ { N }$ should correspond to increasingly better policies $\pi _ { \mu } ^ { N } ( a | s )$ . We show that this is indeed the case.
+
+Theorem 3.4. For all $N , M \in \mathbb { N } ,$ , where $N > M$ , we have that $\forall s \in S , \forall a \in \operatorname { S u p p o r t } ( \mu ( \cdot | s ) )$ $Q _ { \mu } ^ { N } ( s , a ) \geq Q _ { \mu } ^ { M } ( s , a ) .$ . Hence, $\pi _ { \mu } ^ { N } ( a | s )$ is at least as good of a policy as $\pi _ { \mu } ^ { M } ( a | s )$ .
+
+It is also valuable to obtain a sense of how suboptimal $\pi _ { \mu } ^ { N } ( a | s )$ may be with respect to the optimal policy supported by the policy $\mu ( a | s )$ .
+
+Theorem 3.5. For $s \in S$ let,
+
+$$
+\Delta ( s , N ) = \operatorname* { m a x } _ { a \in \mathrm { S u p p o r t } ( \mu ( \cdot | s ) ) } Q _ { \mu } ^ { * } ( s , a ) - \mathbb { E } _ { \{ a _ { i } \} ^ { N } \sim \mu ( \cdot | s ) } [ \operatorname* { m a x } _ { b \in \{ a _ { i } \} ^ { N } } Q _ { \mu } ^ { * } ( s , b ) ]
+$$
+
+The suboptimality of $Q _ { \mu } ^ { N }$ can be upperbounded as follows,
+
+$$
+\bigl \| Q _ { \mu } ^ { N } - Q _ { \mu } ^ { * } \bigr \| _ { \infty } \leq \frac { \gamma } { 1 - \gamma } \operatorname* { m a x } _ { s , a } \mathbb { E } _ { s ^ { \prime } } \Bigl [ \Delta ( s ^ { \prime } , N ) \Bigr ] \leq \frac { \gamma } { 1 - \gamma } \operatorname* { m a x } _ { s } \Delta ( s , N )
+$$
+
+The same also holds when $Q _ { \mu } ^ { * }$ is replaced with $Q _ { \mu } ^ { N }$ in the definition of $\Delta$ .
+
+# 3.3 A MEASURE OF COMPLEXITY FOR OFFLINE RL
+
+The bounds in equation 8 capture the main intuitions about the interplay between $\mu ( a | s )$ and the choice of $N$ . If for each state, $\mu ( a | s )$ places sufficient mass over the optimal actions, $\dot { \pi } _ { \mu } ^ { N }$ will be
+
+# Algorithm 1: Test-Time Policy $\pi _ { \mathrm { t e s t } }$
+
+Function TestEnsemble(values): return $\lambda \cdot \operatorname* { m i n } ( v a l u e s ) + ( 1 - \lambda ) \cdot \operatorname* { m a x } ( v a l u e s )$   
+Function $\pi _ { \mathrm { t e s t } } \left( s \right)$ : $\{ a _ { i } \} ^ { N } \sim \mu ( a | s )$ return arg $\operatorname* { m a x } _ { \{ a _ { i } \} ^ { N } }$ TestEnsemble[Qi(s, a) for all i]

+
+close to $\pi _ { \underline { { \mu } } } ^ { * }$ . The two variants of $\Delta ( s , N )$ , based on $Q _ { \mu } ^ { * }$ or $Q _ { \mu } ^ { N }$ , suggest an intriguing notion of difficulty for an offline RL problem. If we could estimate either of these $\mathrm { Q }$ -value functions, then for a desired set of states (such as initial states) we could plot $\Delta ( s , N )$ as decreasing function of $N$ . The rate at which this function decreases could serve as an intuitive notion of difficulty for a given offline offline RL problem which consists of an MDP and a given behavior policy. While we leave theoretical investigations of this measure for future work, our empirical results in Section 5 demonstrate that the effective value of $N$ may be surprisingly small.
+
+# 3.4 OFFLINE RL SETTING WITH FUNCTION APPROXIMATORS
+
+Typically, we are not provided with the policies that generated the provided trajectories. Hence, as a first step we fit a generative model $\mu ( a | s )$ to the $( s , a )$ pairs in the offline dataset, representing the mixture of policies that generated this data (details below). Having obtained $\mu ( a | s )$ , we move on to the EMaQ training procedure. Similar to prior works (Fujimoto et al., 2018a; Kumar et al., 2019; Wu et al., 2019), we train $K$ Q functions (represented by MLPs) and make use of an ensembling procedure to combat overestimation bias (Hasselt, 2010; Van Hasselt et al., 2016; Fujimoto et al., 2018b). Letting $D$ represent the offline dataset, the objective for the Q functions takes the following form:
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \theta _ { i } ) = \mathbb { E } _ { ( s , a , s ^ { \prime } , r , t ) \sim D } \left[ \Big ( Q _ { \theta _ { i } } ( s , a ) - y ( s , a , s ^ { \prime } , r , t ) \Big ) ^ { 2 } \right] } \\ & { y ( s , a , s ^ { \prime } , r , t ) = \bigg ( r + ( 1 - t ) \cdot \gamma \operatorname* { m a x } _ { a _ { i } ^ { \prime } } Q _ { e n s } ^ { \prime } ( s ^ { \prime } , a _ { i } ^ { \prime } ) \Big ) \quad \mathrm { f o r } \quad a _ { i } ^ { \prime } \sim \mu ( a ^ { \prime } | s ^ { \prime } ) , i = 1 , . . . , N } \end{array}
+$$
+
+where $t$ is the indicator variable $\mathbb { 1 } [ s ^ { \prime }$ is terminal], and $Q _ { e n s } ^ { \prime }$ represents the ensemble of target Q functions. In short, we sample $N$ actions from $\mu ( \bar { a } ^ { \prime } | s ^ { \prime } )$ and take the value of the best action to form the target. The algorithm box describing the full training loop can be viewed in Algorithm 2.
+
+Notably, we do not train an explicit neural network representing the policy. At test-time, given a state $s$ , we sample $N$ actions from $\mu ( a | s )$ and choose the action with the maximum value under the ensemble of Q functions (see Algorithm 1). While TestEnsemble can differ from the Ensemble function used to compute target Q values1, in this work we used the same ensembling procedure with $\lambda = 1 . 0$ (with the exception of experiments in Section F).
+
+# 3.5 INTUITION FOR OFFLINE EMAQ AND MODELING $\mu ( a | s )$
+
+The intuition for how offline $\mathrm { E M a Q }$ aims to address the problem of erroneous value estimates can be understood from attending to equation 10 and the form of the test-time policy (Algorithm 1). In equation 10 we observe that target values for the Q functions are computed by sampling actions from the behavior policy estimate $\pmb { \mu }$ , and not a separately learned policy that may sample out of distribution actions, as in BCQ. At test-time, our implicit policy is also formed by choosing amongst actions sampled from $\mu$ . Hence, if $\mu$ accurately estimates the behavior policy well, we will never sample actions outside the support and will not need to evaluate the value of such actions. In the practical setting where $\mu$ may have inaccuracies, the hyperparameter $N$ acts as an implicit regularizer: Using very large values of $N$ maximizes the chance of sampling actions that are out of distribution and have erroneous value estimates, while smaller $N$ reduces the chance of this happening in every update iteration and therefore smoothens the incorrect values.
+
+With the importance of a good behavior estimates accentuated in our proposed method, we pay closer attention to the choice of generative model used for representing $\mu$ . Past works (Fujimoto et al., 2018a; Kumar et al., 2019; Wu et al., 2019) have typically used Variational Auto-Encoders (VAEs) (Kingma & Welling, 2013; Rezende et al., 2014) to represent the behavior distribution $\mu ( a | s )$ . Unfortunately, after training the aggregate posterior $q _ { \mathrm { a g g } } \bar { ( z ) } : = \mathbb { E } _ { x } [ q ( \boldsymbol { z } | \boldsymbol { x } ) ]$ of a VAE does not typically align well with its prior, making it challenging to sample from in a manner that effectively covers the distribution it was trained $\mathrm { { \dot { o } n ^ { 2 } } }$ . We opt for using an autoregressive architecture based on MADE (Germain et al., 2015) as it allows for representing more expressive distributions and enables more accurate sampling. Inspired by recent works (Metz et al., 2017; Van de Wiele et al., 2020), our generative model architecture also makes use of discretization in each action dimension. Full details can be found in Appendix B.
+
+# 4 RELATED WORK
+
+Offline RL Many recent methods for offline RL (Fujimoto et al., 2018a; Kumar et al., 2019; Wu et al., 2019; Jaques et al., 2019), where no interactive data collection is allowed during training, mostly rely on constraining the learned policy to stay close to the data collection distribution. Fujimoto et al. (2018a) clip the maximum deviation from actions sampled from a base behavior policy, while Kumar et al. (2019); Wu et al. (2019); Jaques et al. (2019) incorporate additional distributional penalties (such as KL divergence or MMD) for regularizing learned policies to remain close to the base policy. Our work is an instance of this family of approaches for offline RL; however, arguably our method is simpler as it does not involve learning an additional proposal-modifying policy Fujimoto et al. (2018a), or modifying reward functions (Kumar et al., 2019; Jaques et al., 2019).
+
+Finding Maximizing Actions Na¨ıvely, EMaQ can also be seen as just performing approximate search for maxa $Q ( s , a )$ in standard Q-learning operator, which has been studied in various prior works for Q-learning in large scale spaces (e.g. continuous). NAF (Gu et al., 2016b) and ICNN (Amos et al., 2017) directly constrain the function family of Q-functions such that the optimization can be closed-form or tractable. QT-OPT (Kalashnikov et al., 2018b) makes use of two iterations of the Cross-Entropy Method (Rubinstein & Kroese, 2013), while CAQL (Ryu et al., 2019) uses Mixed-Integer Programming to find the exact maximizing action while also introducing faster approximate alternatives. In (Van de Wiele et al., 2020) – the most similar approach to our proposed method EMaQ – throughout training a mixture of uniform and learned proposal distributions are used to sample actions. The sampled actions are then evaluated under the learned Q functions, and the top K maximizing actions are distilled back into the proposal distribution. In contrast to our work, these works assume these are approximate maximization procedures and do not provide extensive analysis for the resulting TD operators. Our theoretical analysis on the family of TD operators described by EMaQ can therefore provide new perspectives on some of these highly successful Q-learning algorithms (Kalashnikov et al., 2018a; Van de Wiele et al., 2020) – particularly on how the proposal distribution affects convergence.
+
+Modified Backup Operators Many prior works study modifications to standard backup operators to achieve different convergence properties for action-value functions or their induced optimal policies. $\Psi$ -learning (Rawlik et al., 2013) proposes a modified operator that corresponds to policy iterations with KL-constrained updates (Kakade, 2002; Peters et al., 2010; Schulman et al., 2015) where the action-value function converges to negative infinity for all sub-optimal actions. Similarly but distinctly, Fox et al. (2015); Jaques et al. (2017); Haarnoja et al. (2018); Nachum et al. (2017) study smoothed TD operators for a modified entropy- or KL-regularized RL objective. Bellemare et al. (2016) derives a family of consistent Bellman operators and shows that they lead to increasing action gaps (Farahmand, 2011) for more stable learning. However, most of these operators have not been studied in offline learning. Our work adds a novel family operators to this rich literature of operators for RL, and provides strong empirical validation on how simple modifications of operators can translate to effective offline RL with function approximations.
+
+![](images/16c665db9d8a2331ba8e65c2a8bcd22b5d3f22d709c743455556068c8397e2c4.jpg)  
+Figure 1: Results for evaluating EMaQ on D4RL benchmark’s (Fu et al., 2020b) standard Mujoco domains, with $N \in \{ 5 , 1 0 , 2 5 , 5 0 , 1 0 0 , 2 0 0 , 4 0 0 \}$ . Values above $\mu ( a | s )$ represent the result of evaluating the base behavior policies. Horizontal green lines represent the reported performance of BEAR in the D4RL benchmark (apples to apples comparisons in Figure 2). The types of offline datasets are: random: 1M transitions are collected by a random agent, medium: 1M transitions are collected by a half-trained SAC (Haarnoja et al., 2018) policy, mixed: the replay buffer of this half-trained policy, and medium-expert: combination of the medium dataset and 1M additional transitions from a fully trained policy. Refer to main text (Section 5.1) for description of color-coding. For better legibility, we have included a larger variant of these plots in the Appendix L. Full experimental details in Appendix G.
+
+# 5 EXPERIMENTS
+
+For all experiments we make use of the codebase of (Wu et al., 2019), which presents the BRAC off-policy algorithm and examines the importance of various factors in BCQ (Fujimoto et al., 2018a) and BEAR (Kumar et al., 2019) methods. We implement EMaQ into this codebase. We make use of the recently proposed D4RL (Fu et al., 2020b) datasets for bechmarking offline RL.
+
+Online EMaQ Despite obtaining strong online RL results competitive with and outperforming SAC (Haarnoja et al., 2018) (Figure 3), as the main focus of our work is for the offline setting, we have placed our online RL methodology and results in Appendix F. However, we emphasize that significance of obtaining strong online RL performance with effectively the same algorithm as the offline setting should not be overlooked. Most prior offline RL works have not considered how their methods might transfer to online or batched online setting, and recent work (Nair et al., 2020) has demonstrated the challenges of finetuning from a policy trained offline, in the online setting.
+
+# 5.1 PRACTICAL EFFECT OF $N$ AND THE CHOICE OF GENERATIVE MODEL $\mu$
+
+We begin by empirically evaluating key aspects of offline EMaQ, namely the effect of $N$ , and choice of generative model used for representing the behavior estimate $\mu$ . In prior approaches such as those described in the background section of this work, care must be taken in choosing the hyperparameter that dictates the extent to which learned policies can deviate from the base behavior policies; too small and we cannot improve upon the base policy, too large and the value of actions cannot be correctly estimated. In EMaQ, at least in theory, choosing higher values of $N$ should result in strictly better policies. Additionally, there exists a concern that $N$ may need to be impractically large. Thus, we empirically investigate to what extent the monotonic trend holds in practice, and seek to understand what magnitudes of $N$ result in good policies in practical benchmark domains. Figure 1 presents our results with $N \in \{ 5 , 1 0 , 2 5 , 5 0 , 1 0 0 , 2 0 0 , 4 0 0 \}$ . In the green plots, we observe that empirical results follow our intuitions: with increasing $N$ the resultant policies become better. In the medium-expert settings (i.e. orange plots), while for smaller values of $N$ we observe strong performance, there appears to be a downward trend. As discussed in Section 3.5, smaller values of $N$ result in an implicit regularization. Hence, the orange plots may indicate that even with the stronger choice of generative models in EMaQ, inaccuracies in value estimates may still exist, suggesting the need for future work that introduces better regularizers for the value functions than ensembling (Kumar et al., 2020). Lastly, the red plots indicate settings where behavior is erratic. Closer examination of training curves and our experiments with other off-policy methods (Figure 2) suggests that this may be due to the intrinsic nature of these environment and data settings.
+
+![](images/da85b1c21fe8a3eb1c191cd24a72f2ed6942ad1eb6bb492706a578164b9b1000.jpg)  
+Figure 2: Comparison of EMaQ, BCQ, and BEAR on D4RL (Fu et al., 2020b) benchmark domains when using our proposed autoregressive $\mu ( a | s )$ . For both BCQ and BEAR, from left to right as the value of the hyperparameter increases, the allowed deviation from $\mu ( a | s )$ increases. Horizontal green lines represent the reported performance of BEAR in the D4RL benchmark. Color-coding follows Figure 1. For better legibility, we have included a larger variant of these plots in the Appendix L. Full experimental details in Appendix G.
+
+The dashed horizontal lines in Figure 2 represent the performance of BEAR – which uses a VAE for representing $\mu - \mathrm { a s }$ reported in the D4RL (Fu et al., 2020b) benchmark paper (apples to apples comparison in Section 5.2). Our results demonstrate that the combination of a strong generative model and EMaQ’s simply constrained backup operator can match and in many cases noticeably exceed results from prior algorithms and design choices. Comparing Figure 2 to Figure 6 in the Appendix, we observe that our choice of generative model is crucial to the performance of EMaQ. With a VAE architecture as used in prior work, EMaQ’s performance is significantly reduced, in most cases worse than prior reported results for BEAR, and never exhibits a monotonic trend as a function of $N$ . This is despite the fact that when evaluating the performance of the behavior estimate $\mu$ under the two architecture choices results in almost identical results (the first column of each sub-plot corresponding to $\mu ( a | s ) ,$ ). We do not believe that autoregressive models are intrinsically better than VAEs, but rather our results demonstrate the need for more careful attention on the choice of $\mu ( a | s )$ . Since EMaQ is closely tied to the choice of behavior model, it may be more effective for evaluating how well $\mu ( a | s )$ represents the given offline dataset. From a practical perspective, our results suggest that for a given domain, focusing efforts on building-in good inductive biases in the generative models and value functions might be sufficient to obtain strong offline RL performance in many domains.
+
+# 5.2 COMPARISON ON D4RL OFFLINE RL BENCHMARK
+
+To evaluate EMaQ with respect to prior methods, we compare to two popular and closely related prior methods for offline RL, BCQ (Fujimoto et al., 2018a) and BEAR (Kumar et al., 2019). As with the previous section, full experimental details can be found in Appendix G.1. Figure 2 and Table 1 present our empirical results. Note that with our proposed autoregressive models, the results for BEAR are matched and in some cases noticeably above the values reported in the D4RL benchmark (Fu et al., 2020b) (green horizontal lines). For easier interpretation, the plots are colored
+
+<table><tr><td rowspan=1 colspan=1>Setting</td><td rowspan=1 colspan=1>BC</td><td rowspan=1 colspan=1>BCQ</td><td rowspan=1 colspan=1>BEAR</td><td rowspan=1 colspan=1>EMaQ</td><td rowspan=1 colspan=1>EMaQ N</td></tr><tr><td rowspan=1 colspan=1>kitchen-completekitchen-partialkitchen-mixed</td><td rowspan=1 colspan=1>27.2 ± 3.246.2 ± 2.852.5 ± 3.8</td><td rowspan=1 colspan=1>26.5 ± 4.869.3 ± 5.265.5 ± 1.8</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>36.9 ± 3.774.6 ± 0.670.8 ± 2.3</td><td rowspan=1 colspan=1>6488</td></tr><tr><td rowspan=1 colspan=1>antmaze-umazeantmaze-umaze-diverse</td><td rowspan=1 colspan=1>59.0± 5.558.8± 9.5</td><td rowspan=1 colspan=1>25.5 ± 20.068.0 ± 19.0</td><td rowspan=1 colspan=1>56.3± 28.857.5 ± 39.2</td><td rowspan=1 colspan=1>91.0 ± 4.694.0 ± 2.4</td><td rowspan=1 colspan=1>10050</td></tr><tr><td rowspan=1 colspan=1> antmaze-medium-playantmaze-medium-diverseantmaze-large-playantmaze-large-diverse</td><td rowspan=1 colspan=1>0.7 ± 1.00.4 ± 0.80.0 ± 0.00.0 ± 0.0</td><td rowspan=1 colspan=1>3.5 ± 6.10.5 ± 0.90.0 ± 0.00.0 ± 0.0</td><td rowspan=1 colspan=1>0.2 ± 0.40.2 ± 0.40.0 ± 0.00.0± 0.0</td><td rowspan=1 colspan=1>0.0± 0.00.0 ± 0.00.0 ± 0.00.0 ± 0.0</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>door-clonedhammer-clonedpen-clonedrelocate-cloned</td><td rowspan=1 colspan=1>0.0± 0.01.2 ± 0.624.5 ± 10.2-0.2 ± 0.0</td><td rowspan=1 colspan=1>0.2 ± 0.41.3 ± 0.543.8 ± 6.4-0.2 ± 0.0</td><td rowspan=1 colspan=1>0.0± 0.00.3 ± 0.0-3.1 ± 0.20.0 ± 0.0</td><td rowspan=1 colspan=1>0.2 ± 0.31.0 ± 0.727.9 ± 3.7-0.2 ± 0.2</td><td rowspan=1 colspan=1>646412816</td></tr></table>
+
+Table 1: Results on a series of other environments and data settings from the D4RL benchmark (Fu et al., 2020a). Results are normalized to the range [0, 100], per the D4RL normalization scheme. For each method, for each environment and data setting the results of the best hyperparameter setting are reported. The last column indicates the best value of $N$ in EMaQ amongst the considered hyperparameters (for the larger antmaze domains, we do not report this value since no value of $N$ obtains nonzero returns). All the domains below the blue double-line are effectively unsolved by all methods. We have technical difficulties in evaluating BEAR on the kitchen domains. This manuscript will be updated upon obtaining these results. Additional details can be found in Appendix G.3.
+
+the same as in Figure 1. Our key take-away is that despite its simplistic form, EMaQ is strongly competitive with prior state-of-the-art methods, and in the case of Table 1 outperforms prior approaches. Despite this, there remain many domains in the D4RL benchmark on which none of the considered algorithms make any progress (Table 1), indicating that much algorithmic advances are still necessary for solving many of the considered domains.
+
+A very eye-catching result in above figures is that in almost all settings of the standard Mujoco environments (Figures 1 and 2), just $N = 5$ significantly improves upon $\mu ( a | s )$ and in most settings matches or exceeds significantly beyond previously reported results. Concretely, this means that in the HalfCheetah-Random setting, if at each state we sample 5 actions uniformly random and choose the best one under the learned Q-value function, we convert a random policy with return 0 to a policy with return 2000. In this way, EMaQ provides a quite intuitive and surprising measure of the complexity for offline RL problems. This empirical observation also corroborates our discussion in Section 3.3, encouraging future theoretical investigations into $\Delta ( s , N )$ .
+
+# 6 CONCLUSION
+
+In this work, we investigate a significant simplification of the BCQ (Fujimoto et al., 2018a) algorithm by removing the heuristic perturbation network. By introducing the Expect-Max Q-Learning operator, we present a novel theoretical setup that takes into account the proposal distribution $\mu ( a | s )$ and the number of action samples $N$ , and hence more closely matches the resulting practical algorithm. With fewer moving parts and one less function approximator, EMaQ matches and outperforms prior state-of-the-art in online and offline RL. Our investigations with EMaQ demonstrate the significance of careful considerations in the design of generative models used. Furthermore, our theoretical and empirical findings bring into light novel notions of complexity for offline RL problems. Given the simplicity, tractable theory, and state-of-the-art performance of EMaQ, we hope our work can serve as a foundation for future works on understanding and improving offline RL.
+
+# REFERENCES
+
+Brandon Amos, Lei Xu, and J Zico Kolter. Input convex neural networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 146–155. JMLR. org, 2017.
+
+Marc G Bellemare, Georg Ostrovski, Arthur Guez, Philip S Thomas, and Remi Munos. Increasing ´ the action gap: New operators for reinforcement learning. In Thirtieth AAAI Conference on Artificial Intelligence, 2016.
+
+Richard Y Chen, Szymon Sidor, Pieter Abbeel, and John Schulman. Ucb exploration via qensembles. arXiv preprint arXiv:1706.01502, 2017.
+
+Thomas Degris, Martha White, and Richard S Sutton. Off-policy actor-critic. arXiv preprint arXiv:1205.4839, 2012.
+
+Amir-massoud Farahmand. Action-gap phenomenon in reinforcement learning. In Advances in Neural Information Processing Systems, pp. 172–180, 2011.
+
+Roy Fox, Ari Pakman, and Naftali Tishby. Taming the noise in reinforcement learning via soft updates. arXiv preprint arXiv:1512.08562, 2015.
+
+Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. D4rl: Datasets for deep data-driven reinforcement learning, 2020a.
+
+Justin Fu, Aviral Kumar, Ofir Nachum, George Tucker, and Sergey Levine. Datasets for data-driven reinforcement learning. arXiv preprint arXiv:2004.07219, 2020b.
+
+Scott Fujimoto, David Meger, and Doina Precup. Off-policy deep reinforcement learning without exploration. arXiv preprint arXiv:1812.02900, 2018a.
+
+Scott Fujimoto, Herke Van Hoof, and David Meger. Addressing function approximation error in actor-critic methods. arXiv preprint arXiv:1802.09477, 2018b.
+
+Mathieu Germain, Karol Gregor, Iain Murray, and Hugo Larochelle. Made: Masked autoencoder for distribution estimation. In International Conference on Machine Learning, pp. 881–889, 2015.
+
+Shixiang Gu, Timothy Lillicrap, Zoubin Ghahramani, Richard E Turner, and Sergey Levine. Qprop: Sample-efficient policy gradient with an off-policy critic. arXiv preprint arXiv:1611.02247, 2016a.
+
+Shixiang Gu, Timothy Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. In International Conference on Machine Learning, 2016b.
+
+Shixiang Gu, Ethan Holly, Timothy Lillicrap, and Sergey Levine. Deep reinforcement learning for robotic manipulation with asynchronous off-policy updates. In International Conference on Robotics and Automation, 2017.
+
+Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Offpolicy maximum entropy deep reinforcement learning with a stochastic actor. arXiv preprint arXiv:1801.01290, 2018.
+
+Hado V Hasselt. Double q-learning. In Advances in neural information processing systems, pp. 2613–2621, 2010.
+
+Natasha Jaques, Shixiang Gu, Dzmitry Bahdanau, Jose Miguel Hern ´ andez-Lobato, Richard E ´ Turner, and Douglas Eck. Sequence tutor: Conservative fine-tuning of sequence generation models with kl-control. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pp. 1645–1654. JMLR. org, 2017.
+
+Natasha Jaques, Asma Ghandeharioun, Judy Hanwen Shen, Craig Ferguson, Agata Lapedriza, Noah Jones, Shixiang Gu, and Rosalind Picard. Way off-policy batch deep reinforcement learning of implicit human preferences in dialog. arXiv preprint arXiv:1907.00456, 2019.
+
+Sham M Kakade. A natural policy gradient. In Advances in neural information processing systems, pp. 1531–1538, 2002.
+
+Dmitry Kalashnikov, Alex Irpan, Peter Pastor, Julian Ibarz, Alexander Herzog, Eric Jang, Deirdre Quillen, Ethan Holly, Mrinal Kalakrishnan, Vincent Vanhoucke, and Sergey Levine. Qt-opt: Scalable deep reinforcement learning for vision-based robotic manipulation. In Conference on Robot Learning, 2018a.
+
+Dmitry Kalashnikov, Alex Irpan, Peter Pastor, Julian Ibarz, Alexander Herzog, Eric Jang, Deirdre Quillen, Ethan Holly, Mrinal Kalakrishnan, Vincent Vanhoucke, et al. Qt-opt: Scalable deep reinforcement learning for vision-based robotic manipulation. arXiv preprint arXiv:1806.10293, 2018b.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Aviral Kumar, Justin Fu, Matthew Soh, George Tucker, and Sergey Levine. Stabilizing off-policy q-learning via bootstrapping error reduction. In Advances in Neural Information Processing Systems, 2019.
+
+Aviral Kumar, Aurick Zhou, George Tucker, and Sergey Levine. Conservative q-learning for offline reinforcement learning. arXiv preprint arXiv:2006.04779, 2020.
+
+Sergey Levine, Aviral Kumar, George Tucker, and Justin Fu. Offline reinforcement learning: Tutorial, review, and perspectives on open problems. arXiv preprint arXiv:2005.01643, 2020.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Travis Mandel, Yun-En Liu, Sergey Levine, Emma Brunskill, and Zoran Popovic. Offline policy evaluation across representations with applications to educational games. In International Conference on Autonomous Agents and Multiagent Systems, 2014.
+
+Tatsuya Matsushima, Hiroki Furuta, Yutaka Matsuo, Ofir Nachum, and Shixiang Gu. Deploymentefficient reinforcement learning via model-based offline optimization. arXiv preprint arXiv:2006.03647, 2020.
+
+Luke Metz, Julian Ibarz, Navdeep Jaitly, and James Davidson. Discrete sequential prediction of continuous actions for deep rl. arXiv preprint arXiv:1705.05035, 2017.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Susan A Murphy, Mark J van der Laan, James M Robins, and Conduct Problems Prevention Research Group. Marginal mean models for dynamic regimes. Journal of the American Statistical Association, 2001.
+
+Ofir Nachum, Mohammad Norouzi, and Dale Schuurmans. Bridging the gap between value and policy based reinforcement learning. In Advances in Neural Information Processing Systems, pp. 2772–2782, 2017.
+
+Ashvin Nair, Murtaza Dalal, Abhishek Gupta, and Sergey Levine. Accelerating online reinforcement learning with offline datasets. arXiv preprint arXiv:2006.09359, 2020.
+
+Jan Peters, Katharina Mulling, and Yasemin Altun. Relative entropy policy search. In Twenty-Fourth AAAI Conference on Artificial Intelligence, 2010.
+
+Doina Precup, Richard S Sutton, and Sanjoy Dasgupta. Off-policy temporal-difference learning with function approximation. In International Conference on Machine Learning, 2001.
+
+Konrad Rawlik, Marc Toussaint, and Sethu Vijayakumar. On stochastic optimal control and reinforcement learning by approximate inference. In Twenty-Third International Joint Conference on Artificial Intelligence, 2013.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. arXiv preprint arXiv:1401.4082, 2014.
+
+Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and struc- ´ tured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, pp. 627–635, 2011.
+
+Reuven Y Rubinstein and Dirk P Kroese. The cross-entropy method: a unified approach to combinatorial optimization, Monte-Carlo simulation and machine learning. Springer Science & Business Media, 2013.
+
+Moonkyung Ryu, Yinlam Chow, Ross Anderson, Christian Tjandraatmadja, and Craig Boutilier. Caql: Continuous action q-learning. arXiv preprint arXiv:1909.12397, 2019.
+
+John Schulman, Sergey Levine, Pieter Abbeel, Michael Jordan, and Philipp Moritz. Trust region policy optimization. In International conference on machine learning, pp. 1889–1897, 2015.
+
+Tom Van de Wiele, David Warde-Farley, Andriy Mnih, and Volodymyr Mnih. Q-learning in enormous action spaces via amortized approximate maximization. arXiv preprint arXiv:2001.08116, 2020.
+
+Hado Van Hasselt, Arthur Guez, and David Silver. Deep reinforcement learning with double qlearning. In Thirtieth AAAI conference on artificial intelligence, 2016.
+
+Lilian Weng. Exploration strategies in deep reinforcement learning, Jun 2020. URL https://lilianweng.github.io/lil-log/2020/06/07/ exploration-strategies-in-deep-reinforcement-learning.html.
+
+Yifan Wu, George Tucker, and Ofir Nachum. Behavior regularized offline reinforcement learning. arXiv preprint arXiv:1911.11361, 2019.
+
+# A PROOFS
+
+All the provided proofs operate under the setting where $\mu ( a | s )$ has full support over the action space. When this assumption is not satisfied, the provided proofs can be transferred by assuming we are operating in a new MDP $M _ { \mu }$ as defined below.
+
+Given the MDP $\begin{array} { c c l } { M } & { = } & { \langle { \mathcal S } , { \mathcal A } , r , { \mathcal P } , \gamma \rangle } \end{array}$ and $\mu ( a | s )$ , let us define the new MDP $\begin{array} { r l } { M _ { \mu } } & { { } = } \end{array}$ $\langle S _ { \mu } , \mathcal { A } _ { \mu } , r , \mathcal { P } , \gamma \rangle$ , where $S _ { \mu }$ denotes the set of reachable states by $\mu$ , and $\mathcal { A } _ { \boldsymbol { \mu } }$ is $\mathcal { A }$ restricted to the support of $\mu ( a | s )$ in each state in $S _ { \mu }$ .
+
+# A.1 CONTRACTION MAPPING
+
+Theorem 3.1. In the tabular setting, for any $N \in \mathbb { N }$ , $\mathcal { T } _ { \mu } ^ { N }$ is a contraction operator in the $\mathcal { L } _ { \infty }$ norm. Hence, with repeated applications of the $\mathcal { T } _ { \mu } ^ { N }$ , any initial $Q$ function converges to a unique fixed point.
+
+Proof. Let $Q _ { 1 }$ and $Q _ { 2 }$ be two arbitrary $Q$ functions.
+
+$$
+\begin{array} { l l } { \displaystyle \left\| { \mathcal T } _ { \mu } ^ { N } Q _ { 1 } - { \mathcal T } _ { \mu } ^ { N } Q _ { 2 } \right\| _ { \infty } = } & { ( 1 1 \nu , \forall \mathbf { x } , t _ { \infty } ) } \\ { \displaystyle \operatorname* { m a x } _ { s , a } \left. \left( r ( s , a ) + \gamma \cdot { \mathbb E } _ { s ^ { \prime } } { \mathbb E } _ { \left\{ a _ { i } \right\} ^ { N } } \left[ \operatorname* { m a x } _ { \left\{ a _ { i } \right\} ^ { N } } Q _ { 1 } ( s ^ { \prime } , a ^ { \prime } ) \right] \right) - \left( r ( s , a ) + \gamma \cdot { \mathbb E } _ { s ^ { \prime } } { \mathbb E } _ { \left\{ a _ { i } \right\} ^ { N } } \left[ \operatorname* { m a x } _ { \left\{ a _ { i } \right\} ^ { N } } Q _ { 2 } ( s ^ { \prime } , a ^ { \prime } ) \right] \right) \right) } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \gamma \cdot \underset { s , a } { \operatorname* { m a x } } \left| { \mathbb { E } } _ { s ^ { \prime } } { \mathbb { E } } _ { \{ a _ { i } \} ^ { N } } \left[ \underset { \{ a _ { i } \} ^ { N } } { \operatorname* { m a x } } Q _ { 1 } ( s ^ { \prime } , a ^ { \prime } ) - \underset { \{ a _ { i } \} ^ { N } } { \operatorname* { m a x } } Q _ { 2 } ( s ^ { \prime } , a ^ { \prime } ) \right] \right| \leq } \\ & { \gamma \cdot \underset { s , a } { \operatorname* { m a x } } { \mathbb { E } } _ { s ^ { \prime } } { \mathbb { E } } _ { \{ a _ { i } \} ^ { N } } \left| \underset { \{ a _ { i } \} ^ { N } } { \operatorname* { m a x } } Q _ { 1 } ( s ^ { \prime } , a ^ { \prime } ) - \underset { \{ a _ { i } \} ^ { N } } { \operatorname* { m a x } } Q _ { 2 } ( s ^ { \prime } , a ^ { \prime } ) \right| \leq } \\ & { \gamma \cdot \underset { s , a } { \operatorname* { m a x } } { \mathbb { E } } _ { s ^ { \prime } } { \mathbb { E } } _ { \{ a _ { i } \} ^ { N } } \left\| Q _ { 1 } - Q _ { 2 } \right\| _ { \infty } = } \\ & { \gamma \cdot \left\| Q _ { 1 } - Q _ { 2 } \right\| _ { \infty } } \end{array}
+$$
+
+where line 15 is due to the following: Let $\hat { a } = \arg \operatorname* { m a x } _ { \{ a _ { i } \} ^ { N } } Q _ { 1 } ( s ^ { \prime } , a _ { i } ) ,$
+
+$$
+\begin{array} { r l } & { \underset { \{ a _ { i } \} ^ { N } } { \operatorname* { m a x } } Q _ { 1 } ( s ^ { \prime } , a ^ { \prime } ) - \underset { \{ a _ { i } \} ^ { N } } { \operatorname* { m a x } } Q _ { 2 } ( s ^ { \prime } , a ^ { \prime } ) = Q _ { 1 } ( s ^ { \prime } , \hat { a } ) - \underset { \{ a _ { i } \} ^ { N } } { \operatorname* { m a x } } Q _ { 2 } ( s ^ { \prime } , a ^ { \prime } ) } \\ & { \qquad \leq Q _ { 1 } ( s ^ { \prime } , \hat { a } ) - Q _ { 2 } ( s ^ { \prime } , \hat { a } ) } \\ & { \qquad \leq \left\| Q _ { 1 } - Q _ { 2 } \right\| _ { \infty } } \end{array}
+$$
+
+# A.2 LIMITING BEHAVIOR
+
+Theorem 3.3. Let $\pi _ { \mu } ^ { \ast }$ denote the optimal policy from the class of policies whose actions are restricted to lie within the support of the policy $\mu ( a | s )$ . Let $Q _ { \mu } ^ { \ast }$ denote the $Q$ -value function corresponding to $\pi _ { \mu } ^ { \ast }$ . Furthermore, let $Q _ { \mu }$ denote the $Q$ -value function of the policy $\mu ( a | s )$ . Let $\begin{array} { r } { \mu ^ { * } ( s ) : = \int _ { S u p p o r t ( \pi _ { \mu } ^ { * } ( a \left| s ) ) \right|} \mu ( a  s ) } \end{array}$ denote the probability of optimal actions under $\mu ( a | s )$ . Under the assumption that i $\operatorname* { i n f } _ { s } \mu ^ { * } ( s ) > 0$ and $r ( s , a )$ , we have that,
+
+$$
+Q _ { \mu } ^ { 1 } = Q _ { \mu } \qquad a n d \qquad \operatorname * { l i m } _ { N \to \infty } Q _ { \mu } ^ { N } = Q _ { \mu } ^ { * }
+$$
+
+Let $\begin{array} { r } { \mu ^ { * } ( s ) : = \int _ { \mathrm { S u p p o r t } ( \pi _ { \mu } ^ { * } ( a | s ) ) } \mu ( a | s ) } \end{array}$ denote the probability of optimal actions under $\mu ( a | s )$ . To show $\mathrm { l i m } _ { N \to \infty } Q _ { \mu } ^ { N } = Q _ { \mu } ^ { * }$ , we also require the additional assumption that $\operatorname* { i n f } _ { s } \mu ^ { * } ( s ) > 0$ .
+
+Proof. Given that,
+
+$$
+\begin{array} { r } { \mathcal { T } _ { \mu } ^ { 1 } Q ( s , a ) : = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { \{ a _ { i } \} ^ { N } \sim \mu ( \cdot \vert s ^ { \prime } ) } \left[ Q ( s ^ { \prime } , a ^ { \prime } ) \right] } \end{array}
+$$
+
+the unique fixed-point of $\mathcal { T } _ { \mu } ^ { 1 }$ is the Q-value function of the policy $\mu ( a | s )$ . Hence $Q _ { \mu } ^ { 1 } = Q _ { \mu }$
+
+The second part of this theorem will be proven as a Corollary to Theorem 3.5
+
+# A.3 INCREASINGLY BETTER POLICIES
+
+Theorem 3.4. For all $N , M \in \mathbb { N } ,$ , where $N > M$ , we have that $\forall s \in S , \forall a \in \operatorname { S u p p o r t } ( \mu ( \cdot | s ) )$ , $Q _ { \mu } ^ { N } ( s , a ) \geq Q _ { \mu } ^ { M } ( s , a ) .$ . Hence, $\pi _ { \mu } ^ { N } ( a | s )$ is at least as good of a policy as $\pi _ { \mu } ^ { M } ( a | s )$ .
+
+Proof. It is sufficient to show that $\forall s , a , Q _ { \mu } ^ { N + 1 } ( s , a ) \geq Q _ { \mu } ^ { N } ( s , a )$ . We will do so by induction. Let $Q ^ { i }$ denote the resulting function after applying $\mathcal { T } _ { \mu } ^ { N + 1 }$ , $i$ times, starting from $Q _ { \mu } ^ { N }$ .
+
+# Base Case
+
+By definition $Q ^ { 0 } : = Q _ { \mu } ^ { N }$ . Let $s \in \mathcal S , a \in \mathcal A$
+
+$$
+\begin{array} { r l } & { Q ^ { 1 } ( s , a ) = { \mathcal T } _ { \mu } ^ { N + 1 } Q ^ { 0 } ( s , a ) } \\ & { \qquad = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { \{ a _ { \pm } \} ^ { N + 1 } \sim \mu ( a ^ { \prime } \mid s ^ { \prime } ) } \big [ \operatorname* { m a x } _ { \{ a _ { \pm } \} ^ { N + 1 } } Q ^ { 0 } ( s ^ { \prime } , a ^ { \prime } ) \big ] } \\ & { \qquad \geq r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { \{ a _ { \pm } \} ^ { N } \sim \mu ( a ^ { \prime } \mid s ^ { \prime } ) } \big [ \operatorname* { m a x } _ { \{ a _ { \pm } \} ^ { N } } Q ^ { 0 } ( s ^ { \prime } , a ^ { \prime } ) \big ] } \\ & { \qquad = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { \{ a _ { \pm } \} ^ { N } \sim \mu ( a ^ { \prime } \mid s ^ { \prime } ) } \big [ \operatorname* { m a x } _ { \{ a _ { \pm } \} ^ { N } } Q _ { \mu } ^ { N } ( s ^ { \prime } , a ^ { \prime } ) \big ] } \\ & { \qquad = Q _ { \mu } ^ { N } ( s , a ) } \\ & { \qquad = Q ^ { 0 } ( s , a ) } \end{array}
+$$
+
+Induction Step
+
+Assume $\forall s , a , Q ^ { i } ( s , a ) \geq Q ^ { i - 1 } ( s , a )$ .
+
+$$
+\begin{array} { r l r } { Q ^ { i + 1 } ( s , a ) - Q ^ { i } ( s , a ) = \mathcal { T } _ { \mu } ^ { N + 1 } Q ^ { i } ( s , a ) - \mathcal { T } _ { \mu } ^ { N + 1 } Q ^ { i - 1 } ( s , a ) } & { ( a ) } & { \mathrm { ~ ( ~ s ~ o ~ r ~ } ) } \\ { \ } & { = \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { \{ a _ { i } \} ^ { N + 1 } \sim \mu ( a ^ { \prime } \mid s ^ { \prime } ) } \big [ \underset { \{ a _ { i } \} ^ { N + 1 } } { \operatorname* { m a x } } Q ^ { i } ( s ^ { \prime } , a ^ { \prime } ) - \underset { \{ a _ { i } \} ^ { N + 1 } } { \operatorname* { m a x } } Q ^ { i - 1 } ( s ^ { \prime } , a ^ { \prime } ) \big ] } & { ( a ) } & { ( a ) } \\ { \ } & { \mathrm { ~ ( ~ s ~ o ~ r ~ } ) } & { ( a ) } \\ { \ } & { \geq 0 } & { ( a ) } & { ( a ) } \end{array}
+$$
+
+Hence, by induction we have to $\forall i , j , i > j \implies \forall s , a , Q ^ { i } ( s , a ) \geq Q ^ { j } ( s , a )$ . Since $Q ^ { 0 } = Q _ { \mu } ^ { N }$ and $\begin{array} { r } { \operatorname* { l i m } _ { i \to \infty } Q ^ { i } = Q _ { \mu } ^ { N + 1 } } \end{array}$ , we have than $\forall s , a , Q _ { \mu } ^ { N + 1 } ( s , a ) \geq Q _ { \mu } ^ { N } ( s , a )$ . Thus $\pi _ { \mu } ^ { N + 1 }$ is a better policy than $\pi _ { \mu } ^ { N }$ , and by a simple induction argument, $\pi _ { \mu } ^ { N }$ is a better policy than $\pi _ { \mu } ^ { M }$ when $N > M$ .
+
+# A.4 BOUNDS
+
+Theorem 3.5. For $s \in S$ let,
+
+$$
+\Delta ( s ) = \operatorname* { m a x } _ { a \in \mathrm { S u p p o r t } ( \mu ( \cdot | s ) ) } Q _ { \mu } ^ { * } ( s , a ) - \mathbb { E } _ { \{ a _ { i } \} ^ { N } \sim \mu ( \cdot | s ) } [ \operatorname* { m a x } _ { b \in \{ a _ { i } \} ^ { N } } Q _ { \mu } ^ { * } ( s , b ) ]
+$$
+
+The suboptimality of $Q _ { \mu } ^ { N }$ can be upperbounded as follows,
+
+$$
+\bigl \| Q _ { \mu } ^ { N } - Q _ { \mu } ^ { * } \bigr \| _ { \infty } \leq \frac { \gamma } { 1 - \gamma } \operatorname* { m a x } _ { s , a } \mathbb { E } _ { s ^ { \prime } } \Bigl [ \Delta ( s ^ { \prime } ) \Bigr ] \leq \frac { \gamma } { 1 - \gamma } \operatorname* { m a x } _ { s } \Delta ( s )
+$$
+
+The same also holds when $Q _ { \mu } ^ { * }$ is replaced with $Q _ { \mu } ^ { N }$ in the definition of $\Delta$ .
+
+Proof. The two versions where $\Delta ( s )$ is defined in terms of $Q _ { \mu } ^ { N }$ and $Q _ { \mu } ^ { * }$ have very similar proofs.
+
+Version with $Q _ { \mu } ^ { N }$
+
+Let $\mathcal { T } ^ { Q L }$ denote the backup operation in $Q$ -Learning. Let $( \mathcal T ^ { Q L } ) ^ { m } = \mathcal T ^ { Q L } \circ \mathcal T ^ { Q L } \circ \ldots \circ \mathcal T ^ { Q L }$ . We {zm times know the following statements to be true:
+
+$$
+\begin{array} { r l } & { Q _ { \mu } ^ { N } = \mathcal { T } _ { \mu } ^ { N } Q _ { \mu } ^ { N } = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \mathbb { E } _ { \{ a _ { i } \} ^ { N } \sim \mu ( a ^ { \prime } | s ^ { \prime } ) } \big [ \underset { \{ a _ { i } \} ^ { N } } { \operatorname* { m a x } } Q _ { \mu } ^ { N } ( s ^ { \prime } , a ^ { \prime } ) \big ] } \\ & { \mathcal { T } ^ { Q L } Q _ { \mu } ^ { N } = r ( s , a ) + \gamma \cdot \mathbb { E } _ { s ^ { \prime } } \underset { a ^ { \prime } } { \operatorname* { m a x } } Q _ { \mu } ^ { N } ( s ^ { \prime } , a ^ { \prime } ) } \\ & { \underset { \{ m  \infty } } { \operatorname* { l i m } } ( \mathcal { T } ^ { Q L } ) ^ { m } Q _ { \mu } ^ { N } = Q ^ { \ast }  \\ & { \big \| ( \mathcal { T } ^ { Q L } ) ^ { m + 2 } Q _ { \mu } ^ { N } - ( \mathcal { T } ^ { Q L } ) ^ { m + 1 } Q _ { \mu } ^ { N } \big \| _ { \infty } \leq \gamma \cdot \big \| ( \mathcal { T } ^ { Q L } ) ^ { m + 1 } Q _ { \mu } ^ { N } - ( \mathcal { T } ^ { Q L } ) ^ { m } Q _ { \mu } ^ { N } \big \| _ { \infty } } \\ & { \big \| ( \mathcal { T } ^ { Q L } ) ^ { m + 1 } Q _ { \mu } ^ { N } - ( \mathcal { T } ^ { Q L } ) ^ { m } Q _ { \mu } ^ { N } \big \| _ { \infty } \leq \gamma ^ { m } \cdot \big \| \mathcal { T } ^ { Q L } Q _ { \mu } ^ { N } - Q _ { \mu } ^ { N } \big \| _ { \infty } } \end{array}
+$$
+
+Putting these together we have that,
+
+$$
+\begin{array} { r l } { \| Q _ { p } ^ { N } - Q ^ { * } \| _ { \infty } } & { \leq \displaystyle \sum _ { i = 0 } ^ { \infty } \| ( 7 ^ { 2 } E ^ { 2 } ) ^ { n + 1 } Q _ { p } ^ { N } - ( 7 ^ { 0 } E ^ { 2 } ) ^ { n } Q _ { i } ^ { N } \| _ { \infty } } \\ & { \leq \displaystyle \sum _ { i = 0 } ^ { \infty } \gamma ^ { n + 1 } \| T ^ { 2 } E ^ { 2 } Q _ { p } ^ { N } - Q _ { p } ^ { N } \| _ { \infty } } \\ & { - \displaystyle \sum _ { i = 1 } ^ { \infty } \| T ^ { 2 } e ^ { 2 \theta } Q _ { p } ^ { N } \| _ { \infty } } \\ & { = \displaystyle \frac { 1 } { 1 - \frac { 1 } { 2 } } \frac { 1 } { | \alpha _ { 0 } | } \left[ ( 5 ^ { 0 } \alpha _ { 0 } ^ { 3 } ) \Big | \Big ( Y ^ { 1 } ( \alpha _ { 0 } ^ { 3 } ) + \frac { 1 } { 2 } \gamma \cdot \mathbb { E } _ { \alpha _ { 0 } ^ { 3 } } \frac { \cos { ( B _ { 0 } ^ { N } / \varepsilon ) } } { \sin \alpha _ { 0 } ^ { 3 } } \Big ) \right. } \\ & { \qquad \left. - \left( \Gamma ( \varepsilon ^ { 0 } , \alpha ) + \gamma \cdot \mathbb { E } _ { \alpha _ { 0 } ^ { 3 } } \frac { \cos { ( B _ { 0 } ^ { N } / \varepsilon ) } } { | \alpha _ { 0 } ^ { 3 } - \alpha | ^ { 3 } } \Big ) \frac { \sin { ( B _ { 0 } ^ { N } / \varepsilon ) } ^ { 2 } ( \beta _ { 0 } ^ { 3 } ) } { | \alpha _ { 0 } ^ { 3 } - \alpha | ^ { 3 } } \right] \right\| } \\ &  = \displaystyle \frac { \gamma } { 1 - \frac { 3 } { 2 } } \frac  \sin { ( B _ { 0 } ^ { N } / \varepsilon ) } \left[ \sin { ( B _ { 0 } ^ { N } / \varepsilon ^ { \prime } ) } - \sin { ( B _ { 0 } ^ { N } / \varepsilon ) } \sin { ( B _ { 0 } ^ { N } / \varepsilon ) } \sin { ( B _ { 0 } ^ { N } / \varepsilon ^ { \prime } ) } \right] \frac { \sin { ( B _ { 0 } ^ { N } / \varepsilon ^ { \prime } ) } ^ { 2 } } { | \alpha _ { 0 } ^ { 3 } - \alpha | ^ { 3 } } \rho _ { \alpha } ^ { N } ( \varepsilon ^ { \prime } )  \end{array}
+$$
+
+Version with $Q _ { \mu } ^ { * }$
+
+Very similarly we have,
+
+$$
+\begin{array} { r l } { \| Q _ { \nu } ^ { \nu } - Q ^ { * } \| _ { \infty } \leq } & { \displaystyle \sum _ { n = 0 } ^ { \infty } \| ( f _ { \nu } ^ { ( X _ { n } ) n + 1 } Q ^ { * } - ( f _ { \nu } ^ { ( X _ { n } ) n } ) ^ { n } Q ^ { * } \| _ { \infty } } \\ & { \leq \displaystyle \sum _ { n = 0 } ^ { \infty } \gamma ^ { n } \cdot \| T _ { \nu } ^ { ( X _ { n } ) n } Q ^ { * } - Q ^ { * } \| _ { \infty } } \\ & { = - \displaystyle \sum _ { 1 = \gamma } ^ { \infty } \| Q ^ { * } \ \gamma ^ { ( X _ { n } ) } Q ^ { * } \| _ { \infty } } \\ & { = \frac { 1 } { 1 - \gamma } \displaystyle \sum _ { n = 0 } ^ { \infty } \bigg \| \bigg ( f ( c ^ { ( X _ { n } ) n } + 7 \cdot \mathbb { E } _ { c } \cdot \operatorname* { m a x } _ { \theta \leq t } Q ^ { * } ( \nu ^ { ( X _ { n } ) n } , \theta ) \bigg ) } \\ & { \qquad - \left( f ( c ^ { ( X _ { n } ) n } + 7 \cdot \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \cdot \operatorname* { m a x } _ { \theta \leq t } ( \nu ^ { ( X _ { n } ) n } \log \mathbb { R } ^ { ( \theta _ { \theta } ) } , \theta ^ { * } ) \right) \bigg ) } \\ & { = - \frac { \gamma } { 1 - \gamma } \displaystyle \sum _ { n = 0 } ^ { \infty } \| Q ^ { * } \| _ { \infty } \mathbb { E } \cdot \Big [ \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \Big ( \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \Big ( \nu ^ { ( X _ { n } ) n } \Big ) \Big \| _ { \mathbb { R } ^ { 2 } } Q ^ { * } \Big ( \nu ^ { ( X _ { n } ) n } , \theta \Big ) \Big ] } \\ &  = \frac { \gamma } { 1 - \gamma } \displaystyle \sum _ { n = 0 } ^ { \infty } \mathbb { E } \cdot \Big [ \mathbb { E } _ { c } \Big ( \mathbb { E } _ { c } \cdot \mathbb { E } _ { c } \cdot Q ^ { * } \Big ( \nu ^ { ( X _ { n } ) n } \Big ) \end{array}
+$$
+
+Corollary A.1. Let $V _ { \mu } , Q _ { \mu } , A _ { \mu }$ denote the value, $Q _ { i }$ , and advantage functions of $\mu$ respectively. When $N = 1$ we have that,
+
+$$
+\begin{array} { r l } & { \| Q _ { \mu } - Q ^ { * } \| _ { \infty } \leq \frac { \gamma } { 1 - \gamma } \underset { s ^ { \prime } } { \operatorname* { m a x } } \left| \underset { a ^ { \prime } } { \operatorname* { m a x } } Q _ { \mu } ( s ^ { \prime } , a ^ { \prime } ) - \mathbb { E } _ { a ^ { \prime } \sim \mu ( a ^ { \prime } | s ^ { \prime } ) } [ Q _ { \mu } ( s ^ { \prime } , a ^ { \prime } ) ] \right| } \\ & { \qquad = \frac { \gamma } { 1 - \gamma } \underset { s ^ { \prime } } { \operatorname* { m a x } } \left| \underset { a ^ { \prime } } { \operatorname* { m a x } } Q _ { \mu } ( s ^ { \prime } , a ^ { \prime } ) - V _ { \mu } ( s ^ { \prime } ) \right| } \\ & { \qquad = \frac { \gamma } { 1 - \gamma } \underset { s ^ { \prime } , a ^ { \prime } } { \operatorname* { m a x } } A _ { \mu } ( s ^ { \prime } , a ^ { \prime } ) } \end{array}
+$$
+
+It is interesting how the sub-optimality can be upper-bounded in terms of a policy’s own advantage function.
+
+# Corollary A.2. (Proof for second part of Theorem 3.3)
+
+Proof. We want to show $\mathrm { l i m } _ { N \to \infty } Q _ { \mu } ^ { N } = Q ^ { * }$ . More exactly, what we seek to show is the following,
+
+$$
+\operatorname* { l i m } _ { N \to \infty } \left\| Q _ { \mu } ^ { N } - Q ^ { * } \right\| _ { \infty } = 0
+$$
+
+or,
+
+$$
+\forall \epsilon > 0 , \exists N , \mathrm { ~ s . t . ~ } \forall M \ge N , \left\| Q _ { \mu } ^ { N } - Q ^ { * } \right\| _ { \infty } < \epsilon
+$$
+
+Let $\epsilon > 0$ . Recall,
+
+$$
+\Delta ( s ) = \operatorname* { m a x } _ { a \in \mathrm { S u p p o r t } ( \mu ( \cdot | s ) ) } Q _ { \mu } ^ { * } ( s , a ) - \mathbb { E } _ { \{ a _ { i } \} ^ { N } \sim \mu ( \cdot | s ) } [ \operatorname* { m a x } _ { b \in \{ a _ { i } \} ^ { N } } Q _ { \mu } ^ { * } ( s , b ) ]
+$$
+
+Let $\operatorname* { i n f } _ { s } \mu ^ { * } ( s ) = p > 0$ . Let the lower and upper bounds of rewards be $\ell$ and $L$ , and let $\begin{array} { r } { \alpha = \frac { 1 } { 1 - \gamma } \ell } \end{array}$ and $\begin{array} { r } { \beta = \frac { 1 } { 1 - \gamma } L } \end{array}$ . We have that,
+
+$$
+\mathbb { E } _ { \{ a _ { i } \} ^ { N } \sim \mu ( \cdot \vert s ) } [ \operatorname* { m a x } _ { b \in \{ a _ { i } \} ^ { N } } Q _ { \mu } ^ { * } ( s , b ) ] \geq ( 1 - p ) ^ { N } \cdot \alpha + ( 1 - ( 1 - p ) ^ { N } ) \cdot \operatorname* { m a x } _ { a \in \mathrm { S u p p o r } ( \mu ( \cdot \vert s ) ) } Q _ { \mu } ^ { * } ( s , a )
+$$
+
+Hence $\forall s$
+
+$$
+\begin{array} { r l } & { \Delta ( s ) \leq ( 1 - p ) ^ { N } \cdot \underset { a \in \mathrm { { S u p p o r t } } ( \mu ( \cdot | s ) ) } { \operatorname* { m a x } } Q _ { \mu } ^ { * } ( s , a ) - ( 1 - p ) ^ { N } \cdot \alpha } \\ & { \qquad = ( 1 - p ) ^ { N } \cdot \Big ( \underset { a \in \mathrm { { S u p p o r t } } ( \mu ( \cdot | s ) ) } { \operatorname* { m a x } } Q _ { \mu } ^ { * } ( s , a ) - \alpha \Big ) } \\ & { \qquad \leq ( 1 - p ) ^ { N } \cdot \Big ( \beta - \alpha \Big ) } \end{array}
+$$
+
+Thus, for large enough $N$ we have that,
+
+$$
+\left\| Q _ { \mu } ^ { N } - Q _ { \mu } ^ { * } \right\| _ { \infty } \leq \frac { \gamma } { 1 - \gamma } \operatorname* { m a x } _ { s } \Delta ( s ) < \epsilon
+$$
+
+concluding the proof.
+
+# B AUTOREGRESSIVE GENERATIVE MODEL
+
+The architecture for our autoregressive generative model is inspired by the works of (Metz et al., 2017; Van de Wiele et al., 2020; Germain et al., 2015). Given a state-action pair from the dataset $( s , a )$ , first an MLP produces a $d$ -dimensional embedding for $s$ , which we will denote by $h$ . Below, we use the notation $a _ { i }$ to denote the $i ^ { t h }$ index of $a$ , and $a _ { [ : i ] }$ to represent a slice from first up to and not including the $i ^ { t h }$ index, where indexing begins at 0. We use a discretization in each action dimension. Thus, we discretize the range of each action dimension into $N$ uniformly sized bins, and represent $a$ by the labels of the bins. Let $\ell _ { i }$ denote the label of the $i ^ { t h }$ action index.
+
+Training We use separate MLPs per action dimension. Each MLP takes in the $d$ -dimensional state embedding and ground-truth actions before that index, and outputs $N$ logits for the choice over bins. The probability of a given index’s label is given by,
+
+$$
+p ( \ell _ { i } | s , a [ : i ] ) = \mathrm { S o f t M a x } \Big ( \mathbf { M L P } _ { i } ( d , a [ : i ] ) \Big ) \left[ \ell _ { i } \right]
+$$
+
+We use standard maximum-likelihood training (i.e. cross-entropy loss).
+
+Sampling Given a state $s$ , to sample an action we again embed the state, and sample the action indices one-by-one.
+
+$$
+\begin{array} { r l } & { p ( \ell _ { 0 } | s ) = \mathrm { S o f t M a x } \Big ( \mathrm { M L P } _ { i } ( d ) \Big ) \left[ \ell _ { 0 } \right] } \\ & { \ell _ { 0 } \sim p ( \ell _ { 0 } | s ) , a _ { 0 } \sim \mathrm { U n i f o r m } \big ( \mathrm { B i n c o r r e s p o n d i n g t o } \ell _ { 0 } \big ) } \\ & { p ( \ell _ { i } | s ) = \mathrm { S o f t M a x } \Big ( \mathrm { M L P } _ { i } ( d , a [ : i ] ) \Big ) \left[ \ell _ { i } \right] } \\ & { \ell _ { i } \sim p ( \ell _ { i } | s , a [ : i ] ) , a _ { i } \sim \mathrm { U n i f o r m } \big ( \mathrm { B i n c o r r e s p o n d i n g t o } \ell _ { i } \big ) } \end{array}
+$$
+
+# C ALGORITHM BOX
+
+# Algorithm 2: Full EMaQ Training Algorithm
+
+Offline dataset $\mathcal { D }$ , Pretrain $\mu ( a | s )$ on $\mathcal { D }$   
+Initialize $K$ Q functions with parameters $\theta _ { i }$ , and $K$ target $\mathrm { Q }$ functions with parameters $\theta _ { i } ^ { \mathrm { t a r g e t } }$   
+Ensemble parameter $\lambda$ , Exponential moving average parameter $\alpha$
+
+Function Ensemble(values):
+
+\*/
+
+while not converged do
+
+$$
+\begin{array} { r l } & { \mathcal { L } ( \boldsymbol { \theta } _ { i } ) = \sum _ { m } \Big ( Q _ { i } ( s _ { m } , a _ { m } ) - y _ { \mathrm { t a r g e t } } ( s _ { m } , a _ { m } , s _ { m } ^ { \prime } , r _ { m } , t _ { m } ) \Big ) ^ { 2 } } \\ & { \theta _ { i }  \theta _ { i } - \mathrm { \normalfont ~ \mathscr { A } \mathrm { d } a m U p d a t e } \Big ( \mathcal { L } ( \boldsymbol { \theta } _ { i } ) , \theta _ { i } \Big ) } \\ & { \theta _ { i } ^ { \mathrm { t a r g e t } }  \alpha \cdot \theta _ { i } ^ { \mathrm { t a r g e t } } + ( 1 - \alpha ) \cdot \theta _ { i } } \end{array}
+$$
+
+# D INCONCLUSIVE EXPERIMENTS
+
+# D.1 UPDATING THE PROPOSAL DISTRIBUTION
+
+Akin to the work of (Van de Wiele et al., 2020), we considered maintaining a second proposal distribution $\tilde { \mu }$ that is updated to distill arg $\operatorname* { m a x } _ { \{ a _ { i } \} ^ { N } } Q ( s , a )$ , and sampling from the mixture of $\mu$ and $\tilde { \mu }$ . In our experiments however, we did not observe noticeabel gains. This may potentially be due to the relative simplicity of the Mujoco benchmark domains, and may become more important in more challenging domains with more uniformly distributed $\mu ( a | s )$ .
+
+# E LAUNDRY LIST
+
+• Autoregressive models are slow to generate samples from and EMaQ needs to take many samples, so it was slower to train than the alternative methods. However, this may be addressed by better generative models and engineering effort.
+
+# F ONLINE RL
+
+EMaQ is also applicable to online RL setting. Combining strong offline RL methods with good exploration policies has the potential for producing highly sample-efficient online RL algorithms. Concretely, we refer to online RL as the setting where iteratively, a batch of $M$ environment steps with an exploration policy are interleaved with $M$ RL updates (Levine et al., 2020; Matsushima et al., 2020).
+
+EMaQ is designed to remain within the support of the provided training distribution. This however, is problematic for online RL which requires good exploration interleaved with RL updates. To this end, first, we modify our autoregressive proposal distribution $\mu ( a | s )$ by dividing the logits of all softmaxes by $\tau > 1$ . This has the effect of smoothing the $\mu ( a | s )$ distribution, and increasing the probability of sampling actions from the low-density regions and the boundaries of the support. Given this online proposal distribution, a criteria is required by which to choose amongst sampled actions. While there exists a rich literature on how to design effective RL exploration policies (Weng, 2020), in this work we used a simple UCB-style exploration criterion (Chen et al., 2017) as follows:
+
+$$
+Q ^ { \mathrm { e x p l o r e } } ( s , a ) = \mathrm { m e a n } \Big ( \{ Q _ { i } ( s , a ) \} _ { K } \Big ) + \beta \cdot \mathrm { s t d } \Big ( \{ Q _ { i } ( s , a ) \} _ { K } \Big )
+$$
+
+Given $N$ sampled actions from the modified proposal distribution, we take the action with highest $Q ^ { \mathrm { e x p l o r e } }$ .
+
+We compare the online variant of EMaQ with entropy-constrained Soft Actor Critic (SAC) with automatic tuning of the temperature parameter (Haarnoja et al., 2018). For EMaQ we swept the temperatures and used a fixed bin size of 40, 8 Q-function ensembles and $N = 2 0 0$ . For fairness of comparisons, we also ran SAC with similar sweeps over different collection batch sizes and number of Q-function ensembles. In the fully online setting (trajectory batch size 1, Figure 3a), EMaQ is already competitive with SAC, and more excitingly, in the deployment-efficient setting3 (trajectory batch size 50K, Figure 3b), EMaQ can outperform $\mathsf { S A C ^ { 4 } }$ . Figures 4 and 5 present the results for all hyperparameter settings, for SAC and EMaQ, in the batch size 1 and batch size $5 0 K$ settings respectively. In the fully online setting, EMaQ is already competitive with SAC, and more excitingly, in the deployment-efficient setting, EMaQ can outperform SAC.
+
+# G OFFLINE RL EXPERIMENTAL DETAILS
+
+For each environment and data setting, we train an autoregressive model – as described above – on the provided data with 2 random seeds. These generative models are then frozen, and used by the downstream algorithms (EMaQ, BEAR, and BCQ) as the base behavior policy $( \mu ( a | s )$ in $\mathrm { E M a O } ) ^ { 5 }$ .
+
+# G.1 COMPARING OFFLINE RL METHODS
+
+Following the bechmarking efforts of (Wu et al., 2019), the range of clipping factor considered for BCQ was $\Phi \in \{ 0 . 0 0 5 , 0 . 0 \hat { 1 } 5 , 0 . 0 5 , 0 . 1 5 , 0 . 5 \}$ , and the range of target divergence value considered for BEAR was $\epsilon \in \{ 0 . 0 1 5 , 0 . 0 5 , 0 . 1 5 , 0 . 5 , 1 . 5 \}$ . For both methods, the larger the value of the hyperparameter is, the more the learned policy is allowed to deviate from the $\bar { \mu ( a | s ) }$ .
+
+The rest of the hyperparameters use can be found in Table 2. The autoregressive models have the following architecture sizes (refer to Appendix B for description of the models used). The state embedding MLP consists of 2 hidden layers of dimension 750 with relu activations, followed by a linear embedding into a 750 dimensional state representation. The individual MLP for each action dimension consist of 3 hidden layers of dimension 256 with relu activations. Each action dimension is discretized into 40 equally sized bins.
+
+![](images/6e1bd454c9e7a14595daa50f90ae0313c2e11dfee7cd082b3c458ed764a05509.jpg)
+
+(a) SAC vs. EMaQ, Trajectory Batch Size 1: For easier visual interpretration we plot a single hyperparameter setting of EMaQ that tended to perform well across the 4 domains considered. The hyperparameters considered were $N = 2 0 0$ , $\lambda = 1 . 0$ , $\beta = 1 . 0$ , $\tau \in \{ 1 , 5 , 1 0 , 2 0 \}$ . SAC performed worse when using 8 Q-functions as in EMaQ. $_ \textrm { x }$ -axis unit is 1 million environment steps.
+
+![](images/492575c473846c45cfb884ceba5fc88c3575e4c3cd69cddce6bc67e474c64cbf.jpg)
+
+(b) SAC vs. EMaQ, Trajectory Batch Size 50K: For easier visual interpretration we plot a single hyperparameter setting of EMaQ that tended to perform well across the 4 domains considered. The hyperparameters considered were $N = 2 0 0$ , $\lambda \in \{ 0 . 7 5 , \bar { 1 . 0 } \}$ , $\beta \in \{ 0 . 1 , 1 . 0 \}$ , $\tau \in \{ 1 , 5 , 1 0 , 2 0 \}$ . $_ \textrm { x }$ -axis unit is 1 million environment steps.
+
+![](images/b2ac29ecb77d51fd37fc9c31530bfc6e39e91101beddedc7f691f64b475d26a0.jpg)  
+Figure 3: Online RL results under different trajectory batch sizes.   
+Figure 4: All results for batch size 1
+
+# G.2 EMAQ ABLATION EXPERIMENT
+
+Hyperparameters are identical to those in Table 2, except batch size is 100 and number of updates is 500K.
+
+# G.3 DETAILS FOR TABLE ?? EXPERIMENTS
+
+Generative Model The generative models used are almost identical to the description in Appendix B, with a slight modification that $\mathbf { M L P } _ { i } ( d , a [ : i ] )$ is replace with $\begin{array} { r l } { \mathbf { M L P } _ { i } ( d , \mathrm { L i n } _ { i } ( a [ : i ] ) ) } & { { } } \end{array}$ where $\operatorname { L i n } _ { i }$ is a linear transformation. This change was not necessary for good performance; it was as architectural detail that we experimented with and did not revert prior generating Table ??. The model dimensions for each domain are shown in 3 in the following format (state embedding MLP hidden size, state embedding MLP number of layers, action MLP hidden size, action MLP number of layers, Ouput size of $\operatorname { L i n } _ { i }$ , number of bins for action discretization). Increasing the number of discretization bins from 40 (value for standard Mujoco experiments) to 80 was the most important change. Output dimension of state-embedding MLP is the same as the hidden size.
+
+![](images/6cb95b03fbb363d41605c153e2e6cd9cf5290617a882edb2cbae6a603de6766c.jpg)  
+Figure 5: All results for batch size 50K
+
+Table 2: Hyperparameters for Mujoco Experiments   
+
+<table><tr><td rowspan=1 colspan=2>Shared Hyperparameters</td></tr><tr><td rowspan=1 colspan=1>入Batch SizeNum UpdatesNum Q FunctionsQ Architectureμlrα</td><td rowspan=1 colspan=1>1.02561e68MLP,3layers,75O hid dim,relu5e-40.995</td></tr><tr><td rowspan=1 colspan=1>EMa0</td><td rowspan=1 colspan=1>EMaQHyperparameters</td></tr><tr><td rowspan=1 colspan=1>Qlr</td><td rowspan=1 colspan=1>1e-4</td></tr><tr><td rowspan=1 colspan=1>BEA】</td><td rowspan=1 colspan=1>BEARHyperparameters</td></tr><tr><td rowspan=1 colspan=1>πArchitectureQlrπlr</td><td rowspan=1 colspan=1>MLP,3layers,750 hid dim,relu1e-33e-5</td></tr><tr><td rowspan=1 colspan=1>（BCQ</td><td rowspan=1 colspan=1>BCQHyperparameters</td></tr><tr><td rowspan=1 colspan=1>πArchitectureQlrπlr</td><td rowspan=1 colspan=1>MLP,3layers,750 hiddim,relu1e-45e-4</td></tr></table>
+
+Hyperparameters Table 3 shows the hyperparameters used for the experiments in Table ??.   
+Table 3: Hyperparameters for Table 1 Experiments   
+
+<table><tr><td rowspan=1 colspan=2>Shared Hyperparameters</td></tr><tr><td rowspan=1 colspan=1>入Batch SizeNum UpdatesNum Q FunctionsQ ArchitectureαμlrKitchen μ Arch ParamsAntmaze μ Arch ParamsAdroit μ Arch Params</td><td rowspan=1 colspan=1>1.01281e616MLP, 4 layers, 256 hid dim, relu0.9955e-4(256,4,128,1,128,80)(256,4,128,1,128,80)(256,4,128,1,128,80)</td></tr><tr><td rowspan=1 colspan=1>EMaQH</td><td rowspan=1 colspan=1>EMaQ Hyperparameters</td></tr><tr><td rowspan=1 colspan=1>QlrKitchen N&#x27;s SearchedAntmaze N&#x27;s SearchedAdroitN&#x27;s Searched</td><td rowspan=1 colspan=1>1e-4{4,8,16,32,64}{50,100,150,200}{16,32,64,128}</td></tr><tr><td rowspan=1 colspan=1>BEARH</td><td rowspan=1 colspan=1>BEAR Hyperparameters</td></tr><tr><td rowspan=1 colspan=1>πArchitectureQlrπlr</td><td rowspan=1 colspan=1>MLP, 4 layers,256 hid dim, relu1e-45e-4</td></tr><tr><td rowspan=1 colspan=1>BCQH</td><td rowspan=1 colspan=1>BCQHyperparameters</td></tr><tr><td rowspan=1 colspan=1>πArchitectureQlrπlr</td><td rowspan=1 colspan=1>MLP,4layers,256 hid dim,relu1e-45e-4</td></tr></table>
+
+![](images/608cc5b1b0b6abf9038f04d1c5b09e5341fc289dce5e8719d935d1376e117bd3.jpg)  
+Figure 6: Results for evaluating EMaQ on D4RL (Fu et al., 2020b) benchmark domains when using the described VAE implementation, with $N \in \{ 5 , 1 0 , 2 5 , 5 0 , 1 0 0 , 2 0 0 , 4 0 0 \}$ . Values above $\mu ( a | s )$ represent the result of evaluating the base behavior policies. Horizontal green lines represent the reported performance of BEAR in the D4RL benchmark (apples to apples comparisons in Figure 7).
+
+H VAE RESULTS
+
+# H.1 IMPLEMENTATION
+
+We also ran experiments with VAE parameterizations for $\mu ( a | s )$ . To be approximately matched in parameter count with our autoregressive models, the encoder and decoder both have 3 hidden layers of size 1024 with relu activations. The dimension of the latent space was twice the number of action dimensions. The decoder outputs a vector $v$ which, and the decoder action distribution is defined to be $\mathcal { N } ( \mathrm { T a n h } ( v ) , I )$ . When sampling from the VAE, following prior work, samples from the VAE prior (spherical normal distribution) were clipped to the range $[ - 0 . 5 , 0 . 5 ]$ and mean of the decoder distibution was used (i.e. the decoder distribution was not sampled from). The KL divergence loss term was weighted by 0.5. This VAE implementation was the one used in the benchmarking codebase of (Wu et al., 2019), so we did not modify it.
+
+# H.2 RESULTS
+
+As can be seen in Figure 6, EMaQ has a harder time improving upon $\mu ( a | s )$ when using the VAE architecture described above. However, as can be seen in Figure 7, BCQ and BEAR do show some variability as well when switching to the VAEs. Since as an algorithm EMaQ is much more reliant on $\mu ( a | s )$ , our hypothesis is that if it is true that the autoregressive models better captured the action distribution, letting EMaQ not make poor generalizations to out-of-distribution actions. Figures 8 and 9 show autoregressive and VAE results side-by-side for easier comparison.
+
+# I EMAQ MEDIUM-EXPERT SETTING RESULTS
+
+In HalfCheetah, increasing $N$ significantly slows down the convergence rate of the training curves; while large $N s$ continue to improve, we were unable to train them long enough for convergence. In Walker, for EMaQ, BCQ, and most hyperparameter settings of BEAR, training curves have a prototypical shape of a hump, where performance improves up to a certain high value, and then continues to fall very low. In Hopper, for higher values of $N$ in EMaQ we observed that increasing batch size from 100 to 256 largely resolved the poor performance, but for consistency we did not alter Figure 1 with these values.
+
+# J COMPARISON WITH SOFTMAX BACKUP OPERATORS
+
+![](images/14967858a30977a88669329f25c0e2a7c02bb01c9fea21874ba0fe94c74e5714.jpg)  
+Figure 7: Comparison of EMaQ, BCQ, and BEAR on D4RL (Fu et al., 2020b) benchmark domains when using when using the described VAE implementation for $\mu ( a | s )$ . For both BCQ and BEAR, from left to right the allowed deviation from $\mu ( a | s )$ increases. Horizontal green lines represent the reported performance of BEAR in the D4RL benchmark.
+
+We thank one of our ICLR 2021 reviewers for the motivation for this section. For clarity of writing, we will write the forms for deterministic dynamics and remove the expectations over the next state.
+
+An interesting connection to our proposed backup operators would be the following Softmax backup operator with similarities to EMaQ,
+
+$$
+\begin{array} { r l } & { T _ { \mu } ^ { \alpha } Q ( s , a ) : = r ( s , a ) + \mathbb { E } _ { s o f t ( a ^ { \prime } | s ^ { \prime } ) } [ Q ( s ^ { \prime } , a ^ { \prime } ) ] } \\ & { \ s o f t ( a | s ) \propto \mu ( a | s ) \cdot \exp ( \alpha \cdot Q ( s , a ) ) } \end{array}
+$$
+
+As suggested by our reviewer, the policy corresponding to $s o f t ( a | s )$ is a policy that aims to maximize Q-values, subject to a KL-constraint between itself and the policy $\mu ( a | s )$ . The looser the constraint, the larger the effective $\alpha$ and the farther the policy will be from $\mu$ . One approach to Monte Carlo estimation of the expectation on the right hand side could be to take samples using methods from the energy-based generative modelling literature.
+
+An alternative approach which will more closely resembles EMaQ is to use self-normalized importance sampling,
+
+$$
+\begin{array} { r l } & { T _ { \mu } ^ { \alpha } Q ( s , a ) : = r ( s , a ) + \mathbb { E } _ { s o f t ( a ^ { \prime } | s ^ { \prime } ) } [ Q ( s ^ { \prime } , a ^ { \prime } ) ] } \\ & { \quad \quad \quad = r ( s , a ) + \quad \quad \quad \quad \quad \quad \quad w _ { i } \cdot Q ( s ^ { \prime } , a ^ { \prime } ) } \\ & { \quad \quad \quad \quad \{ a _ { i } \} ^ { N \sim \mu ( a ^ { \prime } | s ^ { \prime } ) } } \\ & { \quad \quad \quad \tilde { w } _ { i } = \frac { \mu ( a _ { i } ^ { \prime } | s ^ { \prime } ) \cdot \exp ( \alpha \cdot Q ( s ^ { \prime } , a _ { i } ^ { \prime } ) ) } { \mu ( a _ { i } ^ { \prime } | s ^ { \prime } ) } } \\ & { \quad \quad \quad \quad w _ { i } = \frac { \tilde { w } _ { i } } { \sum \tilde { w } _ { i } } } \\ & { \quad \quad \quad \quad = s o f t m a x ( \alpha \cdot Q ( s ^ { \prime } , a _ { i } ^ { \prime } ) ) [ i ] } \end{array}
+$$
+
+In this form, the soft backup is similar to EMaQ, where instead of taking ths max Q-value over the N samples, we take an average over the N Q-values, weighted by the softmax probabilities in equation 73. For a given N, the $\alpha = 0$ would be equivalent to Q-evaluation of the policy $\mu ( a | s )$ , and as $\alpha \to \infty$ , the soft backups approach EMaQ backups.
+
+In Figure 10 we present empirical results with the soft backup operators, under a large range $\alpha \in$ {1, 4, 8, 16, 32, 64, 128, 256, 512, 1024}, in the Halfcheetah settings. The EMaQ and soft-EMaQ were run with the same architectures, but were smaller than the ones used for the results in the main text. We used the same checkpoints of the generative models as for the results in the main text. The test-time policy for both approaches is the same, sampling $N$ actions and taking the argmax action under the ensemble Q-value. The only difference between the EMaQ and soft-EMaQ implementations was a one-line change to replace max with a softmax average of the Q-values.
+
+Some interesting observations are the following: As anticipated, the soft EMaQ backups approach EMaQ as the value of $\alpha$ is increased. However, the necessary value of $\alpha$ to match the performance of EMaQ can be quite large. In the medium-expert setting, where figure 1 suggests challenges arising from the combination of large $N s$ and function-approximators, we did not gain much advantage from soft backups, and only $\alpha \in \{ 8 , 1 6 , 3 2 \}$ seem to have provided some mitigation of the problem for $N = 2 5$ . Since the soft backup introduces an additional hyperparameter that cannot be determined ahead of time, and does not seem to provide an advantage (at least in the limited Halfcheetah settings considered), from a practical perspective, we would prefer to use the regular EMaQ backup.
+
+# K QUALITATIVE DIFFERENCES IN TRAINING CURVES
+
+We have sometimes observed that the curves representing agent performance throughout training can be significantly more stable under EMaQ in comparison to BEAR and BCQ. A domain where the differences are particularly striking are the antmaze-umaze and antmaze-umaze-diverse domains. In figure 4 we have included plots of agent performance during training under the variety of considered hyperparameters and random seeds. It can be seen that in these two domains, initially the BCQ agents improves in performance close to the performance of EMaQ, and the drastically degrades with more training. In constrast, EMaQ agents remain stable even after twice as many training iterations as BCQ, which may indicate the downside of the heuristic perturbation model for constraining actions.
+
+![](images/962af39d9265fb8b3181c22d8672d8e669a8a08f8e31b5bbe76d0f7b35878e24.jpg)
+
+Table 4: Comparison of agent returns throughout training, under the variety of hyperparameters and and random seeds, in the small ant domains. We observe that EMaQ is significantly more stable than BCQ in these domains, even though the values of $N$ in EMaQ were fairly large for these plots $N \in \{ 5 0 , 1 0 0 , 1 5 0 , 2 0 0 \}$ .
+
+# L LARGER PLOTS FOR VISIBILITY
+
+Due to larger size of plots, each plot is shown on a separate page below. For ablation results, see Figure 11. For MuJoCo results, see Figure 12.
+
+![](images/bb8f4810ddf3dac3ce95fd608108d412a9274e08e34d6d6e8f9da514097aa7aa.jpg)
+
+![](images/9f98dd7c4decd98a18537693b1845f69c4e81b12137d19f47360df4d315ee200.jpg)
+
+![](images/b9767191567769077f7101a6d05a6453f3c0ffe1635773b8234ce1b32eeb5b42.jpg)
+
+![](images/b617ed0ffc3763276051413e99d4f71f86fe2c00752f3d91ef19f8ee361b751d.jpg)
+
+![](images/8907e3c6887c7e076aaeaf79246f30b636fc5c73d5f52ae8979d59876c6f1fbb.jpg)

parse/train/BJe-_CNKPH/BJe-_CNKPH.md

@@ -0,0 +1,220 @@
+# ATTENTION INTERPRETABILITY ACROSS NLP TASKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+The attention layer in a neural network model provides insights into the model’s reasoning behind its prediction, which are usually criticized for being opaque. Recently, seemingly contradictory viewpoints have emerged about the interpretability of attention weights (Jain & Wallace, 2019; Vig & Belinkov, 2019). Amid such confusion arises the need to understand attention mechanism more systematically. In this work, we attempt to fill this gap by giving a comprehensive explanation which justifies both kinds of observations (i.e., when is attention interpretable and when it is not). Through a series of experiments on diverse NLP tasks, we validate our observations and reinforce our claim of interpretability of attention through manual evaluation.
+
+# 1 INTRODUCTION
+
+Attention is a way of obtaining a weighted sum of the vector representations of a layer in a neural network model (Bahdanau et al., 2015). It is used in diverse tasks ranging from machine translation (Luong et al., 2015), language modeling (Liu & Lapata, 2018) to image captioning (Xu et al., 2015), and object recognition (Ba et al., 2014). Apart from substantial performance benefit (Vaswani et al., 2017), attention also provides interpretability to neural models (Wang et al., 2016; Lin et al., 2017; Ghaeini et al., 2018) which are usually criticized for being black-box function approximators (Chakraborty et al., 2017).
+
+There has been substantial work on understanding attention in neural network models. On the one hand, there is work on showing that attention weights are not interpretable, and altering them does not significantly affect the prediction (Jain & Wallace, 2019; Serrano & Smith, 2019). While on the other hand, some studies have discovered how attention in neural models captures several linguistic notions of syntax and coreference (Vig & Belinkov, 2019; Clark et al., 2019; Tenney et al., 2019). Amid such contrasting views arises a need to understand the attention mechanism more systematically. In this paper, we attempt to fill this gap by giving a comprehensive explanation which justifies both kinds of observations.
+
+The conclusions of Jain & Wallace (2019); Serrano & Smith (2019) have been mostly based on text classification experiments which might not generalize to several other NLP tasks. In Figure 1, we report the performance on text classification, Natural Language Inference (NLI) and Neural Machine Translation (NMT) of two models: one trained with neural attention and the other trained with attention weights fixed to a uniform distribution. The results show that the attention mechanism in text classification does not have an impact on the performance, thus, making inferences about interpretability of attention in these models might not be accurate. However, on tasks such as NLI and NMT uniform attention weights degrades the performance substantially, indicating that attention is a crucial component of the model for these tasks and hence the analysis of attention’s interpretability here is more reasonable.
+
+In comparison to the existing work on interpretability, we analyze attention mechanism on a more diverse set of NLP tasks that include text classification, pairwise text classification (such as NLI), and text generation tasks like neural machine translation (NMT). Moreover, we do not restrict ourselves to a single attention mechanism and also explore models with self-attention. For examining the interpretability of attention weights, we perform manual evaluation. Our key contributions are:
+
+1. We extend the analysis of attention mechanism in prior work to diverse NLP tasks and provide a comprehensive picture which alleviates seemingly contradicting observations.
+
+![](images/86cf3df65d817dbfea2ccedc3ebcc72f3d34d2b627b4e2a5cf64964e9133cb89.jpg)  
+Figure 1: Comparison of performance with and without neural attention on text classification (IMDB), Natural Language Inference tasks (SNLI) and Neural Machine Translation (News Commentary). Here, $\alpha$ and $c$ denote attention weights and context vector respectively. The results show that attention does not substantially effect performance on text classification. However, the same does not hold for other tasks.
+
+2. We identify the conditions when attention weights are interpretable and correlate with feature importance measures – when they are computed using two vectors which are both functions of the input (Figure 1b, c). We also explain why attention weights are not interpretable when the input has only single sequence (Figure 1a), an observation made by Jain & Wallace (2019), by showing that they can be viewed as a gating unit.
+
+3. We validate our hypothesis of interpretability of attention through manual evaluation.
+
+# 2 TASKS AND DATASETS
+
+We investigate the attention mechanism on the following three task categories.
+
+1. Single Sequence tasks are those where the input consists of a single text sequence. For instance, in sentiment analysis, the task is to classify a review as positive or negative. This also includes other text classification tasks such as topic categorization. For the experiments, in this paper, we use three review rating datasets: (1) Stanford Sentiment Treebank (Socher et al., 2013), (2) IMDB (Maas et al., 2011) and (3) Yelp $2 0 1 7 ^ { 1 }$ and one topic categorization dataset AG News Corpus (business vs world).2
+
+2. Pair Sequence tasks comprise of a pair of text sequences as input. The tasks like NLI and question answering come under this category. NLI involves determining whether a hypothesis entails, contradicts, or is undetermined given a premise. We use Stanford Natural Language Inference (SNLI) (Bowman et al., 2015) and Multi-Genre Natural Language Inference (MultiNLI) (Williams et al., 2018) datasets for our analysis. For question answering, similar to Jain & Wallace (2019), we use CNN News Articles (Hermann et al., 2015) and three tasks of the original babI dataset (Weston et al., 2015) in our experiments, i.e., using one, two and three supporting statements as the context for answering the questions.
+
+3. Generation tasks involve generating a sequence based on the input sequence. Neural Machine translation is an instance of generation task which comprises of translating a source text to a target language given translation pairs from a parallel corpus. For our experiments, we use three English-German datasets: Multi30k (Elliott et al., 2016), En-De News Commentary v11 from WMT16 translation task3 and full En-De WMT13 dataset.
+
+# 3 NEURAL ATTENTION MODELS
+
+In this section, we give a brief overview of the neural attention-based models we analyze for different categories of tasks listed in Section 2. The overall architecture for each category is shown in Fig 1.
+
+# 3.1 SINGLE SEQUENCE MODELS:
+
+For single sequence tasks, we adopt the model architecture from Jain & Wallace (2019); Wiegreffe & Pinter (2019). For a given input sequence $\pmb { x } \in \mathbb { R } ^ { T \times | V | }$ , where $T$ and $| V |$ are the number of tokens and vocabulary size, we first represent each token with its $d$ -dimensional GloVe embedding Pennington et al. (2014) to obtain $\pmb { x } _ { e } \in \mathbb { R } ^ { T \times d }$ . Next, we use a Bi-RNN encoder $\mathbf { ( E n c ) }$ to obtain an $m$ -dimensional contextualized representation of tokens: $\pmb { h } = \mathbf { E n c } ( \pmb { x } _ { e } ) \in \mathbb { R } ^ { T \times m }$ . Then, we use the additive formulation of attention proposed by Bahdanau et al. (2015) for computing attention weights $\alpha _ { i }$ for all tokens defined as:
+
+$$
+u _ { i } = \operatorname { t a n h } ( W h _ { i } + b ) ; \quad \alpha _ { i } = \frac { \exp ( { \boldsymbol { u } _ { i } ^ { T } { \boldsymbol { c } } } ) } { \sum _ { j } \exp ( { \boldsymbol { u } _ { j } ^ { T } { \boldsymbol { c } } } ) } ,
+$$
+
+where repres $\boldsymbol { W } \in \mathbb { R } ^ { d ^ { \prime } \times m } , \boldsymbol { b } , \boldsymbol { c } \in \mathbb { R } ^ { d ^ { \prime } }$ arameters of the model. Finally, the weighted instanceis fed to a dense layer (Dec) followed by softmax to $\begin{array} { r } { \pmb { h } _ { \alpha } = \sum _ { i = 1 } ^ { T } \alpha _ { i } \pmb { h } _ { i } \in \mathbb { R } ^ { m } } \end{array}$ obtain prediction $\hat { y } = \sigma (  { \mathbf { D e c } } (  { \pmb { h } } _ { \alpha } ) ) \in \mathbb { R } ^ { | \mathcal { V } | }$ , where $| \mathcal { V } |$ denotes the label set size.
+
+We also analyze the hierarchical attention model (Yang et al., 2016), which involves first computing attention over the tokens to obtain a sentence representation. This is followed by attention over sentences to obtain an instance representation $h _ { \alpha }$ , which is fed to a dense layer for obtaining prediction $\left( \hat { y } \right)$ . At both word and sentence level the attention is computed similar to as defined in Equation 1.
+
+# 3.2 PAIR SEQUENCE MODELS:
+
+For pair sequence, the input consists of two text sequences: $\pmb { x } \in \mathbb { R } ^ { T _ { 1 } \times | V | } , \pmb { y } \in \mathbb { R } ^ { T _ { 2 } \times | V | }$ of length $T _ { 1 }$ and $T _ { 2 }$ . In NLI, $_ { \textbf { \em x } }$ indicates premise and $\textbf {  { y } }$ is hypothesis while in question answering, it is the question and paragraph respectively. Following Bowman et al. (2015), we use two separate RNNs for encoding both the sequences to obtain $\{ h _ { 1 } ^ { x } , . . . , h _ { T _ { 1 } } ^ { x } \}$ and $\{ h _ { 1 } ^ { y } , . . . , h _ { T _ { 2 } } ^ { y } \}$ . Now, similar to Jain & Wallace (2019), attention weight $\alpha _ { i }$ 1over each token of $_ { \textbf { \em x } }$ 2 is computed as:
+
+$$
+u _ { i } = \operatorname { t a n h } ( W _ { 1 } h _ { i } ^ { x } + W _ { 2 } h _ { T _ { 2 } } ^ { y } ) ; \quad \alpha _ { i } = \frac { \exp ( u _ { i } ^ { T } c ) } { \sum _ { j } \exp ( u _ { j } ^ { T } c ) } ,
+$$
+
+where similar to Equation 1, $W _ { 1 } , W _ { 2 } \in \mathbb { R } ^ { d \times d ^ { \prime } }$ denotes the projection matrices and $\boldsymbol { c } \in \mathbb { R } ^ { d ^ { \prime } }$ is a parameter vector. Finally, the representation obtained from a weighted sum of tokens in $_ { \textbf { \em x } }$ : $h _ { \alpha } =$ $\textstyle \sum _ { i = 1 } ^ { T } { \alpha _ { i } } h _ { i } ^ { x }$ is fed to a classifier for prediction.
+
+We also explore a variant of the above attention proposed by Rocktaschel et al. (2016). Instead of ¨ keeping the RNN encoders of both the sequences independent, Rocktaschel et al. (2016) use condi- ¨ the model to obtain a conditional encoding unlike the previous model, attention over the tional encoding where the encoder of is initialized with the final state of $\{ h _ { 1 } ^ { \prime y } , . . . , h _ { T _ { 2 } } ^ { \prime y } \}$ of  de $\textbf {  { y } }$ given the sequence ed as follows: $_ { \textbf { \em x } }$ ’s encoder. This allows $_ { \textbf { \em x } }$ . Moreover, $_ { \textbf { \em x } }$
+
+$$
+M = \operatorname { t a n h } ( W _ { 1 } X + W _ { 2 } h _ { T _ { 2 } } ^ { \prime y } \otimes e _ { T _ { 1 } } ) ; \quad \alpha = \operatorname { s o f t m a x } ( { \pmb w } ^ { T } M ) ,
+$$
+
+where ${ \pmb X } = [ { \pmb h } _ { 1 } ^ { x } , . . . , { \pmb h } _ { T _ { 1 } } ^ { x } ]$ , $\boldsymbol { e } _ { T _ { 1 } } \in \mathbb { R } ^ { T _ { 1 } }$ is a vector of ones and outer product ${ \cal W } _ { 2 } h _ { T _ { 2 } } ^ { \prime y } \otimes e _ { T _ { 1 } }$ denotes repeating linearly transformed $h _ { T _ { 2 } } ^ { \prime y }$ as many times as words in the sequence $_ { \textbf { \em x } }$ (i.e. $T _ { 1 }$ times).
+
+# 3.3 GENERATION TASK MODELS:
+
+In this paper, for generation tasks, we focus on Neural Machine Translation (NMT) problem which involves translating a given source text sentence $\pmb { x } \in \mathbb { R } ^ { T _ { 1 } \times | V _ { 1 } | }$ to a sequence $\pmb { y } ^ { \mathrm { ~ ~ } } \in \mathbb { R } ^ { T _ { 2 } \times | V _ { 2 } | }$ in the target language. The model comprises of two components: (a) an encoder which computes a representation for each source sentence and (b) a decoder which generates a target word at each time step. In this work, we utilize RNN based encoder and decoder models. For each input sentence $_ { \textbf { \em x } }$ , we first obtain a contextualized representation $\{ h _ { 1 } , . . . , h _ { T _ { 1 } } \}$ of its tokens using a multi-layer Bi-RNN. Then, at each time step $t$ , the decoder has a hidden state defined as
+
+$$
+\pmb { c } _ { t } = f ( \pmb { c } _ { t - 1 } , y _ { t - 1 } , \pmb { h } _ { \alpha } ^ { t } ) , \mathrm { w h e r e } \pmb { h } _ { \alpha } ^ { t } = \sum _ { i = 1 } ^ { T _ { 1 } } \alpha _ { t , i } \pmb { h } _ { i } .
+$$
+
+In our work, we compute $\alpha _ { t , i }$ as proposed by Bahdanau et al. (2015) and Luong et al. (2015). The former computes attention weights using a feed-forward network, i.e., $\alpha _ { t , i } = { w } ^ { T } \mathrm { t a n h } ( { W } [ { c } _ { t } ; h _ { i } ] )$ while the latter define it simply as $\alpha _ { t , i } = \pmb { c } _ { t } ^ { T } h _ { i }$ .
+
+# 3.4 SELF-ATTENTION BASED MODELS:
+
+We also examine self-attention based models on all three categories of tasks. For single and pair sequence tasks, we fine-tune pre-trained BERT (Devlin et al., 2019) model on the downstream task. In pair sequence tasks, instead of independently encoding each text, we concatenate both separated by a delimiter and pass it to BERT model. Finally, the embedding corresponding to [CLS] token is fed to a feed-forward network for prediction. For neural machine translation, we use Transformer model proposed by Vaswani et al. (2017) with base configuration.
+
+# 4 IS ATTENTION AN EXPLANATION?
+
+In this section, we attempt to address the question: Is attention an explanation? through a series of experiments which involve analyzing attention weights in a variety of models (§3) on multiple tasks (§2). Following Jain & Wallace (2019), we take the definition of explainability of attention as: inputs with high attention weights are responsible for model output. Jain & Wallace (2019); Serrano & Smith (2019) have extensively investigated this aspect for certain class of problems and have shown that attention does not provide an explanation. However, another series of work (Vig & Belinkov, 2019; Clark et al., 2019; Tenney et al., 2019) has shown that attention does encode several linguistic notions. In our work, we claim that the findings of both the line of work are consistent. We note that the observations of the former works can be explained based on the following proposition.
+
+Proposition 4.1. Attention mechanism as defined in Equation 1 as
+
+$$
+{ \pmb u } _ { i } = \operatorname { t a n h } ( { \pmb W } { \pmb h } _ { i } + { \pmb b } ) ; \quad \alpha _ { i } = \frac { \exp ( { \pmb u } _ { i } ^ { T } { \pmb c } ) } { \sum _ { j } \exp ( { \pmb u } _ { j } ^ { T } { \pmb c } ) }
+$$
+
+for single sequence tasks can be interpreted as a gating unit in the network.
+
+Proof: The attention weighted averaging computed in Equation 1 for single sequence tasks can be interpreted as gating proposed by Dauphin et al. (2017) which is defined as
+
+$$
+h ( { \pmb x } ) = f ( { \pmb x } ) \times \sigma ( g ( { \pmb x } ) ) ,
+$$
+
+where $\pmb { x } \in \mathbb { R } ^ { m }$ is the input and $\times$ denotes product between transformed input $f ( \pmb { x } ) \in \mathbb { R } ^ { m }$ and its computed gating scores $\sigma ( \ b { g } ( \pmb { x } ) ) \in \mathbb { R }$ . Equation 1 can be reduced to the above form by taking $f$ as an identity function and defining $g ( \pmb { x } ) \overset { \cdot } { = } c ^ { T } \mathrm { t a n h } ( \pmb { W } \pmb { x } + \pmb { b } ) \in \mathbb { R }$ and replacing $\sigma$ with softmax. We note that the same reduction does not hold in the case of pair sequence and generation tasks where attention along with input also depends on another text sequence $\mathbf { Y }$ and current hidden state $\mathbf { } _ { c _ { t } }$ , respectively. Thus, attention mechanism for these tasks take the form
+
+$$
+h ( x , y ) = f ( x ) \times \sigma ( g ( x , y ) ) ,
+$$
+
+which does not reduce to the above equation for gating unit.
+
+<table><tr><td></td><td>SST</td><td>IMDB</td><td>AG News</td><td>YELP</td></tr><tr><td>Bahdanau et al. (2015)</td><td>83.4± 0.5</td><td>90.7± 0.7</td><td>96.4± 0.1</td><td>66.7± 0.1</td></tr><tr><td>Uniform (Train+Infer /Infer)</td><td>-1.0/-0.8</td><td>-0.8/-6.3</td><td>-0.1/-0.7</td><td>-0.5/-6.3</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-1.1/-0.9</td><td>-0.6/-6.4</td><td>-0.0/-0.7</td><td>-0.4/-6.4</td></tr><tr><td>Permute (Infer)</td><td>-1.7</td><td>-5.1</td><td>-0.9</td><td>-7.8</td></tr><tr><td>Yang et al. (2016)</td><td>83.2± 0.5</td><td>89.7± 0.6</td><td>96.1 ± 0.2</td><td>65.8 ± 0.1</td></tr><tr><td>Uniform (Train+Infer /Infer)</td><td>-1.0/-0.8</td><td>+0.2/-6.5</td><td>+0.1/-1.5</td><td>-0.7/-8.0</td></tr><tr><td>Random(Train+Infer /Infer)</td><td>-0.9/-1.0</td><td>-1.2/-8.2</td><td>-0.1/-1.8</td><td>-3.0/-10.2</td></tr><tr><td>Permute (Infer)</td><td>-1.8</td><td>-5.1</td><td>-0.7</td><td>-10.7</td></tr></table>
+
+Table 1: Evaluation results on single sequence tasks. We report the base performance of attention models and absolute change in accuracy for its variant. We note that across all datasets, degradation in performance on altering attention weights during inference is more compared to varying them during both training and inference. Overall, the change in performance is less compared to other tasks. Please refer to $\ S 4 . 1$ for more details.
+
+Based on the above proposition, we argue that weights learned in single sequence tasks cannot be interpreted as attention, and therefore, they do not reflect the reasoning behind the model’s prediction. This justifies the observation that for the single sequence tasks examined in Jain & Wallace (2019); Serrano & Smith (2019), attention weights do not correlate with feature importance measures and permuting them does not change the prediction of the model. In light of this observation, we revisit the explainability of attention weights by asking the following questions.
+
+4.1 HOW DOES ALTERING ATTENTION WEIGHTS AFFECT MODEL OUTPUT ON TASKS?
+
+In this section, we compare the performance of various attention mechanism described in $\ S 3$ for different categories of tasks listed in $\ S 2$ . For each model, we analyze its three variants defined as:
+
+• Uniform denotes the case when all the inputs are given equal weights, i.e., $\alpha _ { i } = 1 / T , \forall i \in$ $\{ 1 , . . . , T \}$ . This is similar to the analysis performed by Wiegreffe & Pinter (2019). However, we consider two scenarios when the weights are kept fixed both during training and inference (Train+Infer) and only during inference (Infer).   
+• Random refers to the variant where all the weights are randomly sampled from a uniform distribution: $\alpha _ { i } \sim U ( 0 , 1 )$ , $\forall i \in \{ 1 , . . . , T \}$ , this is followed by normalization. Similar to Uniform, we analyze both Train+Infer and Infer.   
+• Permute refers to the case when the learned attention weights are randomly permuted during inference, i.e., $\pmb { \alpha } = \mathrm { s h u f f e } ( \pmb { \alpha } )$ . Unlike the previous two, here we restrict our analysis to only permuting during inference as Tensorflow currently does not support backpropagation with shuffle operation.4
+
+Effect on single sequence tasks: The evaluation results on single sequence datasets: SST, IMDB, AG News, and YELP are presented in Table 1. We observe that Train+Infer case of Uniform and Random attentions gives around 0.5 and 0.9 average decrease in accuracy compared to the base model. However, in Infer scenario the degradation on average increases to 3.9 and 4.5 absolute points respectively. This is so because the model becomes more robust to handle altered weights in the former case. The reduction in performance from Permute comes around to 4.2 across all datasets and models. The results support the observation of Jain & Wallace (2019); Serrano & Smith (2019) that alternating attention in text classification task does not have much effect on the model output. The slight decrease in performance can be attributed to corrupting the existing gating mechanism which has been shown to give some improvement (Oord et al., 2016; Dauphin et al., 2017; Marcheggiani & Titov, 2017).
+
+Effect on pair sequence and generation tasks: The results on pair sequence and generation tasks are summarized in Table 2 and 3, respectively. Overall, we find that the degradation in performance from altering attention weights in case of pair sequence and generation tasks is much more substantial than single sequence tasks. For instance, in Uniform (Train+Infer), the average relative decrease in performance of single sequence tasks is $0 . 1 \%$ whereas in case of pair sequence and generation tasks it is $4 9 . 5 \%$ and $5 1 . 2 \%$ respectively. The results thereby validate our Proposition 4.1 and show that altering attention does affect model output for a task where the attention layer cannot be modeled as a gating unit in the network.
+
+Table 2: The performance comparison of attention based models and their variants on pair sequence tasks. We find that the degradation in performance is much more than single sequence tasks.   
+
+<table><tr><td></td><td>SNLI</td><td>MultiNLI</td><td>CNN</td><td>babI 0</td><td>babI1</td><td>babI2</td></tr><tr><td>Bahdanau et al. (2015)</td><td>75.7± 0.3</td><td>61.1 ± 0.1</td><td>63.4±0.8</td><td>96.1 ± 4.3</td><td>95.8 ±0.3</td><td>92.8± 0.1</td></tr><tr><td>Uniform (Train+Infer Infer)</td><td>-41.8/-42.9</td><td>-26.6/-28.7</td><td>-30.8/-55.9</td><td>-44.4/-63.4</td><td>-47.4/-60.4</td><td>-48.4/-62.1</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-41.6 /-43.1</td><td>-26.7/-28.6</td><td>-30.9/-55.9</td><td>-45.0/-62.0</td><td>-47.3/-60.4</td><td>-49.9/-62.2</td></tr><tr><td>Permute (Infer)</td><td>-41.0</td><td>-27.6</td><td>-54.8</td><td>-67.8</td><td>-68.3</td><td>-66.7</td></tr><tr><td>Rocktäschel et al.(2016)</td><td>78.1±0.2</td><td>62.4± 0.6</td><td>63.6±0.6</td><td>98.6±1.6</td><td>96.2±0.9</td><td>93.2± 0.1</td></tr><tr><td>Uniform (Train+Infer/Infer)</td><td>-44.2/-45.4</td><td>-27.5/-30.3</td><td>-30.8/-43.1</td><td>−47.7/-67.8</td><td>-47.9/-62.8</td><td>-49.8/-60.9</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-44.3/-44.9</td><td>-27.9/-28.3</td><td>-30.6/-43.3</td><td>-47.5/-64.9</td><td>-48.4/-63.3</td><td>-49.8/-60.9</td></tr><tr><td>Permute (Infer)</td><td>-41.7</td><td>-29.2</td><td>-44.9</td><td>-68.8</td><td>-68.3</td><td>-65.2</td></tr></table>
+
+Table 3: Evaluation results on neural machine translation. Similar to pair sequence tasks, we find that the deterioration in performance is much more substantial than single sequence tasks. Please refer to $\ S 4 . 1$ for more details.   
+
+<table><tr><td>Dataset</td><td>Multi30k</td><td>News Commentary</td></tr><tr><td>Bahdanau et al. (2015)</td><td>31.3 ± 0.1</td><td>12.6 ± 0.1</td></tr><tr><td>Uniform (Train+Infer /Infer)</td><td>-10.4/-29.4</td><td>-8.7/-11.8</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-10.1/-29.4</td><td>-8.8/-11.9</td></tr><tr><td>Permute (Infer)</td><td>-29.7</td><td>-12.1</td></tr><tr><td>Luong et al. (2015)</td><td>31.5 ± 0.2</td><td>12.7 ± 0.2</td></tr><tr><td>Uniform (Train+Infer /Infer)</td><td>-10.6/-29.7</td><td>-8.8 /-12.0</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-10.3/-29.8</td><td>-8.9 /-12.0</td></tr><tr><td>Permute (Infer)</td><td>-30.1</td><td>-12.2</td></tr></table>
+
+Visualizing the effect of permuting attention weights: To further reinforce our claim, similar to Jain & Wallace (2019), we report the median of Total Variation Distance (TVD) between new and original prediction on permuting attention weights for each task. The TVD between two predictions $\hat { y } _ { 1 }$ and asses $\hat { y } _ { 2 }$ is defined as: the problem. $\begin{array} { r } { \mathrm { T V D } ( \hat { y _ { 1 } } , \hat { y } _ { 2 } ) = \frac { 1 } { 2 } \sum _ { i = 1 } ^ { | \bar { y } | } | \hat { y } _ { 1 i } - \hat { y } _ { 2 i } | } \end{array}$ , where nge in o $| \mathcal { V } |$ denotes the total number ofut distribution on permuting the attention weights. In Figure 2, we report the relationship between the maximum attention value and the median induced change in model output over 100 permutations on all categories of tasks. For NMT task, we present change in output at the 25th-percentile length of sentences for both datasets. Overall, we find that for single sequence tasks even with the maximum attention weight in range [0.75, 1.0], the change in prediction is considerably small (the violin plots are to the left of the figure) compared to the pair sequence and generation tasks (the violin plots are to the right of the figure).
+
+# 4.2 DO ATTENTION WEIGHTS CORRELATE WITH FEATURE IMPORTANCE MEASURES?
+
+In this section, similar to the analysis of Serrano & Smith (2019), we investigate the importance of attention weights only when one weight is removed. Let $i ^ { * }$ be the input corresponding to the highest attention weights and let $r$ be any randomly selected input. We denote the original model’s prediction as $\pmb { p }$ and output after removing $i ^ { * }$ and $r$ input as ${ \pmb q } _ { \{ i ^ { * } \} }$ and $\pmb q _ { \{ r \} }$ respectively. Now, to measure the impact of removing $i ^ { * }$ relative to any randomly chosen input $r$ on the model output, we compute the difference of Jensen-Shannon (JS) divergence between $\mathrm { J S } ( p , q _ { \{ i ^ { * } \} } )$ and $\mathrm { J S } ( \pmb { p } , \pmb { q } _ { \{ r \} } )$ given as: $\Delta \mathrm { J S } = \mathrm { J S } ( p , q _ { \{ i ^ { * } \} } ) - \mathrm { J S } ( p , q _ { \{ r \} } )$ . The relationship between the difference of attention weights corresponding to $i ^ { * }$ and $r$ , i.e., $\alpha _ { i ^ { * } } - \alpha _ { r }$ and $\Delta \mathrm { J S }$ for different tasks is presented in Figure 3. In general, we found that for single sequence tasks, the change JS divergence is small even for cases when the difference in attention weight is considerable. However, for pair sequence and generation tasks, there is a substantial change in the model output.
+
+![](images/d742f8efabb51c0323c469be27ae401326114feaa89aa08e4591a4dc13ae5442.jpg)  
+Figure 2: Relationship between maximum attention weight and median change in output on permuting attention weights. For single sequence tasks,  indicate negative and positive class. For MultiNLI, ,   denotes contradiction, entailment and neutral respectively. The results reinforce the claim that altering attention weights in single sequence tasks does not have much effect on performance while the same does not hold with other tasks. Refer to $\ S 4 . 1$ for details.
+
+![](images/e6b53e9c3471d87eeb36af12f65695ce678e117ba6df38fc698fb787660632af.jpg)  
+Figure 3: Analysis of correlation between attention weights and feature importance measure. We report relationship between difference in zeroed attention weights and corresponding change in $J S$ divergence for different tasks. Please refer to $\ S 4 . 2$ for more details.
+
+# 4.3 HOW PERMUTING DIFFERENT LAYERS OF SELF-ATTENTION BASED MODELS AFFECT PERFORMANCE?
+
+In this section, we analyze the importance of attention weights on the performance of self-attention based models as described in $\ S 3 . 4$ . We report the accuracy on single, and pair sequence tasks and BLEU score for NMT on WMT13 dataset on permuting the attention weights of layers cumulatively. For Transformer model, we analyze the effect of altering attention weights in encoder, decoder, and across encoder-decoder (denoted by Across). The results are presented in Figure 4. Overall, we find that unlike the pattern observed in $\ S 4 . 1$ and $\ S 4 . 2$ for single sequence tasks, altering weights in self-attention based models does have a substantial effect on the performance. We note that this is because while computing attention weights over all tokens with respect to a given token, Proposition 4.1 does not hold. Thus, altering them does have an impact across all three tasks. We note that in the case of transformer model, altering the weights in the first step of Decoder and in Across has maximum effect as it almost stops the flow of information from encoder to decoder.
+
+![](images/1438fd06fc2a1a04edbe0b4c97a548e31f6a5970f02060d027b5fb54799b3e06.jpg)  
+Figure 4: Performance comparison with permuting attention weights for different layers in selfattention based models. The results are reported on a representative instance of single sequence, pair sequence and generation tasks. The dotted lines denote the base performance on the task. Refer to $\ S 4 . 3$ for details.
+
+![](images/1f405a4c192f13cde3a1c3f16b33240f14bfa4d0d57feb216a6f3d5de48d9d15.jpg)  
+Figure 5: Manual evaluation of interpretability of attention weights on single and pair sequence tasks. Although with original weights the attention does remain interpretable on both tasks but in the case of single sequence tasks making it meaningless does not change the prediction substantially. However, the same does not hold with pair sequence tasks.
+
+# 4.4 ARE ATTENTION WEIGHTS HUMAN INTERPRETABLE?
+
+To determine if attention weights are human interpretable, here, we address the question of interpretability of attention weights by manually analyzing them on a representative dataset of single and pair sequence task. For each task, we randomly sample 100 samples with original attention weights and 100 with randomly permuted weights. Then, we shuffle all 200 samples together and present them to annotators for deciding whether the top three highest weighted words are relevant for the model’s prediction.
+
+The overall results are reported in Figure 5. Cohen’s kappa score of inter-annotator agreement (Cohen, 1960) on IMDB and babI is 0.84 and 0.82, respectively, which shows near-perfect agreement (Landis & Koch, 1977). We find that in both single and pair sequence tasks, the attention weights in samples with original weights do make sense in general (highlighted with blue color). However, in the former case, the attention mechanism learns to give higher weights to tokens relevant to both kinds of sentiment. For instance, in “This is a great movie. Too bad it is not available on home video.”, tokens great, too, and bad get the highest weight. Such examples demonstrate that the attention mechanism in single sequence tasks works like a gating unit, as shown in $\ S 4 . 1$ .
+
+For permuted samples, in the case of single sequence, the prediction remains correct in majority although the attention weights were meaningless. For example, in “This movie was terrible . the acting was lame , but it ’s hard to tell since the writing was so bad .”, the prediction remains the same on changing attention weights from underlined to bold tokens. However, this does not hold with the pair sequence task. This shows that attention weights in single sequence tasks do not provide a reason for the prediction, which in the case of pairwise tasks, attention do reflect the reasoning behind model output.
+
+# 5 CONCLUSION
+
+In this paper, we addressed the seemingly contradictory viewpoint over explainability of attention weights in NLP. On the one hand, some works have demonstrated that attention weights are not interpretable, and altering them does not affect the model output while several others have shown that attention captures several linguistic notions in the model. We extend the analysis of prior works to diverse NLP tasks and demonstrate that attention weights are interpretable and are correlated with feature importance measures. However, this holds only for cases when attention weights are essential for model’s prediction and cannot simply be reduced to a gating unit. Through a battery of experiments, we validate our claims and reinforce them through manual evaluation.
+
+# REFERENCES
+
+Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. In Proc. of ICLR, 2014.   
+Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In Proc. of ICLR, 2015.   
+Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. A large annotated corpus for learning natural language inference. In Proc. of EMNLP, 2015.   
+S. Chakraborty, R. Tomsett, R. Raghavendra, D. Harborne, M. Alzantot, F. Cerutti, M. Srivastava, A. Preece, S. Julier, R. M. Rao, T. D. Kelley, D. Braines, M. Sensoy, C. J. Willis, and P. Gurram. Interpretability of deep learning models: A survey of results. In Proc. of UbiComp, 2017.   
+Kevin Clark, Urvashi Khandelwal, Omer Levy, and Christopher D. Manning. What does BERT look at? an analysis of bert’s attention. In Proc. of BlackBoxNLP, 2019.   
+J. Cohen. A Coefficient of Agreement for Nominal Scales. Educational and Psychological Measurement, 20(1):37, 1960.   
+Yann N. Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. In Proc. of ICML, 2017.   
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proc. of NAACL, 2019.   
+Desmond Elliott, Stella Frank, Khalil Sima’an, and Lucia Specia. Multi30k: Multilingual englishgerman image descriptions. In Proc of the 5th Workshop on Vision and Language, 2016.   
+Reza Ghaeini, Xiaoli Z. Fern, and Prasad Tadepalli. Interpreting recurrent and attention-based neural models: a case study on natural language inference. In Proc. of EMNLP, 2018.   
+Karl Moritz Hermann, Toma´s Ko ˇ cisk ˇ y, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa ´ Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Proc. of NIPS, 2015.   
+Sarthak Jain and Byron C. Wallace. Attention is not Explanation. In Proc. of ACL, 2019.   
+J. Richard Landis and Gary G. Koch. The measurement of observer agreement for categorical data. Biometrics, 33(1), 1977.   
+Zhouhan Lin, Minwei Feng, C´ıcero Nogueira dos Santos, Mo Yu, Bing Xiang, Bowen Zhou, and Yoshua Bengio. A structured self-attentive sentence embedding. In Proc. of ICLR, 2017.   
+Yang Liu and Mirella Lapata. Learning structured text representations. Transactions of the Association for Computational Linguistics, 6:63–75, 2018. ISSN 2307-387X.   
+Thang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In Proc. of EMNLP, 2015.   
+Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Proc. of ACL, 2011.
+
+Diego Marcheggiani and Ivan Titov. Encoding sentences with graph convolutional networks for semantic role labeling. In Proc. of EMNLP, 2017.
+
+Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray ¨ Kavukcuoglu. Conditional image generation with pixelcnn decoders. In Proc. of NIPS, 2016.
+
+Jeffrey Pennington, Richard Socher, and Christopher D. Manning. Glove: Global vectors for word representation. In Proc. of EMNLP, 2014.
+
+Tim Rocktaschel, Edward Grefenstette, Karl Moritz Hermann, Tomas Kocisky, and Phil Blunsom. ¨ Reasoning about entailment with neural attention. In Proc. of ICLR, 2016.
+
+Sofia Serrano and Noah A. Smith. Is attention interpretable? In Proc. of ACL, 2019.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew $\mathrm { N g }$ and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proc. of EMNLP, 2013.
+
+Ian Tenney, Dipanjan Das, and Ellie Pavlick. BERT rediscovers the classical NLP pipeline. In Proc. of ACL, 2019.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Ł ukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Proc. of NIPS, 2017.
+
+Jesse Vig and Yonatan Belinkov. Analyzing the structure of attention in a transformer language model. In Proc. of BlackBoxNLP, 2019.
+
+Yequan Wang, Minlie Huang, Xiaoyan Zhu, and Li Zhao. Attention-based LSTM for aspect-level sentiment classification. In Proc. of EMNLP, 2016.
+
+Jason Weston, Antoine Bordes, Sumit Chopra, and Tomas Mikolov. Towards ai-complete question answering: A set of prerequisite toy tasks. In Proc. of ICLR, 2015.
+
+Sarah Wiegreffe and Yuval Pinter. Attention is not not explanation. In Proc. of EMNLP, 2019.
+
+Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proc. of NAACL, 2018.
+
+Kelvin Xu, Jimmy Lei Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In Proc. of ICML, 2015.
+
+Zichao Yang, Diyi Yang, Chris Dyer, Xiaodong He, Alex Smola, and Eduard Hovy. Hierarchical attention networks for document classification. In Proc. of NAACL, 2016.

parse/train/BJe-_CNKPH/BJe-_CNKPH_content_list.json

@@ -0,0 +1,1087 @@
+[
+    {
+        "type": "text",
+        "text": "ATTENTION INTERPRETABILITY ACROSS NLP TASKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            812,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The attention layer in a neural network model provides insights into the model’s reasoning behind its prediction, which are usually criticized for being opaque. Recently, seemingly contradictory viewpoints have emerged about the interpretability of attention weights (Jain & Wallace, 2019; Vig & Belinkov, 2019). Amid such confusion arises the need to understand attention mechanism more systematically. In this work, we attempt to fill this gap by giving a comprehensive explanation which justifies both kinds of observations (i.e., when is attention interpretable and when it is not). Through a series of experiments on diverse NLP tasks, we validate our observations and reinforce our claim of interpretability of attention through manual evaluation. ",
+        "bbox": [
+            233,
+            243,
+            764,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            414,
+            336,
+            430
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Attention is a way of obtaining a weighted sum of the vector representations of a layer in a neural network model (Bahdanau et al., 2015). It is used in diverse tasks ranging from machine translation (Luong et al., 2015), language modeling (Liu & Lapata, 2018) to image captioning (Xu et al., 2015), and object recognition (Ba et al., 2014). Apart from substantial performance benefit (Vaswani et al., 2017), attention also provides interpretability to neural models (Wang et al., 2016; Lin et al., 2017; Ghaeini et al., 2018) which are usually criticized for being black-box function approximators (Chakraborty et al., 2017). ",
+        "bbox": [
+            174,
+            446,
+            825,
+            545
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There has been substantial work on understanding attention in neural network models. On the one hand, there is work on showing that attention weights are not interpretable, and altering them does not significantly affect the prediction (Jain & Wallace, 2019; Serrano & Smith, 2019). While on the other hand, some studies have discovered how attention in neural models captures several linguistic notions of syntax and coreference (Vig & Belinkov, 2019; Clark et al., 2019; Tenney et al., 2019). Amid such contrasting views arises a need to understand the attention mechanism more systematically. In this paper, we attempt to fill this gap by giving a comprehensive explanation which justifies both kinds of observations. ",
+        "bbox": [
+            174,
+            551,
+            825,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The conclusions of Jain & Wallace (2019); Serrano & Smith (2019) have been mostly based on text classification experiments which might not generalize to several other NLP tasks. In Figure 1, we report the performance on text classification, Natural Language Inference (NLI) and Neural Machine Translation (NMT) of two models: one trained with neural attention and the other trained with attention weights fixed to a uniform distribution. The results show that the attention mechanism in text classification does not have an impact on the performance, thus, making inferences about interpretability of attention in these models might not be accurate. However, on tasks such as NLI and NMT uniform attention weights degrades the performance substantially, indicating that attention is a crucial component of the model for these tasks and hence the analysis of attention’s interpretability here is more reasonable. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            809
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In comparison to the existing work on interpretability, we analyze attention mechanism on a more diverse set of NLP tasks that include text classification, pairwise text classification (such as NLI), and text generation tasks like neural machine translation (NMT). Moreover, we do not restrict ourselves to a single attention mechanism and also explore models with self-attention. For examining the interpretability of attention weights, we perform manual evaluation. Our key contributions are: ",
+        "bbox": [
+            176,
+            816,
+            823,
+            886
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. We extend the analysis of attention mechanism in prior work to diverse NLP tasks and provide a comprehensive picture which alleviates seemingly contradicting observations. ",
+        "bbox": [
+            184,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/86cf3df65d817dbfea2ccedc3ebcc72f3d34d2b627b4e2a5cf64964e9133cb89.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of performance with and without neural attention on text classification (IMDB), Natural Language Inference tasks (SNLI) and Neural Machine Translation (News Commentary). Here, $\\alpha$ and $c$ denote attention weights and context vector respectively. The results show that attention does not substantially effect performance on text classification. However, the same does not hold for other tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            169,
+            99,
+            825,
+            359
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. We identify the conditions when attention weights are interpretable and correlate with feature importance measures – when they are computed using two vectors which are both functions of the input (Figure 1b, c). We also explain why attention weights are not interpretable when the input has only single sequence (Figure 1a), an observation made by Jain & Wallace (2019), by showing that they can be viewed as a gating unit. ",
+        "bbox": [
+            186,
+            468,
+            825,
+            539
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3. We validate our hypothesis of interpretability of attention through manual evaluation. ",
+        "bbox": [
+            186,
+            539,
+            764,
+            554
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 TASKS AND DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            393,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We investigate the attention mechanism on the following three task categories. ",
+        "bbox": [
+            173,
+            612,
+            686,
+            626
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Single Sequence tasks are those where the input consists of a single text sequence. For instance, in sentiment analysis, the task is to classify a review as positive or negative. This also includes other text classification tasks such as topic categorization. For the experiments, in this paper, we use three review rating datasets: (1) Stanford Sentiment Treebank (Socher et al., 2013), (2) IMDB (Maas et al., 2011) and (3) Yelp $2 0 1 7 ^ { 1 }$ and one topic categorization dataset AG News Corpus (business vs world).2 ",
+        "bbox": [
+            186,
+            636,
+            825,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. Pair Sequence tasks comprise of a pair of text sequences as input. The tasks like NLI and question answering come under this category. NLI involves determining whether a hypothesis entails, contradicts, or is undetermined given a premise. We use Stanford Natural Language Inference (SNLI) (Bowman et al., 2015) and Multi-Genre Natural Language Inference (MultiNLI) (Williams et al., 2018) datasets for our analysis. For question answering, similar to Jain & Wallace (2019), we use CNN News Articles (Hermann et al., 2015) and three tasks of the original babI dataset (Weston et al., 2015) in our experiments, i.e., using one, two and three supporting statements as the context for answering the questions. ",
+        "bbox": [
+            186,
+            723,
+            825,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3. Generation tasks involve generating a sequence based on the input sequence. Neural Machine translation is an instance of generation task which comprises of translating a source text to a target language given translation pairs from a parallel corpus. For our experiments, we use three English-German datasets: Multi30k (Elliott et al., 2016), En-De News Commentary v11 from WMT16 translation task3 and full En-De WMT13 dataset. ",
+        "bbox": [
+            186,
+            840,
+            823,
+            882
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            204,
+            103,
+            820,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 NEURAL ATTENTION MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            155,
+            459,
+            171
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we give a brief overview of the neural attention-based models we analyze for different categories of tasks listed in Section 2. The overall architecture for each category is shown in Fig 1. ",
+        "bbox": [
+            174,
+            186,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 SINGLE SEQUENCE MODELS:",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            418,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For single sequence tasks, we adopt the model architecture from Jain & Wallace (2019); Wiegreffe & Pinter (2019). For a given input sequence $\\pmb { x } \\in \\mathbb { R } ^ { T \\times | V | }$ , where $T$ and $| V |$ are the number of tokens and vocabulary size, we first represent each token with its $d$ -dimensional GloVe embedding Pennington et al. (2014) to obtain $\\pmb { x } _ { e } \\in \\mathbb { R } ^ { T \\times d }$ . Next, we use a Bi-RNN encoder $\\mathbf { ( E n c ) }$ to obtain an $m$ -dimensional contextualized representation of tokens: $\\pmb { h } = \\mathbf { E n c } ( \\pmb { x } _ { e } ) \\in \\mathbb { R } ^ { T \\times m }$ . Then, we use the additive formulation of attention proposed by Bahdanau et al. (2015) for computing attention weights $\\alpha _ { i }$ for all tokens defined as: ",
+        "bbox": [
+            173,
+            261,
+            825,
+            361
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45a086465938ed75ab9a397f367a976a0ca83bc2bf6d58f90ba3aba94fa3e05c.jpg",
+        "text": "$$\nu _ { i } = \\operatorname { t a n h } ( W h _ { i } + b ) ; \\quad \\alpha _ { i } = \\frac { \\exp ( { \\boldsymbol { u } _ { i } ^ { T } { \\boldsymbol { c } } } ) } { \\sum _ { j } \\exp ( { \\boldsymbol { u } _ { j } ^ { T } { \\boldsymbol { c } } } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            369,
+            656,
+            407
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where repres $\\boldsymbol { W } \\in \\mathbb { R } ^ { d ^ { \\prime } \\times m } , \\boldsymbol { b } , \\boldsymbol { c } \\in \\mathbb { R } ^ { d ^ { \\prime } }$ arameters of the model. Finally, the weighted instanceis fed to a dense layer (Dec) followed by softmax to $\\begin{array} { r } { \\pmb { h } _ { \\alpha } = \\sum _ { i = 1 } ^ { T } \\alpha _ { i } \\pmb { h } _ { i } \\in \\mathbb { R } ^ { m } } \\end{array}$ obtain prediction $\\hat { y } = \\sigma (  { \\mathbf { D e c } } (  { \\pmb { h } } _ { \\alpha } ) ) \\in \\mathbb { R } ^ { | \\mathcal { V } | }$ , where $| \\mathcal { V } |$ denotes the label set size. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            465
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We also analyze the hierarchical attention model (Yang et al., 2016), which involves first computing attention over the tokens to obtain a sentence representation. This is followed by attention over sentences to obtain an instance representation $h _ { \\alpha }$ , which is fed to a dense layer for obtaining prediction $\\left( \\hat { y } \\right)$ . At both word and sentence level the attention is computed similar to as defined in Equation 1. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 PAIR SEQUENCE MODELS: ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            398,
+            561
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For pair sequence, the input consists of two text sequences: $\\pmb { x } \\in \\mathbb { R } ^ { T _ { 1 } \\times | V | } , \\pmb { y } \\in \\mathbb { R } ^ { T _ { 2 } \\times | V | }$ of length $T _ { 1 }$ and $T _ { 2 }$ . In NLI, $_ { \\textbf { \\em x } }$ indicates premise and $\\textbf {  { y } }$ is hypothesis while in question answering, it is the question and paragraph respectively. Following Bowman et al. (2015), we use two separate RNNs for encoding both the sequences to obtain $\\{ h _ { 1 } ^ { x } , . . . , h _ { T _ { 1 } } ^ { x } \\}$ and $\\{ h _ { 1 } ^ { y } , . . . , h _ { T _ { 2 } } ^ { y } \\}$ . Now, similar to Jain & Wallace (2019), attention weight $\\alpha _ { i }$ 1over each token of $_ { \\textbf { \\em x } }$ 2 is computed as: ",
+        "bbox": [
+            173,
+            571,
+            825,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67772b11dcf0bfa552324aa9c83ffe41c77db2003512c9232a4360ad1ed4c763.jpg",
+        "text": "$$\nu _ { i } = \\operatorname { t a n h } ( W _ { 1 } h _ { i } ^ { x } + W _ { 2 } h _ { T _ { 2 } } ^ { y } ) ; \\quad \\alpha _ { i } = \\frac { \\exp ( u _ { i } ^ { T } c ) } { \\sum _ { j } \\exp ( u _ { j } ^ { T } c ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            651,
+            679,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where similar to Equation 1, $W _ { 1 } , W _ { 2 } \\in \\mathbb { R } ^ { d \\times d ^ { \\prime } }$ denotes the projection matrices and $\\boldsymbol { c } \\in \\mathbb { R } ^ { d ^ { \\prime } }$ is a parameter vector. Finally, the representation obtained from a weighted sum of tokens in $_ { \\textbf { \\em x } }$ : $h _ { \\alpha } =$ $\\textstyle \\sum _ { i = 1 } ^ { T } { \\alpha _ { i } } h _ { i } ^ { x }$ is fed to a classifier for prediction. ",
+        "bbox": [
+            174,
+            699,
+            825,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We also explore a variant of the above attention proposed by Rocktaschel et al. (2016). Instead of ¨ keeping the RNN encoders of both the sequences independent, Rocktaschel et al. (2016) use condi- ¨ the model to obtain a conditional encoding unlike the previous model, attention over the tional encoding where the encoder of is initialized with the final state of $\\{ h _ { 1 } ^ { \\prime y } , . . . , h _ { T _ { 2 } } ^ { \\prime y } \\}$ of  de $\\textbf {  { y } }$ given the sequence ed as follows: $_ { \\textbf { \\em x } }$ ’s encoder. This allows $_ { \\textbf { \\em x } }$ . Moreover, $_ { \\textbf { \\em x } }$ ",
+        "bbox": [
+            173,
+            752,
+            825,
+            823
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/654c5b58e178f02b7d3a72d7da6f0f354ebcd9be047b3965218b26c6227ea86d.jpg",
+        "text": "$$\nM = \\operatorname { t a n h } ( W _ { 1 } X + W _ { 2 } h _ { T _ { 2 } } ^ { \\prime y } \\otimes e _ { T _ { 1 } } ) ; \\quad \\alpha = \\operatorname { s o f t m a x } ( { \\pmb w } ^ { T } M ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            832,
+            709,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\pmb X } = [ { \\pmb h } _ { 1 } ^ { x } , . . . , { \\pmb h } _ { T _ { 1 } } ^ { x } ]$ , $\\boldsymbol { e } _ { T _ { 1 } } \\in \\mathbb { R } ^ { T _ { 1 } }$ is a vector of ones and outer product ${ \\cal W } _ { 2 } h _ { T _ { 2 } } ^ { \\prime y } \\otimes e _ { T _ { 1 } }$ denotes repeating linearly transformed $h _ { T _ { 2 } } ^ { \\prime y }$ as many times as words in the sequence $_ { \\textbf { \\em x } }$ (i.e. $T _ { 1 }$ times). ",
+        "bbox": [
+            174,
+            861,
+            826,
+            895
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 GENERATION TASK MODELS: ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            419,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this paper, for generation tasks, we focus on Neural Machine Translation (NMT) problem which involves translating a given source text sentence $\\pmb { x } \\in \\mathbb { R } ^ { T _ { 1 } \\times | V _ { 1 } | }$ to a sequence $\\pmb { y } ^ { \\mathrm { ~ ~ } } \\in \\mathbb { R } ^ { T _ { 2 } \\times | V _ { 2 } | }$ in the target language. The model comprises of two components: (a) an encoder which computes a representation for each source sentence and (b) a decoder which generates a target word at each time step. In this work, we utilize RNN based encoder and decoder models. For each input sentence $_ { \\textbf { \\em x } }$ , we first obtain a contextualized representation $\\{ h _ { 1 } , . . . , h _ { T _ { 1 } } \\}$ of its tokens using a multi-layer Bi-RNN. Then, at each time step $t$ , the decoder has a hidden state defined as ",
+        "bbox": [
+            173,
+            128,
+            825,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/06c713b0cc2a8564210e33a751c9f755cc33c2fa7c68aede89bfc078fada4052.jpg",
+        "text": "$$\n\\pmb { c } _ { t } = f ( \\pmb { c } _ { t - 1 } , y _ { t - 1 } , \\pmb { h } _ { \\alpha } ^ { t } ) , \\mathrm { w h e r e } \\pmb { h } _ { \\alpha } ^ { t } = \\sum _ { i = 1 } ^ { T _ { 1 } } \\alpha _ { t , i } \\pmb { h } _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            236,
+            661,
+            280
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our work, we compute $\\alpha _ { t , i }$ as proposed by Bahdanau et al. (2015) and Luong et al. (2015). The former computes attention weights using a feed-forward network, i.e., $\\alpha _ { t , i } = { w } ^ { T } \\mathrm { t a n h } ( { W } [ { c } _ { t } ; h _ { i } ] )$ while the latter define it simply as $\\alpha _ { t , i } = \\pmb { c } _ { t } ^ { T } h _ { i }$ . ",
+        "bbox": [
+            174,
+            285,
+            825,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 SELF-ATTENTION BASED MODELS: ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            348,
+            455,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We also examine self-attention based models on all three categories of tasks. For single and pair sequence tasks, we fine-tune pre-trained BERT (Devlin et al., 2019) model on the downstream task. In pair sequence tasks, instead of independently encoding each text, we concatenate both separated by a delimiter and pass it to BERT model. Finally, the embedding corresponding to [CLS] token is fed to a feed-forward network for prediction. For neural machine translation, we use Transformer model proposed by Vaswani et al. (2017) with base configuration. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            459
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 IS ATTENTION AN EXPLANATION? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            479,
+            490,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we attempt to address the question: Is attention an explanation? through a series of experiments which involve analyzing attention weights in a variety of models (§3) on multiple tasks (§2). Following Jain & Wallace (2019), we take the definition of explainability of attention as: inputs with high attention weights are responsible for model output. Jain & Wallace (2019); Serrano & Smith (2019) have extensively investigated this aspect for certain class of problems and have shown that attention does not provide an explanation. However, another series of work (Vig & Belinkov, 2019; Clark et al., 2019; Tenney et al., 2019) has shown that attention does encode several linguistic notions. In our work, we claim that the findings of both the line of work are consistent. We note that the observations of the former works can be explained based on the following proposition. ",
+        "bbox": [
+            173,
+            511,
+            825,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proposition 4.1. Attention mechanism as defined in Equation 1 as ",
+        "bbox": [
+            173,
+            641,
+            612,
+            656
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/974f85152574853603845858fad55026be468f3a1ec035c4eaf0de1db95f6567.jpg",
+        "text": "$$\n{ \\pmb u } _ { i } = \\operatorname { t a n h } ( { \\pmb W } { \\pmb h } _ { i } + { \\pmb b } ) ; \\quad \\alpha _ { i } = \\frac { \\exp ( { \\pmb u } _ { i } ^ { T } { \\pmb c } ) } { \\sum _ { j } \\exp ( { \\pmb u } _ { j } ^ { T } { \\pmb c } ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            662,
+            655,
+            702
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for single sequence tasks can be interpreted as a gating unit in the network. ",
+        "bbox": [
+            174,
+            707,
+            666,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof: The attention weighted averaging computed in Equation 1 for single sequence tasks can be interpreted as gating proposed by Dauphin et al. (2017) which is defined as ",
+        "bbox": [
+            171,
+            733,
+            821,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd2b2c7647403d0333d0ced98be41b036b756e470d0a22de20b5aaa65a0b6569.jpg",
+        "text": "$$\nh ( { \\pmb x } ) = f ( { \\pmb x } ) \\times \\sigma ( g ( { \\pmb x } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            768,
+            583,
+            786
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { x } \\in \\mathbb { R } ^ { m }$ is the input and $\\times$ denotes product between transformed input $f ( \\pmb { x } ) \\in \\mathbb { R } ^ { m }$ and its computed gating scores $\\sigma ( \\ b { g } ( \\pmb { x } ) ) \\in \\mathbb { R }$ . Equation 1 can be reduced to the above form by taking $f$ as an identity function and defining $g ( \\pmb { x } ) \\overset { \\cdot } { = } c ^ { T } \\mathrm { t a n h } ( \\pmb { W } \\pmb { x } + \\pmb { b } ) \\in \\mathbb { R }$ and replacing $\\sigma$ with softmax. We note that the same reduction does not hold in the case of pair sequence and generation tasks where attention along with input also depends on another text sequence $\\mathbf { Y }$ and current hidden state $\\mathbf { } _ { c _ { t } }$ , respectively. Thus, attention mechanism for these tasks take the form ",
+        "bbox": [
+            173,
+            792,
+            825,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/671c15a54da0ac520f00943f55be38a0f7ed2a97555f9e2df0d69606553bf47f.jpg",
+        "text": "$$\nh ( x , y ) = f ( x ) \\times \\sigma ( g ( x , y ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            885,
+            599,
+            902
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "which does not reduce to the above equation for gating unit. ",
+        "bbox": [
+            173,
+            909,
+            566,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/c6a72af4678e1f10edcb9d98e419eceaf4c72340bc39bdfe7b25b75ffc0cd13e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>SST</td><td>IMDB</td><td>AG News</td><td>YELP</td></tr><tr><td>Bahdanau et al. (2015)</td><td>83.4± 0.5</td><td>90.7± 0.7</td><td>96.4± 0.1</td><td>66.7± 0.1</td></tr><tr><td>Uniform (Train+Infer /Infer)</td><td>-1.0/-0.8</td><td>-0.8/-6.3</td><td>-0.1/-0.7</td><td>-0.5/-6.3</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-1.1/-0.9</td><td>-0.6/-6.4</td><td>-0.0/-0.7</td><td>-0.4/-6.4</td></tr><tr><td>Permute (Infer)</td><td>-1.7</td><td>-5.1</td><td>-0.9</td><td>-7.8</td></tr><tr><td>Yang et al. (2016)</td><td>83.2± 0.5</td><td>89.7± 0.6</td><td>96.1 ± 0.2</td><td>65.8 ± 0.1</td></tr><tr><td>Uniform (Train+Infer /Infer)</td><td>-1.0/-0.8</td><td>+0.2/-6.5</td><td>+0.1/-1.5</td><td>-0.7/-8.0</td></tr><tr><td>Random(Train+Infer /Infer)</td><td>-0.9/-1.0</td><td>-1.2/-8.2</td><td>-0.1/-1.8</td><td>-3.0/-10.2</td></tr><tr><td>Permute (Infer)</td><td>-1.8</td><td>-5.1</td><td>-0.7</td><td>-10.7</td></tr></table>",
+        "bbox": [
+            230,
+            99,
+            767,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Evaluation results on single sequence tasks. We report the base performance of attention models and absolute change in accuracy for its variant. We note that across all datasets, degradation in performance on altering attention weights during inference is more compared to varying them during both training and inference. Overall, the change in performance is less compared to other tasks. Please refer to $\\ S 4 . 1$ for more details. ",
+        "bbox": [
+            173,
+            262,
+            825,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Based on the above proposition, we argue that weights learned in single sequence tasks cannot be interpreted as attention, and therefore, they do not reflect the reasoning behind the model’s prediction. This justifies the observation that for the single sequence tasks examined in Jain & Wallace (2019); Serrano & Smith (2019), attention weights do not correlate with feature importance measures and permuting them does not change the prediction of the model. In light of this observation, we revisit the explainability of attention weights by asking the following questions. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            433
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 HOW DOES ALTERING ATTENTION WEIGHTS AFFECT MODEL OUTPUT ON TASKS? ",
+        "bbox": [
+            173,
+            449,
+            769,
+            463
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare the performance of various attention mechanism described in $\\ S 3$ for different categories of tasks listed in $\\ S 2$ . For each model, we analyze its three variants defined as: ",
+        "bbox": [
+            176,
+            474,
+            826,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Uniform denotes the case when all the inputs are given equal weights, i.e., $\\alpha _ { i } = 1 / T , \\forall i \\in$ $\\{ 1 , . . . , T \\}$ . This is similar to the analysis performed by Wiegreffe & Pinter (2019). However, we consider two scenarios when the weights are kept fixed both during training and inference (Train+Infer) and only during inference (Infer).   \n��� Random refers to the variant where all the weights are randomly sampled from a uniform distribution: $\\alpha _ { i } \\sim U ( 0 , 1 )$ , $\\forall i \\in \\{ 1 , . . . , T \\}$ , this is followed by normalization. Similar to Uniform, we analyze both Train+Infer and Infer.   \n• Permute refers to the case when the learned attention weights are randomly permuted during inference, i.e., $\\pmb { \\alpha } = \\mathrm { s h u f f e } ( \\pmb { \\alpha } )$ . Unlike the previous two, here we restrict our analysis to only permuting during inference as Tensorflow currently does not support backpropagation with shuffle operation.4 ",
+        "bbox": [
+            191,
+            512,
+            825,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Effect on single sequence tasks: The evaluation results on single sequence datasets: SST, IMDB, AG News, and YELP are presented in Table 1. We observe that Train+Infer case of Uniform and Random attentions gives around 0.5 and 0.9 average decrease in accuracy compared to the base model. However, in Infer scenario the degradation on average increases to 3.9 and 4.5 absolute points respectively. This is so because the model becomes more robust to handle altered weights in the former case. The reduction in performance from Permute comes around to 4.2 across all datasets and models. The results support the observation of Jain & Wallace (2019); Serrano & Smith (2019) that alternating attention in text classification task does not have much effect on the model output. The slight decrease in performance can be attributed to corrupting the existing gating mechanism which has been shown to give some improvement (Oord et al., 2016; Dauphin et al., 2017; Marcheggiani & Titov, 2017). ",
+        "bbox": [
+            173,
+            684,
+            825,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Effect on pair sequence and generation tasks: The results on pair sequence and generation tasks are summarized in Table 2 and 3, respectively. Overall, we find that the degradation in performance from altering attention weights in case of pair sequence and generation tasks is much more substantial than single sequence tasks. For instance, in Uniform (Train+Infer), the average relative decrease in performance of single sequence tasks is $0 . 1 \\%$ whereas in case of pair sequence and generation tasks it is $4 9 . 5 \\%$ and $5 1 . 2 \\%$ respectively. The results thereby validate our Proposition 4.1 and show that altering attention does affect model output for a task where the attention layer cannot be modeled as a gating unit in the network. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            901
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/3d524d9e65eb50e45aeff73260ac553380a9ba1db5d4011c0387088c5e1d078e.jpg",
+        "table_caption": [
+            "Table 2: The performance comparison of attention based models and their variants on pair sequence tasks. We find that the degradation in performance is much more than single sequence tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>SNLI</td><td>MultiNLI</td><td>CNN</td><td>babI 0</td><td>babI1</td><td>babI2</td></tr><tr><td>Bahdanau et al. (2015)</td><td>75.7± 0.3</td><td>61.1 ± 0.1</td><td>63.4±0.8</td><td>96.1 ± 4.3</td><td>95.8 ±0.3</td><td>92.8± 0.1</td></tr><tr><td>Uniform (Train+Infer Infer)</td><td>-41.8/-42.9</td><td>-26.6/-28.7</td><td>-30.8/-55.9</td><td>-44.4/-63.4</td><td>-47.4/-60.4</td><td>-48.4/-62.1</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-41.6 /-43.1</td><td>-26.7/-28.6</td><td>-30.9/-55.9</td><td>-45.0/-62.0</td><td>-47.3/-60.4</td><td>-49.9/-62.2</td></tr><tr><td>Permute (Infer)</td><td>-41.0</td><td>-27.6</td><td>-54.8</td><td>-67.8</td><td>-68.3</td><td>-66.7</td></tr><tr><td>Rocktäschel et al.(2016)</td><td>78.1±0.2</td><td>62.4± 0.6</td><td>63.6±0.6</td><td>98.6±1.6</td><td>96.2±0.9</td><td>93.2± 0.1</td></tr><tr><td>Uniform (Train+Infer/Infer)</td><td>-44.2/-45.4</td><td>-27.5/-30.3</td><td>-30.8/-43.1</td><td>−47.7/-67.8</td><td>-47.9/-62.8</td><td>-49.8/-60.9</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-44.3/-44.9</td><td>-27.9/-28.3</td><td>-30.6/-43.3</td><td>-47.5/-64.9</td><td>-48.4/-63.3</td><td>-49.8/-60.9</td></tr><tr><td>Permute (Infer)</td><td>-41.7</td><td>-29.2</td><td>-44.9</td><td>-68.8</td><td>-68.3</td><td>-65.2</td></tr></table>",
+        "bbox": [
+            174,
+            101,
+            823,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/fb7ec5579680b7ce414d694d88d258683676978036948edb61685a224536f1ca.jpg",
+        "table_caption": [
+            "Table 3: Evaluation results on neural machine translation. Similar to pair sequence tasks, we find that the deterioration in performance is much more substantial than single sequence tasks. Please refer to $\\ S 4 . 1$ for more details. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Multi30k</td><td>News Commentary</td></tr><tr><td>Bahdanau et al. (2015)</td><td>31.3 ± 0.1</td><td>12.6 ± 0.1</td></tr><tr><td>Uniform (Train+Infer /Infer)</td><td>-10.4/-29.4</td><td>-8.7/-11.8</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-10.1/-29.4</td><td>-8.8/-11.9</td></tr><tr><td>Permute (Infer)</td><td>-29.7</td><td>-12.1</td></tr><tr><td>Luong et al. (2015)</td><td>31.5 ± 0.2</td><td>12.7 ± 0.2</td></tr><tr><td>Uniform (Train+Infer /Infer)</td><td>-10.6/-29.7</td><td>-8.8 /-12.0</td></tr><tr><td>Random (Train+Infer /Infer)</td><td>-10.3/-29.8</td><td>-8.9 /-12.0</td></tr><tr><td>Permute (Infer)</td><td>-30.1</td><td>-12.2</td></tr></table>",
+        "bbox": [
+            290,
+            284,
+            707,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            511,
+            825,
+            566
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Visualizing the effect of permuting attention weights: To further reinforce our claim, similar to Jain & Wallace (2019), we report the median of Total Variation Distance (TVD) between new and original prediction on permuting attention weights for each task. The TVD between two predictions $\\hat { y } _ { 1 }$ and asses $\\hat { y } _ { 2 }$ is defined as: the problem. $\\begin{array} { r } { \\mathrm { T V D } ( \\hat { y _ { 1 } } , \\hat { y } _ { 2 } ) = \\frac { 1 } { 2 } \\sum _ { i = 1 } ^ { | \\bar { y } | } | \\hat { y } _ { 1 i } - \\hat { y } _ { 2 i } | } \\end{array}$ , where nge in o $| \\mathcal { V } |$ denotes the total number ofut distribution on permuting the attention weights. In Figure 2, we report the relationship between the maximum attention value and the median induced change in model output over 100 permutations on all categories of tasks. For NMT task, we present change in output at the 25th-percentile length of sentences for both datasets. Overall, we find that for single sequence tasks even with the maximum attention weight in range [0.75, 1.0], the change in prediction is considerably small (the violin plots are to the left of the figure) compared to the pair sequence and generation tasks (the violin plots are to the right of the figure). ",
+        "bbox": [
+            173,
+            574,
+            825,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 DO ATTENTION WEIGHTS CORRELATE WITH FEATURE IMPORTANCE MEASURES?",
+        "text_level": 1,
+        "bbox": [
+            173,
+            768,
+            766,
+            782
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, similar to the analysis of Serrano & Smith (2019), we investigate the importance of attention weights only when one weight is removed. Let $i ^ { * }$ be the input corresponding to the highest attention weights and let $r$ be any randomly selected input. We denote the original model’s prediction as $\\pmb { p }$ and output after removing $i ^ { * }$ and $r$ input as ${ \\pmb q } _ { \\{ i ^ { * } \\} }$ and $\\pmb q _ { \\{ r \\} }$ respectively. Now, to measure the impact of removing $i ^ { * }$ relative to any randomly chosen input $r$ on the model output, we compute the difference of Jensen-Shannon (JS) divergence between $\\mathrm { J S } ( p , q _ { \\{ i ^ { * } \\} } )$ and $\\mathrm { J S } ( \\pmb { p } , \\pmb { q } _ { \\{ r \\} } )$ given as: $\\Delta \\mathrm { J S } = \\mathrm { J S } ( p , q _ { \\{ i ^ { * } \\} } ) - \\mathrm { J S } ( p , q _ { \\{ r \\} } )$ . The relationship between the difference of attention weights corresponding to $i ^ { * }$ and $r$ , i.e., $\\alpha _ { i ^ { * } } - \\alpha _ { r }$ and $\\Delta \\mathrm { J S }$ for different tasks is presented in Figure 3. In general, we found that for single sequence tasks, the change JS divergence is small even for cases when the difference in attention weight is considerable. However, for pair sequence and generation tasks, there is a substantial change in the model output. ",
+        "bbox": [
+            173,
+            796,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d742f8efabb51c0323c469be27ae401326114feaa89aa08e4591a4dc13ae5442.jpg",
+        "image_caption": [
+            "Figure 2: Relationship between maximum attention weight and median change in output on permuting attention weights. For single sequence tasks, \u0004 indicate negative and positive class. For MultiNLI, \u0004, \u0004 \u0004 denotes contradiction, entailment and neutral respectively. The results reinforce the claim that altering attention weights in single sequence tasks does not have much effect on performance while the same does not hold with other tasks. Refer to $\\ S 4 . 1$ for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            109,
+            810,
+            358
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/e6b53e9c3471d87eeb36af12f65695ce678e117ba6df38fc698fb787660632af.jpg",
+        "image_caption": [
+            "Figure 3: Analysis of correlation between attention weights and feature importance measure. We report relationship between difference in zeroed attention weights and corresponding change in $J S$ divergence for different tasks. Please refer to $\\ S 4 . 2$ for more details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            463,
+            813,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            683,
+            823,
+            710
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 HOW PERMUTING DIFFERENT LAYERS OF SELF-ATTENTION BASED MODELS AFFECT PERFORMANCE? ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            729,
+            790,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyze the importance of attention weights on the performance of self-attention based models as described in $\\ S 3 . 4$ . We report the accuracy on single, and pair sequence tasks and BLEU score for NMT on WMT13 dataset on permuting the attention weights of layers cumulatively. For Transformer model, we analyze the effect of altering attention weights in encoder, decoder, and across encoder-decoder (denoted by Across). The results are presented in Figure 4. Overall, we find that unlike the pattern observed in $\\ S 4 . 1$ and $\\ S 4 . 2$ for single sequence tasks, altering weights in self-attention based models does have a substantial effect on the performance. We note that this is because while computing attention weights over all tokens with respect to a given token, Proposition 4.1 does not hold. Thus, altering them does have an impact across all three tasks. We note that in the case of transformer model, altering the weights in the first step of Decoder and in Across has maximum effect as it almost stops the flow of information from encoder to decoder. ",
+        "bbox": [
+            173,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1438fd06fc2a1a04edbe0b4c97a548e31f6a5970f02060d027b5fb54799b3e06.jpg",
+        "image_caption": [
+            "Figure 4: Performance comparison with permuting attention weights for different layers in selfattention based models. The results are reported on a representative instance of single sequence, pair sequence and generation tasks. The dotted lines denote the base performance on the task. Refer to $\\ S 4 . 3$ for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            103,
+            790,
+            263
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1f405a4c192f13cde3a1c3f16b33240f14bfa4d0d57feb216a6f3d5de48d9d15.jpg",
+        "image_caption": [
+            "Figure 5: Manual evaluation of interpretability of attention weights on single and pair sequence tasks. Although with original weights the attention does remain interpretable on both tasks but in the case of single sequence tasks making it meaningless does not change the prediction substantially. However, the same does not hold with pair sequence tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            282,
+            371,
+            714,
+            474
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 ARE ATTENTION WEIGHTS HUMAN INTERPRETABLE?",
+        "text_level": 1,
+        "bbox": [
+            173,
+            588,
+            581,
+            602
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To determine if attention weights are human interpretable, here, we address the question of interpretability of attention weights by manually analyzing them on a representative dataset of single and pair sequence task. For each task, we randomly sample 100 samples with original attention weights and 100 with randomly permuted weights. Then, we shuffle all 200 samples together and present them to annotators for deciding whether the top three highest weighted words are relevant for the model’s prediction. ",
+        "bbox": [
+            174,
+            618,
+            825,
+            702
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The overall results are reported in Figure 5. Cohen’s kappa score of inter-annotator agreement (Cohen, 1960) on IMDB and babI is 0.84 and 0.82, respectively, which shows near-perfect agreement (Landis & Koch, 1977). We find that in both single and pair sequence tasks, the attention weights in samples with original weights do make sense in general (highlighted with blue color). However, in the former case, the attention mechanism learns to give higher weights to tokens relevant to both kinds of sentiment. For instance, in “This is a great movie. Too bad it is not available on home video.”, tokens great, too, and bad get the highest weight. Such examples demonstrate that the attention mechanism in single sequence tasks works like a gating unit, as shown in $\\ S 4 . 1$ . ",
+        "bbox": [
+            173,
+            708,
+            825,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For permuted samples, in the case of single sequence, the prediction remains correct in majority although the attention weights were meaningless. For example, in “This movie was terrible . the acting was lame , but it ’s hard to tell since the writing was so bad .”, the prediction remains the same on changing attention weights from underlined to bold tokens. However, this does not hold with the pair sequence task. This shows that attention weights in single sequence tasks do not provide a reason for the prediction, which in the case of pairwise tasks, attention do reflect the reasoning behind model output. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            318,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we addressed the seemingly contradictory viewpoint over explainability of attention weights in NLP. On the one hand, some works have demonstrated that attention weights are not interpretable, and altering them does not affect the model output while several others have shown that attention captures several linguistic notions in the model. We extend the analysis of prior works to diverse NLP tasks and demonstrate that attention weights are interpretable and are correlated with feature importance measures. However, this holds only for cases when attention weights are essential for model’s prediction and cannot simply be reduced to a gating unit. Through a battery of experiments, we validate our claims and reinforce them through manual evaluation. ",
+        "bbox": [
+            173,
+            130,
+            825,
+            241
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            262,
+            285,
+            276
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. In Proc. of ICLR, 2014.   \nDzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly learning to align and translate. In Proc. of ICLR, 2015.   \nSamuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. A large annotated corpus for learning natural language inference. In Proc. of EMNLP, 2015.   \nS. Chakraborty, R. Tomsett, R. Raghavendra, D. Harborne, M. Alzantot, F. Cerutti, M. Srivastava, A. Preece, S. Julier, R. M. Rao, T. D. Kelley, D. Braines, M. Sensoy, C. J. Willis, and P. Gurram. Interpretability of deep learning models: A survey of results. In Proc. of UbiComp, 2017.   \nKevin Clark, Urvashi Khandelwal, Omer Levy, and Christopher D. Manning. What does BERT look at? an analysis of bert’s attention. In Proc. of BlackBoxNLP, 2019.   \nJ. Cohen. A Coefficient of Agreement for Nominal Scales. Educational and Psychological Measurement, 20(1):37, 1960.   \nYann N. Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. In Proc. of ICML, 2017.   \nJacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proc. of NAACL, 2019.   \nDesmond Elliott, Stella Frank, Khalil Sima’an, and Lucia Specia. Multi30k: Multilingual englishgerman image descriptions. In Proc of the 5th Workshop on Vision and Language, 2016.   \nReza Ghaeini, Xiaoli Z. Fern, and Prasad Tadepalli. Interpreting recurrent and attention-based neural models: a case study on natural language inference. In Proc. of EMNLP, 2018.   \nKarl Moritz Hermann, Toma´s Ko ˇ cisk ˇ y, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa ´ Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Proc. of NIPS, 2015.   \nSarthak Jain and Byron C. Wallace. Attention is not Explanation. In Proc. of ACL, 2019.   \nJ. Richard Landis and Gary G. Koch. The measurement of observer agreement for categorical data. Biometrics, 33(1), 1977.   \nZhouhan Lin, Minwei Feng, C´ıcero Nogueira dos Santos, Mo Yu, Bing Xiang, Bowen Zhou, and Yoshua Bengio. A structured self-attentive sentence embedding. In Proc. of ICLR, 2017.   \nYang Liu and Mirella Lapata. Learning structured text representations. Transactions of the Association for Computational Linguistics, 6:63–75, 2018. ISSN 2307-387X.   \nThang Luong, Hieu Pham, and Christopher D. Manning. Effective approaches to attention-based neural machine translation. In Proc. of EMNLP, 2015.   \nAndrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Proc. of ACL, 2011. ",
+        "bbox": [
+            171,
+            280,
+            826,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diego Marcheggiani and Ivan Titov. Encoding sentences with graph convolutional networks for semantic role labeling. In Proc. of EMNLP, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray ¨ Kavukcuoglu. Conditional image generation with pixelcnn decoders. In Proc. of NIPS, 2016. ",
+        "bbox": [
+            174,
+            140,
+            821,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher D. Manning. Glove: Global vectors for word representation. In Proc. of EMNLP, 2014. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tim Rocktaschel, Edward Grefenstette, Karl Moritz Hermann, Tomas Kocisky, and Phil Blunsom. ¨ Reasoning about entailment with neural attention. In Proc. of ICLR, 2016. ",
+        "bbox": [
+            174,
+            215,
+            821,
+            246
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sofia Serrano and Noah A. Smith. Is attention interpretable? In Proc. of ACL, 2019. ",
+        "bbox": [
+            174,
+            253,
+            725,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew $\\mathrm { N g }$ and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proc. of EMNLP, 2013. ",
+        "bbox": [
+            176,
+            279,
+            820,
+            321
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Tenney, Dipanjan Das, and Ellie Pavlick. BERT rediscovers the classical NLP pipeline. In Proc. of ACL, 2019. ",
+        "bbox": [
+            171,
+            329,
+            821,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "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 Proc. of NIPS, 2017. ",
+        "bbox": [
+            171,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jesse Vig and Yonatan Belinkov. Analyzing the structure of attention in a transformer language model. In Proc. of BlackBoxNLP, 2019. ",
+        "bbox": [
+            173,
+            405,
+            823,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yequan Wang, Minlie Huang, Xiaoyan Zhu, and Li Zhao. Attention-based LSTM for aspect-level sentiment classification. In Proc. of EMNLP, 2016. ",
+        "bbox": [
+            173,
+            443,
+            823,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jason Weston, Antoine Bordes, Sumit Chopra, and Tomas Mikolov. Towards ai-complete question answering: A set of prerequisite toy tasks. In Proc. of ICLR, 2015. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sarah Wiegreffe and Yuval Pinter. Attention is not not explanation. In Proc. of EMNLP, 2019. ",
+        "bbox": [
+            173,
+            517,
+            792,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proc. of NAACL, 2018. ",
+        "bbox": [
+            171,
+            542,
+            823,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Lei Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhutdinov, Richard S. Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In Proc. of ICML, 2015. ",
+        "bbox": [
+            176,
+            579,
+            823,
+            623
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zichao Yang, Diyi Yang, Chris Dyer, Xiaodong He, Alex Smola, and Eduard Hovy. Hierarchical attention networks for document classification. In Proc. of NAACL, 2016. ",
+        "bbox": [
+            173,
+            631,
+            821,
+            661
+        ],
+        "page_idx": 9
+    }
+]

parse/train/cVwc7IHWEWi/cVwc7IHWEWi.md

@@ -0,0 +1,317 @@
+# Near-Optimal No-Regret Learning in General Games
+
+Constantinos Daskalakis MIT CSAIL costis@csail.mit.edu
+
+Maxwell Fishelson MIT CSAIL maxfish@mit.edu
+
+Noah Golowich MIT CSAIL nzg@mit.edu
+
+# Abstract
+
+We show that Optimistic Hedge – a common variant of multiplicative-weightsupdates with recency bias – attains poly $( \log T )$ regret in multi-player general-sum games. In particular, when every player of the game uses Optimistic Hedge to iteratively update her strategy in response to the history of play so far, then after $T$ rounds of interaction, each player experiences total regret that is poly $( \log T )$ . Our bound improves, exponentially, the $O ( T ^ { 1 / 2 } )$ regret attainable by standard no-regret learners in games, the $O ( T ^ { 1 / 4 } )$ regret attainable by no-regret learners with recency bias [SALS15], and the $O ( T ^ { 1 / 6 } )$ bound that was recently shown for Optimistic Hedge in the special case of two-player games [CP20]. A corollary of our bound is that Optimistic Hedge converges to coarse correlated equilibrium in general games at a rate of ${ \tilde { O } } \left( { \scriptstyle { \frac { 1 } { T } } } \right)$ .
+
+# 1 Introduction
+
+Online learning has a long history that is intimately related to the development of game theory, convex optimization, and machine learning. One of its earliest instantiations can be traced to Brown’s proposal [Bro49] of fictitious play as a method to solve two-player zero-sum games. Indeed, as shown by [Rob51], when the players of (zero-sum) matrix game use fictitious play to iteratively update their actions in response to each other’s history of play, the resulting dynamics converge in the following sense: the product of the empirical distributions of strategies for each player converges to the set of Nash equilibria in the game, though the rate of convergence is now known to be exponentially slow [DP14]. Moreover, such convergence to Nash equilibria fails in non-zero-sum games [Sha64].
+
+The slow convergence of fictitious play to Nash equilibria in zero-sum matrix games and nonconvergence in general-sum games can be mitigated by appealing to the pioneering works [Bla54, Han57] and the ensuing literature on no-regret learning [CBL06]. It is known that if both players of a zero-sum matrix game experience regret that is at most $\varepsilon ( T )$ , the product of the players’ empirical distributions of strategies is an $O ( \varepsilon ( \bar { T } ) / T )$ -approximate Nash equilibrium. More generally, if each player of a general-sum, multi-player game experiences regret that is at most $\varepsilon ( T )$ , the empirical distribution of joint strategies converges to a coarse correlated equilibrium1 of the game, at a rate of $O ( \varepsilon ( T ) / T )$ . Importantly, a multitude of online learning algorithms, such as the celebrated Hedge and Follow-The-Perturbed-Leader algorithms, guarantee adversarial regret $O ( \sqrt { T } )$ [CBL06]. Thus, when such algorithms are employed by all players in a game, their $O ( \sqrt { T } )$ regret implies convergence to coarse correlated equilibria (and Nash equilibria of matrix games) at a rate of $O ( 1 / \sqrt { T } )$ .
+
+While standard no-regret learners guarantee $O ( \sqrt { T } )$ regret for each player in a game, the players can do better by employing specialized no-regret learning procedures. Indeed, it was established by [DDK11] that there exists a somewhat complex no-regret learner based on Nesterov’s excessive gap technique [Nes05], which guarantees ${ \cal O } ( \log T )$ regret to each player of a two-player zero-sum game.
+
+Table 1: Overview of prior work on fast rates for learning in games. $m$ denotes the number of players, and $n$ denotes the number of actions per player (assumed to be the same for all players). For Optimistic Hedge, the adversarial regret bounds in the right-hand column are obtained via a choice of adaptive step-sizes. The ${ \tilde { O } } ( \cdot )$ notation hides factors that are polynomial in $\log T$ .   
+
+<table><tr><td>Algorithm</td><td>Setting</td><td>Regret in games</td><td>Adversarial regret</td></tr><tr><td>Hedge (&amp; many other algs.)</td><td>multi-player, general-sum</td><td>O(√Tlog n) [CBL06]</td><td>O(√Tlog n) [CBL06]</td></tr><tr><td>Excessive Gap Technique</td><td>2-player, 0-sum</td><td>O(1og n(logT + 10g3/2 n)) [DDK11]</td><td>O(√Tlog n) [DDK11]</td></tr><tr><td>DS-OptMD, OptDA</td><td>2-player, 0-sum</td><td>l0g0(1)(n) [HAM21]</td><td>√T l0go(1)(n) [HAM21]</td></tr><tr><td>Optimistic Hedge</td><td>multi-player, general-sum</td><td>O(log n · √m T1/4) [RS13b, SALS15]</td><td>0(√Tlogn) [RS13b, SALS15]</td></tr><tr><td>Optimistic Hedge</td><td>2-player, general-sum</td><td>O(log5/6 n · T1/6) [CP20]</td><td>O(√Tlogn)</td></tr><tr><td>Optimistic Hedge</td><td>multi-player, general-sum</td><td>O(log n · m · log4 T) (Theorem 3.1)</td><td>0(√Tlogn) (Corollary D.1)</td></tr></table>
+
+This represents an exponential improvement over the regret guaranteed by standard no-regret learners. More generally, [SALS15] established that if players of a multi-player, general-sum game use any algorithm from the family of Optimistic Mirror Descent (MD) or Optimistic Follow-the-RegularizedLeader (FTRL) algorithms (which are analogoues of the MD and FTRL algorithms, respectively, with recency bias), each player enjoys regret that is $O ( T ^ { 1 / 4 } )$ . This was recently improved by [CP20] to $O ( T ^ { 1 / 6 } )$ in the special case of two-player games in which the players use Optimistic Hedge, a particularly simple representative from both the Optimistic MD and Optimistic FTRL families.
+
+The above results for general-sum games represent significant improvements over the $O ( \sqrt { T } )$ regret attainable by standard no-regret learners, but are not as dramatic as the logarithmic regret that has been shown attainable by no-regret learners, albeit more complex ones, in 2-player zero-sum games (e.g., [DDK11]). Indeed, despite extensive work on no-regret learning, understanding the optimal regret that can be guaranteed by no-regret learning algorithms in general-sum games has remained elusive. This question is especially intruiging in light of experiments suggesting that polylogarithmic regret should be attainable [SALS15, HAM21]. In this paper we settle this question by showing that no-regret learners can guarantee polylogarithmic regret to each player in general-sum multi-player games. Moreover, this regret is attainable by a particularly simple algorithm – Optimistic Hedge:
+
+Theorem 1.1 (Abbreviated version of Theorem 3.1). Suppose that m players play a general-sum multi-player game, with a finite set of n strategies per player, over $T$ rounds. Suppose also that each player uses Optimistic Hedge to update her strategy in every round, as a function of the history of play so far. Then each player experiences $O ( m \cdot \log n \cdot \log ^ { 4 } T )$ regret.
+
+An immediate corollary of Theorem 1.1 is that the empirical distribution of play is a O ⇣ m log n log4 TT ⌘ approximate coarse correlated equilibrium (CCE) of the game. We remark that Theorem 1.1 bounds the total regret experienced by each player of the multi-player game, which is the most standard regret objective for no-regret learning in games, and which is essential to achieve convergence to CCE. For the looser objective of the average of all players’ regrets, [RS13b] established a ${ \bar { O } } ( \log n )$ bound for Optimistic Hedge in two-player zero-sum games, and [SALS15] generalized this bound, to $O ( m \log n )$ in $m$ -player general-sum games. Note that since some players may experience negative regret [HAM21], the average of the players’ regrets cannot be used in general to bound the maximum regret experienced by any individual player. Finally, we remark that several results in the literature posit no-regret learning as a model of agents’ rational behavior; for instance, [Rou09, ST13, RST17] show that no-regret learners in smooth games enjoy strong Price-of-Anarchy bounds. By showing that each agent can obtain very small regret in games by playing Optimistic Hedge, Theorem 1.1 strengthens the plausability of the common assumption made in this literature that each agent will choose to use such a no-regret algorithm.
+
+# 1.1 Related work
+
+Table 1 summarizes the prior works that aim to establish optimal regret bounds for no-regret learners in games. We remark that [CP20] shows that the regret of Hedge is $\Omega ( { \sqrt { T } } )$ even in 2-player games where each player has 2 actions, meaning that optimism is necessary to obtain fast rates. The table also includes a recent result of [HAM21] showing that when the players in a 2-player zero-sum game with $n$ actions per player use a variant of Optimistic Hedge with adaptive step size (a special case of their algorithms DS-OptMD and OptDA), each player has $\log ^ { O ( 1 ) } { \bar { n } }$ regret. The techniques of [HAM21] differ substantially from ours: the result in [HAM21] is based on showing that the joint strategies $x ^ { ( t ) }$ rapidly converge, pointwise, to a Nash equilibrium $x ^ { \star }$ . Such a result seems very unlikely to extend to our setting of general-sum games, since finding an approximate Nash equilibrium even in 2-player games is PPAD-complete [CDT09]. We also remark that the earlier work [KHSC18] shows that each player’s regret is at most $O ( \log T \cdot \log n )$ when they use a certain algorithm based on Optimistic MD in 2-player zero-sum games; their technique is heavily tailored to 2-player zero-sum games, relying on the notion of duality in such a setting.
+
+$[ \mathrm { F L L ^ { + } } 1 6 ]$ shows that one can obtain fast rates in games for a broader class of algorithms (e.g., including Hedge) if one adopts a relaxed (approximate) notion of optimality. [WL18] uses optimism to obtain adaptive regret bounds for bandit problems. Many recent papers (e.g., [DP19, GPD20, LGNPw21, HAM21, WLZL21, AIMM21]) have studied the last-iterate convergence of algorithms from the Optimistic Mirror Descent family, which includes Optimistic Hedge. Finally, a long line of papers (e.g., $[ \mathrm { H M c W ^ { + } } 0 3$ , $\mathrm { D F P ^ { + } 1 0 }$ , KLP11, BCM12, PP16, BP18, MPP18, BP19, CP19, $\mathrm { V G F L } ^ { + } 2 0 \bar { ] }$ ) has studied the dynamics of learning algorithms in games. Essentially all of these papers do not use optimism, and many of them show non-convergence (e.g., divergence or recurrence) of the iterates of various learning algorithms such as FTRL and Mirror Descent when used in games.
+
+# 2 Preliminaries
+
+Notation. For a positive integer $n$ , let $[ n ] : = \{ 1 , 2 , . . . , n \}$ . For a finite set $s$ , let $\Delta ( S )$ denote the space of distributions on $s$ . For $\mathcal { S } = [ n ]$ , we will write $\Delta ^ { n } : = \Delta ( S )$ and interpret elements of $\Delta ^ { n }$ as vectors in $\mathbb { R } ^ { n }$ . For a vector $v \in \mathbb { R } ^ { n }$ and $j \in [ n ]$ , we denote the $j$ th coordinate of $v$ as $v ( j )$ . For vectors $v , w \in \mathbb { R } ^ { n }$ , write $\begin{array} { r } { \langle v , w \rangle = \sum _ { j = 1 } ^ { n } v ( j ) w ( j ) } \end{array}$ . The base-2 logarithm of $x > 0$ is denoted $\log x$
+
+No-regret learning in games. We consider a game $G$ with $m \in \mathbb { N }$ players, where player $i \in [ m ]$ has action space $A _ { i }$ with $n _ { i } : = | A _ { i } |$ actions. We may assume that $\mathcal { A } _ { i } = [ n _ { i } ]$ for each player $i$ . The joint action space is $\mathcal { A } : = \mathcal { A } _ { 1 } \times \dots \times \mathcal { A } _ { m }$ . The specification of the game $G$ is completed by a collection of loss functions $\mathcal { L } _ { 1 } , \ldots , \mathcal { L } _ { m } : \mathcal { A }  [ 0 , 1 ]$ . For an action profile $a = ( a _ { 1 } , \ldots , a _ { m } ) \in \mathcal { A }$ and $i \in [ m ]$ , $\mathcal { L } _ { i } ( a )$ is the loss player $i$ experiences when each player $i ^ { \prime } \in [ m ]$ plays $a _ { i ^ { \prime } }$ . A mixed strategy $x _ { i } \in \Delta ( \mathcal { A } _ { i } )$ for player $i$ is a distribution over $A _ { i }$ , with the probability of playing action $j \in \mathcal A _ { i }$ given by $x _ { i } ( j )$ . Given a mixed strategy profile $\boldsymbol { x } = ( x _ { 1 } , \dots , x _ { m } )$ (or an action profile $\boldsymbol { a } = ( a _ { 1 } , \dots , a _ { m } ) )$ and a player $i \in [ m ]$ we let $x _ { - i }$ (or $a _ { - i }$ , respectively) denote the profile after removing the ith mixed strategy $x _ { i }$ (or the $i$ th action $a _ { i }$ , respectively).
+
+The $m$ players play the game $G$ for a total of $T$ rounds. At the beginning of each round $t \in [ T ]$ , each player $i$ chooses a mixed strategy $x _ { i } ^ { ( t ) } \in \Delta ( \mathcal { A } _ { i } )$ . The loss vector of player $i$ , denoted $\ell _ { i } ^ { ( t ) } \in [ 0 , 1 ] ^ { n _ { i } }$ , is defined as $\ell _ { i } ^ { ( t ) } ( j ) = \mathbb { E } _ { a _ { - i } \sim x _ { - i } ^ { ( t ) } } [ \mathcal { L } _ { i } ( \dot { j } , a _ { - i } ) ]$ . As a matter of convention, set $\ell _ { i } ^ { ( 0 ) } = \mathbf { 0 }$ to be the all-zeros vector. We consider the full-information setting in this paper, meaning that player $i$ observes its full loss vector $\ell _ { i } ^ { ( t ) }$ for each round $t$ . Finally, player $i$ experiences a loss of $\langle \ell _ { i } ^ { ( t ) } , x _ { i } ^ { ( t ) } \rangle$ . The goal of each player $i$ is to minimize its regret, defined as: $\begin{array} { r } { \mathrm { R e g } _ { i , T } : = \sum _ { t \in [ T ] } \langle x _ { i } ^ { ( t ) } , \ell _ { i } ^ { ( t ) } \rangle - \operatorname* { m i n } _ { j \in [ n _ { i } ] } \sum _ { t \in [ T ] } \ell _ { i } ^ { ( t ) } ( j ) } \end{array}$ .
+
+Optimistic hedge. The Optimistic Hedge algorithm chooses mixed strategies for player $i \in [ m ]$ as follows: at time $t = 1$ , it sets $x _ { i } ^ { ( 1 ) } = ( 1 / n _ { i } , \ldots , 1 / n _ { i } )$ to be the uniform distribution on $\mathbf { \mathcal { A } } _ { i }$ . Then for all $t < T$ , player $i$ ’s strategy at iteration $t + 1$ is defined as follows, for $j \in [ n _ { i } ]$ :
+
+$$
+x _ { i } ^ { ( t + 1 ) } ( j ) : = \frac { x _ { i } ^ { ( t ) } ( j ) \cdot \exp ( - \eta \cdot ( 2 \ell _ { i } ^ { ( t ) } ( j ) - \ell _ { i } ^ { ( t - 1 ) } ( j ) ) ) } { \sum _ { k \in [ n _ { i } ] } x _ { i } ^ { ( t ) } ( k ) \cdot \exp ( - \eta \cdot ( 2 \ell _ { i } ^ { ( t ) } ( k ) - \ell _ { i } ^ { ( t - 1 ) } ( k ) ) ) } .
+$$
+
+Optimistic Hedge is a modification of Hedge, which performs the updates $x _ { i } ^ { ( t + 1 ) } ( j ) : =$ $\begin{array} { r l } & { \frac { x _ { i } ^ { ( t ) } ( j ) \cdot \exp ( - \eta \cdot \ell _ { i } ^ { ( t ) } ( j ) ) } { \sum _ { k \in [ n _ { i } ] } x _ { i } ^ { ( t ) } ( k ) \cdot \exp ( - \eta \cdot \ell _ { i } ^ { ( t ) } ( k ) ) } } \end{array}$ . The update (1) modifies the Hedge update by replacing the loss vector $\ell _ { i } ^ { ( t ) }$ 2 i   with a predictor of the following iteration’s loss vector, $\ell _ { i } ^ { ( t ) } + ( \ell _ { i } ^ { ( t ) } - \ell _ { i } ^ { ( t - 1 ) } )$ . Hedge corresponds to FTRL with a negative entropy regularizer (see, e.g., [Bub15]), whereas Optimistic Hedge corresponds to Optimistic FTRL with a negative entropy regularizer [RS13b, RS13a].
+
+Distributions $\pmb { \& }$ divergences. For distributions $P , Q$ on a finite domain $[ n ]$ , the $K L$ divergence between $P , Q$ is $\begin{array} { r } { \mathrm { K L } ( P ; Q ) = \sum _ { j = 1 } ^ { n } P ( j ) \cdot \log \left( \frac { P ( j ) } { Q ( j ) } \right) } \end{array}$ . The chi-squared divergence between $P , Q$ is $\begin{array} { r } { \chi ^ { 2 } ( P ; Q ) = \sum _ { j = 1 } ^ { n } Q ( j ) \cdot \left( \frac { P ( j ) } { Q ( j ) } \right) ^ { 2 } - 1 = \sum _ { j = 1 } ^ { n } \frac { ( P ( j ) - Q ( j ) ) ^ { 2 } } { Q ( j ) } } \end{array}$ (P (j)Q(j))2 . For a distribution P on [n] and a vector $v \in \mathbb { R } ^ { n }$ , we write $\begin{array} { r } { \mathrm { V a r } _ { P } \left( v \right) : = \sum _ { j = 1 } ^ { n } P ( j ) \cdot \left( v ( j ) - \sum _ { k = 1 } ^ { n } P ( k ) v ( k ) \right) ^ { 2 } } \end{array}$ . Also define $\begin{array} { r } { \| v \| _ { P } : = \sqrt { \sum _ { j = 1 } ^ { n } P ( j ) \cdot v ( j ) ^ { 2 } } } \end{array}$ . If further $P$ has full support, then define $\begin{array} { r } { \left\| v \right\| _ { P } ^ { \star } = \sqrt { \sum _ { j = 1 } ^ { n } \frac { v ( j ) ^ { 2 } } { P ( j ) } } } \end{array}$ The above notations will often be used when $P$ is the mixed strategy profile $x _ { i }$ for some player $i$ and $v$ is a loss vector $\ell _ { i }$ ; in such a case the norms $\| v \| _ { P }$ and $\| v \| _ { P } ^ { \star }$ are often called local norms.
+
+# 3 Results
+
+Below we state our main theorem, which shows that when all players in a game play according to Optimistic Hedge with appropriate step size, they all experience polylogarithmic individual regrets.
+
+Theorem 3.1 (Formal version of Theorem 1.1). There are constants $C , C ^ { \prime } > 1$ so that the following holds. Suppose a time horizon $T \in \mathbb { N }$ and a game $G$ with m players and $n _ { i }$ actions for each player $i \in [ m ]$ is given. Suppose all players play according to Optimistic Hedge with any positive step size $\begin{array} { r } { \eta \leq \frac { 1 } { C \cdot m \log ^ { 4 } T } } \end{array}$ . Then for any $i \in [ m ]$ , the regret of player $i$ satisfies
+
+$$
+\mathrm { R e g } _ { i , T } \leq \frac { \log n _ { i } } { \eta } + C ^ { \prime } \cdot \log T .
+$$
+
+In particular, if the players’ step size is chosen as $\begin{array} { r } { \eta = \frac { 1 } { C \cdot m \log ^ { 4 } T } } \end{array}$ , then the regret of player $i$ satisfies
+
+$$
+\mathrm { R e g } _ { i , T } \leq O \left( m \cdot \log n _ { i } \cdot \log ^ { 4 } T \right) .
+$$
+
+A common goal in the literature on learning in games is to obtain an algorithm that achieves fast rates whan played by all players, and so that each player $i$ still obtains the optimal rate of $O ( \sqrt { T } )$ in the adversarial setting (i.e., when $i$ receives an arbitrary sequence of losses $\ell _ { i } ^ { ( 1 ) } , \ldots , \ell _ { i } ^ { ( T ) } )$ . We show in Corollary D.1 (in the appendix) that by running Optimistic Hedge with an adaptive step size, this is possible. Table 1 compares our regret bounds discussed in this section to those of prior work.
+
+# 4 Proof overview
+
+In this section we overview the proof of Theorem 3.1; the full proof may be found in the appendix.
+
+# 4.1 New adversarial regret bound
+
+The first step in the proof of Theorem 3.1 is to prove a new regret bound (Lemma 4.1 below) for Optimistic Hedge that holds for an adversarial sequence of losses. We will show in later sections that when all players play according to Optimistic Hedge, the right-hand side of the regret bound (4) is bounded by a quantity that grows only poly-logarithmically in $T$ .
+
+Lemma 4.1. There is a constant $C > 0$ so that the following holds. Suppose any player $i \in [ m ]$ follows the Optimistic Hedge updates (1) with step size $\eta < 1 / C$ , for an arbitrary sequence of losses $\ell _ { i } ^ { ( 1 ) } , \ldots , \ell _ { i } ^ { ( T ) } \in [ 0 , 1 ] ^ { n _ { i } }$ . Then
+
+$$
+\mathrm { R e g } _ { i , T } \leq \frac { \log n _ { i } } { \eta } + \sum _ { t = 1 } ^ { T } \left( \frac { \eta } { 2 } + C \eta ^ { 2 } \right) \mathrm { V a r } _ { x _ { i } ^ { ( t ) } } \left( \ell _ { i } ^ { ( t ) } - \ell _ { i } ^ { ( t - 1 ) } \right) - \sum _ { t = 1 } ^ { T } \frac { ( 1 - C \eta ) \eta } { 2 } \cdot \mathrm { V a r } _ { x _ { i } ^ { ( t ) } } \left( \ell _ { i } ^ { ( t - 1 ) } \right) .
+$$
+
+The detailed proof of Lemma 4.1 can be found in Section A, but we sketch the main steps here. The starting point is a refinement of [RS13a, Lemma 3] (stated as Lemma A.5), which gives an upper
+
+bound for $\mathrm { R e g } _ { i , T }$ in terms of local norms corresponding to each of the iterates $x _ { i } ^ { ( t ) }$ of Optimistic Hedge. The bound involves the difference between the Optimistic Hedge iterates $x _ { i } ^ { ( t ) }$ and iterates $\tilde { x } _ { i } ^ { ( t ) }$ defined by $\begin{array} { r } { \tilde { x } _ { i } ^ { ( t ) } = \frac { x _ { i } ^ { ( t ) } ( j ) \cdot \exp ( - \eta \cdot ( \ell _ { i } ^ { ( t ) } ( j ) - \ell _ { i } ^ { ( t - 1 ) } ( j ) ) ) } { \sum _ { k \in [ n _ { i } ] } x _ { i } ^ { ( t ) } ( k ) \cdot \exp ( - \eta \cdot ( \ell _ { i } ^ { ( t ) } ( k ) - \ell _ { i } ^ { ( t - 1 ) } ( k ) ) ) } } \end{array}$ :
+
+$$
+\mathrm { R e g } _ { i , T } \leq \frac { \log n _ { i } } { \eta } + \sum _ { t = 1 } ^ { T } \left. x _ { i } ^ { ( t ) } - \tilde { x } _ { i } ^ { ( t ) } \right. _ { x _ { i } ^ { ( t ) } } ^ { \times } \sqrt { \mathrm { V a r } _ { x _ { i } ^ { ( t ) } } \left( \ell _ { i } ^ { ( t ) } - \ell _ { i } ^ { ( t - 1 ) } \right) } - \frac { 1 } { \eta } \sum _ { t = 1 } ^ { T } \mathrm { K L } ( \tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } ) - \frac { 1 } { \eta } \sum _ { t = 1 } ^ { T } \mathrm { K L } ( \tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } ) ,
+$$
+
+2) thand $\mathrm { K L } ( \tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } )$ $\mathrm { K L } ( x _ { i } ^ { ( t ) } ; \tilde { x } _ { i } ^ { ( t - 1 ) } )$ may be lower bounded bytively. Note it is a standard $( 1 / 2 - O ( \eta ) ) \cdot \chi ^ { 2 } ( \tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } )$ $( 1 / 2 - O ( \eta ) ) \cdot \chi ^ { 2 } ( x _ { i } ^ { ( t ) } ; \tilde { x } _ { i } ^ { ( t - 1 ) } )$ fact that the KL divergence between two distributions is upper bounded by the chi-squared distribution between them; by contrast, Lemma A.2 can exploit that $x _ { i } ^ { ( t ) }$ , $\tilde { x } _ { i } ^ { ( t ) }$ t) and x˜ (t1)i a re close to each other between lower bo $x _ { i } ^ { ( t ) }$ i and x˜ $\tilde { x } _ { i } ^ { ( t - 1 ) }$ hat the , leadi $\chi ^ { 2 }$ -divergenco the term $\chi ^ { 2 } ( x _ { i } ^ { ( t ) } ; \tilde { x } _ { i } ^ { ( t - 1 ) } )$ $\left( 1 - O ( \eta ) \right) \cdot \eta ^ { 2 } \cdot \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( \ell _ { i } ^ { ( t - 1 ) } \right)$ $\begin{array} { r } { \frac { ( 1 - C \eta ) \eta } { 2 } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( \ell _ { i } ^ { ( t - 1 ) } \right) } \end{array}$ being subtracted in (4). The $\chi ^ { 2 }$ -divergence $\chi ^ { 2 } ( \tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } )$ , as well as the term $\left\| \boldsymbol { x } _ { i } ^ { ( t ) } - \tilde { \boldsymbol { x } } _ { i } ^ { ( t ) } \right\| _ { \boldsymbol { x } _ { i } ^ { ( t ) } } ^ { \star }$ in (5) are bounded in a similar manner to obtain (4).
+
+# 4.2 Finite differences
+
+Given Lemma 4.1, in order to establish Theorem 3.1, it suffices to show Lemma 4.2 below. Indeed, (6) below implies that the right-hand side of (4) is bounded above by $\frac { \log n _ { i } } { \eta } + \eta \cdot O ( \log ^ { 5 } T )$ , which is bounded above by $O ( m \log n _ { i } \log ^ { 4 } T )$ for the choice $\begin{array} { r } { \eta = \Theta \left( \frac { 1 } { m \cdot \log ^ { 4 } T } \right) } \end{array}$ of Theorem 3.1.2
+
+Lemma 4.2 (Abbreviated; detailed version in Section C.3). Suppose all players play according to Optimistic Hedge with step size $\eta$ satifying $\begin{array} { r } { 1 / T \le \eta \le \frac { 1 } { C m \cdot \log ^ { 4 } T } } \end{array}$ for a sufficiently large constant $C$ . Then for any $i \in [ m ]$ , the losses $\ell _ { i } ^ { ( 1 ) } , \ldots , \ell _ { i } ^ { ( T ) } \in \mathbb { R } ^ { n _ { i } }$ for player $i$ satisfy:
+
+$$
+\sum _ { t = 1 } ^ { T } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( \ell _ { i } ^ { ( t ) } - \ell _ { i } ^ { ( t - 1 ) } \right) \leq \frac { 1 } { 2 } \cdot \sum _ { t = 1 } ^ { T } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( \ell _ { i } ^ { ( t - 1 ) } \right) + O \left( \log ^ { 5 } T \right) .
+$$
+
+The definition below allows us to streamline our notation when proving Lemma 4.2.
+
+Definition 4.1 (Finite differences). Suppose ${ \cal L } = ( L ^ { ( 1 ) } , \dots , L ^ { ( T ) } )$ is a sequence of vectors $L ^ { ( t ) } \in \mathbb { R } ^ { n }$ . For integers $h \geq 0$ , the order- $h$ finite difference sequence for the sequence $L$ , denoted by $\mathrm Ḋ _ Ḋ h Ḍ L Ḍ$ , is the sequence $\mathrm D _ { h } L : = \left( \left( \mathrm D _ { h } L \right) ^ { ( 1 ) } , \ldots , \left( \bar { \mathrm D _ { h } } L \right) ^ { ( T - h ) } \right)$ defined recursively as: $\left( \mathrm { D } _ { 0 } L \right) ^ { ( t ) } : = L ^ { ( t ) }$ for all $1 \leq t \leq T$ , and
+
+$$
+( \mathrm Ḋ _ { Ḋ } L Ḍ ) ^ { ( t ) } : = ( \mathrm Ḋ _ { Ḋ } \mathrm Ḋ _ { Ḋ } L Ḍ Ḍ ) ^ { ( t + 1 ) } - ( \mathrm Ḋ _ { Ḋ } \mathrm Ḋ _ { Ḋ } L Ḍ Ḍ ) ^ { ( t ) }
+$$
+
+for all $h \geq 1 , 1 \leq t \leq T - h$ .3
+
+Remark 4.3. Notice that another way of writing (7) is: $\mathrm { D } _ { h } { \cal L } = \mathrm { D } _ { 1 } \mathrm { D } _ { h - 1 } { \cal L }$ . We also remark for later use that $\begin{array} { r } { ( \mathrm { D } _ { h } L ) ^ { ( t ) } = \sum _ { s = 0 } ^ { h } \binom { h } { s } ( - 1 ) ^ { h - s } L ^ { ( t + s ) } } \end{array}$ .
+
+Let $H = \log T$ , where $T$ denotes the fixed time horizon from Theorem 3.1 (and thus Lemma 4.2). In the proof of Lemma 4.2, we will bound the finite differences of order $h \leq H$ for certain sequences. The bound (6) of Lemma 4.2 may be rephased as upper bounding $\textstyle \sum _ { t = 1 } ^ { T } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( { \bigl ( } \operatorname { D } _ { 1 } \ell _ { i } { \bigr ) } ^ { ( t - 1 ) } \right)$ , by $\begin{array} { r } { \frac { 1 } { 2 } \sum _ { t = 1 } ^ { T } \operatorname { V a r } _ { x _ { i } } \Big ( \ell _ { i } ^ { ( t - 1 ) } \Big ) ; } \end{array}$ ; to prove this, we proceed in two steps:
+
+1. (Upwards induction step) First, in Lemma 4.4 below, we find an upper bound on $\left\| \left( \operatorname { D } _ { h } \ell _ { i } \right) ^ { ( t ) } \right\| _ { \infty }$ for all $t \in [ T ]$ , $h \geq 0$ , which decays exponentially in $h$ for $h \leq H$ 1. This is done via upwards induction on $h$ , i.e., first proving the base case $h = 0$ using boundedness of the losses $\ell _ { i } ^ { ( t ) }$ and then $h = 1 , 2 , \ldots$ inductively. The main technical tool we develop for the inductive step is a weak form of the chain rule for finite differences, Lemma 4.5. The inductive step uses the fact that all players are following Optimistic Hedge to relate the $h$ th order finite differences of player $i$ ’s loss sequence $\ell _ { i } ^ { ( t ) }$ to the $h$ th order finite differences of the strategy sequences $x _ { i ^ { \prime } } ^ { ( t ) }$ for players $i ^ { \prime } \neq i$ ; then we use the exponential-weights style updates of Optimistic Hedge and Lemma 4.5 to relate the hth order finite differences of the strategies $x _ { i ^ { \prime } } ^ { ( t ) }$ to the $( h - 1 )$ th order finite differences of the losses $\ell _ { i ^ { \prime } } ^ { ( t ) }$ .
+
+2. (Downwards induction step) We next show that for all $H _ { \mathbf { \varepsilon } } \leq \mathbf { \varepsilon } _ { h } \leq \mathbf { \varepsilon } _ { H } $ $\begin{array} { r } { \sum _ { t = 1 } ^ { T } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( \left( \operatorname { D } _ { h + 1 } \ell _ { i } \right) ^ { ( t - 1 ) } \right) } \end{array}$ is bounded above by $\begin{array} { r } { c _ { h } \cdot \sum _ { t = 1 } ^ { T } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( ( \operatorname { D } _ { h } \ell _ { i } ) ^ { ( t - 1 ) } \right) + \mu _ { h } } \end{array}$ , for some $c _ { h } < 1 / 2$ and $\mu _ { h } < \dot { O } ( \log ^ { 5 } T )$ . This shown via downwards induction on $h$ , namely first establishing the base case $h = H$ by using the result of item 1 for $h = H$ and then treating the cases $h = H - 1 , H - 2 , \dots , 0$ . The inductive step makes use of the discrete Fourier transform (DFT) to relate the finite differences of different orders (see Lemmas 4.7 and 4.8). In particular, Parseval’s equality together with a standard relationship between the DFT of the finite differences of a sequence to the DFT of that sequence allow us to first prove the inductive step in the frequency domain and then transport it back to the original (time) domain.
+
+In the following subsections we explain in further detail how the two steps above are completed.
+
+# 4.3 Upwards induction proof overview
+
+Addressing item 1 in the previous subsection, the lemma below gives a bound on the supremum norm of the $h$ -th order finite differences of each player’s loss vector, when all players play according to Optimistic Hedge and experience losses according to their loss functions $\mathcal { L } _ { 1 } , \ldots , \mathcal { L } _ { m } : \mathcal { A }  [ 0 , 1 ]$ .
+
+Lemma 4.4 (Abbreviated). Fix a step size $\eta > 0$ satisfying $\begin{array} { r } { \eta \ \leq \ o \left( \frac { 1 } { m \log T } \right) } \end{array}$ . If all players follow Optimistic Hedge updates with step size $\eta _ { ; }$ , then for any player $i \in [ m ]$ , integer $h$ satisfying $0 \leq h \leq H$ , and time step $t \in [ T - h ]$ , it holds that $\| \left( \operatorname { D } _ { h } \ell _ { i } \right) ^ { ( t ) } \| _ { \infty } \leq O ( m \eta ) ^ { h } \cdot h ^ { O ( h ) }$ .
+
+A detailed version of Lemma 4.4, together with its full proof, may be found in Section B.4. We next give a proof overview of Lemma 4.4 for the case of 2 players, i.e., $m = 2$ ; we show in Section B.4 how to generalize this computation to general $m$ . Below we introduce the main technical tool in the proof, a “boundedness chain rule,” and then outline how it is used to prove Lemma 4.4.
+
+Main technical tool for Lemma 4.4: boundedness chain rule. We say that a function $\phi : \mathbb { R } ^ { n }  \mathbb { R }$ is a softmax-type function if there are real numbers $\xi _ { 1 } , \ldots , \xi _ { n }$ and some $j \in [ n ]$ so that for all $( z _ { 1 } , \ldots , z _ { n } ) \in \mathbb { R } ^ { n }$ , $\begin{array} { r } { \phi ( ( z _ { 1 } , \ldots , z _ { n } ) ) = \frac { \exp ( z _ { j } ) } { \sum _ { k = 1 } ^ { n } \xi _ { k } \cdot \exp ( z _ { k } ) } } \end{array}$ . Lemma 4.5 below may be interpreted as a “boundedness chain rule” for finite differences. To explain the context for this lemma, recall that given an infinitely differentiable vector-valued function $L : \mathbb { R } \to \mathbb { R } ^ { n }$ and an infinitely differentiable function $\phi : \mathbb { R } ^ { n }  \mathbb { R }$ , the higher order derivatives of the function $\phi ( L ( t ) )$ may be computed in terms of those of $L$ and $\phi$ using the chain rule. Lemma 4.5 considers an analogous setting where the input variable $t$ to $L$ is discrete-valued, taking values in $[ T ]$ (and so we identify the function $L$ with the sequence $L ^ { ( 1 ) } , \dots , L ^ { ( T ) } )$ . In this case, the higher order finite differences of the sequence $L ^ { ( 1 ) } , \dots , L ^ { ( T ) }$ (Definition 4.1) take the place of the higher order derivatives of $L$ with respect to $t$ . Though there is no generic chain rule for finite differences, Lemma 4.5 states that, at least when $\phi$ is a softmax-type function, we may bound the higher order finite differences of the sequence $\phi ( L ^ { ( 1 ) } ) , \dots , \phi ( L ^ { ( T ) } )$ . In the lemma’s statement we let $\phi \circ L$ denote the sequence $\phi ( L ^ { ( 1 ) } ) , \dots , \phi ( L ^ { ( T ) } )$ .
+
+Lemma 4.5 (“Boundedness chain rule” for finite differences; abbreviated). Suppose that $h , n \in \mathbb { N }$ , $\phi : \mathbb { R } ^ { n }  \mathbb { R }$ is a softmax-type function, and ${ \cal L } = ( L ^ { ( 1 ) } , \dots , L ^ { ( T ) } )$ is a sequence of vectors in $\mathbb { R } ^ { n }$ satisfying $\| L ^ { ( t ) } \| _ { \infty } \leq 1$ for $t \in [ T ]$ . Suppose for some $\alpha \in ( 0 , 1 )$ , for each $0 \leq h ^ { \prime } \leq h$ and $t \in [ T - h ^ { \prime } ] ,$ , it holds that $\| \mathrm { D } _ { h ^ { \prime } } L ^ { ( t ) } \| _ { \infty } \leq O ( \alpha ^ { h ^ { \prime } } ) \cdot ( h ^ { \prime } ) ^ { O ( h ^ { \prime } ) }$ . Then for all $t \in [ T - h ]$ ,
+
+A detailed version of Lemma 4.5 may be found in Section B.3. While Lemma 4.5 requires $\phi$ to be a softmax-type function for simplicity (and this is the only type of function $\phi$ we will need to consider for the case $m = 2$ ) we remark that the detailed version of Lemma 4.5 allows $\phi$ to be from a more general family of analytic functions whose higher order derivatives are appropriately bounded. The proof of Lemma 4.4 for all $m \geq 2$ requires that more general form of Lemma 4.5.
+
+The proof of Lemma 4.5 proceeds by considering the Taylor expansion $P _ { \phi } ( \cdot )$ of the function $\phi$ at the origin, which we write as follows: for $z = ( z _ { 1 } , \ldots , z _ { n } ) \in \mathbb { R } ^ { n }$ , $\begin{array} { r } { P _ { \phi } ( z ) : = \sum _ { k \geq 0 , \gamma \in \mathbb { Z } _ { \geq 0 } ^ { n } : \ | \gamma | = k } a _ { \gamma } z ^ { \gamma } } \end{array}$ , where $a _ { \gamma } \in \mathbb { R } , | \gamma |$ denotes the quantity $\gamma _ { 1 } + \cdots + \gamma _ { n }$ and $z ^ { \gamma }$ denotes $z _ { 1 } ^ { \gamma _ { 1 } } \cdots z _ { n } ^ { \gamma _ { n } }$ . The fact that $\phi$ is a softmax-type function ensures that the radius of convergence of its Taylor series is at least 1, i.e., $\phi ( z ) = P _ { \phi } ( z )$ for any $z$ satisfying $\| z \| _ { \infty } \leq 1$ . By the assumption that $\| \dot { L } ^ { ( t ) } \| _ { \infty } \leq 1$ for each $t$ , we may therefore decompose $( \mathrm { D } _ { h } \left( \phi \circ L \right) ) ^ { ( t ) }$ as:
+
+$$
+\left( \mathrm { D } _ { h } \left( \phi \circ L \right) \right) ^ { \left( t \right) } = \sum _ { k \geq 0 , \gamma \in \mathbb { Z } _ { \geq 0 } ^ { n } : \ \vert \gamma \vert = k } a _ { \gamma } \cdot \left( \mathrm { D } _ { h } L ^ { \gamma } \right) ^ { \left( t \right) } ,
+$$
+
+where $L ^ { \gamma }$ denotes the sequence of scalars $( L ^ { \gamma } ) ^ { ( t ) } : = ( L ^ { ( t ) } ) ^ { \gamma }$ for all $t$ . The fact that $\phi$ is a softmaxtype function allows us to establish strong bounds on $| a _ { \gamma } |$ for each $\gamma$ in Lemma B.5. The proof of Lemma B.5 bounds the $| a _ { \gamma } |$ by exploiting the simple form of the derivative of a softmax-type function to decompose each $a _ { \gamma }$ into a sum of $| \gamma |$ ! terms. Then we establish a bijection between the terms of this decomposition and graph structures we refer to as factorial trees; that bijection together with the use of an appropriate generating function allow us to complete the proof of Lemma B.5.
+
+Thus, to prove Lemma 4.5, it suffices to bound $\left| ( \mathrm Ḋ \boldsymbol Ḋ h Ḍ Ḍ L ^ { \gamma } ) ^ { ( t ) } \right|$ for all $\gamma$ . We do so by using Lemma 4.6. Lemma 4.6 (Abbreviated; detailed vesion in Section B.2). Fix any $h \geq 0$ , a multi-index $\gamma \in \mathbb { Z } _ { \geq 0 } ^ { n }$ and set $k = | \gamma |$ . For each of the $k ^ { h }$ functions $\pi : [ h ]  [ k ]$ , and for each $r \in [ k ] .$ , there are integers $h _ { \pi , r } ^ { \prime } \in \{ 0 , 1 , \ldots , h \}$ , $t _ { \pi , r } ^ { \prime } \geq 0$ , and $j _ { \pi , r } ^ { \prime } \in [ n ]$ , so that the following holds. For any sequence $L ^ { ( 1 ) } , \ldots , L ^ { ( T ) } \in \mathbb { R } ^ { n }$ of vectors, it holds that, for each $t \in [ T - h ]$ ,
+
+$$
+( \mathrm { D } _ { h } L ^ { \gamma } ) ^ { ( t ) } = \sum _ { \pi : [ h ]  [ k ] } \prod _ { r = 1 } ^ { k } ( \mathrm { D } _ { h _ { \pi , r } ^ { \prime } } ( L ( j _ { \pi , r } ^ { \prime } ) ) ) ^ { ( t + t _ { \pi , r } ^ { \prime } ) } .
+$$
+
+Lemma 4.6 expresses the $h$ th order finite differences of the sequence $L ^ { \gamma }$ as a sum of $k ^ { h }$ terms, each of which is a product of $k$ finite order differences of a sequence $L ^ { ( t ) } ( j _ { \pi , r } ^ { \prime } )$ (i.e., the $j _ { \pi , r } ^ { \prime }$ th coordinate of the vectors $L ^ { ( t ) }$ ). Crucially, when using Lemma 4.6 to prove Lemma 4.5, the assumption of Lemma 4.5 gives that for each $j ^ { \prime } \in [ n ]$ , each $h ^ { \prime } \in [ h ]$ , and each $t ^ { \prime } \in [ T - h ^ { \prime } ]$ , we have the bound $\left| ( \operatorname { D } _ { h ^ { \prime } } L ( j ^ { \prime } ) ) ^ { ( t ^ { \prime } ) } \right| \le O ( \alpha ^ { h ^ { \prime } } ) \cdot ( h ^ { \prime } ) ^ { O ( h ^ { \prime } ) }$ . These assumed bounds may be used to bound the right-hand side of (9), which together with Lemma 4.6 and (8) lets us complete the proof of Lemma 4.5.
+
+Proving Lemma 4.4 using the boundedness chain rule. Next we discuss how Lemma 4.5 is used to prove Lemma 4.4, namely to bound $\| \left( \mathrm { D } _ { h } \ell _ { i } \right) ^ { ( t ) } \| _ { \infty }$ for each $t \in [ T - h ]$ , $i \in [ m ]$ , and $0 \leq h \leq H$ . Lemma 4.4 is proved using induction, with the base case $h = 0$ being a straightforward consequence of the fact that $\| \left( \operatorname { D } _ { 0 } \ell _ { i } \right) ^ { ( t ) } \| _ { \infty } = \| \ell _ { i } ^ { ( t ) } \| _ { \infty } \leq 1$ for all $i \in [ m ] , t \in [ T ]$ . For the rest of this section we focus on the inductive case, i.e., we pick some $h \in [ H ]$ and assume Lemma 4.4 holds for all $h ^ { \prime } < h$ .
+
+The first step is to reduce the claim of Lemma 4.4 to the claim that the upper bound $\Vert \left( \mathrm { D } _ { h } x _ { i } \right) ^ { ( t ) } \Vert _ { 1 } \leq$ $O \left( m \eta \right) ^ { h } \cdot h ^ { O ( h ) }$ holds for each $t \in [ T - h ] , i \in [ m ]$ . Recalling that we are only sketching here the case $m = 2$ for simplicity, this reduction proceeds as follows: for $i \in \{ 1 , 2 \}$ , define the matrix $A _ { i } \ \in \ \mathbb { R } ^ { n _ { 1 } \times n _ { 2 } }$ by $( A _ { i } ) _ { a _ { 1 } a _ { 2 } } = { \mathcal { L } } _ { i } ( a _ { 1 } , a _ { 2 } )$ , for $a _ { 1 } \in [ n _ { 1 } ] , a _ { 2 } \in [ n _ { 2 } ]$ . We have assumed that all players are using Optimistic Hedge and thus $\ell _ { i } ^ { ( t ) } = \mathbb { E } _ { a _ { i ^ { \prime } } \sim x _ { i ^ { \prime } } ^ { ( t ) } }$ , $\forall i ^ { \prime } \neq i ^ { }  \lbrack \mathcal { L } _ { i } ( a _ { 1 } , \ldots , a _ { n } ) \rbrack$ ; for our case here $( m = 2$ ), this may be rewritten as $\ell _ { 1 } ^ { ( t ) } = A _ { 1 } x _ { 2 } ^ { ( t ) }$ , $\ell _ { 2 } ^ { ( t ) } = A _ { 2 } ^ { \top } x _ { 1 } ^ { ( t ) }$ . Thus
+
+$$
+| ( \mathbf { D } _ { h } \ell _ { 1 } ) ^ { ( t ) } | | _ { \infty } = \| A _ { 1 } \cdot \sum _ { s = 0 } ^ { h } { \binom { h } { s } } ( - 1 ) ^ { h - s } x _ { 2 } ^ { ( t + s ) } \| _ { \infty } \leq \| \sum _ { s = 0 } ^ { h } { \binom { h } { s } } ( - 1 ) ^ { h - s } x _ { 2 } ^ { ( t + s ) } \| _ { 1 } = \| ( \mathbf { D } _ { h } x _ { 2 } ) ^ { ( t ) } \| _ { \infty }
+$$
+
+where the first equality is from Remark 4.3 and the inequality follows since all entries of $A _ { 1 }$ have absolute value $\leq 1$ . A similar computation allows us to show $\| \left( \operatorname { D } _ { h } \ell _ { 2 } \right) ^ { ( t ) } \| _ { \infty } \leq \| \left( \operatorname { D } _ { h } x _ { 1 } \right) ^ { ( t ) } \| _ { 1 }$ .
+
+To complete the inductive step it remains to upper bound the quantities $\Vert \left( \mathrm { D } _ { h } x _ { i } \right) ^ { ( t ) } \Vert _ { 1 }$ for $i \in [ m ] , t \in$ $[ T - h ]$ . To do so, we note that the definition of the Optimistic Hedge updates (1) implies that for any $\bar { i } \in [ m ] , t \in [ T ] , j \in [ n _ { i } ]$ , and $t ^ { \prime } \geq 1$ , we have
+
+$$
+x _ { i } ^ { ( t + t ^ { \prime } ) } ( j ) = \frac { x _ { i } ^ { ( t ) } ( j ) \cdot \exp \left( \eta \cdot \left( \ell _ { i } ^ { ( t - 1 ) } ( j ) - \sum _ { s = 0 } ^ { t ^ { \prime } - 1 } \ell _ { i } ^ { ( t + s ) } ( j ) - \ell _ { i } ^ { ( t + t ^ { \prime } - 1 ) } ( j ) \right) \right) } { \sum _ { k = 1 } ^ { n _ { i } } x _ { i } ^ { ( t ) } ( k ) \cdot \exp \left( \eta \cdot \left( \ell _ { i } ^ { ( t - 1 ) } ( k ) - \sum _ { s = 0 } ^ { t ^ { \prime } - 1 } \ell _ { i } ^ { ( t + s ) } ( k ) - \ell _ { i } ^ { ( t + t ^ { \prime } - 1 ) } ( k ) \right) \right) } .
+$$
+
+For $t \in [ T ] , t ^ { \prime } \geq 0$ , set $\begin{array} { r } { \bar { \ell } _ { i , t } ^ { ( t ^ { \prime } ) } : = \eta \cdot \left( \ell _ { i } ^ { ( t - 1 ) } - \sum _ { s = 0 } ^ { t ^ { \prime } - 1 } \ell _ { i } ^ { ( t + s ) } - \ell _ { i } ^ { ( t + t ^ { \prime } - 1 ) } \right) . } \end{array}$ . Also, for each $i \in [ m ] , j \in$ $[ n _ { i } ] , t \in [ T ]$ , and any vector $z = ( z ( 1 ) , \dots , z ( n _ { i } ) ) \in \mathbb { R } ^ { n _ { i } }$ define $\begin{array} { r } { \overset { \cdot } { \phi _ { t , i , j } ( z ) } : = \frac { x _ { i } ^ { ( t ) } ( j ) \cdot \exp ( z ( j ) ) } { \sum _ { k = 1 } ^ { n _ { i } } x _ { i } ^ { ( t ) } ( k ) \cdot \exp ( z ( k ) ) } } \end{array}$ . Thus (10) gives that for $t ^ { \prime } \geq 1$ , $x _ { i } ^ { ( t + t ^ { \prime } ) } ( j ) = \phi _ { t , i , j } ( \bar { \ell } _ { i , t } ^ { ( t ^ { \prime } ) } )$ . Viewing $t$ k=1 i ·as a fixed parameter and letting $t ^ { \prime }$ vary, it follows that for $h \geq 0$ and $t ^ { \prime } \geq 1$ , $\begin{array} { r } { \left( \mathrm { D } _ { h } x _ { i } ^ { ( t + \cdot ) } ( j ) \right) ^ { ( t ^ { \prime } ) } = \left( \mathrm { D } _ { h } \left( \phi _ { t , i , j } \circ \bar { \ell } _ { i , t } \right) \right) ^ { ( t ^ { \prime } ) } . } \end{array}$
+
+Recalling that our goal is to bound $\vert \left( \mathrm { D } _ { h } x _ { i } ( j ) \right) ^ { ( t + 1 ) } \vert$ for each $t$ , we can do so by using Lemma 4.5 with $\mathbf { \phi } \phi ~ = ~ \phi _ { t , i , j }$ and $\alpha ~ = ~ { \cal { O } } ( m \eta )$ , if we can show that its precondition is met, i.e. that $\begin{array} { r } { \| \left( \mathrm { D } _ { h ^ { \prime } } \bar { \ell } _ { i , t } \right) ^ { ( t ^ { \prime } ) } \| _ { \infty } \le \frac { 1 } { B _ { 1 } } \cdot \alpha ^ { h ^ { \prime } } \cdot ( h ^ { \prime } ) ^ { B _ { 0 } h ^ { \prime } } } \end{array}$ for all $h ^ { \prime } \leq h$ , the appropriate $\alpha$ and appropriate constants B0, B1. Helpfully, the definition of ¯\` (t0 )i,t a s a partial sum allows us to relate the $h ^ { \prime }$ -th order finite differences of the sequence $\bar { \ell } _ { i , t } ^ { ( t ^ { \prime } ) }$ to the $\left( h ^ { \prime } - 1 \right)$ -th order finite differences of the sequence $\ell _ { i } ^ { ( t ) }$ as follows:
+
+$$
+\left( \mathrm { D } _ { h ^ { \prime } } \bar { \ell } _ { i , t } \right) ^ { ( t ^ { \prime } ) } = \eta \cdot \left( \mathrm { D } _ { h ^ { \prime } - 1 } \ell _ { i } \right) ^ { ( t + t ^ { \prime } - 1 ) } - 2 \eta \cdot \left( \mathrm { D } _ { h ^ { \prime } - 1 } \ell _ { i } \right) ^ { ( t + t ^ { \prime } ) } .
+$$
+
+Since $h ^ { \prime } - 1 < h$ for $h ^ { \prime } \leq h$ , the inductive assumption of Lemma 4.4 gives a bound on the $\ell _ { \infty }$ -norm of the terms on the right-hand side of (11), which are sufficient for us to apply Lemma 4.5. Note that the inductive assumption gives an upper bound on $\| \left( \mathrm { D } _ { h ^ { \prime } - 1 } \ell _ { i } \right) ^ { ( t ) } \| _ { \infty }$ that only scales with $\alpha ^ { h ^ { \prime } - 1 }$ , whereas Lemma 4.5 requires scaling of $\alpha ^ { h ^ { \prime } }$ . This discrepancy is corrected by the factor of $\eta$ on the right-hand side of (11), which gives the desired scaling $\alpha ^ { h ^ { \prime } }$ (since $\eta < \alpha$ for the choice $\alpha = { \cal { O } } ( m \eta ) ,$ ).
+
+# 4.4 Downwards induction proof overview
+
+In this section we discuss in further detail item 2 in Section 4.2; in particular, we will show that there is a parameter $\mu = \tilde { \Theta } ( \eta m )$ so that for all integers $h$ satisfying $H - 1 \geq h \geq 0$ ,
+
+$$
+\sum _ { t = 1 } ^ { T - h - 1 } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( ( \operatorname { D } _ { h + 1 } \ell _ { i } ) ^ { ( t ) } \right) \leq O ( 1 / H ) \cdot \sum _ { t = 1 } ^ { T - h } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( ( \operatorname { D } _ { h } \ell _ { i } ) ^ { ( t ) } \right) + \tilde { O } \left( \mu ^ { 2 h } \right) ,
+$$
+
+where $\tilde { O }$ hides factors polynomial in $\log T$ . The validity of (12) for $h = 0$ implies Lemma 4.2. On implies that the other hand, as long we choose the value $\begin{array} { r } { \sum _ { t = 1 } ^ { T - H } \operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \left( \left( \operatorname { D } _ { H } \ell _ { i } \right) ^ { ( t ) } \right) \leq O ( \mu ^ { 2 H } ) } \end{array}$ $\mu$ in (12) to satisfy . This gives that (12) holds for $\mu \geq m \eta H ^ { \Omega ( 1 ) }$ , then Lemma 4.4 $h = H - 1$ . To show that (12) holds for all $H - 1 > h \geq 0$ , we use downwards induction; fix any $h$ , and assume that (12) has been shown for all $h ^ { \prime }$ satisfying $h < h ^ { \prime } \leq H - 1$ . Our main tool in the inductive step is to apply Lemma 4.7 below. To state it, for $\zeta > 0 , n \in \mathbb { N }$ , we say that a sequence of distributions $P ^ { ( 1 ) } , \ldots , P ^ { ( T ) } \in \Delta ^ { n }$ is $\zeta$ -consecutively close if for each $1 \leq t < T$ , it holds that max $\left\{ \left\| \frac { P ^ { ( t ) } } { P ^ { ( t + 1 ) } } \right\| _ { \infty } , \left\| \frac { P ^ { ( t + 1 ) } } { P ^ { ( t ) } } \right\| _ { \infty } \right\} \leq 1 + \zeta$ . 4 Lemma 4.7 shows that given a sequence of vectors for which the variances of its second-order finite differences are bounded by the variances of its first-order finite differences, a similar relationship holds between its first- and zeroth-order finite differences.
+
+Lemma 4.7. There is a sufficiently large constant $C _ { 0 } > 1$ so that the following holds. For any $M , \zeta , \alpha > 0$ and $n \in \mathbb N$ , suppose that $P ^ { ( 1 ) } , \ldots , P ^ { ( T ) } \in \Delta ^ { n }$ and $Z ^ { ( 1 ) } , \ldots , Z ^ { ( \breve { T } ) } \in [ - M , M ] ^ { \breve { n } }$ satisfy the following conditions:
+
+1. The sequence $P ^ { ( 1 ) } , \ldots , P ^ { ( T ) }$ is $\zeta$ -consecutively close for some $\zeta \in [ 1 / ( 2 T ) , \alpha ^ { 4 } / C _ { 0 } ]$
+
+$$
+\begin{array} { r } { \sum _ { t = 1 } ^ { T - 2 } \operatorname { V a r } _ { P ^ { ( t ) } } \left( \left( \operatorname { D } _ { 2 } Z \right) ^ { ( t ) } \right) \leq \alpha \cdot \sum _ { t = 1 } ^ { T - 1 } \operatorname { V a r } _ { P ^ { ( t ) } } \left( \left( \operatorname { D } _ { 1 } Z \right) ^ { ( t ) } \right) + \mu . } \end{array}
+$$
+
+4 Here, for distributions $P , Q \in \Delta ^ { n }$ , $\frac { P } { Q } \in \mathbb { R } ^ { n }$ denotes the vector whose $j$ th entry is $P ( j ) / Q ( j )$ .
+
+$$
+\begin{array} { r } { \sum _ { t = 1 } ^ { T - 1 } \operatorname { V a r } _ { P ^ { ( t ) } } \left( \left( \operatorname { D } _ { 1 } Z \right) ^ { ( t ) } \right) \leq \alpha \cdot \left( 1 + \alpha \right) \sum _ { t = 1 } ^ { T } \operatorname { V a r } _ { P ^ { ( t ) } } \left( Z ^ { ( t ) } \right) + \frac { \mu } { \alpha } + \frac { C _ { 0 } M ^ { 2 } } { \alpha ^ { 3 } } . } \end{array}
+$$
+
+Given Lemma 4.7, the inductive step for establishing (12) is straightforward: we apply Lemma 4.7 with $P ^ { ( t ) } = x _ { i } ^ { ( t ) }$ and $Z ^ { ( t ) } = ( \mathrm { D } _ { h } \ell _ { i } ) ^ { ( t ) }$ for all $t$ . The fact that $x _ { i } ^ { ( t ) }$ are updated with Optimistic Hedge may be used to establish that precondition 1 of Lemma 4.7 holds. Since $\left( \operatorname { D } _ { 1 } Z \right) ^ { ( t ) } = \left( \operatorname { D } _ { h + 1 } \ell _ { i } \right) ^ { ( t ) }$ and $( \mathrm { D } _ { 2 } Z ) ^ { ( t ) } = ( \mathrm { D } _ { h + 2 } \ell _ { i } ) ^ { ( t ) }$ , that the inductive hypothesis (12) holds for $h + 1$ implies that precondition 2 of Lemma 4.7 holds for appropriate $\alpha , \mu > 0$ . Thus Lemma 4.7 implies that (12) holds for the value $h$ , which completes the inductive step.
+
+On the proof of Lemma 4.7. Finally we discuss the proof of Lemma 4.7. One technical challenge is the fact that the vectors $P ^ { ( t ) }$ are not constant functions of $t$ , but rather change slowly (as constrained by being $\zeta$ -consecutively close). The main tool for dealing with this difficulty is Lemma C.1, which shows that for a $\zeta$ -consecutively close sequence $P ^ { ( t ) }$ , for any vector $Z ^ { ( t ) }$ , $\begin{array} { r } { \frac { \dot { \operatorname { V a r } _ { P ^ { ( t ) } } } \left( Z ^ { ( t ) } \right) } { \operatorname { V a r } _ { P ^ { ( t + 1 ) } } \left( Z ^ { ( t ) } \right) } \in \left[ 1 - \zeta , 1 + \right. } \end{array}$ $\zeta ]$ . This fact, together with some algebraic manipulations, lets us to reduce to the case that all $P ^ { ( t ) }$ are equal. It is also relatively straightforward to reduce to the case that $\langle P ^ { ( t ) } , Z ^ { ( t ) } \rangle = 0$ for all $t$ , i.e., so that $\mathrm { V a r } _ { P ( t ) }$ $\left( Z ^ { ( t ) } \right) = \left\| Z ^ { ( t ) } \right\| _ { P ^ { ( t ) } } ^ { 2 }$ . We may further separate $\begin{array} { r } { \left. Z ^ { ( t ) } \right. _ { P ^ { ( t ) } } ^ { 2 } = \sum _ { j = 1 } ^ { n } P ^ { ( t ) } ( j ) \cdot ( Z ^ { ( t ) } ( j ) ) ^ { 2 } } \end{array}$ into its individual components $P ^ { ( t ) } ( j ) \cdot ( Z ^ { ( t ) } ( j ) ) ^ { 2 }$ , and treat each one separately, thus allowing us to reduce to a one-dimensional problem. Finally, we make one further reduction, which is to replace the finite differences $\mathrm { D } _ { h } \left( \cdot \right)$ in Lemma 4.7 with circular finite differences, defined below:
+
+Definition 4.2 (Circular finite difference). Suppose $L = ( L ^ { ( 0 ) } , \dots , L ^ { ( S - 1 ) } )$ is a sequence of vectors $L ^ { ( t ) } \in \mathbb { R } ^ { n }$ . For integers $h \geq 0$ , the level- $h$ circular finite difference sequence for the sequence $L$ , denoted by $\mathrm { D } _ { h } ^ { \circ } L$ , is the sequence defined recursively as: $( \mathrm { D } _ { 0 } ^ { \circ } L ) ^ { ( t ) } = L ^ { \bar { ( t ) } }$ for all $0 \leq t < S$ , and
+
+$$
+\begin{array} { r } { ( \mathrm { D } _ { h } ^ { \circ } L ) ^ { ( t ) } = \left\{ \begin{array} { l l } { \left( \mathrm { D } _ { h - 1 } ^ { \circ } L \right) ^ { ( t + 1 ) } - \left( \mathrm { D } _ { h - 1 } ^ { \circ } L \right) ^ { ( t ) } } & { : 0 \le t \le S - 2 } \\ { \left( \mathrm { D } _ { h - 1 } ^ { \circ } L \right) ^ { ( 1 ) } - \left( \mathrm { D } _ { h - 1 } ^ { \circ } L \right) ^ { ( T ) } } & { : t = S - 1 . } \end{array} \right. } \end{array}
+$$
+
+Circular finite differences for a sequence $L ^ { ( 0 ) } , \ldots , L ^ { ( S - 1 ) }$ are defined similarly to finite differences (Definition 4.1) except that unlike for finite differences, where (Dh L) (Sh) , $\left( \mathrm { D } _ { h } \cal L \right) ^ { ( S - h ) } , . . . , \left( \mathrm { D } _ { h } \cal L \right) ^ { ( S - 1 ) }$ are not defined, (Dh L) (Sh) , $\big ( \mathrm { D } _ { h } ^ { \circ } L \big ) ^ { ( S - h ) } , \ldots , \big ( \mathrm { D } _ { h } ^ { \circ } L \big ) ^ { ( S - 1 ) }$ are defined by “wrapping around” back to the beginning of the sequence. The above-described reductions, which are worked out in detail in Section C.2, allow us to reduce proving Lemma 4.7 to proving the following simpler lemma:
+
+Lemma 4.8. Suppose $\mu \in \mathbb { R } , \alpha > 0$ , and $W ^ { ( 0 ) } , \ldots , W ^ { ( S - 1 ) } \in \mathbb { R }$ is a sequence of reals satisfying
+
+$$
+\begin{array} { c } { \displaystyle \sum _ { t = 0 } ^ { S - 1 } \left( ( \mathrm { D } _ { 2 } ^ { \circ } W ) ^ { ( t ) } \right) ^ { 2 } \leq \alpha \cdot \displaystyle \sum _ { t = 0 } ^ { S - 1 } \left( ( \mathrm { D } _ { 1 } ^ { \circ } W ) ^ { ( t ) } \right) ^ { 2 } + \mu . } \\ { \displaystyle \neg s - 1 \left( ( \mathrm { D } _ { 1 } ^ { \circ } W ) ^ { ( t ) } \right) ^ { 2 } \leq \alpha \cdot \sum _ { t = 1 } ^ { S - 1 } ( W ^ { ( t ) } ) ^ { 2 } + \mu / \alpha . } \end{array}
+$$
+
+To prove Lemma 4.8, we apply the discrete Fourier transform to both sides of (14) and use the CauchySchwarz inequality in frequency dFourier transform is the sequence ence defi $W ^ { ( 0 ) } , \ldots , W ^ { ( S - 1 ) } \in \mathbb { R }$ . $\widehat { W } ^ { ( 0 ) } , \ldots , \widehat { W } ^ { ( S - \overline { { 1 } } ) }$ $\begin{array} { r } { \widehat { W } ^ { ( s ) } = \sum _ { t = 0 } ^ { S - 1 } W ^ { ( t ) } \cdot e ^ { - \frac { 2 \pi i s t } { S } } } \end{array}$ Below we prove Lemma 4.8 for the special case $\mu = 0$ ; we defer the general case to Section C.1.
+
+Proof of Lemma 4.8 for special case $\mu = 0$ . We have the following:
+
+$$
+\sum _ { i = 1 } ^ { r } ( ( \mathrm { D } _ { 1 } ^ { \circ } W ) ^ { ( t ) } ) ^ { 2 } = \sum _ { s = 1 } ^ { T } | \widehat { \mathrm { D } _ { 1 } ^ { \circ } W } ^ { ( s ) } | ^ { 2 } = \sum _ { s = 1 } ^ { T } | \widehat { W } ^ { ( s ) } ( e ^ { 2 \pi i s / T - 1 } ) | ^ { 2 } \leq \sqrt { \sum _ { s = 1 } ^ { T } | \widehat { W } ^ { ( s ) } | ^ { 2 } } \sqrt { \sum _ { s = 1 } ^ { T } | \widehat { W } ^ { ( s ) } | ^ { 2 } | e ^ { 2 \pi } }
+$$
+
+where the first equality uses Parseval’s equality, the second uses Fact C.3 (in the appendix) for $h = 1$ , and the inequality uses Cauchy-Schwarz. By Parseval’s inequality and Fact C.3 for $h = 2$ , the righthand side of the above equals $S \cdot \sqrt { \textstyle \sum _ { t = 1 } ^ { T } ( W ^ { ( t ) } ) ^ { 2 } } \cdot \sqrt { \textstyle \sum _ { t = 1 } ^ { T } \left( \big ( \mathrm { D } _ { 2 } ^ { \circ } W \big ) ^ { ( t ) } \right) ^ { 2 } }$ , which, by assumption, is $\operatorname { a t } \operatorname { m o s t } S \cdot { \sqrt { \sum _ { t = 1 } ^ { T } ( W ^ { ( t ) } ) ^ { 2 } } } \cdot { \sqrt { \alpha \cdot \sum _ { t = 1 } ^ { T } \left( \left( \mathrm { D } _ { 1 } ^ { \circ } W \right) ^ { ( t ) } \right) ^ { 2 } } }$ . Rearranging terms completes the proof.
+
+# Acknowledgments and Disclosure of Funding
+
+C.D. is Supported by NSF Awards CCF-1901292, DMS-2022448 and DMS-2134108, by a Simons Investigator Award, by the Simons Collaboration on the Theory of Algorithmic Fairness, by a DSTA grant, and by the DOE PhILMs project (No. DE-AC05-76RL01830). N.G. is supported by a Fannie & John Hertz Foundation Fellowship and an NSF Graduate Fellowship.
+
+# References
+
+[AIMM21] Waïss Azizian, Franck Iutzeler, Jérome Malick, and Panayotis Mertikopoulos. The last-iterate convergence rate of optimistic mirror descent in stochastic variational inequalities. In Conference on Learning Theory, pages 1–32, 2021.   
+[BCM12] Maria-Florina Balcan, Florin Constantin, and Ruta Mehta. The Weighted Majority Algorithm does not Converge in Nearly Zero-sum Games. In ICML Workshop on Markets, Mechanisms, and Multi-Agent Models, 2012.   
+[Bla54] David Blackwell. Controlled Random Walks. In Proceedings of the International Congress of Mathematicians, volume 3, pages 336–338, 1954.   
+[BP18] James P. Bailey and Georgios Piliouras. Multiplicative Weights Update in Zero-Sum Games. In Proceedings of the 2018 ACM Conference on Economics and Computation - EC ’18, pages 321–338, Ithaca, NY, USA, 2018. ACM Press.   
+[BP19] James P. Bailey and Georgios Piliouras. Fast and furious learning in zero-sum games: Vanishing regret with non-vanishing step sizes. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 12977–12987, 2019.   
+[Bro49] George W Brown. Some Notes on Computation of Games Solutions. Technical report, RAND CORP SANTA MONICA CA, 1949.   
+[Bub15] Sébastien Bubeck. Convex Optimization: Algorithms and Complexity. Found. Trends Mach. Learn., 8(3–4):231–357, November 2015.   
+[CBL06] Nicolo Cesa-Bianchi and Gábor Lugosi. Prediction, Learning, and Games. Cambridge university press, 2006.   
+[CDT09] Xi Chen, Xiaotie Deng, and Shang-Hua Teng. Settling the complexity of computing two-player nash equilibria. Journal of the ACM (JACM), 56(3):1–57, 2009.   
+[CP19] Yun Kuen Cheung and Georgios Piliouras. Vortices instead of equilibria in minmax optimization: Chaos and butterfly effects of online learning in zero-sum games. In Proceedings of the ThirtySecond Conference on Learning Theory, pages 807–834, 2019.   
+[CP20] Xi Chen and Binghui Peng. Hedging in games: Faster convergence of external and swap regrets. In Advances in Neural Information Processing Systems, volume 33, pages 18990–18999. Curran Associates, Inc., 2020.   
+[CS04] Imre Csiszár and Paul C. Shields. Information Theory and Statistics: A Tutorial. Commun. Inf. Theory, 1(4):417–528, December 2004.   
+[DDK11] Constantinos Daskalakis, Alan Deckelbaum, and Anthony Kim. Near-Optimal No-Regret Algorithms for Zero-Sum Games. In Proceedings of the twenty-second annual ACM-SIAM symposium on Discrete Algorithms (SODA), 2011.   
+$[ \mathrm { D F P ^ { + } 1 0 } ]$ Constantinos Daskalakis, Rafael Frongillo, Christos H. Papadimitriou, George Pierrakos, and Gregory Valiant. On learning algorithms for nash equilibria. In Proceedings of the Third International Conference on Algorithmic Game Theory, SAGT’10, page 114–125, Berlin, Heidelberg, 2010. Springer-Verlag.   
+[DGP06] Constantinos Daskalakis, Paul W. Goldberg, and Christos H. Papadimitriou. The complexity of computing a nash equilibrium. In Proceedings of the Thirty-Eighth Annual ACM Symposium on Theory of Computing (STOC), 2006.   
+[DP14] Constantinos Daskalakis and Qinxuan Pan. A counter-example to Karlin’s strong conjecture for fictitious play. In Proceedings of the 55th Annual Symposium on Foundations of Computer Science (FOCS), 2014.   
+[DP19] Constantinos Daskalakis and Ioannis Panageas. Last-iterate convergence: Zero-sum games and constrained min-max optimization. In 10th Innovations in Theoretical Computer Science Conference, ITCS 2019, January 10-12, 2019, San Diego, California, USA, volume 124 of LIPIcs, pages 27:1–27:18. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019.   
+$[ \mathrm { F L L ^ { + } } 1 6 ]$ Dylan J Foster, Zhiyuan Li, Thodoris Lykouris, Karthik Sridharan, and Eva Tardos. Learning in games: Robustness of fast convergence. In Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   
+[GKP89] Ronald L. Graham, Donald E. Knuth, and Oren Patashnik. Concrete Mathematics: A Foundation for Computer Science. Addison-Wesley, Reading, 1989.   
+[GPD20] Noah Golowich, Sarath Pattathil, and Constantinos Daskalakis. Tight last-iterate convergence rates for no-regret learning in multi-player games. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.   
+[HAM21] Yu-Guan Hsieh, Kimon Antonakopoulos, and Panayotis Mertikopoulos. Adaptive learning in continuous games: Optimal regret bounds and convergence to nash equilibrium. In Conference on Learning Theory, 2021.   
+[Han57] James Hannan. Approximation to Bayes risk in repeated play. Contributions to the Theory of Games, 3:97–139, 1957.   
+$[ \mathrm { H M c W ^ { + } } 0 3 ]$ ] Hart, Andreu Mas-colell, Of Jörgen W. Weibull, O Vega, Drew Fudenberg, David K. Levine, Josef Hofbauer, Karl Sigmund, Eric Maskin, Motty Perry, and Er Vasin. Uncoupled dynamics do not lead to nash equilibrium. Amer. Econ. Rev, pages 1830–1836, 2003.   
+[KHSC18] Ehsan Asadi Kangarshahi, Ya-Ping Hsieh, Mehmet Fatih Sahin, and Volkan Cevher. Let’s be honest: An optimal no-regret framework for zero-sum games. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 2488–2496. PMLR, 10–15 Jul 2018.   
+[KLP11] Robert Kleinberg, Katrina Ligett, and Georgios Piliouras. Beyond the nash equilibrium barrier. In In Innovations in Computer Science (ICS, pages 125–140, 2011.   
+[LGNPw21] Qi Lei, Sai Ganesh Nagarajan, Ioannis Panageas, and xiao wang. Last iterate convergence in no-regret learning: constrained min-max optimization for convex-concave landscapes. In Arindam Banerjee and Kenji Fukumizu, editors, Proceedings of The 24th International Conference on Artificial Intelligence and Statistics, volume 130 of Proceedings of Machine Learning Research, pages 1441–1449. PMLR, 13–15 Apr 2021.   
+[MPP18] Panayotis Mertikopoulos, Christos Papadimitriou, and Georgios Piliouras. Cycles in adversarial regularized learning. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’18, page 2703–2717, USA, 2018. Society for Industrial and Applied Mathematics.   
+[Nes05] Yu Nesterov. Excessive gap technique in nonsmooth convex minimization. SIAM Journal on Optimization, 16(1):235–249, 2005.   
+[PP16] Christos Papadimitriou and Georgios Piliouras. From nash equilibria to chain recurrent sets: Solution concepts and topology. In Proceedings of the 2016 ACM Conference on Innovations in Theoretical Computer Science, ITCS ’16, page 227–235, New York, NY, USA, 2016. Association for Computing Machinery.   
+[Rob51] Julia Robinson. An Iterative Method of Solving a Game. Annals of mathematics, pages 296–301, 1951.   
+[Rou09] Tim Roughgarden. Intrinsic robustness of the price of anarchy. In Proceedings of the Forty-First Annual ACM Symposium on Theory of Computing, STOC ’09, page 513–522, New York, NY, USA, 2009. Association for Computing Machinery.   
+[RS13a] Alexander Rakhlin and Karthik Sridharan. Online learning with predictable sequences. In Proceedings of the 26th Annual Conference on Learning Theory, pages 993–1019, 2013.   
+[RS13b] Alexander Rakhlin and Karthik Sridharan. Optimization, Learning, and Games with Predictable Sequences. arXiv:1311.1869 [cs], November 2013. arXiv: 1311.1869.   
+[RST17] Tim Roughgarden, Vasilis Syrgkanis, and Éva Tardos. The price of anarchy in auctions. J. Artif. Int. Res., 59(1):59–101, May 2017.   
+[SALS15] Vasilis Syrgkanis, Alekh Agarwal, Haipeng Luo, and Robert E Schapire. Fast convergence of regularized learning in games. In Advances in Neural Information Processing Systems, volume 28. Curran Associates, Inc., 2015.   
+[Sha64] L. Shapley. Some Topics in Two-Person Games. Advances in Game theory, 1964.   
+[ST13] Vasilis Syrgkanis and Eva Tardos. Composable and efficient mechanisms. In Proceedings of the Forty-Fifth Annual ACM Symposium on Theory of Computing, STOC ’13, page 211–220, New York, NY, USA, 2013. Association for Computing Machinery.   
+[VGFL $^ { + } 2 0 ]$ 1 Emmanouil-Vasileios Vlatakis-Gkaragkounis, Lampros Flokas, Thanasis Lianeas, Panayotis Mertikopoulos, and Georgios Piliouras. No-regret learning and mixed nash equilibria: They do not mix. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 1380–1391. Curran Associates, Inc., 2020.   
+[WL18] Chen-Yu Wei and Haipeng Luo. More adaptive algorithms for adversarial bandits. In Proceedings of the 31st Conference On Learning Theory, pages 1263–1291, 2018.   
+[WLZL21] Chen-Yu Wei, Chung-Wei Lee, Mengxiao Zhang, and Haipeng Luo. Linear last-iterate convergence in constrained saddle-point optimization. In International Conference on Learning Representations, 2021.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] See Sections 2 and 3.   
+(b) Did you include complete proofs of all theoretical results? [Yes] See Section 4 and the appendix (in the supplementary material).
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [N/A]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [N/A]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [N/A]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [N/A]   
+(b) Did you mention the license of the assets? [N/A]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/cVwc7IHWEWi/cVwc7IHWEWi_content_list.json

@@ -0,0 +1,1355 @@
+[
+    {
+        "type": "text",
+        "text": "Near-Optimal No-Regret Learning in General Games ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            122,
+            820,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Constantinos Daskalakis MIT CSAIL costis@csail.mit.edu ",
+        "bbox": [
+            228,
+            200,
+            403,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Maxwell Fishelson MIT CSAIL maxfish@mit.edu ",
+        "bbox": [
+            464,
+            200,
+            598,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Noah Golowich MIT CSAIL nzg@mit.edu ",
+        "bbox": [
+            658,
+            200,
+            767,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            279,
+            535,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We show that Optimistic Hedge – a common variant of multiplicative-weightsupdates with recency bias – attains poly $( \\log T )$ regret in multi-player general-sum games. In particular, when every player of the game uses Optimistic Hedge to iteratively update her strategy in response to the history of play so far, then after $T$ rounds of interaction, each player experiences total regret that is poly $( \\log T )$ . Our bound improves, exponentially, the $O ( T ^ { 1 / 2 } )$ regret attainable by standard no-regret learners in games, the $O ( T ^ { 1 / 4 } )$ regret attainable by no-regret learners with recency bias [SALS15], and the $O ( T ^ { 1 / 6 } )$ bound that was recently shown for Optimistic Hedge in the special case of two-player games [CP20]. A corollary of our bound is that Optimistic Hedge converges to coarse correlated equilibrium in general games at a rate of ${ \\tilde { O } } \\left( { \\scriptstyle { \\frac { 1 } { T } } } \\right)$ . ",
+        "bbox": [
+            233,
+            310,
+            766,
+            472
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            497,
+            312,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Online learning has a long history that is intimately related to the development of game theory, convex optimization, and machine learning. One of its earliest instantiations can be traced to Brown’s proposal [Bro49] of fictitious play as a method to solve two-player zero-sum games. Indeed, as shown by [Rob51], when the players of (zero-sum) matrix game use fictitious play to iteratively update their actions in response to each other’s history of play, the resulting dynamics converge in the following sense: the product of the empirical distributions of strategies for each player converges to the set of Nash equilibria in the game, though the rate of convergence is now known to be exponentially slow [DP14]. Moreover, such convergence to Nash equilibria fails in non-zero-sum games [Sha64]. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            630
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The slow convergence of fictitious play to Nash equilibria in zero-sum matrix games and nonconvergence in general-sum games can be mitigated by appealing to the pioneering works [Bla54, Han57] and the ensuing literature on no-regret learning [CBL06]. It is known that if both players of a zero-sum matrix game experience regret that is at most $\\varepsilon ( T )$ , the product of the players’ empirical distributions of strategies is an $O ( \\varepsilon ( \\bar { T } ) / T )$ -approximate Nash equilibrium. More generally, if each player of a general-sum, multi-player game experiences regret that is at most $\\varepsilon ( T )$ , the empirical distribution of joint strategies converges to a coarse correlated equilibrium1 of the game, at a rate of $O ( \\varepsilon ( T ) / T )$ . Importantly, a multitude of online learning algorithms, such as the celebrated Hedge and Follow-The-Perturbed-Leader algorithms, guarantee adversarial regret $O ( \\sqrt { T } )$ [CBL06]. Thus, when such algorithms are employed by all players in a game, their $O ( \\sqrt { T } )$ regret implies convergence to coarse correlated equilibria (and Nash equilibria of matrix games) at a rate of $O ( 1 / \\sqrt { T } )$ . ",
+        "bbox": [
+            174,
+            636,
+            825,
+            796
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While standard no-regret learners guarantee $O ( \\sqrt { T } )$ regret for each player in a game, the players can do better by employing specialized no-regret learning procedures. Indeed, it was established by [DDK11] that there exists a somewhat complex no-regret learner based on Nesterov’s excessive gap technique [Nes05], which guarantees ${ \\cal O } ( \\log T )$ regret to each player of a two-player zero-sum game. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            859
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/cd0a19042770db015f55f9a14e21a1cb673c24da4b2e86bec54c8201ecf719f1.jpg",
+        "table_caption": [
+            "Table 1: Overview of prior work on fast rates for learning in games. $m$ denotes the number of players, and $n$ denotes the number of actions per player (assumed to be the same for all players). For Optimistic Hedge, the adversarial regret bounds in the right-hand column are obtained via a choice of adaptive step-sizes. The ${ \\tilde { O } } ( \\cdot )$ notation hides factors that are polynomial in $\\log T$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm</td><td>Setting</td><td>Regret in games</td><td>Adversarial regret</td></tr><tr><td>Hedge (&amp; many other algs.)</td><td>multi-player, general-sum</td><td>O(√Tlog n) [CBL06]</td><td>O(√Tlog n) [CBL06]</td></tr><tr><td>Excessive Gap Technique</td><td>2-player, 0-sum</td><td>O(1og n(logT + 10g3/2 n)) [DDK11]</td><td>O(√Tlog n) [DDK11]</td></tr><tr><td>DS-OptMD, OptDA</td><td>2-player, 0-sum</td><td>l0g0(1)(n) [HAM21]</td><td>√T l0go(1)(n) [HAM21]</td></tr><tr><td>Optimistic Hedge</td><td>multi-player, general-sum</td><td>O(log n · √m T1/4) [RS13b, SALS15]</td><td>0(√Tlogn) [RS13b, SALS15]</td></tr><tr><td>Optimistic Hedge</td><td>2-player, general-sum</td><td>O(log5/6 n · T1/6) [CP20]</td><td>O(√Tlogn)</td></tr><tr><td>Optimistic Hedge</td><td>multi-player, general-sum</td><td>O(log n · m · log4 T) (Theorem 3.1)</td><td>0(√Tlogn) (Corollary D.1)</td></tr></table>",
+        "bbox": [
+            165,
+            154,
+            838,
+            387
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This represents an exponential improvement over the regret guaranteed by standard no-regret learners. More generally, [SALS15] established that if players of a multi-player, general-sum game use any algorithm from the family of Optimistic Mirror Descent (MD) or Optimistic Follow-the-RegularizedLeader (FTRL) algorithms (which are analogoues of the MD and FTRL algorithms, respectively, with recency bias), each player enjoys regret that is $O ( T ^ { 1 / 4 } )$ . This was recently improved by [CP20] to $O ( T ^ { 1 / 6 } )$ in the special case of two-player games in which the players use Optimistic Hedge, a particularly simple representative from both the Optimistic MD and Optimistic FTRL families. ",
+        "bbox": [
+            173,
+            420,
+            826,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The above results for general-sum games represent significant improvements over the $O ( \\sqrt { T } )$ regret attainable by standard no-regret learners, but are not as dramatic as the logarithmic regret that has been shown attainable by no-regret learners, albeit more complex ones, in 2-player zero-sum games (e.g., [DDK11]). Indeed, despite extensive work on no-regret learning, understanding the optimal regret that can be guaranteed by no-regret learning algorithms in general-sum games has remained elusive. This question is especially intruiging in light of experiments suggesting that polylogarithmic regret should be attainable [SALS15, HAM21]. In this paper we settle this question by showing that no-regret learners can guarantee polylogarithmic regret to each player in general-sum multi-player games. Moreover, this regret is attainable by a particularly simple algorithm – Optimistic Hedge: ",
+        "bbox": [
+            173,
+            529,
+            825,
+            654
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1.1 (Abbreviated version of Theorem 3.1). Suppose that m players play a general-sum multi-player game, with a finite set of n strategies per player, over $T$ rounds. Suppose also that each player uses Optimistic Hedge to update her strategy in every round, as a function of the history of play so far. Then each player experiences $O ( m \\cdot \\log n \\cdot \\log ^ { 4 } T )$ regret. ",
+        "bbox": [
+            174,
+            661,
+            826,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An immediate corollary of Theorem 1.1 is that the empirical distribution of play is a O ⇣ m log n log4 TT ⌘ approximate coarse correlated equilibrium (CCE) of the game. We remark that Theorem 1.1 bounds the total regret experienced by each player of the multi-player game, which is the most standard regret objective for no-regret learning in games, and which is essential to achieve convergence to CCE. For the looser objective of the average of all players’ regrets, [RS13b] established a ${ \\bar { O } } ( \\log n )$ bound for Optimistic Hedge in two-player zero-sum games, and [SALS15] generalized this bound, to $O ( m \\log n )$ in $m$ -player general-sum games. Note that since some players may experience negative regret [HAM21], the average of the players’ regrets cannot be used in general to bound the maximum regret experienced by any individual player. Finally, we remark that several results in the literature posit no-regret learning as a model of agents’ rational behavior; for instance, [Rou09, ST13, RST17] show that no-regret learners in smooth games enjoy strong Price-of-Anarchy bounds. By showing that each agent can obtain very small regret in games by playing Optimistic Hedge, Theorem 1.1 strengthens the plausability of the common assumption made in this literature that each agent will choose to use such a no-regret algorithm. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.1 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            136,
+            307,
+            150
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 1 summarizes the prior works that aim to establish optimal regret bounds for no-regret learners in games. We remark that [CP20] shows that the regret of Hedge is $\\Omega ( { \\sqrt { T } } )$ even in 2-player games where each player has 2 actions, meaning that optimism is necessary to obtain fast rates. The table also includes a recent result of [HAM21] showing that when the players in a 2-player zero-sum game with $n$ actions per player use a variant of Optimistic Hedge with adaptive step size (a special case of their algorithms DS-OptMD and OptDA), each player has $\\log ^ { O ( 1 ) } { \\bar { n } }$ regret. The techniques of [HAM21] differ substantially from ours: the result in [HAM21] is based on showing that the joint strategies $x ^ { ( t ) }$ rapidly converge, pointwise, to a Nash equilibrium $x ^ { \\star }$ . Such a result seems very unlikely to extend to our setting of general-sum games, since finding an approximate Nash equilibrium even in 2-player games is PPAD-complete [CDT09]. We also remark that the earlier work [KHSC18] shows that each player’s regret is at most $O ( \\log T \\cdot \\log n )$ when they use a certain algorithm based on Optimistic MD in 2-player zero-sum games; their technique is heavily tailored to 2-player zero-sum games, relying on the notion of duality in such a setting. ",
+        "bbox": [
+            173,
+            154,
+            825,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$[ \\mathrm { F L L ^ { + } } 1 6 ]$ shows that one can obtain fast rates in games for a broader class of algorithms (e.g., including Hedge) if one adopts a relaxed (approximate) notion of optimality. [WL18] uses optimism to obtain adaptive regret bounds for bandit problems. Many recent papers (e.g., [DP19, GPD20, LGNPw21, HAM21, WLZL21, AIMM21]) have studied the last-iterate convergence of algorithms from the Optimistic Mirror Descent family, which includes Optimistic Hedge. Finally, a long line of papers (e.g., $[ \\mathrm { H M c W ^ { + } } 0 3$ , $\\mathrm { D F P ^ { + } 1 0 }$ , KLP11, BCM12, PP16, BP18, MPP18, BP19, CP19, $\\mathrm { V G F L } ^ { + } 2 0 \\bar { ] }$ ) has studied the dynamics of learning algorithms in games. Essentially all of these papers do not use optimism, and many of them show non-convergence (e.g., divergence or recurrence) of the iterates of various learning algorithms such as FTRL and Mirror Descent when used in games. ",
+        "bbox": [
+            173,
+            344,
+            826,
+            470
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminaries ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            318,
+            506
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Notation. For a positive integer $n$ , let $[ n ] : = \\{ 1 , 2 , . . . , n \\}$ . For a finite set $s$ , let $\\Delta ( S )$ denote the space of distributions on $s$ . For $\\mathcal { S } = [ n ]$ , we will write $\\Delta ^ { n } : = \\Delta ( S )$ and interpret elements of $\\Delta ^ { n }$ as vectors in $\\mathbb { R } ^ { n }$ . For a vector $v \\in \\mathbb { R } ^ { n }$ and $j \\in [ n ]$ , we denote the $j$ th coordinate of $v$ as $v ( j )$ . For vectors $v , w \\in \\mathbb { R } ^ { n }$ , write $\\begin{array} { r } { \\langle v , w \\rangle = \\sum _ { j = 1 } ^ { n } v ( j ) w ( j ) } \\end{array}$ . The base-2 logarithm of $x > 0$ is denoted $\\log x$ ",
+        "bbox": [
+            174,
+            510,
+            825,
+            568
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "No-regret learning in games. We consider a game $G$ with $m \\in \\mathbb { N }$ players, where player $i \\in [ m ]$ has action space $A _ { i }$ with $n _ { i } : = | A _ { i } |$ actions. We may assume that $\\mathcal { A } _ { i } = [ n _ { i } ]$ for each player $i$ . The joint action space is $\\mathcal { A } : = \\mathcal { A } _ { 1 } \\times \\dots \\times \\mathcal { A } _ { m }$ . The specification of the game $G$ is completed by a collection of loss functions $\\mathcal { L } _ { 1 } , \\ldots , \\mathcal { L } _ { m } : \\mathcal { A }  [ 0 , 1 ]$ . For an action profile $a = ( a _ { 1 } , \\ldots , a _ { m } ) \\in \\mathcal { A }$ and $i \\in [ m ]$ , $\\mathcal { L } _ { i } ( a )$ is the loss player $i$ experiences when each player $i ^ { \\prime } \\in [ m ]$ plays $a _ { i ^ { \\prime } }$ . A mixed strategy $x _ { i } \\in \\Delta ( \\mathcal { A } _ { i } )$ for player $i$ is a distribution over $A _ { i }$ , with the probability of playing action $j \\in \\mathcal A _ { i }$ given by $x _ { i } ( j )$ . Given a mixed strategy profile $\\boldsymbol { x } = ( x _ { 1 } , \\dots , x _ { m } )$ (or an action profile $\\boldsymbol { a } = ( a _ { 1 } , \\dots , a _ { m } ) )$ and a player $i \\in [ m ]$ we let $x _ { - i }$ (or $a _ { - i }$ , respectively) denote the profile after removing the ith mixed strategy $x _ { i }$ (or the $i$ th action $a _ { i }$ , respectively). ",
+        "bbox": [
+            173,
+            570,
+            825,
+            698
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The $m$ players play the game $G$ for a total of $T$ rounds. At the beginning of each round $t \\in [ T ]$ , each player $i$ chooses a mixed strategy $x _ { i } ^ { ( t ) } \\in \\Delta ( \\mathcal { A } _ { i } )$ . The loss vector of player $i$ , denoted $\\ell _ { i } ^ { ( t ) } \\in [ 0 , 1 ] ^ { n _ { i } }$ , is defined as $\\ell _ { i } ^ { ( t ) } ( j ) = \\mathbb { E } _ { a _ { - i } \\sim x _ { - i } ^ { ( t ) } } [ \\mathcal { L } _ { i } ( \\dot { j } , a _ { - i } ) ]$ . As a matter of convention, set $\\ell _ { i } ^ { ( 0 ) } = \\mathbf { 0 }$ to be the all-zeros \u0000vector. We consider the full-information setting in this paper, meaning that player $i$ observes its full loss vector $\\ell _ { i } ^ { ( t ) }$ for each round $t$ . Finally, player $i$ experiences a loss of $\\langle \\ell _ { i } ^ { ( t ) } , x _ { i } ^ { ( t ) } \\rangle$ . The goal of each player $i$ is to minimize its regret, defined as: $\\begin{array} { r } { \\mathrm { R e g } _ { i , T } : = \\sum _ { t \\in [ T ] } \\langle x _ { i } ^ { ( t ) } , \\ell _ { i } ^ { ( t ) } \\rangle - \\operatorname* { m i n } _ { j \\in [ n _ { i } ] } \\sum _ { t \\in [ T ] } \\ell _ { i } ^ { ( t ) } ( j ) } \\end{array}$ . ",
+        "bbox": [
+            173,
+            702,
+            826,
+            809
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Optimistic hedge. The Optimistic Hedge algorithm chooses mixed strategies for player $i \\in [ m ]$ as follows: at time $t = 1$ , it sets $x _ { i } ^ { ( 1 ) } = ( 1 / n _ { i } , \\ldots , 1 / n _ { i } )$ to be the uniform distribution on $\\mathbf { \\mathcal { A } } _ { i }$ . Then for all $t < T$ , player $i$ ’s strategy at iteration $t + 1$ is defined as follows, for $j \\in [ n _ { i } ]$ : ",
+        "bbox": [
+            173,
+            813,
+            825,
+            859
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e98e66f1e0c53ede55b6edc0701cba77e3b17d661036dc90761ff6953b542c7.jpg",
+        "text": "$$\nx _ { i } ^ { ( t + 1 ) } ( j ) : = \\frac { x _ { i } ^ { ( t ) } ( j ) \\cdot \\exp ( - \\eta \\cdot ( 2 \\ell _ { i } ^ { ( t ) } ( j ) - \\ell _ { i } ^ { ( t - 1 ) } ( j ) ) ) } { \\sum _ { k \\in [ n _ { i } ] } x _ { i } ^ { ( t ) } ( k ) \\cdot \\exp ( - \\eta \\cdot ( 2 \\ell _ { i } ^ { ( t ) } ( k ) - \\ell _ { i } ^ { ( t - 1 ) } ( k ) ) ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            281,
+            866,
+            715,
+            910
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Optimistic Hedge is a modification of Hedge, which performs the updates $x _ { i } ^ { ( t + 1 ) } ( j ) : =$ $\\begin{array} { r l } & { \\frac { x _ { i } ^ { ( t ) } ( j ) \\cdot \\exp ( - \\eta \\cdot \\ell _ { i } ^ { ( t ) } ( j ) ) } { \\sum _ { k \\in [ n _ { i } ] } x _ { i } ^ { ( t ) } ( k ) \\cdot \\exp ( - \\eta \\cdot \\ell _ { i } ^ { ( t ) } ( k ) ) } } \\end{array}$ . The update (1) modifies the Hedge update by replacing the loss vector $\\ell _ { i } ^ { ( t ) }$ 2 i   with a predictor of the following iteration’s loss vector, $\\ell _ { i } ^ { ( t ) } + ( \\ell _ { i } ^ { ( t ) } - \\ell _ { i } ^ { ( t - 1 ) } )$ . Hedge corresponds to FTRL with a negative entropy regularizer (see, e.g., [Bub15]), whereas Optimistic Hedge corresponds to Optimistic FTRL with a negative entropy regularizer [RS13b, RS13a]. ",
+        "bbox": [
+            173,
+            88,
+            826,
+            181
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Distributions $\\pmb { \\& }$ divergences. For distributions $P , Q$ on a finite domain $[ n ]$ , the $K L$ divergence between $P , Q$ is $\\begin{array} { r } { \\mathrm { K L } ( P ; Q ) = \\sum _ { j = 1 } ^ { n } P ( j ) \\cdot \\log \\left( \\frac { P ( j ) } { Q ( j ) } \\right) } \\end{array}$ . The chi-squared divergence between $P , Q$ is $\\begin{array} { r } { \\chi ^ { 2 } ( P ; Q ) = \\sum _ { j = 1 } ^ { n } Q ( j ) \\cdot \\left( \\frac { P ( j ) } { Q ( j ) } \\right) ^ { 2 } - 1 = \\sum _ { j = 1 } ^ { n } \\frac { ( P ( j ) - Q ( j ) ) ^ { 2 } } { Q ( j ) } } \\end{array}$ (P (j)\u0000Q(j))2 . For a distribution P on [n] and a vector $v \\in \\mathbb { R } ^ { n }$ , we write $\\begin{array} { r } { \\mathrm { V a r } _ { P } \\left( v \\right) : = \\sum _ { j = 1 } ^ { n } P ( j ) \\cdot \\left( v ( j ) - \\sum _ { k = 1 } ^ { n } P ( k ) v ( k ) \\right) ^ { 2 } } \\end{array}$ . Also define $\\begin{array} { r } { \\| v \\| _ { P } : = \\sqrt { \\sum _ { j = 1 } ^ { n } P ( j ) \\cdot v ( j ) ^ { 2 } } } \\end{array}$ . If further $P$ has full support, then define $\\begin{array} { r } { \\left\\| v \\right\\| _ { P } ^ { \\star } = \\sqrt { \\sum _ { j = 1 } ^ { n } \\frac { v ( j ) ^ { 2 } } { P ( j ) } } } \\end{array}$ The above notations will often be used when $P$ is the mixed strategy profile $x _ { i }$ for some player $i$ and $v$ is a loss vector $\\ell _ { i }$ ; in such a case the norms $\\| v \\| _ { P }$ and $\\| v \\| _ { P } ^ { \\star }$ are often called local norms. ",
+        "bbox": [
+            171,
+            184,
+            826,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Results ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            340,
+            267,
+            357
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Below we state our main theorem, which shows that when all players in a game play according to Optimistic Hedge with appropriate step size, they all experience polylogarithmic individual regrets. ",
+        "bbox": [
+            173,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.1 (Formal version of Theorem 1.1). There are constants $C , C ^ { \\prime } > 1$ so that the following holds. Suppose a time horizon $T \\in \\mathbb { N }$ and a game $G$ with m players and $n _ { i }$ actions for each player $i \\in [ m ]$ is given. Suppose all players play according to Optimistic Hedge with any positive step size $\\begin{array} { r } { \\eta \\leq \\frac { 1 } { C \\cdot m \\log ^ { 4 } T } } \\end{array}$ . Then for any $i \\in [ m ]$ , the regret of player $i$ satisfies ",
+        "bbox": [
+            173,
+            392,
+            825,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5b8efb817be169fa2acaeb10e7f455f262ca7f62dede47d94db4f0f176fa2d3.jpg",
+        "text": "$$\n\\mathrm { R e g } _ { i , T } \\leq \\frac { \\log n _ { i } } { \\eta } + C ^ { \\prime } \\cdot \\log T .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            458,
+            599,
+            492
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In particular, if the players’ step size is chosen as $\\begin{array} { r } { \\eta = \\frac { 1 } { C \\cdot m \\log ^ { 4 } T } } \\end{array}$ , then the regret of player $i$ satisfies ",
+        "bbox": [
+            174,
+            498,
+            825,
+            518
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7a13f16705c7c1019ff8577e8f4d33bbbe426af046ca996a7e05387a0f95a1a4.jpg",
+        "text": "$$\n\\mathrm { R e g } _ { i , T } \\leq O \\left( m \\cdot \\log n _ { i } \\cdot \\log ^ { 4 } T \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            525,
+            612,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A common goal in the literature on learning in games is to obtain an algorithm that achieves fast rates whan played by all players, and so that each player $i$ still obtains the optimal rate of $O ( \\sqrt { T } )$ in the adversarial setting (i.e., when $i$ receives an arbitrary sequence of losses $\\ell _ { i } ^ { ( 1 ) } , \\ldots , \\ell _ { i } ^ { ( T ) } )$ . We show in Corollary D.1 (in the appendix) that by running Optimistic Hedge with an adaptive step size, this is possible. Table 1 compares our regret bounds discussed in this section to those of prior work. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Proof overview ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            651,
+            331,
+            667
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section we overview the proof of Theorem 3.1; the full proof may be found in the appendix. ",
+        "bbox": [
+            171,
+            671,
+            818,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 New adversarial regret bound ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            695,
+            421,
+            710
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first step in the proof of Theorem 3.1 is to prove a new regret bound (Lemma 4.1 below) for Optimistic Hedge that holds for an adversarial sequence of losses. We will show in later sections that when all players play according to Optimistic Hedge, the right-hand side of the regret bound (4) is bounded by a quantity that grows only poly-logarithmically in $T$ . ",
+        "bbox": [
+            173,
+            713,
+            825,
+            770
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.1. There is a constant $C > 0$ so that the following holds. Suppose any player $i \\in [ m ]$ follows the Optimistic Hedge updates (1) with step size $\\eta < 1 / C$ , for an arbitrary sequence of losses $\\ell _ { i } ^ { ( 1 ) } , \\ldots , \\ell _ { i } ^ { ( T ) } \\in [ 0 , 1 ] ^ { n _ { i } }$ . Then ",
+        "bbox": [
+            171,
+            773,
+            825,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0ca9db761f3715b76bf5340872410a7719ce4906f8c1afb6d30066737420f9a4.jpg",
+        "text": "$$\n\\mathrm { R e g } _ { i , T } \\leq \\frac { \\log n _ { i } } { \\eta } + \\sum _ { t = 1 } ^ { T } \\left( \\frac { \\eta } { 2 } + C \\eta ^ { 2 } \\right) \\mathrm { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\ell _ { i } ^ { ( t ) } - \\ell _ { i } ^ { ( t - 1 ) } \\right) - \\sum _ { t = 1 } ^ { T } \\frac { ( 1 - C \\eta ) \\eta } { 2 } \\cdot \\mathrm { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\ell _ { i } ^ { ( t - 1 ) } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            148,
+            827,
+            795,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The detailed proof of Lemma 4.1 can be found in Section A, but we sketch the main steps here. The starting point is a refinement of [RS13a, Lemma 3] (stated as Lemma A.5), which gives an upper ",
+        "bbox": [
+            171,
+            882,
+            826,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "bound for $\\mathrm { R e g } _ { i , T }$ in terms of local norms corresponding to each of the iterates $x _ { i } ^ { ( t ) }$ of Optimistic Hedge. The bound involves the difference between the Optimistic Hedge iterates $x _ { i } ^ { ( t ) }$ and iterates $\\tilde { x } _ { i } ^ { ( t ) }$ defined by $\\begin{array} { r } { \\tilde { x } _ { i } ^ { ( t ) } = \\frac { x _ { i } ^ { ( t ) } ( j ) \\cdot \\exp ( - \\eta \\cdot ( \\ell _ { i } ^ { ( t ) } ( j ) - \\ell _ { i } ^ { ( t - 1 ) } ( j ) ) ) } { \\sum _ { k \\in [ n _ { i } ] } x _ { i } ^ { ( t ) } ( k ) \\cdot \\exp ( - \\eta \\cdot ( \\ell _ { i } ^ { ( t ) } ( k ) - \\ell _ { i } ^ { ( t - 1 ) } ( k ) ) ) } } \\end{array}$ : ",
+        "bbox": [
+            171,
+            89,
+            828,
+            156
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3baa2e34f23dd46d157e7567859b9b531eb516b4d90bc7b95fd2a6e3e2d29bc4.jpg",
+        "text": "$$\n\\mathrm { R e g } _ { i , T } \\leq \\frac { \\log n _ { i } } { \\eta } + \\sum _ { t = 1 } ^ { T } \\left. x _ { i } ^ { ( t ) } - \\tilde { x } _ { i } ^ { ( t ) } \\right. _ { x _ { i } ^ { ( t ) } } ^ { \\times } \\sqrt { \\mathrm { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\ell _ { i } ^ { ( t ) } - \\ell _ { i } ^ { ( t - 1 ) } \\right) } - \\frac { 1 } { \\eta } \\sum _ { t = 1 } ^ { T } \\mathrm { K L } ( \\tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } ) - \\frac { 1 } { \\eta } \\sum _ { t = 1 } ^ { T } \\mathrm { K L } ( \\tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            137,
+            162,
+            795,
+            207
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2) thand $\\mathrm { K L } ( \\tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } )$ $\\mathrm { K L } ( x _ { i } ^ { ( t ) } ; \\tilde { x } _ { i } ^ { ( t - 1 ) } )$ may be lower bounded bytively. Note it is a standard $( 1 / 2 - O ( \\eta ) ) \\cdot \\chi ^ { 2 } ( \\tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } )$ $( 1 / 2 - O ( \\eta ) ) \\cdot \\chi ^ { 2 } ( x _ { i } ^ { ( t ) } ; \\tilde { x } _ { i } ^ { ( t - 1 ) } )$ fact that the KL divergence between two distributions is upper bounded by the chi-squared distribution between them; by contrast, Lemma A.2 can exploit that $x _ { i } ^ { ( t ) }$ , $\\tilde { x } _ { i } ^ { ( t ) }$ t) and x˜ (t\u00001)i a re close to each other between lower bo $x _ { i } ^ { ( t ) }$ i and x˜ $\\tilde { x } _ { i } ^ { ( t - 1 ) }$ hat the , leadi $\\chi ^ { 2 }$ -divergenco the term $\\chi ^ { 2 } ( x _ { i } ^ { ( t ) } ; \\tilde { x } _ { i } ^ { ( t - 1 ) } )$ $\\left( 1 - O ( \\eta ) \\right) \\cdot \\eta ^ { 2 } \\cdot \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\ell _ { i } ^ { ( t - 1 ) } \\right)$ $\\begin{array} { r } { \\frac { ( 1 - C \\eta ) \\eta } { 2 } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\ell _ { i } ^ { ( t - 1 ) } \\right) } \\end{array}$ being subtracted in (4). The $\\chi ^ { 2 }$ -divergence $\\chi ^ { 2 } ( \\tilde { x } _ { i } ^ { ( t ) } ; x _ { i } ^ { ( t ) } )$ , as well as the term $\\left\\| \\boldsymbol { x } _ { i } ^ { ( t ) } - \\tilde { \\boldsymbol { x } } _ { i } ^ { ( t ) } \\right\\| _ { \\boldsymbol { x } _ { i } ^ { ( t ) } } ^ { \\star }$ in (5) are bounded in a similar manner to obtain (4). ",
+        "bbox": [
+            171,
+            228,
+            826,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Finite differences ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            409,
+            334,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given Lemma 4.1, in order to establish Theorem 3.1, it suffices to show Lemma 4.2 below. Indeed, (6) below implies that the right-hand side of (4) is bounded above by $\\frac { \\log n _ { i } } { \\eta } + \\eta \\cdot O ( \\log ^ { 5 } T )$ , which is bounded above by $O ( m \\log n _ { i } \\log ^ { 4 } T )$ for the choice $\\begin{array} { r } { \\eta = \\Theta \\left( \\frac { 1 } { m \\cdot \\log ^ { 4 } T } \\right) } \\end{array}$ of Theorem 3.1.2 ",
+        "bbox": [
+            173,
+            428,
+            826,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.2 (Abbreviated; detailed version in Section C.3). Suppose all players play according to Optimistic Hedge with step size $\\eta$ satifying $\\begin{array} { r } { 1 / T \\le \\eta \\le \\frac { 1 } { C m \\cdot \\log ^ { 4 } T } } \\end{array}$ for a sufficiently large constant $C$ . Then for any $i \\in [ m ]$ , the losses $\\ell _ { i } ^ { ( 1 ) } , \\ldots , \\ell _ { i } ^ { ( T ) } \\in \\mathbb { R } ^ { n _ { i } }$ for player $i$ satisfy: ",
+        "bbox": [
+            173,
+            486,
+            826,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/668780befe828288ad82e78eeba01f03d71e41eab1e9145536160d8c45c80cce.jpg",
+        "text": "$$\n\\sum _ { t = 1 } ^ { T } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\ell _ { i } ^ { ( t ) } - \\ell _ { i } ^ { ( t - 1 ) } \\right) \\leq \\frac { 1 } { 2 } \\cdot \\sum _ { t = 1 } ^ { T } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\ell _ { i } ^ { ( t - 1 ) } \\right) + O \\left( \\log ^ { 5 } T \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            545,
+            730,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The definition below allows us to streamline our notation when proving Lemma 4.2. ",
+        "bbox": [
+            173,
+            601,
+            723,
+            616
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 4.1 (Finite differences). Suppose ${ \\cal L } = ( L ^ { ( 1 ) } , \\dots , L ^ { ( T ) } )$ is a sequence of vectors $L ^ { ( t ) } \\in \\mathbb { R } ^ { n }$ . For integers $h \\geq 0$ , the order- $h$ finite difference sequence for the sequence $L$ , denoted by $\\mathrm Ḋ _ Ḋ h Ḍ L Ḍ$ , is the sequence $\\mathrm D _ { h } L : = \\left( \\left( \\mathrm D _ { h } L \\right) ^ { ( 1 ) } , \\ldots , \\left( \\bar { \\mathrm D _ { h } } L \\right) ^ { ( T - h ) } \\right)$ defined recursively as: $\\left( \\mathrm { D } _ { 0 } L \\right) ^ { ( t ) } : = L ^ { ( t ) }$ for all $1 \\leq t \\leq T$ , and ",
+        "bbox": [
+            173,
+            619,
+            826,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/02e8dd0c308818b2c074a730112feabe1e3816dcc84b7a69399bf6159f2c7656.jpg",
+        "text": "$$\n( \\mathrm Ḋ _ { Ḋ } L Ḍ ) ^ { ( t ) } : = ( \\mathrm Ḋ _ { Ḋ } \\mathrm Ḋ _ { Ḋ } L Ḍ Ḍ ) ^ { ( t + 1 ) } - ( \\mathrm Ḋ _ { Ḋ } \\mathrm Ḋ _ { Ḋ } L Ḍ Ḍ ) ^ { ( t ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            679,
+            645,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "for all $h \\geq 1 , 1 \\leq t \\leq T - h$ .3 ",
+        "bbox": [
+            173,
+            702,
+            375,
+            719
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark 4.3. Notice that another way of writing (7) is: $\\mathrm { D } _ { h } { \\cal L } = \\mathrm { D } _ { 1 } \\mathrm { D } _ { h - 1 } { \\cal L }$ . We also remark for later use that $\\begin{array} { r } { ( \\mathrm { D } _ { h } L ) ^ { ( t ) } = \\sum _ { s = 0 } ^ { h } \\binom { h } { s } ( - 1 ) ^ { h - s } L ^ { ( t + s ) } } \\end{array}$ . ",
+        "bbox": [
+            173,
+            722,
+            825,
+            758
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $H = \\log T$ , where $T$ denotes the fixed time horizon from Theorem 3.1 (and thus Lemma 4.2). In the proof of Lemma 4.2, we will bound the finite differences of order $h \\leq H$ for certain sequences. The bound (6) of Lemma 4.2 may be rephased as upper bounding $\\textstyle \\sum _ { t = 1 } ^ { T } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( { \\bigl ( } \\operatorname { D } _ { 1 } \\ell _ { i } { \\bigr ) } ^ { ( t - 1 ) } \\right)$ , by $\\begin{array} { r } { \\frac { 1 } { 2 } \\sum _ { t = 1 } ^ { T } \\operatorname { V a r } _ { x _ { i } } \\Big ( \\ell _ { i } ^ { ( t - 1 ) } \\Big ) ; } \\end{array}$ ; to prove this, we proceed in two steps: ",
+        "bbox": [
+            173,
+            765,
+            826,
+            843
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. (Upwards induction step) First, in Lemma 4.4 below, we find an upper bound on $\\left\\| \\left( \\operatorname { D } _ { h } \\ell _ { i } \\right) ^ { ( t ) } \\right\\| _ { \\infty }$ for all $t \\in [ T ]$ , $h \\geq 0$ , which decays exponentially in $h$ for $h \\leq H$ 1. This is done via upwards induction on $h$ , i.e., first proving the base case $h = 0$ using boundedness of the losses $\\ell _ { i } ^ { ( t ) }$ and then $h = 1 , 2 , \\ldots$ inductively. The main technical tool we develop for the inductive step is a weak form of the chain rule for finite differences, Lemma 4.5. The inductive step uses the fact that all players are following Optimistic Hedge to relate the $h$ th order finite differences of player $i$ ’s loss sequence $\\ell _ { i } ^ { ( t ) }$ to the $h$ th order finite differences of the strategy sequences $x _ { i ^ { \\prime } } ^ { ( t ) }$ for players $i ^ { \\prime } \\neq i$ ; then we use the exponential-weights style updates of Optimistic Hedge and Lemma 4.5 to relate the hth order finite differences of the strategies $x _ { i ^ { \\prime } } ^ { ( t ) }$ to the $( h - 1 )$ th order finite differences of the losses $\\ell _ { i ^ { \\prime } } ^ { ( t ) }$ . ",
+        "bbox": [
+            173,
+            87,
+            825,
+            234
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2. (Downwards induction step) We next show that for all $H _ { \\mathbf { \\varepsilon } } \\leq \\mathbf { \\varepsilon } _ { h } \\leq \\mathbf { \\varepsilon } _ { H } $ $\\begin{array} { r } { \\sum _ { t = 1 } ^ { T } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\left( \\operatorname { D } _ { h + 1 } \\ell _ { i } \\right) ^ { ( t - 1 ) } \\right) } \\end{array}$ is bounded above by $\\begin{array} { r } { c _ { h } \\cdot \\sum _ { t = 1 } ^ { T } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( ( \\operatorname { D } _ { h } \\ell _ { i } ) ^ { ( t - 1 ) } \\right) + \\mu _ { h } } \\end{array}$ , for some $c _ { h } < 1 / 2$ and $\\mu _ { h } < \\dot { O } ( \\log ^ { 5 } T )$ . This shown via downwards induction on $h$ , namely first establishing the base case $h = H$ by using the result of item 1 for $h = H$ and then treating the cases $h = H - 1 , H - 2 , \\dots , 0$ . The inductive step makes use of the discrete Fourier transform (DFT) to relate the finite differences of different orders (see Lemmas 4.7 and 4.8). In particular, Parseval’s equality together with a standard relationship between the DFT of the finite differences of a sequence to the DFT of that sequence allow us to first prove the inductive step in the frequency domain and then transport it back to the original (time) domain. ",
+        "bbox": [
+            173,
+            237,
+            826,
+            375
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the following subsections we explain in further detail how the two steps above are completed. ",
+        "bbox": [
+            169,
+            382,
+            802,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Upwards induction proof overview ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            454,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Addressing item 1 in the previous subsection, the lemma below gives a bound on the supremum norm of the $h$ -th order finite differences of each player’s loss vector, when all players play according to Optimistic Hedge and experience losses according to their loss functions $\\mathcal { L } _ { 1 } , \\ldots , \\mathcal { L } _ { m } : \\mathcal { A }  [ 0 , 1 ]$ . ",
+        "bbox": [
+            174,
+            430,
+            823,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.4 (Abbreviated). Fix a step size $\\eta > 0$ satisfying $\\begin{array} { r } { \\eta \\ \\leq \\ o \\left( \\frac { 1 } { m \\log T } \\right) } \\end{array}$ . If all players follow Optimistic Hedge updates with step size $\\eta _ { ; }$ , then for any player $i \\in [ m ]$ , integer $h$ satisfying $0 \\leq h \\leq H$ , and time step $t \\in [ T - h ]$ , it holds that $\\| \\left( \\operatorname { D } _ { h } \\ell _ { i } \\right) ^ { ( t ) } \\| _ { \\infty } \\leq O ( m \\eta ) ^ { h } \\cdot h ^ { O ( h ) }$ . ",
+        "bbox": [
+            173,
+            476,
+            825,
+            532
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A detailed version of Lemma 4.4, together with its full proof, may be found in Section B.4. We next give a proof overview of Lemma 4.4 for the case of 2 players, i.e., $m = 2$ ; we show in Section B.4 how to generalize this computation to general $m$ . Below we introduce the main technical tool in the proof, a “boundedness chain rule,” and then outline how it is used to prove Lemma 4.4. ",
+        "bbox": [
+            173,
+            539,
+            825,
+            595
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Main technical tool for Lemma 4.4: boundedness chain rule. We say that a function $\\phi : \\mathbb { R } ^ { n }  \\mathbb { R }$ is a softmax-type function if there are real numbers $\\xi _ { 1 } , \\ldots , \\xi _ { n }$ and some $j \\in [ n ]$ so that for all $( z _ { 1 } , \\ldots , z _ { n } ) \\in \\mathbb { R } ^ { n }$ , $\\begin{array} { r } { \\phi ( ( z _ { 1 } , \\ldots , z _ { n } ) ) = \\frac { \\exp ( z _ { j } ) } { \\sum _ { k = 1 } ^ { n } \\xi _ { k } \\cdot \\exp ( z _ { k } ) } } \\end{array}$ . Lemma 4.5 below may be interpreted as a “boundedness chain rule” for finite differences. To explain the context for this lemma, recall that given an infinitely differentiable vector-valued function $L : \\mathbb { R } \\to \\mathbb { R } ^ { n }$ and an infinitely differentiable function $\\phi : \\mathbb { R } ^ { n }  \\mathbb { R }$ , the higher order derivatives of the function $\\phi ( L ( t ) )$ may be computed in terms of those of $L$ and $\\phi$ using the chain rule. Lemma 4.5 considers an analogous setting where the input variable $t$ to $L$ is discrete-valued, taking values in $[ T ]$ (and so we identify the function $L$ with the sequence $L ^ { ( 1 ) } , \\dots , L ^ { ( T ) } )$ . In this case, the higher order finite differences of the sequence $L ^ { ( 1 ) } , \\dots , L ^ { ( T ) }$ (Definition 4.1) take the place of the higher order derivatives of $L$ with respect to $t$ . Though there is no generic chain rule for finite differences, Lemma 4.5 states that, at least when $\\phi$ is a softmax-type function, we may bound the higher order finite differences of the sequence $\\phi ( L ^ { ( 1 ) } ) , \\dots , \\phi ( L ^ { ( T ) } )$ . In the lemma’s statement we let $\\phi \\circ L$ denote the sequence $\\phi ( L ^ { ( 1 ) } ) , \\dots , \\phi ( L ^ { ( T ) } )$ . ",
+        "bbox": [
+            171,
+            598,
+            826,
+            790
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.5 (“Boundedness chain rule” for finite differences; abbreviated). Suppose that $h , n \\in \\mathbb { N }$ , $\\phi : \\mathbb { R } ^ { n }  \\mathbb { R }$ is a softmax-type function, and ${ \\cal L } = ( L ^ { ( 1 ) } , \\dots , L ^ { ( T ) } )$ is a sequence of vectors in $\\mathbb { R } ^ { n }$ satisfying $\\| L ^ { ( t ) } \\| _ { \\infty } \\leq 1$ for $t \\in [ T ]$ . Suppose for some $\\alpha \\in ( 0 , 1 )$ , for each $0 \\leq h ^ { \\prime } \\leq h$ and $t \\in [ T - h ^ { \\prime } ] ,$ , it holds that $\\| \\mathrm { D } _ { h ^ { \\prime } } L ^ { ( t ) } \\| _ { \\infty } \\leq O ( \\alpha ^ { h ^ { \\prime } } ) \\cdot ( h ^ { \\prime } ) ^ { O ( h ^ { \\prime } ) }$ . Then for all $t \\in [ T - h ]$ , ",
+        "bbox": [
+            173,
+            792,
+            826,
+            853
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A detailed version of Lemma 4.5 may be found in Section B.3. While Lemma 4.5 requires $\\phi$ to be a softmax-type function for simplicity (and this is the only type of function $\\phi$ we will need to consider for the case $m = 2$ ) we remark that the detailed version of Lemma 4.5 allows $\\phi$ to be from a more general family of analytic functions whose higher order derivatives are appropriately bounded. The proof of Lemma 4.4 for all $m \\geq 2$ requires that more general form of Lemma 4.5. ",
+        "bbox": [
+            173,
+            882,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The proof of Lemma 4.5 proceeds by considering the Taylor expansion $P _ { \\phi } ( \\cdot )$ of the function $\\phi$ at the origin, which we write as follows: for $z = ( z _ { 1 } , \\ldots , z _ { n } ) \\in \\mathbb { R } ^ { n }$ , $\\begin{array} { r } { P _ { \\phi } ( z ) : = \\sum _ { k \\geq 0 , \\gamma \\in \\mathbb { Z } _ { \\geq 0 } ^ { n } : \\ | \\gamma | = k } a _ { \\gamma } z ^ { \\gamma } } \\end{array}$ , where $a _ { \\gamma } \\in \\mathbb { R } , | \\gamma |$ denotes the quantity $\\gamma _ { 1 } + \\cdots + \\gamma _ { n }$ and $z ^ { \\gamma }$ denotes $z _ { 1 } ^ { \\gamma _ { 1 } } \\cdots z _ { n } ^ { \\gamma _ { n } }$ . The fact that $\\phi$ is a softmax-type function ensures that the radius of convergence of its Taylor series is at least 1, i.e., $\\phi ( z ) = P _ { \\phi } ( z )$ for any $z$ satisfying $\\| z \\| _ { \\infty } \\leq 1$ . By the assumption that $\\| \\dot { L } ^ { ( t ) } \\| _ { \\infty } \\leq 1$ for each $t$ , we may therefore decompose $( \\mathrm { D } _ { h } \\left( \\phi \\circ L \\right) ) ^ { ( t ) }$ as: ",
+        "bbox": [
+            173,
+            138,
+            826,
+            236
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/51bef82b3a17e7e2602eab2eb5a13098baefba805f179d1d00b33f435880933c.jpg",
+        "text": "$$\n\\left( \\mathrm { D } _ { h } \\left( \\phi \\circ L \\right) \\right) ^ { \\left( t \\right) } = \\sum _ { k \\geq 0 , \\gamma \\in \\mathbb { Z } _ { \\geq 0 } ^ { n } : \\ \\vert \\gamma \\vert = k } a _ { \\gamma } \\cdot \\left( \\mathrm { D } _ { h } L ^ { \\gamma } \\right) ^ { \\left( t \\right) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            239,
+            669,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $L ^ { \\gamma }$ denotes the sequence of scalars $( L ^ { \\gamma } ) ^ { ( t ) } : = ( L ^ { ( t ) } ) ^ { \\gamma }$ for all $t$ . The fact that $\\phi$ is a softmaxtype function allows us to establish strong bounds on $| a _ { \\gamma } |$ for each $\\gamma$ in Lemma B.5. The proof of Lemma B.5 bounds the $| a _ { \\gamma } |$ by exploiting the simple form of the derivative of a softmax-type function to decompose each $a _ { \\gamma }$ into a sum of $| \\gamma |$ ! terms. Then we establish a bijection between the terms of this decomposition and graph structures we refer to as factorial trees; that bijection together with the use of an appropriate generating function allow us to complete the proof of Lemma B.5. ",
+        "bbox": [
+            173,
+            286,
+            826,
+            372
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Thus, to prove Lemma 4.5, it suffices to bound $\\left| ( \\mathrm Ḋ \\boldsymbol Ḋ h Ḍ Ḍ L ^ { \\gamma } ) ^ { ( t ) } \\right|$ for all $\\gamma$ . We do so by using Lemma 4.6. Lemma 4.6 (Abbreviated; detailed vesion in Section B.2). Fix any $h \\geq 0$ , a multi-index $\\gamma \\in \\mathbb { Z } _ { \\geq 0 } ^ { n }$ and set $k = | \\gamma |$ . For each of the $k ^ { h }$ functions $\\pi : [ h ]  [ k ]$ , and for each $r \\in [ k ] .$ , there are integers $h _ { \\pi , r } ^ { \\prime } \\in \\{ 0 , 1 , \\ldots , h \\}$ , $t _ { \\pi , r } ^ { \\prime } \\geq 0$ , and $j _ { \\pi , r } ^ { \\prime } \\in [ n ]$ , so that the following holds. For any sequence $L ^ { ( 1 ) } , \\ldots , L ^ { ( T ) } \\in \\mathbb { R } ^ { n }$ of vectors, it holds that, for each $t \\in [ T - h ]$ , ",
+        "bbox": [
+            169,
+            377,
+            826,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d3103af04e4d419b3196fe1dfc1700d85f0f1d3e96cead73163684b0e76f886a.jpg",
+        "text": "$$\n( \\mathrm { D } _ { h } L ^ { \\gamma } ) ^ { ( t ) } = \\sum _ { \\pi : [ h ]  [ k ] } \\prod _ { r = 1 } ^ { k } ( \\mathrm { D } _ { h _ { \\pi , r } ^ { \\prime } } ( L ( j _ { \\pi , r } ^ { \\prime } ) ) ) ^ { ( t + t _ { \\pi , r } ^ { \\prime } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            474,
+            678,
+            521
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.6 expresses the $h$ th order finite differences of the sequence $L ^ { \\gamma }$ as a sum of $k ^ { h }$ terms, each of which is a product of $k$ finite order differences of a sequence $L ^ { ( t ) } ( j _ { \\pi , r } ^ { \\prime } )$ (i.e., the $j _ { \\pi , r } ^ { \\prime }$ th coordinate of the vectors $L ^ { ( t ) }$ ). Crucially, when using Lemma 4.6 to prove Lemma 4.5, the assumption of Lemma 4.5 gives that for each $j ^ { \\prime } \\in [ n ]$ , each $h ^ { \\prime } \\in [ h ]$ , and each $t ^ { \\prime } \\in [ T - h ^ { \\prime } ]$ , we have the bound $\\left| ( \\operatorname { D } _ { h ^ { \\prime } } L ( j ^ { \\prime } ) ) ^ { ( t ^ { \\prime } ) } \\right| \\le O ( \\alpha ^ { h ^ { \\prime } } ) \\cdot ( h ^ { \\prime } ) ^ { O ( h ^ { \\prime } ) }$ . These assumed bounds may be used to bound the right-hand side of (9), which together with Lemma 4.6 and (8) lets us complete the proof of Lemma 4.5. ",
+        "bbox": [
+            173,
+            535,
+            826,
+            635
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Proving Lemma 4.4 using the boundedness chain rule. Next we discuss how Lemma 4.5 is used to prove Lemma 4.4, namely to bound $\\| \\left( \\mathrm { D } _ { h } \\ell _ { i } \\right) ^ { ( t ) } \\| _ { \\infty }$ for each $t \\in [ T - h ]$ , $i \\in [ m ]$ , and $0 \\leq h \\leq H$ . Lemma 4.4 is proved using induction, with the base case $h = 0$ being a straightforward consequence of the fact that $\\| \\left( \\operatorname { D } _ { 0 } \\ell _ { i } \\right) ^ { ( t ) } \\| _ { \\infty } = \\| \\ell _ { i } ^ { ( t ) } \\| _ { \\infty } \\leq 1$ for all $i \\in [ m ] , t \\in [ T ]$ . For the rest of this section we focus on the inductive case, i.e., we pick some $h \\in [ H ]$ and assume Lemma 4.4 holds for all $h ^ { \\prime } < h$ . ",
+        "bbox": [
+            173,
+            637,
+            826,
+            715
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The first step is to reduce the claim of Lemma 4.4 to the claim that the upper bound $\\Vert \\left( \\mathrm { D } _ { h } x _ { i } \\right) ^ { ( t ) } \\Vert _ { 1 } \\leq$ $O \\left( m \\eta \\right) ^ { h } \\cdot h ^ { O ( h ) }$ holds for each $t \\in [ T - h ] , i \\in [ m ]$ . Recalling that we are only sketching here the case $m = 2$ for simplicity, this reduction proceeds as follows: for $i \\in \\{ 1 , 2 \\}$ , define the matrix $A _ { i } \\ \\in \\ \\mathbb { R } ^ { n _ { 1 } \\times n _ { 2 } }$ by $( A _ { i } ) _ { a _ { 1 } a _ { 2 } } = { \\mathcal { L } } _ { i } ( a _ { 1 } , a _ { 2 } )$ , for $a _ { 1 } \\in [ n _ { 1 } ] , a _ { 2 } \\in [ n _ { 2 } ]$ . We have assumed that all players are using Optimistic Hedge and thus $\\ell _ { i } ^ { ( t ) } = \\mathbb { E } _ { a _ { i ^ { \\prime } } \\sim x _ { i ^ { \\prime } } ^ { ( t ) } }$ , $\\forall i ^ { \\prime } \\neq i ^ { }  \\lbrack \\mathcal { L } _ { i } ( a _ { 1 } , \\ldots , a _ { n } ) \\rbrack$ ; for our case here $( m = 2$ ), this may be rewritten as $\\ell _ { 1 } ^ { ( t ) } = A _ { 1 } x _ { 2 } ^ { ( t ) }$ , $\\ell _ { 2 } ^ { ( t ) } = A _ { 2 } ^ { \\top } x _ { 1 } ^ { ( t ) }$ . Thus ",
+        "bbox": [
+            173,
+            720,
+            826,
+            825
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/314064ce52e95c9f0110a5af6872ad4ef557260bc60ad407beb4eabc28379b8e.jpg",
+        "text": "$$\n| ( \\mathbf { D } _ { h } \\ell _ { 1 } ) ^ { ( t ) } | | _ { \\infty } = \\| A _ { 1 } \\cdot \\sum _ { s = 0 } ^ { h } { \\binom { h } { s } } ( - 1 ) ^ { h - s } x _ { 2 } ^ { ( t + s ) } \\| _ { \\infty } \\leq \\| \\sum _ { s = 0 } ^ { h } { \\binom { h } { s } } ( - 1 ) ^ { h - s } x _ { 2 } ^ { ( t + s ) } \\| _ { 1 } = \\| ( \\mathbf { D } _ { h } x _ { 2 } ) ^ { ( t ) } \\| _ { \\infty }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            830,
+            839,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where the first equality is from Remark 4.3 and the inequality follows since all entries of $A _ { 1 }$ have absolute value $\\leq 1$ . A similar computation allows us to show $\\| \\left( \\operatorname { D } _ { h } \\ell _ { 2 } \\right) ^ { ( t ) } \\| _ { \\infty } \\leq \\| \\left( \\operatorname { D } _ { h } x _ { 1 } \\right) ^ { ( t ) } \\| _ { 1 }$ . ",
+        "bbox": [
+            174,
+            880,
+            823,
+            914
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To complete the inductive step it remains to upper bound the quantities $\\Vert \\left( \\mathrm { D } _ { h } x _ { i } \\right) ^ { ( t ) } \\Vert _ { 1 }$ for $i \\in [ m ] , t \\in$ $[ T - h ]$ . To do so, we note that the definition of the Optimistic Hedge updates (1) implies that for any $\\bar { i } \\in [ m ] , t \\in [ T ] , j \\in [ n _ { i } ]$ , and $t ^ { \\prime } \\geq 1$ , we have ",
+        "bbox": [
+            174,
+            88,
+            823,
+            135
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/16ed038e2540dd3d042ee44c30ce61c3bd53be79d295355118dd4776778c4eb3.jpg",
+        "text": "$$\nx _ { i } ^ { ( t + t ^ { \\prime } ) } ( j ) = \\frac { x _ { i } ^ { ( t ) } ( j ) \\cdot \\exp \\left( \\eta \\cdot \\left( \\ell _ { i } ^ { ( t - 1 ) } ( j ) - \\sum _ { s = 0 } ^ { t ^ { \\prime } - 1 } \\ell _ { i } ^ { ( t + s ) } ( j ) - \\ell _ { i } ^ { ( t + t ^ { \\prime } - 1 ) } ( j ) \\right) \\right) } { \\sum _ { k = 1 } ^ { n _ { i } } x _ { i } ^ { ( t ) } ( k ) \\cdot \\exp \\left( \\eta \\cdot \\left( \\ell _ { i } ^ { ( t - 1 ) } ( k ) - \\sum _ { s = 0 } ^ { t ^ { \\prime } - 1 } \\ell _ { i } ^ { ( t + s ) } ( k ) - \\ell _ { i } ^ { ( t + t ^ { \\prime } - 1 ) } ( k ) \\right) \\right) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            138,
+            774,
+            193
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For $t \\in [ T ] , t ^ { \\prime } \\geq 0$ , set $\\begin{array} { r } { \\bar { \\ell } _ { i , t } ^ { ( t ^ { \\prime } ) } : = \\eta \\cdot \\left( \\ell _ { i } ^ { ( t - 1 ) } - \\sum _ { s = 0 } ^ { t ^ { \\prime } - 1 } \\ell _ { i } ^ { ( t + s ) } - \\ell _ { i } ^ { ( t + t ^ { \\prime } - 1 ) } \\right) . } \\end{array}$ . Also, for each $i \\in [ m ] , j \\in$ $[ n _ { i } ] , t \\in [ T ]$ , and any vector $z = ( z ( 1 ) , \\dots , z ( n _ { i } ) ) \\in \\mathbb { R } ^ { n _ { i } }$ define $\\begin{array} { r } { \\overset { \\cdot } { \\phi _ { t , i , j } ( z ) } : = \\frac { x _ { i } ^ { ( t ) } ( j ) \\cdot \\exp ( z ( j ) ) } { \\sum _ { k = 1 } ^ { n _ { i } } x _ { i } ^ { ( t ) } ( k ) \\cdot \\exp ( z ( k ) ) } } \\end{array}$ . Thus (10) gives that for $t ^ { \\prime } \\geq 1$ , $x _ { i } ^ { ( t + t ^ { \\prime } ) } ( j ) = \\phi _ { t , i , j } ( \\bar { \\ell } _ { i , t } ^ { ( t ^ { \\prime } ) } )$ . Viewing $t$ k=1 i ·as a fixed parameter and letting $t ^ { \\prime }$ vary, it follows that for $h \\geq 0$ and $t ^ { \\prime } \\geq 1$ , $\\begin{array} { r } { \\left( \\mathrm { D } _ { h } x _ { i } ^ { ( t + \\cdot ) } ( j ) \\right) ^ { ( t ^ { \\prime } ) } = \\left( \\mathrm { D } _ { h } \\left( \\phi _ { t , i , j } \\circ \\bar { \\ell } _ { i , t } \\right) \\right) ^ { ( t ^ { \\prime } ) } . } \\end{array}$ ",
+        "bbox": [
+            171,
+            196,
+            825,
+            297
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Recalling that our goal is to bound $\\vert \\left( \\mathrm { D } _ { h } x _ { i } ( j ) \\right) ^ { ( t + 1 ) } \\vert$ for each $t$ , we can do so by using Lemma 4.5 with $\\mathbf { \\phi } \\phi ~ = ~ \\phi _ { t , i , j }$ and $\\alpha ~ = ~ { \\cal { O } } ( m \\eta )$ , if we can show that its precondition is met, i.e. that $\\begin{array} { r } { \\| \\left( \\mathrm { D } _ { h ^ { \\prime } } \\bar { \\ell } _ { i , t } \\right) ^ { ( t ^ { \\prime } ) } \\| _ { \\infty } \\le \\frac { 1 } { B _ { 1 } } \\cdot \\alpha ^ { h ^ { \\prime } } \\cdot ( h ^ { \\prime } ) ^ { B _ { 0 } h ^ { \\prime } } } \\end{array}$ for all $h ^ { \\prime } \\leq h$ , the appropriate $\\alpha$ and appropriate constants B0, B1. Helpfully, the definition of ¯\\` (t0 )i,t a s a partial sum allows us to relate the $h ^ { \\prime }$ -th order finite differences of the sequence $\\bar { \\ell } _ { i , t } ^ { ( t ^ { \\prime } ) }$ to the $\\left( h ^ { \\prime } - 1 \\right)$ -th order finite differences of the sequence $\\ell _ { i } ^ { ( t ) }$ as follows: ",
+        "bbox": [
+            173,
+            304,
+            826,
+            409
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15d1fc02591fd78c85a84039c11e0ffec0507703142d597bd80a2c197df9cf2c.jpg",
+        "text": "$$\n\\left( \\mathrm { D } _ { h ^ { \\prime } } \\bar { \\ell } _ { i , t } \\right) ^ { ( t ^ { \\prime } ) } = \\eta \\cdot \\left( \\mathrm { D } _ { h ^ { \\prime } - 1 } \\ell _ { i } \\right) ^ { ( t + t ^ { \\prime } - 1 ) } - 2 \\eta \\cdot \\left( \\mathrm { D } _ { h ^ { \\prime } - 1 } \\ell _ { i } \\right) ^ { ( t + t ^ { \\prime } ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            405,
+            705,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since $h ^ { \\prime } - 1 < h$ for $h ^ { \\prime } \\leq h$ , the inductive assumption of Lemma 4.4 gives a bound on the $\\ell _ { \\infty }$ -norm of the terms on the right-hand side of (11), which are sufficient for us to apply Lemma 4.5. Note that the inductive assumption gives an upper bound on $\\| \\left( \\mathrm { D } _ { h ^ { \\prime } - 1 } \\ell _ { i } \\right) ^ { ( t ) } \\| _ { \\infty }$ that only scales with $\\alpha ^ { h ^ { \\prime } - 1 }$ , whereas Lemma 4.5 requires scaling of $\\alpha ^ { h ^ { \\prime } }$ . This discrepancy is corrected by the factor of $\\eta$ on the right-hand side of (11), which gives the desired scaling $\\alpha ^ { h ^ { \\prime } }$ (since $\\eta < \\alpha$ for the choice $\\alpha = { \\cal { O } } ( m \\eta ) ,$ ). ",
+        "bbox": [
+            173,
+            430,
+            826,
+            508
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Downwards induction proof overview ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            523,
+            473,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section we discuss in further detail item 2 in Section 4.2; in particular, we will show that there is a parameter $\\mu = \\tilde { \\Theta } ( \\eta m )$ so that for all integers $h$ satisfying $H - 1 \\geq h \\geq 0$ , ",
+        "bbox": [
+            171,
+            539,
+            823,
+            570
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d4a01c3d312c3cb162aff0331af09ebda1b9de80ffdb66d97685b038555db6d.jpg",
+        "text": "$$\n\\sum _ { t = 1 } ^ { T - h - 1 } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( ( \\operatorname { D } _ { h + 1 } \\ell _ { i } ) ^ { ( t ) } \\right) \\leq O ( 1 / H ) \\cdot \\sum _ { t = 1 } ^ { T - h } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( ( \\operatorname { D } _ { h } \\ell _ { i } ) ^ { ( t ) } \\right) + \\tilde { O } \\left( \\mu ^ { 2 h } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            574,
+            767,
+            617
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $\\tilde { O }$ hides factors polynomial in $\\log T$ . The validity of (12) for $h = 0$ implies Lemma 4.2. On implies that the other hand, as long we choose the value $\\begin{array} { r } { \\sum _ { t = 1 } ^ { T - H } \\operatorname { V a r } _ { x _ { i } ^ { ( t ) } } \\left( \\left( \\operatorname { D } _ { H } \\ell _ { i } \\right) ^ { ( t ) } \\right) \\leq O ( \\mu ^ { 2 H } ) } \\end{array}$ $\\mu$ in (12) to satisfy \u0000. This gives that (12) holds for $\\mu \\geq m \\eta H ^ { \\Omega ( 1 ) }$ , then Lemma 4.4 $h = H - 1$ . To show that (12) holds for all $H - 1 > h \\geq 0$ , we use downwards induction; fix any $h$ , and assume that (12) has been shown for all $h ^ { \\prime }$ satisfying $h < h ^ { \\prime } \\leq H - 1$ . Our main tool in the inductive step is to apply Lemma 4.7 below. To state it, for $\\zeta > 0 , n \\in \\mathbb { N }$ , we say that a sequence of distributions $P ^ { ( 1 ) } , \\ldots , P ^ { ( T ) } \\in \\Delta ^ { n }$ is $\\zeta$ -consecutively close if for each $1 \\leq t < T$ , it holds that max $\\left\\{ \\left\\| \\frac { P ^ { ( t ) } } { P ^ { ( t + 1 ) } } \\right\\| _ { \\infty } , \\left\\| \\frac { P ^ { ( t + 1 ) } } { P ^ { ( t ) } } \\right\\| _ { \\infty } \\right\\} \\leq 1 + \\zeta$ . 4 Lemma 4.7 shows that given a sequence of vectors for which the variances of its second-order finite differences are bounded by the variances of its first-order finite differences, a similar relationship holds between its first- and zeroth-order finite differences. ",
+        "bbox": [
+            173,
+            622,
+            826,
+            785
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.7. There is a sufficiently large constant $C _ { 0 } > 1$ so that the following holds. For any $M , \\zeta , \\alpha > 0$ and $n \\in \\mathbb N$ , suppose that $P ^ { ( 1 ) } , \\ldots , P ^ { ( T ) } \\in \\Delta ^ { n }$ and $Z ^ { ( 1 ) } , \\ldots , Z ^ { ( \\breve { T } ) } \\in [ - M , M ] ^ { \\breve { n } }$ satisfy the following conditions: ",
+        "bbox": [
+            174,
+            786,
+            823,
+            830
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1. The sequence $P ^ { ( 1 ) } , \\ldots , P ^ { ( T ) }$ is $\\zeta$ -consecutively close for some $\\zeta \\in [ 1 / ( 2 T ) , \\alpha ^ { 4 } / C _ { 0 } ]$ ",
+        "bbox": [
+            207,
+            837,
+            790,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8451563dd3aff45186b7eea34fb1da3069749b33fb5a706d5aa4bcd0503a9fa4.jpg",
+        "text": "$$\n\\begin{array} { r } { \\sum _ { t = 1 } ^ { T - 2 } \\operatorname { V a r } _ { P ^ { ( t ) } } \\left( \\left( \\operatorname { D } _ { 2 } Z \\right) ^ { ( t ) } \\right) \\leq \\alpha \\cdot \\sum _ { t = 1 } ^ { T - 1 } \\operatorname { V a r } _ { P ^ { ( t ) } } \\left( \\left( \\operatorname { D } _ { 1 } Z \\right) ^ { ( t ) } \\right) + \\mu . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            862,
+            761,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Here, for distributions $P , Q \\in \\Delta ^ { n }$ , $\\frac { P } { Q } \\in \\mathbb { R } ^ { n }$ denotes the vector whose $j$ th entry is $P ( j ) / Q ( j )$ . ",
+        "bbox": [
+            192,
+            893,
+            758,
+            914
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f4cd80d406c5419a7b938dbf4f03b30d2b5fdf161fd35e6b70132644cc2daa41.jpg",
+        "text": "$$\n\\begin{array} { r } { \\sum _ { t = 1 } ^ { T - 1 } \\operatorname { V a r } _ { P ^ { ( t ) } } \\left( \\left( \\operatorname { D } _ { 1 } Z \\right) ^ { ( t ) } \\right) \\leq \\alpha \\cdot \\left( 1 + \\alpha \\right) \\sum _ { t = 1 } ^ { T } \\operatorname { V a r } _ { P ^ { ( t ) } } \\left( Z ^ { ( t ) } \\right) + \\frac { \\mu } { \\alpha } + \\frac { C _ { 0 } M ^ { 2 } } { \\alpha ^ { 3 } } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            88,
+            732,
+            114
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Given Lemma 4.7, the inductive step for establishing (12) is straightforward: we apply Lemma 4.7 with $P ^ { ( t ) } = x _ { i } ^ { ( t ) }$ and $Z ^ { ( t ) } = ( \\mathrm { D } _ { h } \\ell _ { i } ) ^ { ( t ) }$ for all $t$ . The fact that $x _ { i } ^ { ( t ) }$ are updated with Optimistic Hedge may be used to establish that precondition 1 of Lemma 4.7 holds. Since $\\left( \\operatorname { D } _ { 1 } Z \\right) ^ { ( t ) } = \\left( \\operatorname { D } _ { h + 1 } \\ell _ { i } \\right) ^ { ( t ) }$ and $( \\mathrm { D } _ { 2 } Z ) ^ { ( t ) } = ( \\mathrm { D } _ { h + 2 } \\ell _ { i } ) ^ { ( t ) }$ , that the inductive hypothesis (12) holds for $h + 1$ implies that precondition 2 of Lemma 4.7 holds for appropriate $\\alpha , \\mu > 0$ . Thus Lemma 4.7 implies that (12) holds for the value $h$ , which completes the inductive step. ",
+        "bbox": [
+            173,
+            121,
+            826,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "On the proof of Lemma 4.7. Finally we discuss the proof of Lemma 4.7. One technical challenge is the fact that the vectors $P ^ { ( t ) }$ are not constant functions of $t$ , but rather change slowly (as constrained by being $\\zeta$ -consecutively close). The main tool for dealing with this difficulty is Lemma C.1, which shows that for a $\\zeta$ -consecutively close sequence $P ^ { ( t ) }$ , for any vector $Z ^ { ( t ) }$ , $\\begin{array} { r } { \\frac { \\dot { \\operatorname { V a r } _ { P ^ { ( t ) } } } \\left( Z ^ { ( t ) } \\right) } { \\operatorname { V a r } _ { P ^ { ( t + 1 ) } } \\left( Z ^ { ( t ) } \\right) } \\in \\left[ 1 - \\zeta , 1 + \\right. } \\end{array}$ $\\zeta ]$ . This fact, together with some algebraic manipulations, lets us to reduce to the case that all $P ^ { ( t ) }$ are equal. It is also relatively straightforward to reduce to the case that $\\langle P ^ { ( t ) } , Z ^ { ( t ) } \\rangle = 0$ for all $t$ , i.e., so that $\\mathrm { V a r } _ { P ( t ) }$ $\\left( Z ^ { ( t ) } \\right) = \\left\\| Z ^ { ( t ) } \\right\\| _ { P ^ { ( t ) } } ^ { 2 }$ . We may further separate $\\begin{array} { r } { \\left. Z ^ { ( t ) } \\right. _ { P ^ { ( t ) } } ^ { 2 } = \\sum _ { j = 1 } ^ { n } P ^ { ( t ) } ( j ) \\cdot ( Z ^ { ( t ) } ( j ) ) ^ { 2 } } \\end{array}$ into its individual components $P ^ { ( t ) } ( j ) \\cdot ( Z ^ { ( t ) } ( j ) ) ^ { 2 }$ , and treat each one separately, thus allowing us to reduce to a one-dimensional problem. Finally, we make one further reduction, which is to replace the finite differences $\\mathrm { D } _ { h } \\left( \\cdot \\right)$ in Lemma 4.7 with circular finite differences, defined below: ",
+        "bbox": [
+            173,
+            218,
+            826,
+            386
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Definition 4.2 (Circular finite difference). Suppose $L = ( L ^ { ( 0 ) } , \\dots , L ^ { ( S - 1 ) } )$ is a sequence of vectors $L ^ { ( t ) } \\in \\mathbb { R } ^ { n }$ . For integers $h \\geq 0$ , the level- $h$ circular finite difference sequence for the sequence $L$ , denoted by $\\mathrm { D } _ { h } ^ { \\circ } L$ , is the sequence defined recursively as: $( \\mathrm { D } _ { 0 } ^ { \\circ } L ) ^ { ( t ) } = L ^ { \\bar { ( t ) } }$ for all $0 \\leq t < S$ , and ",
+        "bbox": [
+            173,
+            388,
+            826,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/757938f9b645b3b0f2fda8224eccc18ed07024c37f696b557f418d7cf4051aea.jpg",
+        "text": "$$\n\\begin{array} { r } { ( \\mathrm { D } _ { h } ^ { \\circ } L ) ^ { ( t ) } = \\left\\{ \\begin{array} { l l } { \\left( \\mathrm { D } _ { h - 1 } ^ { \\circ } L \\right) ^ { ( t + 1 ) } - \\left( \\mathrm { D } _ { h - 1 } ^ { \\circ } L \\right) ^ { ( t ) } } & { : 0 \\le t \\le S - 2 } \\\\ { \\left( \\mathrm { D } _ { h - 1 } ^ { \\circ } L \\right) ^ { ( 1 ) } - \\left( \\mathrm { D } _ { h - 1 } ^ { \\circ } L \\right) ^ { ( T ) } } & { : t = S - 1 . } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            440,
+            707,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Circular finite differences for a sequence $L ^ { ( 0 ) } , \\ldots , L ^ { ( S - 1 ) }$ are defined similarly to finite differences (Definition 4.1) except that unlike for finite differences, where (Dh L) (S\u0000h) , $\\left( \\mathrm { D } _ { h } \\cal L \\right) ^ { ( S - h ) } , . . . , \\left( \\mathrm { D } _ { h } \\cal L \\right) ^ { ( S - 1 ) }$ are not defined, (D\u0000h L) (S\u0000h) , $\\big ( \\mathrm { D } _ { h } ^ { \\circ } L \\big ) ^ { ( S - h ) } , \\ldots , \\big ( \\mathrm { D } _ { h } ^ { \\circ } L \\big ) ^ { ( S - 1 ) }$ are defined by “wrapping around” back to the beginning of the sequence. The above-described reductions, which are worked out in detail in Section C.2, allow us to reduce proving Lemma 4.7 to proving the following simpler lemma: ",
+        "bbox": [
+            173,
+            493,
+            826,
+            571
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lemma 4.8. Suppose $\\mu \\in \\mathbb { R } , \\alpha > 0$ , and $W ^ { ( 0 ) } , \\ldots , W ^ { ( S - 1 ) } \\in \\mathbb { R }$ is a sequence of reals satisfying ",
+        "bbox": [
+            176,
+            574,
+            818,
+            592
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d364c072446b5219ddc93c0bf530ede3f123364d66063831ae469c1782627f14.jpg",
+        "text": "$$\n\\begin{array} { c } { \\displaystyle \\sum _ { t = 0 } ^ { S - 1 } \\left( ( \\mathrm { D } _ { 2 } ^ { \\circ } W ) ^ { ( t ) } \\right) ^ { 2 } \\leq \\alpha \\cdot \\displaystyle \\sum _ { t = 0 } ^ { S - 1 } \\left( ( \\mathrm { D } _ { 1 } ^ { \\circ } W ) ^ { ( t ) } \\right) ^ { 2 } + \\mu . } \\\\ { \\displaystyle \\neg s - 1 \\left( ( \\mathrm { D } _ { 1 } ^ { \\circ } W ) ^ { ( t ) } \\right) ^ { 2 } \\leq \\alpha \\cdot \\sum _ { t = 1 } ^ { S - 1 } ( W ^ { ( t ) } ) ^ { 2 } + \\mu / \\alpha . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            173,
+            595,
+            665,
+            671
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To prove Lemma 4.8, we apply the discrete Fourier transform to both sides of (14) and use the CauchySchwarz inequality in frequency dFourier transform is the sequence ence defi $W ^ { ( 0 ) } , \\ldots , W ^ { ( S - 1 ) } \\in \\mathbb { R }$ . $\\widehat { W } ^ { ( 0 ) } , \\ldots , \\widehat { W } ^ { ( S - \\overline { { 1 } } ) }$ $\\begin{array} { r } { \\widehat { W } ^ { ( s ) } = \\sum _ { t = 0 } ^ { S - 1 } W ^ { ( t ) } \\cdot e ^ { - \\frac { 2 \\pi i s t } { S } } } \\end{array}$ Below we prove Lemma 4.8 for the special case $\\mu = 0$ ; we defer the general case to Section C.1. ",
+        "bbox": [
+            173,
+            676,
+            830,
+            738
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Proof of Lemma 4.8 for special case $\\mu = 0$ . We have the following: ",
+        "bbox": [
+            173,
+            751,
+            620,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bff31ed4c742e19033dd1ad1b804bd4c1e671940732d3e83e517cc733712e618.jpg",
+        "text": "$$\n\\sum _ { i = 1 } ^ { r } ( ( \\mathrm { D } _ { 1 } ^ { \\circ } W ) ^ { ( t ) } ) ^ { 2 } = \\sum _ { s = 1 } ^ { T } | \\widehat { \\mathrm { D } _ { 1 } ^ { \\circ } W } ^ { ( s ) } | ^ { 2 } = \\sum _ { s = 1 } ^ { T } | \\widehat { W } ^ { ( s ) } ( e ^ { 2 \\pi i s / T - 1 } ) | ^ { 2 } \\leq \\sqrt { \\sum _ { s = 1 } ^ { T } | \\widehat { W } ^ { ( s ) } | ^ { 2 } } \\sqrt { \\sum _ { s = 1 } ^ { T } | \\widehat { W } ^ { ( s ) } | ^ { 2 } | e ^ { 2 \\pi } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            770,
+            839,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "where the first equality uses Parseval’s equality, the second uses Fact C.3 (in the appendix) for $h = 1$ , and the inequality uses Cauchy-Schwarz. By Parseval’s inequality and Fact C.3 for $h = 2$ , the righthand side of the above equals $S \\cdot \\sqrt { \\textstyle \\sum _ { t = 1 } ^ { T } ( W ^ { ( t ) } ) ^ { 2 } } \\cdot \\sqrt { \\textstyle \\sum _ { t = 1 } ^ { T } \\left( \\big ( \\mathrm { D } _ { 2 } ^ { \\circ } W \\big ) ^ { ( t ) } \\right) ^ { 2 } }$ , which, by assumption, is $\\operatorname { a t } \\operatorname { m o s t } S \\cdot { \\sqrt { \\sum _ { t = 1 } ^ { T } ( W ^ { ( t ) } ) ^ { 2 } } } \\cdot { \\sqrt { \\alpha \\cdot \\sum _ { t = 1 } ^ { T } \\left( \\left( \\mathrm { D } _ { 1 } ^ { \\circ } W \\right) ^ { ( t ) } \\right) ^ { 2 } } }$ . Rearranging terms completes the proof. ",
+        "bbox": [
+            171,
+            821,
+            826,
+            915
+        ],
+        "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": "C.D. is Supported by NSF Awards CCF-1901292, DMS-2022448 and DMS-2134108, by a Simons Investigator Award, by the Simons Collaboration on the Theory of Algorithmic Fairness, by a DSTA grant, and by the DOE PhILMs project (No. DE-AC05-76RL01830). N.G. is supported by a Fannie & John Hertz Foundation Fellowship and an NSF Graduate Fellowship. ",
+        "bbox": [
+            174,
+            119,
+            825,
+            176
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            195,
+            266,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[AIMM21] Waïss Azizian, Franck Iutzeler, Jérome Malick, and Panayotis Mertikopoulos. The last-iterate convergence rate of optimistic mirror descent in stochastic variational inequalities. In Conference on Learning Theory, pages 1–32, 2021.   \n[BCM12] Maria-Florina Balcan, Florin Constantin, and Ruta Mehta. The Weighted Majority Algorithm does not Converge in Nearly Zero-sum Games. In ICML Workshop on Markets, Mechanisms, and Multi-Agent Models, 2012.   \n[Bla54] David Blackwell. Controlled Random Walks. In Proceedings of the International Congress of Mathematicians, volume 3, pages 336–338, 1954.   \n[BP18] James P. Bailey and Georgios Piliouras. Multiplicative Weights Update in Zero-Sum Games. In Proceedings of the 2018 ACM Conference on Economics and Computation - EC ’18, pages 321–338, Ithaca, NY, USA, 2018. ACM Press.   \n[BP19] James P. Bailey and Georgios Piliouras. Fast and furious learning in zero-sum games: Vanishing regret with non-vanishing step sizes. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 12977–12987, 2019.   \n[Bro49] George W Brown. Some Notes on Computation of Games Solutions. Technical report, RAND CORP SANTA MONICA CA, 1949.   \n[Bub15] Sébastien Bubeck. Convex Optimization: Algorithms and Complexity. Found. Trends Mach. Learn., 8(3–4):231–357, November 2015.   \n[CBL06] Nicolo Cesa-Bianchi and Gábor Lugosi. Prediction, Learning, and Games. Cambridge university press, 2006.   \n[CDT09] Xi Chen, Xiaotie Deng, and Shang-Hua Teng. Settling the complexity of computing two-player nash equilibria. Journal of the ACM (JACM), 56(3):1–57, 2009.   \n[CP19] Yun Kuen Cheung and Georgios Piliouras. Vortices instead of equilibria in minmax optimization: Chaos and butterfly effects of online learning in zero-sum games. In Proceedings of the ThirtySecond Conference on Learning Theory, pages 807–834, 2019.   \n[CP20] Xi Chen and Binghui Peng. Hedging in games: Faster convergence of external and swap regrets. In Advances in Neural Information Processing Systems, volume 33, pages 18990–18999. Curran Associates, Inc., 2020.   \n[CS04] Imre Csiszár and Paul C. Shields. Information Theory and Statistics: A Tutorial. Commun. Inf. Theory, 1(4):417–528, December 2004.   \n[DDK11] Constantinos Daskalakis, Alan Deckelbaum, and Anthony Kim. Near-Optimal No-Regret Algorithms for Zero-Sum Games. In Proceedings of the twenty-second annual ACM-SIAM symposium on Discrete Algorithms (SODA), 2011.   \n$[ \\mathrm { D F P ^ { + } 1 0 } ]$ Constantinos Daskalakis, Rafael Frongillo, Christos H. Papadimitriou, George Pierrakos, and Gregory Valiant. On learning algorithms for nash equilibria. In Proceedings of the Third International Conference on Algorithmic Game Theory, SAGT’10, page 114–125, Berlin, Heidelberg, 2010. Springer-Verlag.   \n[DGP06] Constantinos Daskalakis, Paul W. Goldberg, and Christos H. Papadimitriou. The complexity of computing a nash equilibrium. In Proceedings of the Thirty-Eighth Annual ACM Symposium on Theory of Computing (STOC), 2006.   \n[DP14] Constantinos Daskalakis and Qinxuan Pan. A counter-example to Karlin’s strong conjecture for fictitious play. In Proceedings of the 55th Annual Symposium on Foundations of Computer Science (FOCS), 2014.   \n[DP19] Constantinos Daskalakis and Ioannis Panageas. Last-iterate convergence: Zero-sum games and constrained min-max optimization. In 10th Innovations in Theoretical Computer Science Conference, ITCS 2019, January 10-12, 2019, San Diego, California, USA, volume 124 of LIPIcs, pages 27:1–27:18. Schloss Dagstuhl - Leibniz-Zentrum für Informatik, 2019.   \n$[ \\mathrm { F L L ^ { + } } 1 6 ]$ Dylan J Foster, Zhiyuan Li, Thodoris Lykouris, Karthik Sridharan, and Eva Tardos. Learning in games: Robustness of fast convergence. In Advances in Neural Information Processing Systems, volume 29. Curran Associates, Inc., 2016.   \n[GKP89] Ronald L. Graham, Donald E. Knuth, and Oren Patashnik. Concrete Mathematics: A Foundation for Computer Science. Addison-Wesley, Reading, 1989.   \n[GPD20] Noah Golowich, Sarath Pattathil, and Constantinos Daskalakis. Tight last-iterate convergence rates for no-regret learning in multi-player games. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.   \n[HAM21] Yu-Guan Hsieh, Kimon Antonakopoulos, and Panayotis Mertikopoulos. Adaptive learning in continuous games: Optimal regret bounds and convergence to nash equilibrium. In Conference on Learning Theory, 2021.   \n[Han57] James Hannan. Approximation to Bayes risk in repeated play. Contributions to the Theory of Games, 3:97–139, 1957.   \n$[ \\mathrm { H M c W ^ { + } } 0 3 ]$ ] Hart, Andreu Mas-colell, Of Jörgen W. Weibull, O Vega, Drew Fudenberg, David K. Levine, Josef Hofbauer, Karl Sigmund, Eric Maskin, Motty Perry, and Er Vasin. Uncoupled dynamics do not lead to nash equilibrium. Amer. Econ. Rev, pages 1830–1836, 2003.   \n[KHSC18] Ehsan Asadi Kangarshahi, Ya-Ping Hsieh, Mehmet Fatih Sahin, and Volkan Cevher. Let’s be honest: An optimal no-regret framework for zero-sum games. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pages 2488–2496. PMLR, 10–15 Jul 2018.   \n[KLP11] Robert Kleinberg, Katrina Ligett, and Georgios Piliouras. Beyond the nash equilibrium barrier. In In Innovations in Computer Science (ICS, pages 125–140, 2011.   \n[LGNPw21] Qi Lei, Sai Ganesh Nagarajan, Ioannis Panageas, and xiao wang. Last iterate convergence in no-regret learning: constrained min-max optimization for convex-concave landscapes. In Arindam Banerjee and Kenji Fukumizu, editors, Proceedings of The 24th International Conference on Artificial Intelligence and Statistics, volume 130 of Proceedings of Machine Learning Research, pages 1441–1449. PMLR, 13–15 Apr 2021.   \n[MPP18] Panayotis Mertikopoulos, Christos Papadimitriou, and Georgios Piliouras. Cycles in adversarial regularized learning. In Proceedings of the Twenty-Ninth Annual ACM-SIAM Symposium on Discrete Algorithms, SODA ’18, page 2703–2717, USA, 2018. Society for Industrial and Applied Mathematics.   \n[Nes05] Yu Nesterov. Excessive gap technique in nonsmooth convex minimization. SIAM Journal on Optimization, 16(1):235–249, 2005.   \n[PP16] Christos Papadimitriou and Georgios Piliouras. From nash equilibria to chain recurrent sets: Solution concepts and topology. In Proceedings of the 2016 ACM Conference on Innovations in Theoretical Computer Science, ITCS ’16, page 227–235, New York, NY, USA, 2016. Association for Computing Machinery.   \n[Rob51] Julia Robinson. An Iterative Method of Solving a Game. Annals of mathematics, pages 296–301, 1951.   \n[Rou09] Tim Roughgarden. Intrinsic robustness of the price of anarchy. In Proceedings of the Forty-First Annual ACM Symposium on Theory of Computing, STOC ’09, page 513–522, New York, NY, USA, 2009. Association for Computing Machinery.   \n[RS13a] Alexander Rakhlin and Karthik Sridharan. Online learning with predictable sequences. In Proceedings of the 26th Annual Conference on Learning Theory, pages 993–1019, 2013.   \n[RS13b] Alexander Rakhlin and Karthik Sridharan. Optimization, Learning, and Games with Predictable Sequences. arXiv:1311.1869 [cs], November 2013. arXiv: 1311.1869.   \n[RST17] Tim Roughgarden, Vasilis Syrgkanis, and Éva Tardos. The price of anarchy in auctions. J. Artif. Int. Res., 59(1):59–101, May 2017.   \n[SALS15] Vasilis Syrgkanis, Alekh Agarwal, Haipeng Luo, and Robert E Schapire. Fast convergence of regularized learning in games. In Advances in Neural Information Processing Systems, volume 28. Curran Associates, Inc., 2015.   \n[Sha64] L. Shapley. Some Topics in Two-Person Games. Advances in Game theory, 1964.   \n[ST13] Vasilis Syrgkanis and Eva Tardos. Composable and efficient mechanisms. In Proceedings of the Forty-Fifth Annual ACM Symposium on Theory of Computing, STOC ’13, page 211–220, New York, NY, USA, 2013. Association for Computing Machinery.   \n[VGFL $^ { + } 2 0 ]$ 1 Emmanouil-Vasileios Vlatakis-Gkaragkounis, Lampros Flokas, Thanasis Lianeas, Panayotis Mertikopoulos, and Georgios Piliouras. No-regret learning and mixed nash equilibria: They do not mix. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 1380–1391. Curran Associates, Inc., 2020.   \n[WL18] Chen-Yu Wei and Haipeng Luo. More adaptive algorithms for adversarial bandits. In Proceedings of the 31st Conference On Learning Theory, pages 1263–1291, 2018.   \n[WLZL21] Chen-Yu Wei, Chung-Wei Lee, Mengxiao Zhang, and Haipeng Luo. Linear last-iterate convergence in constrained saddle-point optimization. In International Conference on Learning Representations, 2021. ",
+        "bbox": [
+            173,
+            213,
+            826,
+            921
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            64,
+            826,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            826,
+            229
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            227
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            231,
+            493,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] See Sections 2 and 3.   \n(b) Did you include complete proofs of all theoretical results? [Yes] See Section 4 and the appendix (in the supplementary material). ",
+        "bbox": [
+            238,
+            248,
+            825,
+            308
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            311,
+            393,
+            327
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [N/A]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [N/A]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [N/A] ",
+        "bbox": [
+            238,
+            330,
+            825,
+            449
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            217,
+            453,
+            823,
+            468
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [N/A]   \n(b) Did you mention the license of the assets? [N/A]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [N/A]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            472,
+            825,
+            593
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            598,
+            705,
+            612
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            616,
+            825,
+            705
+        ],
+        "page_idx": 12
+    }
+]

parse/train/k7aeAz4Vbb/k7aeAz4Vbb.md

@@ -0,0 +1,289 @@
+# Instance-Conditional Knowledge Distillation for Object Detection
+
+Zijian Kang∗ Xi’an Jiaotong University kzj123@stu.xjtu.edu.cn
+
+Peizhen Zhang∗ MEGVII Technology zhangpeizhen@megvii.com
+
+Xiangyu Zhang MEGVII Technology zhangxiangyu@megvii.com
+
+Jian Sun MEGVII Technology sunjian@megvii.com
+
+Nanning Zheng Xi’an Jiaotong University nnzheng@mail.xjtu.edu.cn
+
+# Abstract
+
+Knowledge distillation has shown great success in classification, however, it is still challenging for detection. In a typical image for detection, representations from different locations may have different contributions to detection targets, making the distillation hard to balance. In this paper, we propose a conditional distillation framework to distill the desired knowledge, namely knowledge that is beneficial in terms of both classification and localization for every instance. The framework introduces a learnable conditional decoding module, which retrieves information given each target instance as query. Specifically, we encode the condition information as query and use the teacher’s representations as key. The attention between query and key is used to measure the contribution of different features, guided by a localization-recognition-sensitive auxiliary task. Extensive experiments demonstrate the efficacy of our method: we observe impressive improvements under various settings. Notably, we boost RetinaNet with ResNet-50 backbone from 37.4 to $4 0 . 7 \mathrm { m A P }$ $\left( + 3 . 3 \right)$ under $1 \times$ schedule, that even surpasses the teacher (40.4 mAP) with ResNet-101 backbone under $3 \times$ schedule. Code has been released on https://github.com/megvii-research/ICD.
+
+# 1 Introduction
+
+Deep learning applications blossom in recent years with the breakthrough of Deep Neural Networks (DNNs) [17, 24, 21]. In pursuit of high performance, advanced DNNs usually stack tons of blocks with millions of parameters, which are computation and memory consuming. The heavy design hinders the deployment of many practical downstream applications like object detection in resource-limited devices. Plenty of techniques have been proposed to address this issue, like network pruning [15, 27, 18], quantization [22, 23, 35], mobile architecture design [38, 39] and knowledge distillation (KD) [19, 37, 43]. Among them, KD is one of the most popular choices, since it can boost a target network without introducing extra inference-time burden or modifications.
+
+KD is popularized by Hinton et al. [19], where knowledge of a strong pretrained teacher network is transferred to a small target student network in the classification scenario. Many good works emerge following the classification track [50, 37, 32]. However, most methods for classification perform badly in the detection: only slight improvements are observed [28, 51]. This can be attributed to two reasons: (1) Other than category classification, another challenging goal to localize the object is seldomly considered. (2) Multiple target objects are presented in an image for detection, where objects can distribute in different locations. Due to these reasons, the knowledge becomes rather ambiguous and imbalance in detection: representations from different positions like foreground or background, borders or centers, could have different contributions, which makes distillation challenging.
+
+![](images/d42521b8ba9824717a7cf824913ac3671acb0f17bcca343180144f7444febb0a.jpg)  
+Figure 1: Compare with different methods for knowledge distillation. (a) KD [19] for classification transfers logits. (b) Recent methods for detection KD distill intermediate features, different regionbased sampling methods are proposed. (c) Our method explicitly distill the desired knowledge.
+
+To handle the above challenge, two strategies are usually adopted by previous methods in detection. First, the distillation is usually conducted among intermediate representations, which cover all necessary features for both classification and localization. Second, different feature selection methods are proposed to overcome the imbalance issue. Existent works could be divided into three types according to the feature selection paradigm: proposal-based, rule-based and attention-based. In proposal-based methods [28, 11, 6], proposal regions predicted by the RPN [36] or detector are sampled for distillation. In rule-based methods [14, 45], regions selected by predesigned rules like foreground or label-assigned regions are sampled. Despite their improvements, limitations still exist due to the hand-crafted designs, e.g., many methods neglect the informative context regions or involve meticulous decisions. Recently, Zhang et al. [51] propose to use attention [43], a type of intermediate activation of the network, to guide the distillation. Although attention provides inherent hints for discriminative areas, the relation between activation and knowledge for detection is still unclear. To further improve KD quality, we hope to provide an explicit solution to connect the desired knowledge with feature selection.
+
+Towards this goal, we present Instance-Conditional knowledge Distillation (ICD), which introduces a new KD framework based-on conditional knowledge retrieval. In ICD, we propose to use a decoding network to find and distill knowledge associated with different instances, we deem such knowledge as instance-conditional knowledge. Fig. 1 shows the framework and compares it with former ones, ICD learns to find desired knowledge, which is much more flexible than previous methods, and is more consistent with detection targets. In detail, we design a conditional decoding module to locate knowledge, the correlation between knowledge and each instance is measured by the instance-aware attention via the transformer decoder [5, 43]. In which human observed instances are projected to query and the correlation is measured by scaled-product attention between query and teacher’s representations. Following this formulation, the distillation is conducted over features decomposed by the decoder and weighted by the instance-aware attention. Last but not least, to optimize the decoding module, we also introduce an auxiliary task, which teaches the decoder to find useful information for identification and localization. The task defines the goal for knowledge retrieval, it facilitates the decoder instead of the student. Overall, our contribution is summarized in three-fold:
+
+• We introduce a novel framework to locate useful knowledge in detection KD, we formulate the knowledge retrieval explicitly by a decoding network and optimize it via an auxiliary task. • We adopt the conditional modeling paradigm to facilitate instance-wise knowledge transferring. We encode human observed instances as query and decompose teacher’s representations to key and value to locate fine-grained knowledge. To our knowledge, it is the first trial to explore instance-oriented knowledge for detection. • We perform comprehensive experiments on challenging benchmarks. Results demonstrate impressive improvements over various detectors with up to 4 AP gain in MS-COCO, including recent detectors for instance segmentation [41, 46, 16]. In some cases, students with $1 \times$ schedule are even able to outperform their teachers with larger backbones trained $3 \times$ longer.
+
+# 2 Related Works
+
+# 2.1 Knowledge Distillation
+
+Knowledge distillation aims to transfer knowledge from a strong teacher to a weaker student network to facilitate supervised learning. The teacher is usually a large pretrained network, who provides smoother supervision and more hints on visual concepts, that improves the training quality and convergence speed [49, 9]. KD for image classification has been studied for years, they are usually categorized into three types [13]: response-based [19], feature-based [37, 43] and relation-based [32].
+
+Among them, feature-based distillation over multi-scale features is adopted from most of detection KD works, to deal with knowledge among multiple instances in different regions. Most of these works can be formulated as region selection for distillation, where foreground-background unbalancing is considered as a key problem in some studies [45, 51, 14]. Under this paradigm, we divide them into three kinds: (1) proposal-based, (2) rule-based and (3) attention-based.
+
+(1) Proposal-based methods rely on the prediction of the RPN or detection network to find foreground regions, e.g., Chen et al. [6] and Li et al. [28] propose to distilling regions predicted by RPN [36], Dai et al. [11] proposes GI scores to locate controversial predictions for distillation.
+
+(2) Rule-based methods rely on designed rules that can be inflexible and hyper-parameters inefficient, e.g., Wang et al. [45] distill assigned regions where anchor and ground-truth have a large IoU, Guo et al. [14] distill foreground and background regions separately with different factors.
+
+(3) Attention-based methods rely on activations to locate discriminative areas, yet they do not direct to knowledge that the student needs. Only a recent work from Zhang et al. [51] considers attention, they build the spatial-channel-wise attention to weigh the distillation.
+
+To overcome the above limitations, we explore the instance-conditional knowledge retrieval formulated by a decoder to explicitly search for useful knowledge. Like other methods, ICD does not have extra cost during inference or use extra data (besides existing labels and a pretrained teacher).
+
+# 2.2 Conditional Computation
+
+Conditional computation is widely adopted to infer contents on a given condition. Our study mostly focuses on how to identify visual contents given an instance as a condition. This is usually formulated as query an instance on the image, e.g., visual question answer [1, 2] and image-text matching [26] queries information and regions specified by natural language. Besides query by language, other types of query are proposed in recent years. For example, DETR [5] queries on fixed proposal embeddings, Chen et al. [8] encodes points as queries to facilitate weakly-supervised learning. These works adopt transformer decoder to infer upon global receptive fields that cover all visual contents, yet they usually rely on cascaded decoders that are costly for training. From another perspective, CondInst [41] and SOLOv2 [46] generate queries based on network predictions and achieves great performance on instance segmentation. Different from them, this work adopts the query-based approach to retrieve knowledge and build query based on annotated instances.
+
+# 2.3 Object Detection
+
+Object detection has been developed rapidly. Modern detectors are roughly divided into two-stage or one-stage detectors. Two-stage detectors usually adopt Region Proposal Network (RPN) to generate initial rough predictions and refine them with detection heads, the typical example is Faster R-CNN [36]. On the contrary, one-stage detectors directly predict on the feature map, which are usually faster, they include RetinaNet [30], FCOS [42]. Besides of this rough division, many extensions are introduced in recent years, e.g., extension to instance segmentation [41, 46, 16], anchor-free models [42, 25] and end-to-end detection [5, 44, 20]. Among these works, multi-scale features are usually adopted to enhance performance, e.g., FPN [29], which is considered as a typical case for our study. To generalize to various methods, the proposed method distills the intermediate features and does not rely on detector-specific designs.
+
+# 3 Method
+
+# 3.1 Overview
+
+As discussed in former studies [14, 51], useful knowledge for detection distributes unevenly in intermediate features. To facilitate KD, we propose to transfer instance-conditional knowledge between student and teacher network, termed $\kappa _ { i } ^ { S }$ and $\kappa _ { i } ^ { \mathcal { T } }$ corresponding to the $i _ { \mathrm { t h } }$ instance:
+
+$$
+\mathcal { L } _ { d i s t i l l } = \sum _ { i = 1 } ^ { N } \mathcal { L } _ { d } ( \kappa _ { i } ^ { S } , \kappa _ { i } ^ { T } )
+$$
+
+The knowledge towards teacher’s representations $\tau$ and condition $y _ { i }$ is formulated as $\kappa _ { i } ^ { \mathcal { T } } = \mathcal { G } ( \mathcal { T } , y _ { i } )$ ${ \kappa } _ { i } ^ { S }$ similarly), where $\mathcal { G }$ is the instance-conditional decoding module, optimized by an auxiliary loss illustrated in Sec. 3.3. The overall framework is shown in Fig. 2.
+
+In the following sections, we will introduce the instance-conditional knowledge (Sec. 3.2), describe the auxiliary task design (Sec. 3.3), and discuss the knowledge transferring (Sec. 3.4).
+
+# 3.2 Instance-conditional Knowledge
+
+In this section, we elaborate the instanceconditional decoding module $\mathcal { G }$ , which computes instance-conditional knowledge $\kappa _ { i } ^ { \mathcal { T } }$ from (1) unconditional knowledge given (2) instance conditions.
+
+(1) The unconditional knowledge $\tau$ , symbolizes all available information from the teacher detector. Since modern detectors commonly involve a feature pyramid network (FPN) [29] to extract rich multi-scale representations, we present multi-scale representations as $\mathcal T ~ = ~ \bar  \{ X _ { p } ~ \in ~ $ $\mathbb { R } ^ { D \times H _ { p } \times W _ { p } } \} _ { p \in \mathcal { P } }$ , where $\mathcal { P }$ signifies the spatial resolutions while $D$ is the channel dimension. By concatenating representations at different scales along the spatial dimension, we obtain $\mathbf { A } ^ { \mathcal { T } } \in \mathbb { R } ^ { L \times \mathbf { \smile } }$ , where $\begin{array} { r } { L = \sum _ { p \in \mathcal { P } } H _ { p } W _ { p } } \end{array}$ is the sum of total pixels number across scales.
+
+![](images/25e2b995f25211ec29c9dcb5e6072f7c1761f226e166013e18fe0d98ea312278.jpg)  
+Figure 2: We propose a decoding module to retrieve knowledge via query-based attention, where instance annotations are encoded as a query. An auxiliary task is proposed to optimize the decoding module and the feature-based distillation loss weighted by the attention is used to update student.
+
+(2) The instance condition, originally describing a human-observed object, is denoted by ${ \mathcal { V } } =$
+
+$\{ \mathfrak { y } _ { i } \} _ { i = 1 } ^ { N }$ , where $N$ is the object number and $\mathsf { y } _ { i } = \left( c _ { i } , \mathbf { b } _ { i } \right)$ is the annotation for the $i$ -th instance, including category $c _ { i }$ and box location $\mathbf { b } _ { i } = \left( x _ { i } , y _ { i } , w _ { i } , h _ { i } \right)$ which specifies the localization and size information.
+
+To produce learnable embeddings for each instance, the annotation is mapped to a query feature vector $\mathbf { q } _ { i }$ in the hidden space, which specifies a condition to collect desired knowledge:
+
+$$
+\mathbf { q } _ { i } = \mathcal { F } _ { q } ( \mathcal { E } ( \mathbf { y } _ { i } ) ) , \ \mathbf { q } _ { i } \in \mathbb { R } ^ { D }
+$$
+
+where $\mathcal { E } ( \cdot )$ is a instance encoding function (detailed in in Sec. 3) and $\mathcal { F } _ { q }$ is a Multi-Layer Perception network (MLP).
+
+We retrieve knowledge from $\tau$ given $\mathbf { q } _ { i }$ by measuring responses of correlation. This is formulated by dot-product attention [43] with $M$ concurrent heads in a query-key attention manner. In which each head $j$ corresponds to three linear layers $( \mathcal { F } _ { j } ^ { k } , \mathcal { F } _ { j } ^ { q } , \mathcal { F } _ { j } ^ { v } ) \mathop { w . r . t . }$ . the key, query and value construction.
+
+The key feature $\mathrm { K } _ { j } ^ { \mathcal { T } }$ is computed by projecting teacher’s representations $\mathrm { A } ^ { \tau }$ with the positional embeddings [43, 5] $\mathrm { P } \in \mathbb { R } ^ { L \times d }$ as in Eq. 3, where $\mathcal { F } _ { p e }$ denotes a linear projection over position embeddings. The value feature $\mathrm { V } _ { j } ^ { \mathcal { T } }$ and query ${ \bf q } _ { i j }$ is projected by linear mappings to a sub-space with $d = D / M$ channels, $\mathcal { F } _ { j } ^ { v }$ on $\mathrm { A } ^ { \tau }$ and $\mathcal { F } _ { j } ^ { q }$ over $\mathbf { q } _ { i }$ respectively, as shown in Eq. 4. At last, an instance-aware attention mask $\mathbf { m } _ { i j }$ of the $i$ -th instance by the $j$ -th head is obtained by normalized dot-product between $\mathrm { K } _ { j } ^ { \mathcal { T } }$ and $\mathbf { q } _ { i j }$ :
+
+![](images/26f2f0d1133a571e224a34b9c1b4806a50feadae4f96310903a3434d50f769d5.jpg)  
+Figure 3: The illustration of the auxiliary task. (a) The instance encoding function encodes a instance condition to a vector, it is then projected as query features. (b) The identification task learns to identify the existence the queried instance. (c) The localization task learns to predict the boundary given an uncertain position provided by the query.
+
+$$
+\begin{array} { r l } & { \mathrm { K } _ { j } ^ { \mathcal { T } } = \mathcal { F } _ { j } ^ { k } ( \mathrm { A } ^ { \mathcal { T } } + \mathcal { F } _ { p e } ( \mathrm { P } ) ) , \mathrm { K } _ { j } ^ { \mathcal { T } } \in \mathbb { R } ^ { L \times d } } \\ & { \mathrm { V } _ { j } ^ { \mathcal { T } } = \mathcal { F } _ { j } ^ { v } ( \mathrm { A } ^ { \mathcal { T } } ) , \mathrm { V } _ { j } ^ { \mathcal { T } } \in \mathbb { R } ^ { L \times d } } \\ & { \mathbf { q } _ { i j } = \mathcal { F } _ { j } ^ { q } ( \mathbf { q } _ { i } ) , \mathbf { q } _ { i j } \in \mathbb { R } ^ { d } } \\ & { \mathbf { m } _ { i j } = s o f t m a x ( \frac { \mathrm { K } _ { j } ^ { \mathcal { T } } \mathbf { q } _ { i j } } { \sqrt { d } } ) , \mathbf { m } _ { i j } \in \mathbb { R } ^ { L } } \end{array}
+$$
+
+Intuitively, the querying along the key features and value features describes the correlation between representations and instances. We collect $\kappa _ { i } ^ { \mathcal { T } } = \{ ( \mathbf { m } _ { i j } , \mathrm { V } _ { j } ^ { \mathcal { T } } ) \} _ { j = 1 } ^ { M }$ as the instance-conditional knowledge from $\tau$ , which encodes knowledge corresponds to the ith instance.
+
+# 3.3 Auxiliary Task
+
+In this section, we introduce the auxiliary task to optimize the decoding module $\mathcal { G }$ . First, we aggregate instance-level information to identify and localize objects. This could be obtained by aggregating the instance-conditional knowledge by the function $\mathcal { F } _ { a g g }$ , which includes sum-product aggregation over attention $\mathbf { m } _ { i j }$ and $\mathrm { V } _ { j } ^ { \mathcal { T } }$ , concatenate features from each head, add residuals and project with a feed-forward network as proposed in [43, 5]:
+
+$$
+\mathbf { g } _ { i } ^ { T } = \mathcal { F } _ { a g g } ( \kappa _ { i } ^ { T } , \mathbf { q } _ { i } ) , \ \mathbf { g } _ { i } ^ { T } \in \mathbb { R } ^ { D }
+$$
+
+To let the instance-level aggregated information $\mathbf { g } _ { i } ^ { \mathcal { T } }$ retain sufficient instance cues, one could design an instance-sensitive task to optimize it as below:
+
+$$
+\mathcal { L } _ { a u x } = \mathcal { L } _ { i n s } ( \mathbf { g } _ { i } ^ { T } , \mathcal { H } ( \mathbf { y } _ { i } ) )
+$$
+
+where $\mathcal { H }$ encodes the instance information as targets. However, directly adopt Eq. 8 might lead to trivial solution, since ${ \tt y } _ { i }$ is accessible from both $\mathbf { g } _ { i } ^ { \top }$ (through $\mathbf { q } _ { i }$ , see Eq. 2) and $\mathcal { H } ( \mathtt { y } _ { i } )$ . It is possible that parameters will learn a shortcut, that ignore the teacher representations $\tau$ . To resolve this issue, we propose to drop information on encoding function $\mathcal { E } ( \cdot )$ , to force the aggregation function $\mathcal { F } _ { a g g }$ to excavate hints from $\tau$ .
+
+The information dropping is adopted by replacing the accurate annotation for instance conditions to uncertain ones. For bounding box annotations, we relieve them to rough box centers with rough scales indicators. The rough box center $( x _ { i } ^ { \prime } , y _ { i } ^ { \prime } )$ is obtained by random jittering as shown below:
+
+$$
+\left\{ \begin{array} { l l } { x _ { i } ^ { \prime } = x _ { i } + \phi _ { x } w _ { i } , } \\ { y _ { i } ^ { \prime } = y _ { i } + \phi _ { y } h _ { i } , } \end{array} \right.
+$$
+
+where $( w _ { i } , h _ { i } )$ is the width and height of the bounding box and $\phi _ { x } , \phi _ { y }$ are sampled from a uniform distribution $\begin{array} { r } { \dot { \Phi } \sim U [ - a , a ] } \end{array}$ , where we set $\mathrm { a } { = } 0 . 3$ empirically. The scales indicators are obtained by rounding the box sizes in the logarithmic space, i.e., $\textcircled { l o g _ { 2 } ( w _ { i } ) } $ , $\lfloor l o g _ { 2 } ( h _ { i } ) \rfloor$ . In addition, to let the decoder learn to identify instances and be aware of the uncertainty, we generate fake instances for the identification task according to dataset distributions, this is detailed in Appendix A. As a result, it collect coarse information and obtain instance encoding through $\mathcal { E } ( \cdot )$ as depicted in Fig. 3a. where $c _ { i }$ is the category, $\mathcal { F } _ { o h }$ is the one hot vectorization, concat is the concatenation operator and $\mathcal { F } _ { p e }$ is the position embedding function.
+
+Finally, the aggregated representation $\mathbf { g } _ { i } ^ { T }$ are optimized by the auxiliary task. We introduces two predictors denoted by $\mathcal { F } _ { o b j }$ and $\mathcal { F } _ { r e g }$ respectively to predict identification and localization results. We adopt binary cross entropy loss (BCE) to optimize the real-fake identification and $L 1$ loss to optimize the regression.
+
+$$
+\mathcal { L } _ { a u x } = \mathcal { L } _ { B C E } ( \mathcal { F } _ { o b j } ( \mathbf { g } _ { i } ^ { T } ) , \delta _ { o b j } ( \mathbf { y } _ { i } ) ) + \mathcal { L } _ { 1 } ( \mathcal { F } _ { r e g } ( \mathbf { g } _ { i } ^ { T } ) , \delta _ { r e g } ( \mathbf { y } _ { i } ) )
+$$
+
+where $\delta _ { o b j } ( \cdot )$ is an indicator, it yields 1 if $\mathtt { y } _ { i }$ is real and 0 otherwise. Following common practice, the localization loss for fake examples is ignored. $\delta _ { r e g }$ is the preparing function for regression targets, following [42]. Appendix A provides more implementation details.
+
+# 3.4 Instance-Conditional Distillation
+
+Lastly, we present the formulation for conditional knowledge distillation. We obtain the projected value features $\mathrm { V } _ { j } ^ { S } \in \mathbb { R } ^ { L \times d }$ of the student representations analogous to Eq. 4 in Sec. 3.2. By adopting the instance-aware attention mask as a measurement of correlations between feature and each instance, we formulate the distillation loss as value features mimicking guided by the attention:
+
+$$
+\mathcal { L } _ { d i s t i l l } = \frac { 1 } { M N _ { r } } \sum _ { j = 1 } ^ { M } \sum _ { i = 1 } ^ { N } \delta _ { o b j } ( \mathrm { y } _ { i } ) \cdot < \mathbf { m } _ { i j } , \mathcal { L } _ { M S E } ( \mathrm { V } _ { j } ^ { S } , \mathrm { V } _ { j } ^ { \mathcal { T } } ) >
+$$
+
+where $\begin{array} { r } { N _ { r } = \sum _ { i = 1 } ^ { N } \delta _ { o b j } ( \mathbf { y } _ { i } ) } \end{array}$ , $( N _ { r } \leq N )$ is the real instances number, $\mathcal { L } _ { M S E } ( \mathrm { V } _ { j } ^ { S } , \mathrm { V } _ { j } ^ { T } ) \in \mathbb { R } ^ { L }$ is the pixel-wise mean-square error along the hidden dimension2 and $< \cdot , \cdot >$ is the Dirac notation for inner product. For stability, the learnable variable $\mathbf { m } _ { i j }$ and $\mathrm { V } _ { j } ^ { \mathcal { T } } .$ are detached during distillation. Combine with the supervised learning loss $\mathcal { L } _ { d e t }$ , the overall loss with a coefficient $\lambda$ is summarized below:
+
+$$
+\mathcal { L } _ { t o t a l } = \mathcal { L } _ { d e t } + \mathcal { L } _ { a u x } + \lambda \mathcal { L } _ { d i s t i l l }
+$$
+
+It is worth noticing, only the gradients w.r.t. $\mathcal { L } _ { d i s t i l l }$ and $\mathcal { L } _ { d e t }$ back-propagate to the student network (from representations $s$ ). The gradients of $\mathcal { L } _ { a u x }$ only update the instance-conditional decoding function $\mathcal { G }$ and auxiliary task related modules.
+
+# 4 Experiments
+
+# 4.1 Experiment Settings
+
+We conduct experiments on Pytorch [34] with the widely used Detectron2 library [47] and AdelaiDet library 3 [40]. All experiments are running on eight 2080ti GPUs with 2 images in each. We adopt the $1 \times$ scheduler, which denotes 9k iterations of training, following the standard protocols in Detectron2 unless otherwise specified. Scale jittering with random flip is adopted as data augmentation.
+
+For distillation, the hyper-parameter $\lambda$ is set to 8 for one-stage detectors and 3 for two-stage detectors respectively. To optimize the transformer decoder, we adopt AdamW optimizer [33] for the decoder and MLPs following common settings for transformer [43, 5]. Corresponding hyper-parameters follows [5], where the initial learning rate and weight decay are set to 1e-4. We adopt the 256 hidden dimension for our decoder and all MLPs, the decoder has 8 heads in parallel. The projection layer $\mathcal { F } _ { q }$ is a 3 layer MLP, $F _ { r e g }$ and $F _ { o b j }$ share another 3 layer MLP. In addition, we notice some newly initialized modules of the student share the same size of the teacher, e.g., the detection head, FPN.
+
+Table 1: Comparison with previous methods on challenging benchmark MS-COCO. The method proposed by Li et al. [28] does not apply to RetinaNet. $\dagger$ denotes the inheriting strategy.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">Faster R-CNN [36] APs</td><td colspan="4">RetinaNet [30]</td></tr><tr><td>AP</td><td>APM</td><td>APL</td><td>AP</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>Teacher w. ResNet-101 (3×)</td><td>42.0</td><td>25.2 45.6</td><td>54.6</td><td>40.4</td><td>24.0</td><td>44.3</td><td>52.2</td></tr><tr><td>Student w. ResNet-50 (1×)</td><td>37.9</td><td>22.4 41.1</td><td>49.1</td><td>37.4</td><td>23.1</td><td>41.6</td><td>48.3</td></tr><tr><td>+ FitNet [37]</td><td>39.3 (+1.4)</td><td>22.7 42.3</td><td>51.7</td><td>38.2(+0.8)</td><td>21.8</td><td>42.6</td><td>48.8</td></tr><tr><td>+ Li et al. [28]</td><td>39.5 (+1.5)</td><td>23.3 43.0</td><td>51.4</td><td></td><td>1</td><td>-</td><td>-</td></tr><tr><td>+ Wang et al. [45]</td><td>39.2 (+1.3)</td><td>23.2 42.8</td><td>50.4</td><td>38.4 (+1.0)</td><td>23.3</td><td>42.6</td><td>49.1</td></tr><tr><td>+ Zhang et al. [51]</td><td>40.0 (+2.1)</td><td>23.2 43.3</td><td>52.5</td><td>39.3 (+1.9)</td><td>23.4</td><td>43.6</td><td>50.6</td></tr><tr><td>+ Ours</td><td>40.4 (+2.5)</td><td>23.4 44.0</td><td>52.0</td><td>39.9 (+2.5)</td><td>25.0</td><td>43.9</td><td>51.0</td></tr><tr><td>+Ours+</td><td>40.9 (+3.0)</td><td>24.5</td><td>44.2 53.5</td><td>40.7 (+3.3)</td><td>24.2</td><td>45.0</td><td>52.7</td></tr></table>
+
+Table 2: Experiments on more detectors with ICD. Type denotes the AP score is evaluated on bounding box (BBox) or instance mask $( \tt M a s k )$ . $\dagger$ denotes using the inheriting strategy.   
+
+<table><tr><td>Detector</td><td>Setting</td><td>Type</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>FCOS [42]</td><td>Teacher (3×) Student (1×)</td><td rowspan="4">BBox</td><td>42.6</td><td>61.6</td><td>45.8</td><td>26.2</td><td>46.3</td><td>53.8</td></tr><tr><td></td><td></td><td>39.4</td><td>58.2</td><td>42.4</td><td>24.2</td><td>43.4</td><td>49.4</td></tr><tr><td>Teacher: 18.8 FPS /51.2M</td><td>+ Ours + Ours †</td><td>41.7(+2.3)</td><td>60.3</td><td>45.4</td><td>26.9</td><td>45.9</td><td>52.6</td></tr><tr><td>Student: 25.0 FPS /32.2M</td><td></td><td>42.9(+3.5)</td><td>61.6</td><td>46.6</td><td>27.8 46.8</td><td></td><td>54.6</td></tr><tr><td rowspan="6">Mask R-CNN [16] Teacher: 17.5 FPS /63.3M Student: 22.9 FPS /44.3M</td><td>Teacher(3×) Student (1×)</td><td rowspan="4">BBox</td><td>42.9</td><td>63.3</td><td>46.8</td><td>26.4</td><td>46.6</td><td>56.1</td></tr><tr><td></td><td>38.6</td><td>59.5</td><td>42.1</td><td>22.5</td><td>42.0</td><td>49.9</td></tr><tr><td>+ Ours</td><td>40.4 (+1.8)</td><td>60.9</td><td>44.2</td><td>24.4</td><td>43.7</td><td>52.0</td></tr><tr><td>+ Ours †</td><td>41.2 (+2.6)</td><td>62.0</td><td>45.0</td><td>25.1</td><td>44.5</td><td>53.6</td></tr><tr><td>Teacher(3×) Student (1×)</td><td>38.6 35.2</td><td>60.4 56.3</td><td>41.3</td><td>19.5</td><td>41.3</td><td>55.3</td></tr><tr><td rowspan="4">SOLOv2 [46]</td><td>+ Ours</td><td>Mask</td><td>36.7 (+1.5)</td><td></td><td>37.5</td><td>17.2</td><td>37.7</td><td>50.3</td></tr><tr><td></td><td>37.4 (+2.2)</td><td>58.0 58.7</td><td>39.2</td><td>18.4</td><td>38.9</td><td></td><td>52.5</td></tr><tr><td>+ Ours † Teacher (3×)</td><td>39.0</td><td></td><td></td><td>40.1</td><td>19.1</td><td>39.8</td><td>53.7</td></tr><tr><td>Student</td><td>34.6</td><td>59.4 54.7</td><td>41.9 36.9</td><td>16.2 13.2</td><td></td><td>43.1</td><td>58.2 53.3</td></tr><tr><td>Teacher: 16.6 FPS/65.5M Student: 21.4 FPS /46.5M</td><td>+ Ours + Ours †</td><td>Mask</td><td>37.2 (+2.6)</td><td>57.6</td><td>39.8</td><td>14.8</td><td>37.9 40.7</td><td>57.0</td></tr><tr><td rowspan="6">CondInst [41]</td><td>Teacher(3×)</td><td rowspan="3">BBox</td><td>38.5 (+3.9)</td><td>59.0</td><td>41.2</td><td>15.9</td><td>42.3</td><td>58.9</td></tr><tr><td></td><td>44.6</td><td>63.7</td><td></td><td></td><td></td><td></td></tr><tr><td>Student (1×)</td><td>39.7</td><td></td><td>48.4</td><td>27.5</td><td>47.8</td><td>58.4</td></tr><tr><td>+ Ours</td><td rowspan="3"></td><td></td><td>58.8</td><td>43.1</td><td>23.9</td><td>43.3</td><td>50.1</td></tr><tr><td>+ Ours †</td><td>42.4 (+2.7) 43.7 (+4.0)</td><td>61.5 62.9</td><td>46.1 47.2</td><td>25.3 27.1</td><td>46.0</td><td>54.3</td></tr><tr><td>Teacher(3×)</td><td>39.8</td><td></td><td></td><td></td><td>47.3</td><td>56.6</td></tr><tr><td rowspan="4">Teacher: 16.8FPS/53.5M Student: 21.3 FPS /34.1M</td><td></td><td rowspan="4">Mask</td><td></td><td>61.4</td><td>42.6</td><td>19.4</td><td>43.5</td><td>58.3</td></tr><tr><td>Student (1×)</td><td>35.7</td><td>56.7</td><td>37.7</td><td>16.8</td><td>39.1</td><td>50.3</td></tr><tr><td>+ Ours</td><td>37.8 (+2.1)</td><td>59.1</td><td>40.4</td><td>17.5</td><td>41.4</td><td>54.7</td></tr><tr><td>+ Ours †</td><td>39.1 (+3.4)</td><td>60.5</td><td>42.0</td><td>19.1</td><td>42.6</td><td>57.0</td></tr></table>
+
+We find initialize these modules with teacher’s parameters will lead to faster convergence, we call it the inheriting strategy in experiments.
+
+Most experiments are conducted on a large scale object detection benchmark MS-COCO 4[31] with 80 classes. We train models on MS-COCO 2017 trainval115k subset and validate on minival subset. Following common protocols, we report mean Average Precision (AP) as an evaluation metric, together with AP under different thresholds and scales, i.e., $\mathrm { { A P } _ { 5 0 } }$ , $\mathsf { A P } _ { 7 5 }$ , $\mathsf { A P } _ { \mathrm { S } }$ , $\mathsf { A P _ { M } }$ , $\mathsf { A P } _ { \mathrm { L } }$ . Other experiments are listed in Appendix B, e.g., on VOC [12] and Cityscapes [10], more ablations.
+
+# 4.2 Main Results
+
+Compare with state-of-the-art methods. We compare our method (ICD) with previous stateof-the-arts (SOTAs), including a classic distillation method FitNet [37], two typical detection KD methods [28, 45], and a very recent work with strong performance from Zhang et al. [51]. The comparison is conducted on two classic detectors: Faster R-CNN [36] and RetinaNet [30]. We adopt detectron2 official released models with ResNet-101 backbone trained on $3 \times$ scheduler as teacher networks, the student is trained on $1 \times$ with ResNet-50 backbone following the above settings.
+
+Table 3: Experiments on mobile backbones. $\dagger$ denotes using the inheriting strategy.   
+
+<table><tr><td>Detector</td><td>Setting</td><td>Backbone</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td rowspan="4">RetinaNet [30]</td><td>Teacher (3×)</td><td>ResNet-101[17]</td><td>40.4</td><td>60.3</td><td>43.2</td><td>24.0</td><td>44.3</td><td>52.2</td></tr><tr><td>Student (1×)</td><td></td><td>26.4</td><td>42.0</td><td>27.8</td><td>13.8</td><td>28.8</td><td>34.1</td></tr><tr><td>+ Ours</td><td>MBV2 [38]</td><td>29.5 (+3.1)</td><td>45.5</td><td>31.2</td><td>16.2</td><td>32.2</td><td>38.3</td></tr><tr><td>+ Ours †</td><td></td><td>31.6(+5.2)</td><td>48.5</td><td>33.4</td><td>17.6</td><td>34.7</td><td>41.3</td></tr><tr><td rowspan="4">RetinaNet [30]</td><td>Teacher (3×)</td><td>ResNet-101[17]</td><td>40.4</td><td>60.3</td><td>43.2</td><td>24.0</td><td>44.3</td><td>52.2</td></tr><tr><td>Student (1×)</td><td></td><td>34.9</td><td>54.8</td><td>37.0</td><td>20.9</td><td>38.9</td><td>44.8</td></tr><tr><td>+ Ours</td><td>Eff-B0 [39]</td><td>36.7 (+1.8)</td><td>56.0</td><td>38.7</td><td>21.1</td><td>40.6</td><td>48.1</td></tr><tr><td>+ Ours †</td><td></td><td>38.0 (+3.1)</td><td>57.5</td><td>40.2</td><td>22.4</td><td>41.6</td><td>50.3</td></tr><tr><td rowspan="4">FRCNN [36]</td><td>Teacher(3×)</td><td>ResNet-101[17]</td><td>42.0</td><td>62.5</td><td>45.9</td><td>25.2</td><td>45.6</td><td>54.6</td></tr><tr><td>Student (1×)</td><td></td><td>27.2</td><td>44.7</td><td>28.8</td><td>14.6</td><td>29.6</td><td>35.6</td></tr><tr><td>+ Ours</td><td>MBV2 [38]</td><td>30.2 (+3.0)</td><td>48.0</td><td>32.5</td><td>17.0</td><td>32.2</td><td>39.1</td></tr><tr><td>+ Ours †</td><td></td><td>31.4 (+4.2)</td><td>49.4</td><td>33.6</td><td>17.6</td><td>33.5</td><td>41.3</td></tr><tr><td rowspan="4">FRCNN [36]</td><td>Teacher (3×)</td><td>ResNet-101[17]</td><td>42.0</td><td>62.5</td><td>45.9</td><td>25.2</td><td>45.6</td><td>54.6</td></tr><tr><td>Student (1×)</td><td></td><td>35.3</td><td>56.8</td><td>37.8</td><td>20.8</td><td>38.2</td><td>45.1</td></tr><tr><td>+ Ours</td><td>Eff-B0 [39]</td><td>37.0 (+1.7)</td><td>58.0</td><td>39.6</td><td>21.1</td><td>40.0</td><td>48.3</td></tr><tr><td>+ Ours †</td><td></td><td>37.9 (+2.6)</td><td>58.7</td><td>40.8</td><td>21.4</td><td>40.9</td><td>49.5</td></tr></table>
+
+As shown in Table 1, ICD brings about $2 . 5 \mathrm { A P }$ and 3.0 AP improvement for plain training and training with the inheriting strategy respectively. Especially for RetinaNet, the student with distillation even outperforms a strong teacher trained on $3 \times$ scheduler. Compare with previous SOTAs, the proposed method leads to a considerable margin for about 0.5 AP without the inheriting strategy.
+
+Results on other settings. We further evaluate ICD under various detectors, e.g., a commonly used anchor-free detector FCOS [42], and three detectors that have been extended to instance segmentation: Mask R-CNN [16], SOLOv2 [46] and CondInst [41]. We adopt networks with ResNet-101 on $3 \times$ scheduler as teachers and networks with ResNet-50 on $1 \times$ scheduler as students following the above settings. As shown in Table 2, we observe consistent improvements for both detection and instance segmentation. There are at most around 4 AP improvement on CondInst [41] on object detection and SOLOv2 [46] on instance segmentation. Moreover, students with weaker backbone (ResNet-50 v.s. ResNet-101) and less training images $( 1 / 3 )$ even outperform (FCOS) or perform on par (SOLOv2, CondInst) with teachers. Note that ICD does not introduce extra burden during inference, our method improves about $2 5 \%$ of $\mathrm { F P S ^ { 5 } }$ and reduces $40 \%$ of parameters compared with teachers.
+
+Mobile backbones. Aside from main experiments on commonly used ResNet [17], we also conduct experiments on mobile backbones, which are frequently used in low-power devices. We evaluate our method on two prevalent architectures: MobileNet V2 (MBV2) [38] and EfficientNet-B0 (Eff-B0) [39]. The latter one adopts the MobileNet V2 as basis, and further extends it with advanced designs like stronger data augmentation and better activations.
+
+Experiments are conducted on Faster R-CNN (abbr., FRCNN) [36] and RetinaNet [30] following the above settings. As shown in Table 3, our method also significantly improves the performance on smaller backbones. For instance, we improve the RetinaNet with MobileNet V2 backbone with 5.2 AP gain and 3.1 AP gain with and without inheriting strategy respectively, and up to 3.1 AP gain for EfficientNet-B0. We also observe consistent improvements over Faster R-CNN, with up to 4.2 AP gain for MobileNet-V2 and 2.6 AP gain for EfficientNet-B0.
+
+# 4.3 Ablation Studies
+
+To verify the design options and the effectiveness of each component, we conduct ablation studies with the classic RetinaNet detector on MS-COCO following the above settings.
+
+Design of the auxiliary task. To better understand the role of our auxiliary task, we conduct experiments to evaluate the contribution of each sub-task. Specifically, our auxiliary task is composed of an identification task with binary cross-entropy loss and a localization task with regression loss, the localization task is further augmented with a hint on bounding box scales. As shown in Table 4, the identification task itself leads to $2 . 2 \ : \mathrm { A P }$ gain compare with the baseline, this high-light the importance of knowledge on object perception. The regression task itself leads to $1 . 8 \mathrm { A P }$ gain, and the scale information boosts it for extra 0.2 AP gain. Combine two of them, we achieve $2 . 5 \mathrm { \ A P }$ overall improvement, which indicates the fusion of two knowledge brings extra benefits. Note the auxiliary task only update the decoder and does not introduce extra data, which is very different from multitask learning, e.g., Mask R-CNN[16].
+
+Table 4: Comparison with different auxiliary task designs.   
+
+<table><tr><td>Identification</td><td>Localization</td><td>+ Scale</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td rowspan="4">√</td><td></td><td></td><td>37.4</td><td>56.7</td><td>40.3</td><td>23.1</td><td>41.6</td><td>48.3</td></tr><tr><td></td><td></td><td>39.6</td><td>59.2</td><td>42.8</td><td>23.4</td><td>44.0</td><td>50.4</td></tr><tr><td>√</td><td></td><td>39.2</td><td>58.6</td><td>42.4</td><td>23.1</td><td>43.5</td><td>50.3</td></tr><tr><td>√</td><td>√</td><td>39.4</td><td>58.8</td><td>42.4</td><td>23.2</td><td>43.8</td><td>50.5</td></tr><tr><td>√</td><td>√</td><td>√</td><td>39.9</td><td>59.4</td><td>43.1</td><td>25.0</td><td>43.9</td><td>51.0</td></tr></table>
+
+Impact of the instance-aware attention. To verify the effectiveness of instance-aware attention learned by conditional computation, we directly replace it with different variations: the fine-grained mask in [45], pixel-wise attention activation [51, 43], foreground mask analog to [14] and no attention mask. The result in Fig. 5 shows our instance-aware mask leads to about 0.9 AP gain over the baseline and $0 . 4 \ : \mathrm { A P }$ gain compare with the best replacement.
+
+Table 5: Comparison with different types of attention.   
+
+<table><tr><td>Attention Type</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APm</td><td>APL</td></tr><tr><td>No Attention</td><td>39.0</td><td>58.4</td><td>42.1</td><td>23.5</td><td>43.2</td><td>49.9</td></tr><tr><td>Foreground Mask</td><td>39.4</td><td>58.9</td><td>42.4</td><td>23.5</td><td>43.6</td><td>50.0</td></tr><tr><td>Fine-grained Mask [45]</td><td>39.5</td><td>59.0</td><td>42.4</td><td>23.4</td><td>43.8</td><td>50.2</td></tr><tr><td>Attention Activation [43]</td><td>39.3</td><td>58.6</td><td>42.3</td><td>22.6</td><td>43.6</td><td>50.1</td></tr><tr><td>Instance-conditional Attention</td><td>39.9</td><td>59.4</td><td>43.1</td><td>25.0</td><td>43.9</td><td>51.0</td></tr></table>
+
+Design of the decoder. We mainly verify two properties of the decoder design, as shown in Table 6. First, we find a proper number of heads is important for the best performance. The head number balances the dimension for each sub-space and the number of spaces. The best number lies around 8, which is consistent with former studies [5]. Second, we evaluate the effectiveness of cascaded decoders, as it is widely adopted in former studies [43, 5, 8]. However, we do not find significant differences between different cascade levels, it might because we use a fixed teacher to provide knowledge, that limited the learning ability.
+
+(a) Number of heads.   
+
+<table><tr><td>Heads</td><td>AP</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>1</td><td>39.4</td><td>23.7</td><td>43.8</td><td>50.5</td></tr><tr><td>4</td><td>39.7</td><td>24.0</td><td>43.9</td><td>51.2</td></tr><tr><td>8</td><td>39.9</td><td>25.0</td><td>43.9</td><td>51.0</td></tr><tr><td>16</td><td>39.7</td><td>23.6</td><td>44.2</td><td>50.5</td></tr></table>
+
+Table 6: Ablation on the number of heads and cascade levels.   
+(b) Number of cascade levels.   
+
+<table><tr><td>Levels</td><td>AP</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>1</td><td>39.9</td><td>25.0</td><td>43.9</td><td>51.0</td></tr><tr><td>2</td><td>39.9</td><td>24.1</td><td>44.0</td><td>51.4</td></tr><tr><td>4</td><td>39.8</td><td>24.3</td><td>44.0</td><td>50.9</td></tr></table>
+
+# 5 Discussion
+
+Qualitative analysis. We present a visualization of our learned instance-aware attention in Fig. 4. We find different heads attend to different components related to each instance, e.g., salient parts, boundaries. This might suggest that salient parts are important and knowledge for regression mostly lies around boundaries, instead of averaged on the foreground as assumed in former studies. The head (vi) and (vii) are smoother around key regions, which may relate to context. The head (iv) mainly attends on image corners, which might be a degenerated case or relate to some implicit descriptors.
+
+![](images/79a4e47f6f93555faf0423d87ee2ec1cf031a9a4f50e4f5deb905de4c0c3f216.jpg)  
+Figure 4: Visualization of our learned instance-aware attention over each head. Red denotes weak areas and pink denotes strong areas.
+
+Resource consumption. We benchmark the training speed for our distillation method. As shown in Fig. 5, training the decoder introduces negligible cost. Specifically, we benchmark on $1 \times$ scheduler on RetinaNet [30] with eight 2080ti, following the same configuration in Section 4.2. The major time consumption is spent on training the teacher $( 3 \times )$ , which takes about 33 hours. Training (forward and backward) the student takes about 8 hours, while training decoder and distillation only take 1.3 hours. Besides the training time, memory consumption of our method is also limited. One can update the decoder part and the student part in consecutive iterations, leaving only intermediate features for distillation in memory across iterations.
+
+![](images/a47542bc79e0df0de2c5ff11492738d63ba0a63cd78f33e9abc38697a02569c0.jpg)  
+Figure 5: Time consumption.
+
+Real-world impact. The proposed method provides a convenient approach to enhance a detector under a certain setting, resulting in that a small model can perform on par with a larger one. On the positive side, it allows users to replace a big model with a smaller one, which reduces energy consumption. On the potentially negative side, the teacher could be costly in training, also the student might inherit biases from the teacher, which is hard for tracing.
+
+# 6 Conclusion
+
+We introduce a novel framework for knowledge distillation. The proposed Instance-Conditional knowledge Distillation (ICD) method utilizes instance-feature cross attention to select and locate knowledge that correlates with human observed instances, which provides a new framework for KD. Our formulation encodes instance as query and teacher’s representation as key. To teach the decoder how to find knowledge, we design an auxiliary task that relies on knowledge for recognition and localization. The proposed method consistently improves various detectors, leading to impressive performance gain, some student networks even surpass their teachers. In addition to our design of the auxiliary task, we believe there are other alternations that can cover different situations or provide a theoretical formulation of knowledge, which will be a potential direction for further researches.
+
+# Acknowledgments and Disclosure of Funding
+
+This paper is supported by the National Key R&D Plan of the Ministry of Science and Technology (Project No. 2020AAA0104400) and Beijing Academy of Artificial Intelligence (BAAI).
+
+# References
+
+[1] Peter Anderson, Xiaodong He, Chris Buehler, Damien Teney, Mark Johnson, Stephen Gould, and Lei Zhang. Bottom-up and top-down attention for image captioning and visual question answering. In CVPR, 2018.   
+[2] Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence Zitnick, and Devi Parikh. VQA: visual question answering. In ICCV, 2015.   
+[3] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. ArXiv preprint, 2016.   
+[4] Zhaowei Cai and Nuno Vasconcelos. Cascade r-cnn: Delving into high quality object detection. In CVPR, 2018.   
+[5] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In ECCV, 2020.   
+[6] Guobin Chen, Wongun Choi, Xiang Yu, Tony X. Han, and Manmohan Chandraker. Learning efficient object detection models with knowledge distillation. In NeurIPS, 2017.   
+[7] Kai Chen, Jiaqi Wang, Jiangmiao Pang, Yuhang Cao, Yu Xiong, Xiaoxiao Li, Shuyang Sun, Wansen Feng, Ziwei Liu, Jiarui Xu, Zheng Zhang, Dazhi Cheng, Chenchen Zhu, Tianheng Cheng, Qijie Zhao, Buyu Li, Xin Lu, Rui Zhu, Yue Wu, Jifeng Dai, Jingdong Wang, Jianping Shi, Wanli Ouyang, Chen Change Loy, and Dahua Lin. MMDetection: Open mmlab detection toolbox and benchmark. arXiv preprint arXiv:1906.07155, 2019.   
+[8] Liangyu Chen, Tong Yang, Xiangyu Zhang, Wei Zhang, and Jian Sun. Points as queries: Weakly semi-supervised object detection by points. In CVPR, 2021.   
+[9] Xu Cheng, Zhefan Rao, Yilan Chen, and Quanshi Zhang. Explaining knowledge distillation by quantifying the knowledge. In CVPR, 2020.   
+[10] Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In CVPR, 2016.   
+[11] Xing Dai, Zeren Jiang, Zhao Wu, Yiping Bao, Zhicheng Wang, Si Liu, and Erjin Zhou. General instance distillation for object detection. In CVPR, 2021.   
+[12] M. Everingham, S. M. A. Eslami, L. Van Gool, C. K. I. Williams, J. Winn, and A. Zisserman. The pascal visual object classes challenge: A retrospective. IJCV, 2015.   
+[13] Jianping Gou, Baosheng Yu, Stephen J Maybank, and Dacheng Tao. Knowledge distillation: A survey. IJCV, 2021.   
+[14] Jianyuan Guo, Kai Han, Yunhe Wang, Han Wu, Xinghao Chen, Chunjing Xu, and Chang Xu. Distilling object detectors via decoupled features. In CVPR, 2021.   
+[15] Song Han, Jeff Pool, John Tran, and William J Dally. Learning both weights and connections for efficient neural networks. In NeurIPS, 2015.   
+[16] Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross B. Girshick. Mask R-CNN. In ICCV, 2017.   
+[17] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   
+[18] Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In ICCV, 2017.   
+[19] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. In NeurIPS, 2014.   
+[20] Han Hu, Jiayuan Gu, Zheng Zhang, Jifeng Dai, and Yichen Wei. Relation networks for object detection. In CVPR, 2018.   
+[21] Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In CVPR, 2017.   
+[22] Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. In NeurIPS, 2016.   
+[23] Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Quantized neural networks: Training neural networks with low precision weights and activations. JMLR, 2017.   
+[24] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, 2012.   
+[25] Hei Law and Jia Deng. Cornernet: Detecting objects as paired keypoints. In ECCV, 2018.   
+[26] Kuang-Huei Lee, Xi Chen, Gang Hua, Houdong Hu, and Xiaodong He. Stacked cross attention for image-text matching. In ECCV, 2018.   
+[27] Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017.   
+[28] Quanquan Li, Shengying Jin, and Junjie Yan. Mimicking very efficient network for object detection. In CVPR, 2017.   
+[29] Tsung-Yi Lin, Piotr Dollár, Ross B. Girshick, Kaiming He, Bharath Hariharan, and Serge J. Belongie. Feature pyramid networks for object detection. In CVPR, 2017.   
+[30] Tsung-Yi Lin, Priya Goyal, Ross B. Girshick, Kaiming He, and Piotr Dollár. Focal loss for dense object detection. In ICCV, 2017.   
+[31] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ECCV, 2014.   
+[32] Yufan Liu, Jiajiong Cao, Bing Li, Chunfeng Yuan, Weiming Hu, Yangxi Li, and Yunqiang Duan. Knowledge distillation via instance relationship graph. In CVPR, 2019.   
+[33] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In ICLR, 2019.   
+[34] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In NeurIPS, 2019.   
+[35] Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, 2016.   
+[36] Shaoqing Ren, Kaiming He, Ross B. Girshick, and Jian Sun. Faster R-CNN: towards real-time object detection with region proposal networks. In NeurIPS, 2015.   
+[37] Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. In ICLR, 2015.   
+[38] Mark Sandler, Andrew G. Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In CVPR, 2018.   
+[39] Mingxing Tan and Quoc V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In ICML, Proceedings of Machine Learning Research, 2019.   
+[40] Zhi Tian, Hao Chen, Xinlong Wang, Yuliang Liu, and Chunhua Shen. AdelaiDet: A toolbox for instance-level recognition tasks. https://git.io/adelaidet, 2019.   
+[41] Zhi Tian, Chunhua Shen, and Hao Chen. Conditional convolutions for instance segmentation. In Proc. Eur. Conf. Computer Vision (ECCV), 2020.   
+[42] Zhi Tian, Chunhua Shen, Hao Chen, and Tong He. FCOS: fully convolutional one-stage object detection. In ICCV, 2019.   
+[43] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.   
+[44] Jianfeng Wang, Lin Song, Zeming Li, Hongbin Sun, Jian Sun, and Nanning Zheng. End-to-end object detection with fully convolutional network. In CVPR, 2021.   
+[45] Tao Wang, Li Yuan, Xiaopeng Zhang, and Jiashi Feng. Distilling object detectors with finegrained feature imitation. In CVPR, 2019.   
+[46] Xinlong Wang, Rufeng Zhang, Tao Kong, Lei Li, and Chunhua Shen. SOLOv2: Dynamic and fast instance segmentation. In NeurIPS, 2020.   
+[47] Yuxin Wu, Alexander Kirillov, Francisco Massa, Wan-Yen Lo, and Ross Girshick. Detectron2. https://github.com/facebookresearch/detectron2, 2019.   
+[48] Jianwei Yang, Jiasen Lu, Dhruv Batra, and Devi Parikh. A faster pytorch implementation of faster r-cnn. https://github.com/jwyang/faster-rcnn.pytorch, 2017.   
+[49] Li Yuan, Francis E. H. Tay, Guilin Li, Tao Wang, and Jiashi Feng. Revisiting knowledge distillation via label smoothing regularization. In CVPR, 2020.   
+[50] Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. In ICLR, 2017.   
+[51] Linfeng Zhang and Kaisheng Ma. Improve object detection with feature-based knowledge distillation: Towards accurate and efficient detectors. In ICLR, 2021.

parse/train/k7aeAz4Vbb/k7aeAz4Vbb_content_list.json

@@ -0,0 +1,1295 @@
+[
+    {
+        "type": "text",
+        "text": "Instance-Conditional Knowledge Distillation for Object Detection ",
+        "text_level": 1,
+        "bbox": [
+            209,
+            122,
+            789,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zijian Kang∗ Xi’an Jiaotong University kzj123@stu.xjtu.edu.cn ",
+        "bbox": [
+            184,
+            226,
+            375,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Peizhen Zhang∗ MEGVII Technology zhangpeizhen@megvii.com ",
+        "bbox": [
+            395,
+            226,
+            593,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xiangyu Zhang MEGVII Technology zhangxiangyu@megvii.com ",
+        "bbox": [
+            612,
+            226,
+            812,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jian Sun MEGVII Technology sunjian@megvii.com ",
+        "bbox": [
+            267,
+            290,
+            423,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nanning Zheng Xi’an Jiaotong University nnzheng@mail.xjtu.edu.cn ",
+        "bbox": [
+            522,
+            289,
+            730,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Knowledge distillation has shown great success in classification, however, it is still challenging for detection. In a typical image for detection, representations from different locations may have different contributions to detection targets, making the distillation hard to balance. In this paper, we propose a conditional distillation framework to distill the desired knowledge, namely knowledge that is beneficial in terms of both classification and localization for every instance. The framework introduces a learnable conditional decoding module, which retrieves information given each target instance as query. Specifically, we encode the condition information as query and use the teacher’s representations as key. The attention between query and key is used to measure the contribution of different features, guided by a localization-recognition-sensitive auxiliary task. Extensive experiments demonstrate the efficacy of our method: we observe impressive improvements under various settings. Notably, we boost RetinaNet with ResNet-50 backbone from 37.4 to $4 0 . 7 \\mathrm { m A P }$ $\\left( + 3 . 3 \\right)$ under $1 \\times$ schedule, that even surpasses the teacher (40.4 mAP) with ResNet-101 backbone under $3 \\times$ schedule. Code has been released on https://github.com/megvii-research/ICD. ",
+        "bbox": [
+            233,
+            398,
+            766,
+            618
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            645,
+            310,
+            661
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning applications blossom in recent years with the breakthrough of Deep Neural Networks (DNNs) [17, 24, 21]. In pursuit of high performance, advanced DNNs usually stack tons of blocks with millions of parameters, which are computation and memory consuming. The heavy design hinders the deployment of many practical downstream applications like object detection in resource-limited devices. Plenty of techniques have been proposed to address this issue, like network pruning [15, 27, 18], quantization [22, 23, 35], mobile architecture design [38, 39] and knowledge distillation (KD) [19, 37, 43]. Among them, KD is one of the most popular choices, since it can boost a target network without introducing extra inference-time burden or modifications. ",
+        "bbox": [
+            174,
+            676,
+            825,
+            787
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "KD is popularized by Hinton et al. [19], where knowledge of a strong pretrained teacher network is transferred to a small target student network in the classification scenario. Many good works emerge following the classification track [50, 37, 32]. However, most methods for classification perform badly in the detection: only slight improvements are observed [28, 51]. This can be attributed to two reasons: (1) Other than category classification, another challenging goal to localize the object is seldomly considered. (2) Multiple target objects are presented in an image for detection, where objects can distribute in different locations. Due to these reasons, the knowledge becomes rather ambiguous and imbalance in detection: representations from different positions like foreground or background, borders or centers, could have different contributions, which makes distillation challenging. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/d42521b8ba9824717a7cf824913ac3671acb0f17bcca343180144f7444febb0a.jpg",
+        "image_caption": [
+            "Figure 1: Compare with different methods for knowledge distillation. (a) KD [19] for classification transfers logits. (b) Recent methods for detection KD distill intermediate features, different regionbased sampling methods are proposed. (c) Our method explicitly distill the desired knowledge. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            94,
+            808,
+            239
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            303,
+            821,
+            344
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To handle the above challenge, two strategies are usually adopted by previous methods in detection. First, the distillation is usually conducted among intermediate representations, which cover all necessary features for both classification and localization. Second, different feature selection methods are proposed to overcome the imbalance issue. Existent works could be divided into three types according to the feature selection paradigm: proposal-based, rule-based and attention-based. In proposal-based methods [28, 11, 6], proposal regions predicted by the RPN [36] or detector are sampled for distillation. In rule-based methods [14, 45], regions selected by predesigned rules like foreground or label-assigned regions are sampled. Despite their improvements, limitations still exist due to the hand-crafted designs, e.g., many methods neglect the informative context regions or involve meticulous decisions. Recently, Zhang et al. [51] propose to use attention [43], a type of intermediate activation of the network, to guide the distillation. Although attention provides inherent hints for discriminative areas, the relation between activation and knowledge for detection is still unclear. To further improve KD quality, we hope to provide an explicit solution to connect the desired knowledge with feature selection. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            544
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Towards this goal, we present Instance-Conditional knowledge Distillation (ICD), which introduces a new KD framework based-on conditional knowledge retrieval. In ICD, we propose to use a decoding network to find and distill knowledge associated with different instances, we deem such knowledge as instance-conditional knowledge. Fig. 1 shows the framework and compares it with former ones, ICD learns to find desired knowledge, which is much more flexible than previous methods, and is more consistent with detection targets. In detail, we design a conditional decoding module to locate knowledge, the correlation between knowledge and each instance is measured by the instance-aware attention via the transformer decoder [5, 43]. In which human observed instances are projected to query and the correlation is measured by scaled-product attention between query and teacher’s representations. Following this formulation, the distillation is conducted over features decomposed by the decoder and weighted by the instance-aware attention. Last but not least, to optimize the decoding module, we also introduce an auxiliary task, which teaches the decoder to find useful information for identification and localization. The task defines the goal for knowledge retrieval, it facilitates the decoder instead of the student. Overall, our contribution is summarized in three-fold: ",
+        "bbox": [
+            173,
+            550,
+            825,
+            744
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We introduce a novel framework to locate useful knowledge in detection KD, we formulate the knowledge retrieval explicitly by a decoding network and optimize it via an auxiliary task. • We adopt the conditional modeling paradigm to facilitate instance-wise knowledge transferring. We encode human observed instances as query and decompose teacher’s representations to key and value to locate fine-grained knowledge. To our knowledge, it is the first trial to explore instance-oriented knowledge for detection. • We perform comprehensive experiments on challenging benchmarks. Results demonstrate impressive improvements over various detectors with up to 4 AP gain in MS-COCO, including recent detectors for instance segmentation [41, 46, 16]. In some cases, students with $1 \\times$ schedule are even able to outperform their teachers with larger backbones trained $3 \\times$ longer. ",
+        "bbox": [
+            173,
+            757,
+            826,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            330,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Knowledge Distillation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            128,
+            370,
+            143
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Knowledge distillation aims to transfer knowledge from a strong teacher to a weaker student network to facilitate supervised learning. The teacher is usually a large pretrained network, who provides smoother supervision and more hints on visual concepts, that improves the training quality and convergence speed [49, 9]. KD for image classification has been studied for years, they are usually categorized into three types [13]: response-based [19], feature-based [37, 43] and relation-based [32]. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            229
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Among them, feature-based distillation over multi-scale features is adopted from most of detection KD works, to deal with knowledge among multiple instances in different regions. Most of these works can be formulated as region selection for distillation, where foreground-background unbalancing is considered as a key problem in some studies [45, 51, 14]. Under this paradigm, we divide them into three kinds: (1) proposal-based, (2) rule-based and (3) attention-based. ",
+        "bbox": [
+            174,
+            234,
+            825,
+            305
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(1) Proposal-based methods rely on the prediction of the RPN or detection network to find foreground regions, e.g., Chen et al. [6] and Li et al. [28] propose to distilling regions predicted by RPN [36], Dai et al. [11] proposes GI scores to locate controversial predictions for distillation. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            353
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(2) Rule-based methods rely on designed rules that can be inflexible and hyper-parameters inefficient, e.g., Wang et al. [45] distill assigned regions where anchor and ground-truth have a large IoU, Guo et al. [14] distill foreground and background regions separately with different factors. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            401
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(3) Attention-based methods rely on activations to locate discriminative areas, yet they do not direct to knowledge that the student needs. Only a recent work from Zhang et al. [51] considers attention, they build the spatial-channel-wise attention to weigh the distillation. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To overcome the above limitations, we explore the instance-conditional knowledge retrieval formulated by a decoder to explicitly search for useful knowledge. Like other methods, ICD does not have extra cost during inference or use extra data (besides existing labels and a pretrained teacher). ",
+        "bbox": [
+            174,
+            455,
+            825,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Conditional Computation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            529,
+            392,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Conditional computation is widely adopted to infer contents on a given condition. Our study mostly focuses on how to identify visual contents given an instance as a condition. This is usually formulated as query an instance on the image, e.g., visual question answer [1, 2] and image-text matching [26] queries information and regions specified by natural language. Besides query by language, other types of query are proposed in recent years. For example, DETR [5] queries on fixed proposal embeddings, Chen et al. [8] encodes points as queries to facilitate weakly-supervised learning. These works adopt transformer decoder to infer upon global receptive fields that cover all visual contents, yet they usually rely on cascaded decoders that are costly for training. From another perspective, CondInst [41] and SOLOv2 [46] generate queries based on network predictions and achieves great performance on instance segmentation. Different from them, this work adopts the query-based approach to retrieve knowledge and build query based on annotated instances. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 Object Detection ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            741,
+            330,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Object detection has been developed rapidly. Modern detectors are roughly divided into two-stage or one-stage detectors. Two-stage detectors usually adopt Region Proposal Network (RPN) to generate initial rough predictions and refine them with detection heads, the typical example is Faster R-CNN [36]. On the contrary, one-stage detectors directly predict on the feature map, which are usually faster, they include RetinaNet [30], FCOS [42]. Besides of this rough division, many extensions are introduced in recent years, e.g., extension to instance segmentation [41, 46, 16], anchor-free models [42, 25] and end-to-end detection [5, 44, 20]. Among these works, multi-scale features are usually adopted to enhance performance, e.g., FPN [29], which is considered as a typical case for our study. To generalize to various methods, the proposed method distills the intermediate features and does not rely on detector-specific designs. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Method ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            89,
+            271,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Overview ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            119,
+            279,
+            135
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As discussed in former studies [14, 51], useful knowledge for detection distributes unevenly in intermediate features. To facilitate KD, we propose to transfer instance-conditional knowledge between student and teacher network, termed $\\kappa _ { i } ^ { S }$ and $\\kappa _ { i } ^ { \\mathcal { T } }$ corresponding to the $i _ { \\mathrm { t h } }$ instance: ",
+        "bbox": [
+            174,
+            145,
+            825,
+            189
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e013119ab86b21e33d2a565254641b211d57d7eefca001f262c88363fa9362eb.jpg",
+        "text": "$$\n\\mathcal { L } _ { d i s t i l l } = \\sum _ { i = 1 } ^ { N } \\mathcal { L } _ { d } ( \\kappa _ { i } ^ { S } , \\kappa _ { i } ^ { T } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            195,
+            588,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The knowledge towards teacher’s representations $\\tau$ and condition $y _ { i }$ is formulated as $\\kappa _ { i } ^ { \\mathcal { T } } = \\mathcal { G } ( \\mathcal { T } , y _ { i } )$ ${ \\kappa } _ { i } ^ { S }$ similarly), where $\\mathcal { G }$ is the instance-conditional decoding module, optimized by an auxiliary loss illustrated in Sec. 3.3. The overall framework is shown in Fig. 2. ",
+        "bbox": [
+            173,
+            253,
+            826,
+            297
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the following sections, we will introduce the instance-conditional knowledge (Sec. 3.2), describe the auxiliary task design (Sec. 3.3), and discuss the knowledge transferring (Sec. 3.4). ",
+        "bbox": [
+            171,
+            303,
+            823,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Instance-conditional Knowledge ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            348,
+            436,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we elaborate the instanceconditional decoding module $\\mathcal { G }$ , which computes instance-conditional knowledge $\\kappa _ { i } ^ { \\mathcal { T } }$ from (1) unconditional knowledge given (2) instance conditions. ",
+        "bbox": [
+            173,
+            373,
+            485,
+            443
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(1) The unconditional knowledge $\\tau$ , symbolizes all available information from the teacher detector. Since modern detectors commonly involve a feature pyramid network (FPN) [29] to extract rich multi-scale representations, we present multi-scale representations as $\\mathcal T ~ = ~ \\bar  \\{ X _ { p } ~ \\in ~ $ $\\mathbb { R } ^ { D \\times H _ { p } \\times W _ { p } } \\} _ { p \\in \\mathcal { P } }$ , where $\\mathcal { P }$ signifies the spatial resolutions while $D$ is the channel dimension. By concatenating representations at different scales along the spatial dimension, we obtain $\\mathbf { A } ^ { \\mathcal { T } } \\in \\mathbb { R } ^ { L \\times \\mathbf { \\smile } }$ , where $\\begin{array} { r } { L = \\sum _ { p \\in \\mathcal { P } } H _ { p } W _ { p } } \\end{array}$ is the sum of total pixels number across scales. ",
+        "bbox": [
+            173,
+            449,
+            485,
+            618
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/25e2b995f25211ec29c9dcb5e6072f7c1761f226e166013e18fe0d98ea312278.jpg",
+        "image_caption": [
+            "Figure 2: We propose a decoding module to retrieve knowledge via query-based attention, where instance annotations are encoded as a query. An auxiliary task is proposed to optimize the decoding module and the feature-based distillation loss weighted by the attention is used to update student. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            501,
+            356,
+            823,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(2) The instance condition, originally describing a human-observed object, is denoted by ${ \\mathcal { V } } =$ ",
+        "bbox": [
+            173,
+            625,
+            483,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\{ \\mathfrak { y } _ { i } \\} _ { i = 1 } ^ { N }$ , where $N$ is the object number and $\\mathsf { y } _ { i } = \\left( c _ { i } , \\mathbf { b } _ { i } \\right)$ is the annotation for the $i$ -th instance, including category $c _ { i }$ and box location $\\mathbf { b } _ { i } = \\left( x _ { i } , y _ { i } , w _ { i } , h _ { i } \\right)$ which specifies the localization and size information. ",
+        "bbox": [
+            176,
+            654,
+            821,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To produce learnable embeddings for each instance, the annotation is mapped to a query feature vector $\\mathbf { q } _ { i }$ in the hidden space, which specifies a condition to collect desired knowledge: ",
+        "bbox": [
+            169,
+            700,
+            823,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c40dedb2df7d946a4b77f9cbd45eddc8f8cd4551e0e35190f0aa46660f3d884e.jpg",
+        "text": "$$\n\\mathbf { q } _ { i } = \\mathcal { F } _ { q } ( \\mathcal { E } ( \\mathbf { y } _ { i } ) ) , \\ \\mathbf { q } _ { i } \\in \\mathbb { R } ^ { D }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            736,
+            589,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { E } ( \\cdot )$ is a instance encoding function (detailed in in Sec. 3) and $\\mathcal { F } _ { q }$ is a Multi-Layer Perception network (MLP). ",
+        "bbox": [
+            174,
+            761,
+            825,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We retrieve knowledge from $\\tau$ given $\\mathbf { q } _ { i }$ by measuring responses of correlation. This is formulated by dot-product attention [43] with $M$ concurrent heads in a query-key attention manner. In which each head $j$ corresponds to three linear layers $( \\mathcal { F } _ { j } ^ { k } , \\mathcal { F } _ { j } ^ { q } , \\mathcal { F } _ { j } ^ { v } ) \\mathop { w . r . t . }$ . the key, query and value construction. ",
+        "bbox": [
+            173,
+            795,
+            825,
+            840
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The key feature $\\mathrm { K } _ { j } ^ { \\mathcal { T } }$ is computed by projecting teacher’s representations $\\mathrm { A } ^ { \\tau }$ with the positional embeddings [43, 5] $\\mathrm { P } \\in \\mathbb { R } ^ { L \\times d }$ as in Eq. 3, where $\\mathcal { F } _ { p e }$ denotes a linear projection over position embeddings. The value feature $\\mathrm { V } _ { j } ^ { \\mathcal { T } }$ and query ${ \\bf q } _ { i j }$ is projected by linear mappings to a sub-space with $d = D / M$ channels, $\\mathcal { F } _ { j } ^ { v }$ on $\\mathrm { A } ^ { \\tau }$ and $\\mathcal { F } _ { j } ^ { q }$ over $\\mathbf { q } _ { i }$ respectively, as shown in Eq. 4. At last, an instance-aware attention mask $\\mathbf { m } _ { i j }$ of the $i$ -th instance by the $j$ -th head is obtained by normalized dot-product between $\\mathrm { K } _ { j } ^ { \\mathcal { T } }$ and $\\mathbf { q } _ { i j }$ : ",
+        "bbox": [
+            174,
+            847,
+            825,
+            914
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/26f2f0d1133a571e224a34b9c1b4806a50feadae4f96310903a3434d50f769d5.jpg",
+        "image_caption": [
+            "Figure 3: The illustration of the auxiliary task. (a) The instance encoding function encodes a instance condition to a vector, it is then projected as query features. (b) The identification task learns to identify the existence the queried instance. (c) The localization task learns to predict the boundary given an uncertain position provided by the query. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            87,
+            808,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            314,
+            821,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c688ddfb981ed8dc0544368a7f436331606b3ec56010e4d9e634d553fdee1423.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { K } _ { j } ^ { \\mathcal { T } } = \\mathcal { F } _ { j } ^ { k } ( \\mathrm { A } ^ { \\mathcal { T } } + \\mathcal { F } _ { p e } ( \\mathrm { P } ) ) , \\mathrm { K } _ { j } ^ { \\mathcal { T } } \\in \\mathbb { R } ^ { L \\times d } } \\\\ & { \\mathrm { V } _ { j } ^ { \\mathcal { T } } = \\mathcal { F } _ { j } ^ { v } ( \\mathrm { A } ^ { \\mathcal { T } } ) , \\mathrm { V } _ { j } ^ { \\mathcal { T } } \\in \\mathbb { R } ^ { L \\times d } } \\\\ & { \\mathbf { q } _ { i j } = \\mathcal { F } _ { j } ^ { q } ( \\mathbf { q } _ { i } ) , \\mathbf { q } _ { i j } \\in \\mathbb { R } ^ { d } } \\\\ & { \\mathbf { m } _ { i j } = s o f t m a x ( \\frac { \\mathrm { K } _ { j } ^ { \\mathcal { T } } \\mathbf { q } _ { i j } } { \\sqrt { d } } ) , \\mathbf { m } _ { i j } \\in \\mathbb { R } ^ { L } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            352,
+            637,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the querying along the key features and value features describes the correlation between representations and instances. We collect $\\kappa _ { i } ^ { \\mathcal { T } } = \\{ ( \\mathbf { m } _ { i j } , \\mathrm { V } _ { j } ^ { \\mathcal { T } } ) \\} _ { j = 1 } ^ { M }$ as the instance-conditional knowledge from $\\tau$ , which encodes knowledge corresponds to the ith instance. ",
+        "bbox": [
+            174,
+            465,
+            826,
+            508
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Auxiliary Task ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            523,
+            315,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the auxiliary task to optimize the decoding module $\\mathcal { G }$ . First, we aggregate instance-level information to identify and localize objects. This could be obtained by aggregating the instance-conditional knowledge by the function $\\mathcal { F } _ { a g g }$ , which includes sum-product aggregation over attention $\\mathbf { m } _ { i j }$ and $\\mathrm { V } _ { j } ^ { \\mathcal { T } }$ , concatenate features from each head, add residuals and project with a feed-forward network as proposed in [43, 5]: ",
+        "bbox": [
+            173,
+            547,
+            825,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/335388df20d486987a5e9258482b0ffa53ddc06681685467d1f09359cf684128.jpg",
+        "text": "$$\n\\mathbf { g } _ { i } ^ { T } = \\mathcal { F } _ { a g g } ( \\kappa _ { i } ^ { T } , \\mathbf { q } _ { i } ) , \\ \\mathbf { g } _ { i } ^ { T } \\in \\mathbb { R } ^ { D }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            626,
+            606,
+            646
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To let the instance-level aggregated information $\\mathbf { g } _ { i } ^ { \\mathcal { T } }$ retain sufficient instance cues, one could design an instance-sensitive task to optimize it as below: ",
+        "bbox": [
+            173,
+            659,
+            823,
+            688
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5613b431532b5cffb452d4c282236811b525f6f89e613840b04655d54114cb47.jpg",
+        "text": "$$\n\\mathcal { L } _ { a u x } = \\mathcal { L } _ { i n s } ( \\mathbf { g } _ { i } ^ { T } , \\mathcal { H } ( \\mathbf { y } _ { i } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            693,
+            584,
+            713
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { H }$ encodes the instance information as targets. However, directly adopt Eq. 8 might lead to trivial solution, since ${ \\tt y } _ { i }$ is accessible from both $\\mathbf { g } _ { i } ^ { \\top }$ (through $\\mathbf { q } _ { i }$ , see Eq. 2) and $\\mathcal { H } ( \\mathtt { y } _ { i } )$ . It is possible that parameters will learn a shortcut, that ignore the teacher representations $\\tau$ . To resolve this issue, we propose to drop information on encoding function $\\mathcal { E } ( \\cdot )$ , to force the aggregation function $\\mathcal { F } _ { a g g }$ to excavate hints from $\\tau$ . ",
+        "bbox": [
+            173,
+            718,
+            825,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The information dropping is adopted by replacing the accurate annotation for instance conditions to uncertain ones. For bounding box annotations, we relieve them to rough box centers with rough scales indicators. The rough box center $( x _ { i } ^ { \\prime } , y _ { i } ^ { \\prime } )$ is obtained by random jittering as shown below: ",
+        "bbox": [
+            173,
+            794,
+            825,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c3cfb8c9517b4dbe16cda6c2672bf94f2c864102100877e82ffb70dd7fabb35b.jpg",
+        "text": "$$\n\\left\\{ \\begin{array} { l l } { x _ { i } ^ { \\prime } = x _ { i } + \\phi _ { x } w _ { i } , } \\\\ { y _ { i } ^ { \\prime } = y _ { i } + \\phi _ { y } h _ { i } , } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            843,
+            552,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $( w _ { i } , h _ { i } )$ is the width and height of the bounding box and $\\phi _ { x } , \\phi _ { y }$ are sampled from a uniform distribution $\\begin{array} { r } { \\dot { \\Phi } \\sim U [ - a , a ] } \\end{array}$ , where we set $\\mathrm { a } { = } 0 . 3$ empirically. The scales indicators are obtained by rounding the box sizes in the logarithmic space, i.e., $\\textcircled { l o g _ { 2 } ( w _ { i } ) } $ , $\\lfloor l o g _ { 2 } ( h _ { i } ) \\rfloor$ . In addition, to let the decoder learn to identify instances and be aware of the uncertainty, we generate fake instances for the identification task according to dataset distributions, this is detailed in Appendix A. As a result, it collect coarse information and obtain instance encoding through $\\mathcal { E } ( \\cdot )$ as depicted in Fig. 3a. where $c _ { i }$ is the category, $\\mathcal { F } _ { o h }$ is the one hot vectorization, concat is the concatenation operator and $\\mathcal { F } _ { p e }$ is the position embedding function. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            175
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, the aggregated representation $\\mathbf { g } _ { i } ^ { T }$ are optimized by the auxiliary task. We introduces two predictors denoted by $\\mathcal { F } _ { o b j }$ and $\\mathcal { F } _ { r e g }$ respectively to predict identification and localization results. We adopt binary cross entropy loss (BCE) to optimize the real-fake identification and $L 1$ loss to optimize the regression. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            237
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af7bb8afe0a58cd75764a645ba03e94b48dc610de26922d5f3d1ffb40796af89.jpg",
+        "text": "$$\n\\mathcal { L } _ { a u x } = \\mathcal { L } _ { B C E } ( \\mathcal { F } _ { o b j } ( \\mathbf { g } _ { i } ^ { T } ) , \\delta _ { o b j } ( \\mathbf { y } _ { i } ) ) + \\mathcal { L } _ { 1 } ( \\mathcal { F } _ { r e g } ( \\mathbf { g } _ { i } ^ { T } ) , \\delta _ { r e g } ( \\mathbf { y } _ { i } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            253,
+            707,
+            275
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta _ { o b j } ( \\cdot )$ is an indicator, it yields 1 if $\\mathtt { y } _ { i }$ is real and 0 otherwise. Following common practice, the localization loss for fake examples is ignored. $\\delta _ { r e g }$ is the preparing function for regression targets, following [42]. Appendix A provides more implementation details. ",
+        "bbox": [
+            174,
+            284,
+            826,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Instance-Conditional Distillation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            343,
+            441,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we present the formulation for conditional knowledge distillation. We obtain the projected value features $\\mathrm { V } _ { j } ^ { S } \\in \\mathbb { R } ^ { L \\times d }$ of the student representations analogous to Eq. 4 in Sec. 3.2. By adopting the instance-aware attention mask as a measurement of correlations between feature and each instance, we formulate the distillation loss as value features mimicking guided by the attention: ",
+        "bbox": [
+            173,
+            368,
+            826,
+            425
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6f7bad57fe54e67c244dfc48335122d2e93a1afcb349baf96fb24135fe4a7b95.jpg",
+        "text": "$$\n\\mathcal { L } _ { d i s t i l l } = \\frac { 1 } { M N _ { r } } \\sum _ { j = 1 } ^ { M } \\sum _ { i = 1 } ^ { N } \\delta _ { o b j } ( \\mathrm { y } _ { i } ) \\cdot < \\mathbf { m } _ { i j } , \\mathcal { L } _ { M S E } ( \\mathrm { V } _ { j } ^ { S } , \\mathrm { V } _ { j } ^ { \\mathcal { T } } ) >\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            431,
+            704,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { N _ { r } = \\sum _ { i = 1 } ^ { N } \\delta _ { o b j } ( \\mathbf { y } _ { i } ) } \\end{array}$ , $( N _ { r } \\leq N )$ is the real instances number, $\\mathcal { L } _ { M S E } ( \\mathrm { V } _ { j } ^ { S } , \\mathrm { V } _ { j } ^ { T } ) \\in \\mathbb { R } ^ { L }$ is the pixel-wise mean-square error along the hidden dimension2 and $< \\cdot , \\cdot >$ is the Dirac notation for inner product. For stability, the learnable variable $\\mathbf { m } _ { i j }$ and $\\mathrm { V } _ { j } ^ { \\mathcal { T } } .$ are detached during distillation. Combine with the supervised learning loss $\\mathcal { L } _ { d e t }$ , the overall loss with a coefficient $\\lambda$ is summarized below: ",
+        "bbox": [
+            173,
+            484,
+            825,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/766645ca6dd38a224b6b0ab543eda7bfcc9f1bea20b912e061f6f3ffac7de111.jpg",
+        "text": "$$\n\\mathcal { L } _ { t o t a l } = \\mathcal { L } _ { d e t } + \\mathcal { L } _ { a u x } + \\lambda \\mathcal { L } _ { d i s t i l l }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            566,
+            612,
+            583
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is worth noticing, only the gradients w.r.t. $\\mathcal { L } _ { d i s t i l l }$ and $\\mathcal { L } _ { d e t }$ back-propagate to the student network (from representations $s$ ). The gradients of $\\mathcal { L } _ { a u x }$ only update the instance-conditional decoding function $\\mathcal { G }$ and auxiliary task related modules. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            636
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            313,
+            672
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experiment Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            688,
+            354,
+            703
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on Pytorch [34] with the widely used Detectron2 library [47] and AdelaiDet library 3 [40]. All experiments are running on eight 2080ti GPUs with 2 images in each. We adopt the $1 \\times$ scheduler, which denotes 9k iterations of training, following the standard protocols in Detectron2 unless otherwise specified. Scale jittering with random flip is adopted as data augmentation. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            768
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For distillation, the hyper-parameter $\\lambda$ is set to 8 for one-stage detectors and 3 for two-stage detectors respectively. To optimize the transformer decoder, we adopt AdamW optimizer [33] for the decoder and MLPs following common settings for transformer [43, 5]. Corresponding hyper-parameters follows [5], where the initial learning rate and weight decay are set to 1e-4. We adopt the 256 hidden dimension for our decoder and all MLPs, the decoder has 8 heads in parallel. The projection layer $\\mathcal { F } _ { q }$ is a 3 layer MLP, $F _ { r e g }$ and $F _ { o b j }$ share another 3 layer MLP. In addition, we notice some newly initialized modules of the student share the same size of the teacher, e.g., the detection head, FPN. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/3bf912a07975adcbbbb3c3e894dee5b7538df695449effc856ecbd6e1d8a86a1.jpg",
+        "table_caption": [
+            "Table 1: Comparison with previous methods on challenging benchmark MS-COCO. The method proposed by Li et al. [28] does not apply to RetinaNet. $\\dagger$ denotes the inheriting strategy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"3\">Faster R-CNN [36] APs</td><td colspan=\"4\">RetinaNet [30]</td></tr><tr><td>AP</td><td>APM</td><td>APL</td><td>AP</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>Teacher w. ResNet-101 (3×)</td><td>42.0</td><td>25.2 45.6</td><td>54.6</td><td>40.4</td><td>24.0</td><td>44.3</td><td>52.2</td></tr><tr><td>Student w. ResNet-50 (1×)</td><td>37.9</td><td>22.4 41.1</td><td>49.1</td><td>37.4</td><td>23.1</td><td>41.6</td><td>48.3</td></tr><tr><td>+ FitNet [37]</td><td>39.3 (+1.4)</td><td>22.7 42.3</td><td>51.7</td><td>38.2(+0.8)</td><td>21.8</td><td>42.6</td><td>48.8</td></tr><tr><td>+ Li et al. [28]</td><td>39.5 (+1.5)</td><td>23.3 43.0</td><td>51.4</td><td></td><td>1</td><td>-</td><td>-</td></tr><tr><td>+ Wang et al. [45]</td><td>39.2 (+1.3)</td><td>23.2 42.8</td><td>50.4</td><td>38.4 (+1.0)</td><td>23.3</td><td>42.6</td><td>49.1</td></tr><tr><td>+ Zhang et al. [51]</td><td>40.0 (+2.1)</td><td>23.2 43.3</td><td>52.5</td><td>39.3 (+1.9)</td><td>23.4</td><td>43.6</td><td>50.6</td></tr><tr><td>+ Ours</td><td>40.4 (+2.5)</td><td>23.4 44.0</td><td>52.0</td><td>39.9 (+2.5)</td><td>25.0</td><td>43.9</td><td>51.0</td></tr><tr><td>+Ours+</td><td>40.9 (+3.0)</td><td>24.5</td><td>44.2 53.5</td><td>40.7 (+3.3)</td><td>24.2</td><td>45.0</td><td>52.7</td></tr></table>",
+        "bbox": [
+            174,
+            131,
+            825,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/fb06ca2109088fc5e667745685db7a75060d162dba0e5695edc3df18782e6b02.jpg",
+        "table_caption": [
+            "Table 2: Experiments on more detectors with ICD. Type denotes the AP score is evaluated on bounding box (BBox) or instance mask $( \\tt M a s k )$ . $\\dagger$ denotes using the inheriting strategy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Detector</td><td>Setting</td><td>Type</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>FCOS [42]</td><td>Teacher (3×) Student (1×)</td><td rowspan=\"4\">BBox</td><td>42.6</td><td>61.6</td><td>45.8</td><td>26.2</td><td>46.3</td><td>53.8</td></tr><tr><td></td><td></td><td>39.4</td><td>58.2</td><td>42.4</td><td>24.2</td><td>43.4</td><td>49.4</td></tr><tr><td>Teacher: 18.8 FPS /51.2M</td><td>+ Ours + Ours †</td><td>41.7(+2.3)</td><td>60.3</td><td>45.4</td><td>26.9</td><td>45.9</td><td>52.6</td></tr><tr><td>Student: 25.0 FPS /32.2M</td><td></td><td>42.9(+3.5)</td><td>61.6</td><td>46.6</td><td>27.8 46.8</td><td></td><td>54.6</td></tr><tr><td rowspan=\"6\">Mask R-CNN [16] Teacher: 17.5 FPS /63.3M Student: 22.9 FPS /44.3M</td><td>Teacher(3×) Student (1×)</td><td rowspan=\"4\">BBox</td><td>42.9</td><td>63.3</td><td>46.8</td><td>26.4</td><td>46.6</td><td>56.1</td></tr><tr><td></td><td>38.6</td><td>59.5</td><td>42.1</td><td>22.5</td><td>42.0</td><td>49.9</td></tr><tr><td>+ Ours</td><td>40.4 (+1.8)</td><td>60.9</td><td>44.2</td><td>24.4</td><td>43.7</td><td>52.0</td></tr><tr><td>+ Ours †</td><td>41.2 (+2.6)</td><td>62.0</td><td>45.0</td><td>25.1</td><td>44.5</td><td>53.6</td></tr><tr><td>Teacher(3×) Student (1×)</td><td>38.6 35.2</td><td>60.4 56.3</td><td>41.3</td><td>19.5</td><td>41.3</td><td>55.3</td></tr><tr><td rowspan=\"4\">SOLOv2 [46]</td><td>+ Ours</td><td>Mask</td><td>36.7 (+1.5)</td><td></td><td>37.5</td><td>17.2</td><td>37.7</td><td>50.3</td></tr><tr><td></td><td>37.4 (+2.2)</td><td>58.0 58.7</td><td>39.2</td><td>18.4</td><td>38.9</td><td></td><td>52.5</td></tr><tr><td>+ Ours † Teacher (3×)</td><td>39.0</td><td></td><td></td><td>40.1</td><td>19.1</td><td>39.8</td><td>53.7</td></tr><tr><td>Student</td><td>34.6</td><td>59.4 54.7</td><td>41.9 36.9</td><td>16.2 13.2</td><td></td><td>43.1</td><td>58.2 53.3</td></tr><tr><td>Teacher: 16.6 FPS/65.5M Student: 21.4 FPS /46.5M</td><td>+ Ours + Ours †</td><td>Mask</td><td>37.2 (+2.6)</td><td>57.6</td><td>39.8</td><td>14.8</td><td>37.9 40.7</td><td>57.0</td></tr><tr><td rowspan=\"6\">CondInst [41]</td><td>Teacher(3×)</td><td rowspan=\"3\">BBox</td><td>38.5 (+3.9)</td><td>59.0</td><td>41.2</td><td>15.9</td><td>42.3</td><td>58.9</td></tr><tr><td></td><td>44.6</td><td>63.7</td><td></td><td></td><td></td><td></td></tr><tr><td>Student (1×)</td><td>39.7</td><td></td><td>48.4</td><td>27.5</td><td>47.8</td><td>58.4</td></tr><tr><td>+ Ours</td><td rowspan=\"3\"></td><td></td><td>58.8</td><td>43.1</td><td>23.9</td><td>43.3</td><td>50.1</td></tr><tr><td>+ Ours †</td><td>42.4 (+2.7) 43.7 (+4.0)</td><td>61.5 62.9</td><td>46.1 47.2</td><td>25.3 27.1</td><td>46.0</td><td>54.3</td></tr><tr><td>Teacher(3×)</td><td>39.8</td><td></td><td></td><td></td><td>47.3</td><td>56.6</td></tr><tr><td rowspan=\"4\">Teacher: 16.8FPS/53.5M Student: 21.3 FPS /34.1M</td><td></td><td rowspan=\"4\">Mask</td><td></td><td>61.4</td><td>42.6</td><td>19.4</td><td>43.5</td><td>58.3</td></tr><tr><td>Student (1×)</td><td>35.7</td><td>56.7</td><td>37.7</td><td>16.8</td><td>39.1</td><td>50.3</td></tr><tr><td>+ Ours</td><td>37.8 (+2.1)</td><td>59.1</td><td>40.4</td><td>17.5</td><td>41.4</td><td>54.7</td></tr><tr><td>+ Ours †</td><td>39.1 (+3.4)</td><td>60.5</td><td>42.0</td><td>19.1</td><td>42.6</td><td>57.0</td></tr></table>",
+        "bbox": [
+            187,
+            320,
+            812,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We find initialize these modules with teacher’s parameters will lead to faster convergence, we call it the inheriting strategy in experiments. ",
+        "bbox": [
+            178,
+            660,
+            821,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Most experiments are conducted on a large scale object detection benchmark MS-COCO 4[31] with 80 classes. We train models on MS-COCO 2017 trainval115k subset and validate on minival subset. Following common protocols, we report mean Average Precision (AP) as an evaluation metric, together with AP under different thresholds and scales, i.e., $\\mathrm { { A P } _ { 5 0 } }$ , $\\mathsf { A P } _ { 7 5 }$ , $\\mathsf { A P } _ { \\mathrm { S } }$ , $\\mathsf { A P _ { M } }$ , $\\mathsf { A P } _ { \\mathrm { L } }$ . Other experiments are listed in Appendix B, e.g., on VOC [12] and Cityscapes [10], more ablations. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            765
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Main Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            785,
+            305,
+            799
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Compare with state-of-the-art methods. We compare our method (ICD) with previous stateof-the-arts (SOTAs), including a classic distillation method FitNet [37], two typical detection KD methods [28, 45], and a very recent work with strong performance from Zhang et al. [51]. The comparison is conducted on two classic detectors: Faster R-CNN [36] and RetinaNet [30]. We adopt detectron2 official released models with ResNet-101 backbone trained on $3 \\times$ scheduler as teacher networks, the student is trained on $1 \\times$ with ResNet-50 backbone following the above settings. ",
+        "bbox": [
+            174,
+            813,
+            825,
+            867
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b3f861f14bad7a14306b2f7365137293ea6ef759ac0cb2f8f2b061f6345e5c5.jpg",
+        "table_caption": [
+            "Table 3: Experiments on mobile backbones. $\\dagger$ denotes using the inheriting strategy. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Detector</td><td>Setting</td><td>Backbone</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td rowspan=\"4\">RetinaNet [30]</td><td>Teacher (3×)</td><td>ResNet-101[17]</td><td>40.4</td><td>60.3</td><td>43.2</td><td>24.0</td><td>44.3</td><td>52.2</td></tr><tr><td>Student (1×)</td><td></td><td>26.4</td><td>42.0</td><td>27.8</td><td>13.8</td><td>28.8</td><td>34.1</td></tr><tr><td>+ Ours</td><td>MBV2 [38]</td><td>29.5 (+3.1)</td><td>45.5</td><td>31.2</td><td>16.2</td><td>32.2</td><td>38.3</td></tr><tr><td>+ Ours †</td><td></td><td>31.6(+5.2)</td><td>48.5</td><td>33.4</td><td>17.6</td><td>34.7</td><td>41.3</td></tr><tr><td rowspan=\"4\">RetinaNet [30]</td><td>Teacher (3×)</td><td>ResNet-101[17]</td><td>40.4</td><td>60.3</td><td>43.2</td><td>24.0</td><td>44.3</td><td>52.2</td></tr><tr><td>Student (1×)</td><td></td><td>34.9</td><td>54.8</td><td>37.0</td><td>20.9</td><td>38.9</td><td>44.8</td></tr><tr><td>+ Ours</td><td>Eff-B0 [39]</td><td>36.7 (+1.8)</td><td>56.0</td><td>38.7</td><td>21.1</td><td>40.6</td><td>48.1</td></tr><tr><td>+ Ours †</td><td></td><td>38.0 (+3.1)</td><td>57.5</td><td>40.2</td><td>22.4</td><td>41.6</td><td>50.3</td></tr><tr><td rowspan=\"4\">FRCNN [36]</td><td>Teacher(3×)</td><td>ResNet-101[17]</td><td>42.0</td><td>62.5</td><td>45.9</td><td>25.2</td><td>45.6</td><td>54.6</td></tr><tr><td>Student (1×)</td><td></td><td>27.2</td><td>44.7</td><td>28.8</td><td>14.6</td><td>29.6</td><td>35.6</td></tr><tr><td>+ Ours</td><td>MBV2 [38]</td><td>30.2 (+3.0)</td><td>48.0</td><td>32.5</td><td>17.0</td><td>32.2</td><td>39.1</td></tr><tr><td>+ Ours †</td><td></td><td>31.4 (+4.2)</td><td>49.4</td><td>33.6</td><td>17.6</td><td>33.5</td><td>41.3</td></tr><tr><td rowspan=\"4\">FRCNN [36]</td><td>Teacher (3×)</td><td>ResNet-101[17]</td><td>42.0</td><td>62.5</td><td>45.9</td><td>25.2</td><td>45.6</td><td>54.6</td></tr><tr><td>Student (1×)</td><td></td><td>35.3</td><td>56.8</td><td>37.8</td><td>20.8</td><td>38.2</td><td>45.1</td></tr><tr><td>+ Ours</td><td>Eff-B0 [39]</td><td>37.0 (+1.7)</td><td>58.0</td><td>39.6</td><td>21.1</td><td>40.0</td><td>48.3</td></tr><tr><td>+ Ours †</td><td></td><td>37.9 (+2.6)</td><td>58.7</td><td>40.8</td><td>21.4</td><td>40.9</td><td>49.5</td></tr></table>",
+        "bbox": [
+            173,
+            117,
+            830,
+            339
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            353,
+            823,
+            382
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As shown in Table 1, ICD brings about $2 . 5 \\mathrm { A P }$ and 3.0 AP improvement for plain training and training with the inheriting strategy respectively. Especially for RetinaNet, the student with distillation even outperforms a strong teacher trained on $3 \\times$ scheduler. Compare with previous SOTAs, the proposed method leads to a considerable margin for about 0.5 AP without the inheriting strategy. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            444
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results on other settings. We further evaluate ICD under various detectors, e.g., a commonly used anchor-free detector FCOS [42], and three detectors that have been extended to instance segmentation: Mask R-CNN [16], SOLOv2 [46] and CondInst [41]. We adopt networks with ResNet-101 on $3 \\times$ scheduler as teachers and networks with ResNet-50 on $1 \\times$ scheduler as students following the above settings. As shown in Table 2, we observe consistent improvements for both detection and instance segmentation. There are at most around 4 AP improvement on CondInst [41] on object detection and SOLOv2 [46] on instance segmentation. Moreover, students with weaker backbone (ResNet-50 v.s. ResNet-101) and less training images $( 1 / 3 )$ even outperform (FCOS) or perform on par (SOLOv2, CondInst) with teachers. Note that ICD does not introduce extra burden during inference, our method improves about $2 5 \\%$ of $\\mathrm { F P S ^ { 5 } }$ and reduces $40 \\%$ of parameters compared with teachers. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Mobile backbones. Aside from main experiments on commonly used ResNet [17], we also conduct experiments on mobile backbones, which are frequently used in low-power devices. We evaluate our method on two prevalent architectures: MobileNet V2 (MBV2) [38] and EfficientNet-B0 (Eff-B0) [39]. The latter one adopts the MobileNet V2 as basis, and further extends it with advanced designs like stronger data augmentation and better activations. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experiments are conducted on Faster R-CNN (abbr., FRCNN) [36] and RetinaNet [30] following the above settings. As shown in Table 3, our method also significantly improves the performance on smaller backbones. For instance, we improve the RetinaNet with MobileNet V2 backbone with 5.2 AP gain and 3.1 AP gain with and without inheriting strategy respectively, and up to 3.1 AP gain for EfficientNet-B0. We also observe consistent improvements over Faster R-CNN, with up to 4.2 AP gain for MobileNet-V2 and 2.6 AP gain for EfficientNet-B0. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            772
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            328,
+            804
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To verify the design options and the effectiveness of each component, we conduct ablation studies with the classic RetinaNet detector on MS-COCO following the above settings. ",
+        "bbox": [
+            173,
+            814,
+            821,
+            843
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Design of the auxiliary task. To better understand the role of our auxiliary task, we conduct experiments to evaluate the contribution of each sub-task. Specifically, our auxiliary task is composed of an identification task with binary cross-entropy loss and a localization task with regression loss, the localization task is further augmented with a hint on bounding box scales. As shown in Table 4, the identification task itself leads to $2 . 2 \\ : \\mathrm { A P }$ gain compare with the baseline, this high-light the importance of knowledge on object perception. The regression task itself leads to $1 . 8 \\mathrm { A P }$ gain, and the scale information boosts it for extra 0.2 AP gain. Combine two of them, we achieve $2 . 5 \\mathrm { \\ A P }$ overall improvement, which indicates the fusion of two knowledge brings extra benefits. Note the auxiliary task only update the decoder and does not introduce extra data, which is very different from multitask learning, e.g., Mask R-CNN[16]. ",
+        "bbox": [
+            174,
+            858,
+            821,
+            886
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            203
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/81966c3720a2a79edec3a4a7cc46ee443928549cc0034f310e601c0a9022f06d.jpg",
+        "table_caption": [
+            "Table 4: Comparison with different auxiliary task designs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Identification</td><td>Localization</td><td>+ Scale</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td rowspan=\"4\">√</td><td></td><td></td><td>37.4</td><td>56.7</td><td>40.3</td><td>23.1</td><td>41.6</td><td>48.3</td></tr><tr><td></td><td></td><td>39.6</td><td>59.2</td><td>42.8</td><td>23.4</td><td>44.0</td><td>50.4</td></tr><tr><td>√</td><td></td><td>39.2</td><td>58.6</td><td>42.4</td><td>23.1</td><td>43.5</td><td>50.3</td></tr><tr><td>√</td><td>√</td><td>39.4</td><td>58.8</td><td>42.4</td><td>23.2</td><td>43.8</td><td>50.5</td></tr><tr><td>√</td><td>√</td><td>√</td><td>39.9</td><td>59.4</td><td>43.1</td><td>25.0</td><td>43.9</td><td>51.0</td></tr></table>",
+        "bbox": [
+            205,
+            239,
+            794,
+            328
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Impact of the instance-aware attention. To verify the effectiveness of instance-aware attention learned by conditional computation, we directly replace it with different variations: the fine-grained mask in [45], pixel-wise attention activation [51, 43], foreground mask analog to [14] and no attention mask. The result in Fig. 5 shows our instance-aware mask leads to about 0.9 AP gain over the baseline and $0 . 4 \\ : \\mathrm { A P }$ gain compare with the best replacement. ",
+        "bbox": [
+            173,
+            338,
+            825,
+            409
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ab0fa2b066378a37d2bc46132df1422e259d8a688766ddb42de589811ac1025e.jpg",
+        "table_caption": [
+            "Table 5: Comparison with different types of attention. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attention Type</td><td>AP</td><td>AP50</td><td>AP75</td><td>APs</td><td>APm</td><td>APL</td></tr><tr><td>No Attention</td><td>39.0</td><td>58.4</td><td>42.1</td><td>23.5</td><td>43.2</td><td>49.9</td></tr><tr><td>Foreground Mask</td><td>39.4</td><td>58.9</td><td>42.4</td><td>23.5</td><td>43.6</td><td>50.0</td></tr><tr><td>Fine-grained Mask [45]</td><td>39.5</td><td>59.0</td><td>42.4</td><td>23.4</td><td>43.8</td><td>50.2</td></tr><tr><td>Attention Activation [43]</td><td>39.3</td><td>58.6</td><td>42.3</td><td>22.6</td><td>43.6</td><td>50.1</td></tr><tr><td>Instance-conditional Attention</td><td>39.9</td><td>59.4</td><td>43.1</td><td>25.0</td><td>43.9</td><td>51.0</td></tr></table>",
+        "bbox": [
+            233,
+            445,
+            764,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Design of the decoder. We mainly verify two properties of the decoder design, as shown in Table 6. First, we find a proper number of heads is important for the best performance. The head number balances the dimension for each sub-space and the number of spaces. The best number lies around 8, which is consistent with former studies [5]. Second, we evaluate the effectiveness of cascaded decoders, as it is widely adopted in former studies [43, 5, 8]. However, we do not find significant differences between different cascade levels, it might because we use a fixed teacher to provide knowledge, that limited the learning ability. ",
+        "bbox": [
+            173,
+            544,
+            825,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/8feb400515edcbaaee94c8f52f59fe111aeeaaf69f6cf3d4c6a738d2de639d84.jpg",
+        "table_caption": [
+            "(a) Number of heads. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Heads</td><td>AP</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>1</td><td>39.4</td><td>23.7</td><td>43.8</td><td>50.5</td></tr><tr><td>4</td><td>39.7</td><td>24.0</td><td>43.9</td><td>51.2</td></tr><tr><td>8</td><td>39.9</td><td>25.0</td><td>43.9</td><td>51.0</td></tr><tr><td>16</td><td>39.7</td><td>23.6</td><td>44.2</td><td>50.5</td></tr></table>",
+        "bbox": [
+            187,
+            696,
+            449,
+            771
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ae7499a9a1da8cba22a496ebb3cfd8da975caa167214f496ce486abd04e1de77.jpg",
+        "table_caption": [
+            "Table 6: Ablation on the number of heads and cascade levels. ",
+            "(b) Number of cascade levels. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Levels</td><td>AP</td><td>APs</td><td>APM</td><td>APL</td></tr><tr><td>1</td><td>39.9</td><td>25.0</td><td>43.9</td><td>51.0</td></tr><tr><td>2</td><td>39.9</td><td>24.1</td><td>44.0</td><td>51.4</td></tr><tr><td>4</td><td>39.8</td><td>24.3</td><td>44.0</td><td>50.9</td></tr></table>",
+        "bbox": [
+            537,
+            704,
+            803,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            786,
+            294,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Qualitative analysis. We present a visualization of our learned instance-aware attention in Fig. 4. We find different heads attend to different components related to each instance, e.g., salient parts, boundaries. This might suggest that salient parts are important and knowledge for regression mostly lies around boundaries, instead of averaged on the foreground as assumed in former studies. The head (vi) and (vii) are smoother around key regions, which may relate to context. The head (iv) mainly attends on image corners, which might be a degenerated case or relate to some implicit descriptors. ",
+        "bbox": [
+            173,
+            816,
+            826,
+            901
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/79a4e47f6f93555faf0423d87ee2ec1cf031a9a4f50e4f5deb905de4c0c3f216.jpg",
+        "image_caption": [
+            "Figure 4: Visualization of our learned instance-aware attention over each head. Red denotes weak areas and pink denotes strong areas. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            85,
+            805,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Resource consumption. We benchmark the training speed for our distillation method. As shown in Fig. 5, training the decoder introduces negligible cost. Specifically, we benchmark on $1 \\times$ scheduler on RetinaNet [30] with eight 2080ti, following the same configuration in Section 4.2. The major time consumption is spent on training the teacher $( 3 \\times )$ , which takes about 33 hours. Training (forward and backward) the student takes about 8 hours, while training decoder and distillation only take 1.3 hours. Besides the training time, memory consumption of our method is also limited. One can update the decoder part and the student part in consecutive iterations, leaving only intermediate features for distillation in memory across iterations. ",
+        "bbox": [
+            174,
+            435,
+            517,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/a47542bc79e0df0de2c5ff11492738d63ba0a63cd78f33e9abc38697a02569c0.jpg",
+        "image_caption": [
+            "Figure 5: Time consumption. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            563,
+            444,
+            797,
+            570
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            614,
+            722,
+            627
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Real-world impact. The proposed method provides a convenient approach to enhance a detector under a certain setting, resulting in that a small model can perform on par with a larger one. On the positive side, it allows users to replace a big model with a smaller one, which reduces energy consumption. On the potentially negative side, the teacher could be costly in training, also the student might inherit biases from the teacher, which is hard for tracing. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            720
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            750,
+            299,
+            766
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We introduce a novel framework for knowledge distillation. The proposed Instance-Conditional knowledge Distillation (ICD) method utilizes instance-feature cross attention to select and locate knowledge that correlates with human observed instances, which provides a new framework for KD. Our formulation encodes instance as query and teacher’s representation as key. To teach the decoder how to find knowledge, we design an auxiliary task that relies on knowledge for recognition and localization. The proposed method consistently improves various detectors, leading to impressive performance gain, some student networks even surpass their teachers. In addition to our design of the auxiliary task, we believe there are other alternations that can cover different situations or provide a theoretical formulation of knowledge, which will be a potential direction for further researches. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            88,
+            553,
+            107
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This paper is supported by the National Key R&D Plan of the Ministry of Science and Technology (Project No. 2020AAA0104400) and Beijing Academy of Artificial Intelligence (BAAI). ",
+        "bbox": [
+            176,
+            121,
+            825,
+            150
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            169,
+            266,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Peter Anderson, Xiaodong He, Chris Buehler, Damien Teney, Mark Johnson, Stephen Gould, and Lei Zhang. Bottom-up and top-down attention for image captioning and visual question answering. In CVPR, 2018.   \n[2] Stanislaw Antol, Aishwarya Agrawal, Jiasen Lu, Margaret Mitchell, Dhruv Batra, C. Lawrence Zitnick, and Devi Parikh. VQA: visual question answering. In ICCV, 2015.   \n[3] Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. ArXiv preprint, 2016.   \n[4] Zhaowei Cai and Nuno Vasconcelos. Cascade r-cnn: Delving into high quality object detection. In CVPR, 2018.   \n[5] Nicolas Carion, Francisco Massa, Gabriel Synnaeve, Nicolas Usunier, Alexander Kirillov, and Sergey Zagoruyko. End-to-end object detection with transformers. In ECCV, 2020.   \n[6] Guobin Chen, Wongun Choi, Xiang Yu, Tony X. Han, and Manmohan Chandraker. Learning efficient object detection models with knowledge distillation. In NeurIPS, 2017.   \n[7] Kai Chen, Jiaqi Wang, Jiangmiao Pang, Yuhang Cao, Yu Xiong, Xiaoxiao Li, Shuyang Sun, Wansen Feng, Ziwei Liu, Jiarui Xu, Zheng Zhang, Dazhi Cheng, Chenchen Zhu, Tianheng Cheng, Qijie Zhao, Buyu Li, Xin Lu, Rui Zhu, Yue Wu, Jifeng Dai, Jingdong Wang, Jianping Shi, Wanli Ouyang, Chen Change Loy, and Dahua Lin. MMDetection: Open mmlab detection toolbox and benchmark. arXiv preprint arXiv:1906.07155, 2019.   \n[8] Liangyu Chen, Tong Yang, Xiangyu Zhang, Wei Zhang, and Jian Sun. Points as queries: Weakly semi-supervised object detection by points. In CVPR, 2021.   \n[9] Xu Cheng, Zhefan Rao, Yilan Chen, and Quanshi Zhang. Explaining knowledge distillation by quantifying the knowledge. In CVPR, 2020.   \n[10] Marius Cordts, Mohamed Omran, Sebastian Ramos, Timo Rehfeld, Markus Enzweiler, Rodrigo Benenson, Uwe Franke, Stefan Roth, and Bernt Schiele. The cityscapes dataset for semantic urban scene understanding. In CVPR, 2016.   \n[11] Xing Dai, Zeren Jiang, Zhao Wu, Yiping Bao, Zhicheng Wang, Si Liu, and Erjin Zhou. General instance distillation for object detection. In CVPR, 2021.   \n[12] M. Everingham, S. M. A. Eslami, L. Van Gool, C. K. I. Williams, J. Winn, and A. Zisserman. The pascal visual object classes challenge: A retrospective. IJCV, 2015.   \n[13] Jianping Gou, Baosheng Yu, Stephen J Maybank, and Dacheng Tao. Knowledge distillation: A survey. IJCV, 2021.   \n[14] Jianyuan Guo, Kai Han, Yunhe Wang, Han Wu, Xinghao Chen, Chunjing Xu, and Chang Xu. Distilling object detectors via decoupled features. In CVPR, 2021.   \n[15] Song Han, Jeff Pool, John Tran, and William J Dally. Learning both weights and connections for efficient neural networks. In NeurIPS, 2015.   \n[16] Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross B. Girshick. Mask R-CNN. In ICCV, 2017.   \n[17] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   \n[18] Yihui He, Xiangyu Zhang, and Jian Sun. Channel pruning for accelerating very deep neural networks. In ICCV, 2017.   \n[19] Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. In NeurIPS, 2014.   \n[20] Han Hu, Jiayuan Gu, Zheng Zhang, Jifeng Dai, and Yichen Wei. Relation networks for object detection. In CVPR, 2018.   \n[21] Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. In CVPR, 2017.   \n[22] Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Binarized neural networks. In NeurIPS, 2016.   \n[23] Itay Hubara, Matthieu Courbariaux, Daniel Soudry, Ran El-Yaniv, and Yoshua Bengio. Quantized neural networks: Training neural networks with low precision weights and activations. JMLR, 2017.   \n[24] Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. In NeurIPS, 2012.   \n[25] Hei Law and Jia Deng. Cornernet: Detecting objects as paired keypoints. In ECCV, 2018.   \n[26] Kuang-Huei Lee, Xi Chen, Gang Hua, Houdong Hu, and Xiaodong He. Stacked cross attention for image-text matching. In ECCV, 2018.   \n[27] Hao Li, Asim Kadav, Igor Durdanovic, Hanan Samet, and Hans Peter Graf. Pruning filters for efficient convnets. In ICLR, 2017.   \n[28] Quanquan Li, Shengying Jin, and Junjie Yan. Mimicking very efficient network for object detection. In CVPR, 2017.   \n[29] Tsung-Yi Lin, Piotr Dollár, Ross B. Girshick, Kaiming He, Bharath Hariharan, and Serge J. Belongie. Feature pyramid networks for object detection. In CVPR, 2017.   \n[30] Tsung-Yi Lin, Priya Goyal, Ross B. Girshick, Kaiming He, and Piotr Dollár. Focal loss for dense object detection. In ICCV, 2017.   \n[31] Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In ECCV, 2014.   \n[32] Yufan Liu, Jiajiong Cao, Bing Li, Chunfeng Yuan, Weiming Hu, Yangxi Li, and Yunqiang Duan. Knowledge distillation via instance relationship graph. In CVPR, 2019.   \n[33] Ilya Loshchilov and Frank Hutter. Decoupled weight decay regularization. In ICLR, 2019.   \n[34] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Edward Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In NeurIPS, 2019.   \n[35] Mohammad Rastegari, Vicente Ordonez, Joseph Redmon, and Ali Farhadi. Xnor-net: Imagenet classification using binary convolutional neural networks. In ECCV, 2016.   \n[36] Shaoqing Ren, Kaiming He, Ross B. Girshick, and Jian Sun. Faster R-CNN: towards real-time object detection with region proposal networks. In NeurIPS, 2015.   \n[37] Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. In ICLR, 2015.   \n[38] Mark Sandler, Andrew G. Howard, Menglong Zhu, Andrey Zhmoginov, and Liang-Chieh Chen. Mobilenetv2: Inverted residuals and linear bottlenecks. In CVPR, 2018.   \n[39] Mingxing Tan and Quoc V. Le. Efficientnet: Rethinking model scaling for convolutional neural networks. In ICML, Proceedings of Machine Learning Research, 2019.   \n[40] Zhi Tian, Hao Chen, Xinlong Wang, Yuliang Liu, and Chunhua Shen. AdelaiDet: A toolbox for instance-level recognition tasks. https://git.io/adelaidet, 2019.   \n[41] Zhi Tian, Chunhua Shen, and Hao Chen. Conditional convolutions for instance segmentation. In Proc. Eur. Conf. Computer Vision (ECCV), 2020.   \n[42] Zhi Tian, Chunhua Shen, Hao Chen, and Tong He. FCOS: fully convolutional one-stage object detection. In ICCV, 2019.   \n[43] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In NeurIPS, 2017.   \n[44] Jianfeng Wang, Lin Song, Zeming Li, Hongbin Sun, Jian Sun, and Nanning Zheng. End-to-end object detection with fully convolutional network. In CVPR, 2021.   \n[45] Tao Wang, Li Yuan, Xiaopeng Zhang, and Jiashi Feng. Distilling object detectors with finegrained feature imitation. In CVPR, 2019.   \n[46] Xinlong Wang, Rufeng Zhang, Tao Kong, Lei Li, and Chunhua Shen. SOLOv2: Dynamic and fast instance segmentation. In NeurIPS, 2020.   \n[47] Yuxin Wu, Alexander Kirillov, Francisco Massa, Wan-Yen Lo, and Ross Girshick. Detectron2. https://github.com/facebookresearch/detectron2, 2019.   \n[48] Jianwei Yang, Jiasen Lu, Dhruv Batra, and Devi Parikh. A faster pytorch implementation of faster r-cnn. https://github.com/jwyang/faster-rcnn.pytorch, 2017.   \n[49] Li Yuan, Francis E. H. Tay, Guilin Li, Tao Wang, and Jiashi Feng. Revisiting knowledge distillation via label smoothing regularization. In CVPR, 2020.   \n[50] Sergey Zagoruyko and Nikos Komodakis. Paying more attention to attention: Improving the performance of convolutional neural networks via attention transfer. In ICLR, 2017.   \n[51] Linfeng Zhang and Kaisheng Ma. Improve object detection with feature-based knowledge distillation: Towards accurate and efficient detectors. In ICLR, 2021. ",
+        "bbox": [
+            176,
+            191,
+            826,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            55,
+            828,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            88,
+            828,
+            577
+        ],
+        "page_idx": 12
+    }
+]

parse/train/x1Lp2bOlVIo/x1Lp2bOlVIo.md

@@ -0,0 +1,321 @@
+# Diffusion Normalizing Flow
+
+Qinsheng Zhang Georgia Institute of Technology qzhang419@gatech.edu
+
+Yongxin Chen Georgia Institute of Technology yongchen@gatech.edu
+
+# Abstract
+
+We present a novel generative modeling method called diffusion normalizing flow based on stochastic differential equations (SDEs). The algorithm consists of two neural SDEs: a forward SDE that gradually adds noise to the data to transform the data into Gaussian random noise, and a backward SDE that gradually removes the noise to sample from the data distribution. By jointly training the two neural SDEs to minimize a common cost function that quantifies the difference between the two, the backward SDE converges to a diffusion process the starts with a Gaussian distribution and ends with the desired data distribution. Our method is closely related to normalizing flow and diffusion probabilistic models and can be viewed as a combination of the two. Compared with normalizing flow, diffusion normalizing flow is able to learn distributions with sharp boundaries. Compared with diffusion probabilistic models, diffusion normalizing flow requires fewer discretization steps and thus has better sampling efficiency. Our algorithm demonstrates competitive performance in both high-dimension data density estimation and image generation tasks.
+
+# 1 Introduction
+
+Generative model is a class of machine learning models used to estimate data distributions and sometimes generate new samples from the distributions [8, 35, 16, 37, 7]. Many generative models learn the data distributions by transforming a latent variable $\mathbf { z }$ with a tractable prior distribution to the data space [8, 35, 32]. To generate new samples, one can sample from the latent space and then follow the transformation to the data space. There exist a large class of generative models where the latent space and the data space are of the same dimension. The latent variable and the data are coupled through trajectories in the same space. These trajectories serve two purposes: in the forward direction $\mathbf x \to \mathbf z$ , the trajectories infer the posterior distribution in the latent space associated with a given data sample $\mathbf { x }$ , and in the backward direction $\mathbf z \to \mathbf x$ , it generates new samples by simulating the trajectories starting from the latent space. This type of generative model can be roughly divided into two categories, depending on whether these trajectories connecting the latent space and the data space are deterministic or stochastic.
+
+When deterministic trajectories are used, these generative models are known as flow-based models. The latent space and the data space are connected through an invertible map, which could either be realized by the composition of multiple invertible maps [35, 8, 20] or a differential equation [4, 14]. In these models, the probability density at each data point can be evaluated explicitly using the change of variable theorem, and thus the training can be carried out by minimizing the negative log-likelihood (NLL) directly. One limitation of the flow-based model is that the invertible map parameterized by neural networks used in it imposes topological constraints on the transformation from z to x. Such limitation affects the performance significantly when the prior distribution on $\mathbf { z }$ is a simple unimodal distribution such as Gaussian while the target data distribution is a well-separated multi-modal distribution, i.e., its support has multiple isolated components. In [6], it is shown that there are some fundamental issues of using well-conditioned invertible functions to approximate such complicated multi-modal data distributions.
+
+When stochastic trajectories are used, the generative models are often known as the diffusion model [38]. In a diffusion model, a prespecified stochastic forward process gradually adds noise into the data to transform the data samples into simple random variables. A separate backward process is trained to revert this process to gradually remove the noise from the data to recover the original data distributions. When the forward process is modeled by a stochastic differential equation (SDE), the optimal backward SDE [1] can be retrieved by learning the score function [39, 40, 17, 2]. When the noise is added to the data sufficiently slow in the forward process, the backward diffusion can often revert the forward one reasonably well and is able to generate high fidelity samples. However, this also means that the trajectories have to be sufficiently long with a large number of time-discretization steps, which leads to slow training and sampling. In addition, since the forward process is fixed, the way noise is added is independent of the data distribution. As a consequence, the learned model may miss some complex but important details in the data distribution, as we will explain later.
+
+In this work, we present a new generative modeling algorithm that resembles both the flow-based models and the diffusion models. It extends the normalizing flow method by gradually adding noise to the sampling trajectories to make them stochastic. It extends the diffusion model by making the forward process from $\mathbf { x }$ to $\mathbf { z }$ trainable. Our algorithm is thus termed Diffusion Normalizing Flow (DiffFlow). The comparisons and relations among DiffFlow, normalizing flow, and diffusion models are shown in Figure 1. When the noise in DiffFlow shrinks to zero, DiffFlow reduces to a standard normalizing flow. When the forward process is fixed to some specific type of diffusion, DiffFlow reduces to a diffusion model.
+
+![](images/f41fd5e2cbf6a41d5a91af9d55ce17d5f4efe68c20cb429577ea460fd051ba0d.jpg)  
+Figure 1: The schematic diagram for normalizing flows, diffusion models, and DiffFlow. In normalizing flow, both the forward and the backward processes are deterministic. They are the inverse of each other and thus collapse into a single process. The diffusion model has a fixed forward process and trainable backward process, both are stochastic. In DiffFlow, both the forward and the backward processes are trainable and stochastic.
+
+In DiffFlow, the forward and backward diffusion processes are trained simultaneously by minimizing the distance between the forward and the backward process in terms of the Kullback-Leibler (KL) divergence of the induced probability measures [42]. This cost turns out to be equivalent to (see Section 3 for a derivation) the (amortized) negative evidence lower bound (ELBO) widely used in variational inference [21]. One advantage to use the KL divergence directly is that it can be estimated with no bias using sampled trajectories of the diffusion processes. The KL divergence in the trajectory space also bounds the KL divergence of the marginals, providing an alternative method to bound the likelihood (see Section 3 for details). To summarize, we have made the following contributions.
+
+1. We propose a novel density estimation model termed diffusion normalizing flow (DiffFlow) that extends both the flow-based models and the diffusion models. The added stochasticity in DiffFlow boosts the expressive power of the normalizing flow and results in better performance in terms of sampling quality and likelihood. Compared with diffusion models, DiffFlow is able to learn a forward diffusion process to add noise to the data adaptively and more efficiently. This avoids adding noise to regions where noise is not so desirable. The learnable forward process also shortens the trajectory length, making the sampling much faster than standard diffusion models (We observe a 20 times speedup over diffusion models without decreasing sampling quality much).
+
+2. We develop a stochastic adjoint algorithm to train the DiffFlow model. This algorithm evaluates the objective function and its gradient sequentially along the trajectory. It avoids storing all the intermediate values in the computational graph, making it possible to train DiffFlow for highdimensional problems.
+
+3. We apply the DiffFlow model to several generative modeling tasks with both synthetic and real datasets, and verify the performance of DiffFlow and its advantages over other methods.
+
+# 2 Background
+
+Below we provide a brief introduction to normalizing flows and diffusion models. In both of these models, we use $\tau = \{ \mathbf { x } ( t ) , 0 \leq t \leq T \}$ to denote trajectories from the data space to the latent space in the continuous-time setting, and $\boldsymbol \tau \doteq \{ \mathbf { x } _ { 0 } , \mathbf { x } _ { 1 } , \cdot \cdot \cdot , \mathbf { x } _ { N } \}$ in the discrete-time setting.
+
+Normalizing Flows: The trajectory in normalizing flows is modeled by a differential equation
+
+$$
+\begin{array} { r } { \dot { \mathbf { x } } = \mathbf { f } ( \mathbf { x } , t , \theta ) , } \end{array}
+$$
+
+parameterized by $\theta$ . This differential equation starts from random ${ \bf x } ( 0 ) = { \bf x }$ and ends at ${ \mathbf x } ( T ) = { \mathbf z }$ Denote by $p ( \mathbf { x } ( t ) )$ the probability distribution of ${ \bf x } ( t )$ , then under mild assumptions, it evolves following [4]
+
+$$
+\frac { \partial \log p ( \mathbf { x } ( t ) ) } { \partial t } = - \mathrm { t r } ( \frac { \partial \mathbf { f } } { \partial \mathbf { x } } ) .
+$$
+
+Using this relation (1) (2) one can compute the likelihood of the model at any data point $\mathbf { x }$
+
+In the discrete-time setting, the map from $\mathbf { x }$ to $\mathbf { z }$ in normalizing flows is a composition of a collection of bijective functions as $F = F _ { N } \circ F _ { N - 1 } \cdot \cdot \cdot F _ { 2 } \circ F _ { 1 }$ . The trajectory $\boldsymbol \tau = \{ \mathbf { x } _ { 0 } , \mathbf { x } _ { 1 } , \cdot \cdot \cdot , \mathbf { x } _ { N } \}$ satisfies
+
+$$
+\mathbf { x } _ { i } = F _ { i } ( \mathbf { x } _ { i - 1 } , \theta ) , \quad \mathbf { x } _ { i - 1 } = F _ { i } ^ { - 1 } ( \mathbf { x } _ { i } , \theta )
+$$
+
+for all $i$ . Similar to Equation (2), based on the rule for change of variable, the log-likelihood of any data samples $\mathbf { x } _ { 0 } = \mathbf { x }$ can be evaluated as
+
+$$
+\log p ( \mathbf { x } _ { 0 } ) = \log p ( \mathbf { x } _ { N } ) - \sum _ { i = 1 } ^ { N } \log | \mathbf { d e t } ( \frac { \partial F _ { i } ^ { - 1 } ( \mathbf { x } _ { i } ) } { \partial \mathbf { x } _ { i } } ) | .
+$$
+
+Since the exact likelihood is accessible in normalizing flows, these models can be trained by minimizing the negative log-likelihood directly.
+
+Diffusion Models: The trajectories in diffusion models are modeled by stochastic differential equations. More explicitly, the forward process is of the form
+
+$$
+\begin{array} { r } { d \mathbf { x } = \mathbf { f } ( \mathbf { x } , t ) d t + g ( t ) d \mathbf { w } , } \end{array}
+$$
+
+where the drift term $\textbf { f } : \mathbb { R } ^ { d } \times \mathbb { R }  \mathbb { R } ^ { d }$ is a vector-valued function, and the diffusion coefficient $g : \mathbb { R }  \mathbb { R }$ is a scalar function (in fact, $g$ is often chosen to be a constant). Here w denotes the standard Brownian motion. The forward process is normally a simple linear diffusion process [38, 16]. The forward trajectory $\tau$ can be sampled using (5) initialized with the data distribution. Denote by $p _ { F }$ the resulting probability distribution over the trajectories. With a slight abuse of notation, we also use $p _ { F }$ to denote the marginal distribution of the forward process.
+
+The backward diffusion from ${ \mathbf z } = { \mathbf x } ( T )$ to ${ \bf x } = { \bf x } ( 0 )$ is of the form
+
+$$
+d \mathbf { x } = [ \mathbf { f } ( \mathbf { x } , t ) - g ^ { 2 } ( t ) \mathbf { s } ( \mathbf { x } , t , \theta ) ] d t + g ( t ) d \mathbf { w } .
+$$
+
+It is well-known that when s coincides with the score function $\nabla \log p _ { F }$ , and $\mathbf { x } ( T )$ in the forward and backward processes share the same distribution, the distribution $p _ { B }$ induced by the backward process (6) is equal to $p _ { F }$ [1],[29, Chapter 13]. To train the score network $\mathbf { s } ( \mathbf { x } , t , \theta )$ , one can use the KL divergence between $p _ { F }$ and $p _ { B }$ as an objective function to reduce the difference between $p _ { F }$ and $p _ { B }$ . When the difference is sufficiently small, $p _ { F }$ and $p _ { B }$ should have similar distribution over ${ \bf x } ( 0 )$ , and one can then use the backward diffusion (6) to sample from the data distribution.
+
+In the discrete setting, the trajectory distributions can be more explicitly written as
+
+$$
+p _ { F } ( \tau ) = p _ { F } ( \mathbf { x } _ { 0 } ) \prod _ { i = 1 } ^ { N } p _ { F } ( \mathbf { x } _ { i } | \mathbf { x } _ { i - 1 } ) , \quad p _ { B } ( \tau ) = p _ { B } ( \mathbf { x } _ { T } ) \prod _ { i = 1 } ^ { N } p _ { B } ( \mathbf { x } _ { i - 1 } | \mathbf { x } _ { i } ) .
+$$
+
+The KL divergence between $p _ { F }$ and $p _ { B }$ can be decomposed according to this expression (7). Most diffusion models use this decomposition, and meanwhile take advantage of the simple structure of the forward process (5), to evaluate the objective function in training [39, 40, 41].
+
+# 3 Diffusion normalizing flow
+
+We next present our diffusion normalizing flow models. Similar to diffusion models, the DiffFlow models also has a forward process
+
+$$
+\begin{array} { r } { d \mathbf { x } = \mathbf { f } ( \mathbf { x } , t , \theta ) d t + g ( t ) d \mathbf { w } , } \end{array}
+$$
+
+and a backward process
+
+$$
+d \mathbf { x } = [ \mathbf { f } ( \mathbf { x } , t , \theta ) - g ^ { 2 } ( t ) \mathbf { s } ( \mathbf { x } , t , \theta ) ] d t + g ( t ) d \mathbf { w } .
+$$
+
+The major difference is that, instead of being a fixed linear function as in most diffusion models, the drift term f is also learnable in DiffFlow. The forward process is initialized with the data samples at $t = 0$ and the backward process is initialized with a given noise distribution at $t = T$ . Our goal is to ensure the distribution of the backward process at time $t = 0$ is close to the real data distribution. That is, we would like the difference between $p _ { B } ( \mathbf { x } ( 0 ) )$ and $p _ { F } ( \mathbf { x } ( 0 ) )$ to be small.
+
+To this end, we use the KL divergence between $p _ { B } ( \tau )$ and $p _ { F } ( \tau )$ over the trajectory space as the training objective function. Since
+
+$$
+K L ( p _ { F } ( \mathbf { x } ( t ) ) | p _ { B } ( \mathbf { x } ( t ) ) ) \leq K L ( p _ { F } ( \tau ) | p _ { B } ( \tau ) )
+$$
+
+for any $0 \leq t \leq T$ by data processing inequality, small difference between $p _ { B } ( \tau )$ and $p _ { F } ( \tau )$ implies small difference between $\bar { p } _ { B } ( \mathbf { x } ( 0 ) )$ and $p _ { F } ( { \bf \bar { x } } ( 0 ) )$ in terms of KL divergence (more details are included in Appendix B).
+
+# 3.1 Implementation
+
+In real implementation, we discretize the forward process (8) and the backward process (9) as
+
+$$
+\begin{array} { r c l } { \mathbf { x } _ { i + 1 } } & { = } & { \mathbf { x } _ { i } + \mathbf { f } _ { i } ( \mathbf { x } _ { i } ) \Delta t _ { i } + g _ { i } \delta _ { i } ^ { F } \sqrt { \Delta t _ { i } } } \\ { \mathbf { x } _ { i } } & { = } & { \mathbf { x } _ { i + 1 } - [ \mathbf { f } _ { i + 1 } ( \mathbf { x } _ { i + 1 } ) - g _ { i + 1 } ^ { 2 } \mathbf { s } _ { i + 1 } ( \mathbf { x } _ { i + 1 } ) ] \Delta t _ { i } + g _ { i + 1 } \delta _ { i } ^ { B } \sqrt { \Delta t _ { i } } , } \end{array}
+$$
+
+where $\delta _ { i } ^ { F } , \delta _ { i } ^ { B } \sim \mathcal { N } ( 0 , \mathbf { I } )$ are unit Gaussian noise, $\{ t _ { i } \} _ { i = 0 } ^ { N }$ are the discretization time points, and $\Delta t _ { i } = t _ { i + 1 } - t _ { i }$ is the step size at the $i$ -th step. Here we have dropped the dependence on the parameter $\theta$ to simplify the notation. With this discretization, the KL divergence between trajectory distributions becomes
+
+$$
+\small \mathrm { K } L ( p _ { F } ( \tau ) | p _ { B } ( \tau ) ) = \underbrace { \mathbb { E } _ { \tau \sim p _ { F } } [ \log p _ { F } ( \mathbf { x } _ { 0 } ) ] } _ { L _ { 0 } } + \underbrace { \mathbb { E } _ { \tau \sim p _ { F } } [ - \log p _ { B } ( \mathbf { x } _ { N } ) ] } _ { L _ { N } } + \underbrace { \sum _ { i = 1 } ^ { N - 1 } \mathbb { E } _ { \tau \sim p _ { F } } [ \log \frac { p _ { F } ( \mathbf { x } _ { i } | \mathbf { x } _ { i - 1 } ) } { p _ { B } ( \mathbf { x } _ { i - 1 } | \mathbf { x } _ { i } ) } ] } _ { L _ { i } } .
+$$
+
+The term $L _ { 0 }$ in (13) is a constant determined by entropy of the dataset as
+
+$$
+\underset { \tau \sim p _ { F } } { \mathbb { E } } [ \log p _ { F } ( \mathbf { x } _ { 0 } ) ] = \underset { \mathbf { x } _ { 0 } \sim p _ { F } } { \mathbb { E } } [ \log p _ { F } ( \mathbf { x } _ { 0 } ) ] = : - H ( p _ { F } ( x ( 0 ) ) ) .
+$$
+
+The term $L _ { N }$ is easy to calculate since $p _ { B } ( x _ { N } )$ is a simple distribution, typically standard Gaussian distribution.
+
+To evaluate $L _ { 1 : N - 1 }$ , we estimate it over sampled trajectory from the forward process $p _ { F }$ . For a given trajectory $\tau$ sampled from $p _ { F } ( \tau )$ , we need to calculate $p _ { B } ( \tau )$ along the same trajectory. To this end, a specific group of $\{ \delta _ { i } ^ { B } \}$ is chosen such that the same trajectory can be reconstructed from the backward process. Thus, $\delta _ { i } ^ { B }$ satisfies
+
+$$
+\delta _ { i } ^ { B } ( \tau ) = \frac { 1 } { g _ { i + 1 } \sqrt { \Delta t } } \Bigg [ \mathbf { x } _ { i } - \mathbf { x } _ { i + 1 } + [ \mathbf { f } _ { i + 1 } ( \mathbf { x } _ { i + 1 } ) - g _ { i + 1 } ^ { 2 } \mathbf { s } _ { i + 1 } ( \mathbf { x } _ { i + 1 } ) ] \Delta t \Bigg ] .
+$$
+
+Since $\delta _ { i } ^ { B }$ is a Gaussian noise, the negative log-likelihood term $p _ { B } \big ( \mathbf { x } _ { i } \big | \mathbf { x } _ { i + 1 } \big )$ is equal to $\textstyle \frac { 1 } { 2 } ( \delta _ { i } ^ { B } ( \tau ) ) ^ { 2 }$ after dropping constants (see more details in Appendix B). In view of the fact that the expectation of $\begin{array} { r } { \sum _ { i } \frac { 1 } { 2 } \bar { ( \delta _ { i } ^ { F } ( \tau ) ) } ^ { 2 } } \end{array}$ remains a constant, minimizing Equation (13) is equivalent to minimizing the following loss (see Appendix $\textrm { C }$ for the full derivation):
+
+$$
+L : = \mathbb { E } _ { \tau \sim p _ { F } } [ - \log p _ { B } ( \mathbf { x } _ { N } ) + \sum _ { i } \frac { 1 } { 2 } ( \delta _ { i } ^ { B } ( \tau ) ) ^ { 2 } ] = \mathbb { E } _ { \delta ^ { F } ; \mathbf { x } _ { 0 } \sim p _ { 0 } } [ - \log p _ { B } ( \mathbf { x } _ { N } ) + \sum _ { i } \frac { 1 } { 2 } ( \delta _ { i } ^ { B } ( \tau ) ) ^ { 2 } ] ,
+$$
+
+where the last equality is based on a reparameterization trick [21]. We can minimize the loss in Equation (15) with Monto Carlo gradient estimation as in Algorithm 1.
+
+# Algorithm 1 Training
+
+<table><tr><td>repeat</td></tr><tr><td>Xq ~ Real data distribution EN~N(0,I)</td></tr><tr><td></td></tr><tr><td>Sample: T = {xi}o based on :N</td></tr><tr><td>Gradient descent step Vθ[-log pB(xN) +∑i 1(δB(τ))²]</td></tr><tr><td>until converged</td></tr></table>
+
+# Algorithm 2 Stochastic Adjoint Algorithm for DiffFlow
+
+1: Input: Forward trajectory $\{ \mathbf { x } _ { i } \} _ { i = 0 } ^ { N }$   
+2: $\begin{array} { r } { \frac { \partial L } { \partial \mathbf { x } _ { N } } = \frac { 1 } { 2 } \frac { \partial ( \delta _ { N } ^ { B } ( \tau ) ) ^ { 2 } } { \partial \mathbf { x } _ { N } } - \frac { \partial \log p _ { B } ( \mathbf { x } _ { N } ) } { \mathbf { x } _ { N } } } \end{array}$   
+3: $\begin{array} { r } { \frac { \partial L } { \partial \theta } = 0 } \end{array}$   
+4: for $i = N , N - 1 , \cdots , 1 \mathbf { d } \mathbf { c }$   
+5: $\begin{array} { r } { \frac { \partial L } { \partial \mathbf { x } _ { i - 1 } } = \bigl ( \frac { \partial L } { \partial \mathbf { x } _ { i } } + \frac { 1 } { 2 } \frac { \partial ( \delta _ { i } ^ { B } ( \tau ) ) ^ { 2 } } { \partial \mathbf { x } _ { i } } \bigr ) \frac { \partial \mathbf { x } _ { i } } { \partial \mathbf { x } _ { i - 1 } } + \frac { 1 } { 2 } \frac { \partial ( \delta _ { i } ^ { B } ( \tau ) ) ^ { 2 } } { \partial \mathbf { x } _ { i - 1 } } } \end{array}$   
+6: $\begin{array} { r } { \frac { \partial L } { \partial \theta } + = \frac { 1 } { 2 } \frac { \partial ( \delta _ { i } ^ { B } ( \tau ) ) ^ { 2 } } { \partial \theta } + \big ( \frac { \partial L } { \partial \mathbf { x } _ { i } } + \frac { 1 } { 2 } \frac { \partial ( \delta _ { i } ^ { B } ( \tau ) ) ^ { 2 } } { \partial \mathbf { x } _ { i } } \big ) \frac { \partial \mathbf { x } _ { i } } { \partial \theta } } \end{array}$   
+7: end for
+
+![](images/49cd013ef89cc1946014c84d7ba2aee62ed71f6502db8b0ece59afa8b7288b38.jpg)  
+Figure 2: Gradient Flowchart.
+
+# 3.2 Stochastic Adjoint method
+
+One challenge in training DiffFlow is memory consumption. When a naive backpropagation strategy is used, the memory consumption explodes quickly. Indeed, differentiating through the operations of the forward pass requires unrolling networks $N$ times and caching all network intermediate values for every step, which prevents this naive implementation of DiffFlow from being applied in high dimensional applications. Inspired by the adjoint method in Neural ODE [4], we propose the adjoint variable $\frac { \partial L } { \partial \mathbf { x } _ { i } }$ and a stochastic adjoint algorithm that allows training the DiffFlow model with reduced memory consumption. In this adjoint method, we cache intermediate states $\mathbf { x } _ { i }$ and, based on these intermediate states, reproduce the whole process, including $\delta _ { i } ^ { F } , \delta _ { i } ^ { B }$ as well as $f _ { i } , s _ { i }$ exactly.
+
+We note another similar approach [26] of training SDEs caches random noise dw and further takes advantage of the pseudo-random generator to save memory for the intermediate noises, resulting in constant memory consumption However, the approach can not reproduce exact trajectories due to time discretization error and requires extra computation to recover $d \mathbf { w }$ from the pseudo-random generator. We found that in our image experiments in Section 4, the cached $\left\{ { { \bf { x } } _ { i } } \right\}$ consumes only about $\bar { 2 } \%$ memory out of all the memory being used during training. Due to the accuracy and acceptable memory overhead, the introduced stochastic adjoint approach is a better choice for DiffFlow. We summarize the method in Algorithm 2 and Figure 2. We also include the PyTorch [34] implementation in the supplemental material.
+
+# 3.3 Time discretization and progressive training
+
+We propose two time discretization schemes for training DiffFlow: fixed timestamps $L _ { \beta }$ and flexible timestamps $\hat { L } _ { \beta }$ . For fixed timestamps, the time interval $[ 0 , T ]$ is discretized with fixed schedule $\begin{array} { r } { t _ { i } = ( \frac { i } { N } ) ^ { \beta } T } \end{array}$ . With such fixed time discretization over batches, we denote the loss function as $L _ { \beta }$ . Empirically, we found $\beta = 0 . 9$ works well. This choice of $\beta$ increases stepsize $\Delta t _ { i }$ when the forward process approaches $\mathbf { z } = \mathbf { x } _ { N }$ and provides higher resolution when the backward process is close to $\mathbf { x } _ { \mathrm { 0 } }$ . We found such discretization generates samples with good quality and high fidelity details. The choice of polynomial function is arbitrary; other functions of similar sharps may work as well.
+
+![](images/f6accf23b17a9bda034232201a1c3f3a701629c30d8d8cea68513827ba867368.jpg)  
+Figure 3: $\Delta t _ { i }$ of $L _ { \beta }$ and $\hat { L } _ { \beta }$
+
+In the flexiable timestamps scheme, we train different batches with different time discretization points. Specifically, $t _ { i }$ is sampled uniformly from the interval $\begin{array} { r } { \big [ \big ( \frac { i - 1 } { N - 1 } \big ) ^ { \beta } T , ( \frac { i } { N - 1 } ) ^ { \beta } T \big ] } \end{array}$ for each batch. We denote the training objective function with such random time discretization as $\hat { L } _ { \beta }$ . We empirically found such implementation results in lower loss and better stability when we conduct progressive training where we increase $N$ gradually as training progresses. In progressive training, we refine the forward and backward processes as $N$ increase. This training scheme can significantly save training time compared with the other method that uses a fixed large $N$ during the whole process. Empirically, we found that progressive training can speed up the training up to 16 times.
+
+To understand why such random time discretization scheme is more stable, we hypothesis that this choice encourages a smoother f , s since it seeks functions f , s to reduce objective loss under different sets of $\{ t _ { i } \}$ instead of a specific $\{ t _ { i } \}$ . We illustrate fixed timestamps in $L _ { \beta }$ and a realization of random discretization in $\hat { L } _ { \beta }$ in Figure 3 with $\beta = 0 . 9$ .
+
+# 3.4 Learnable forward process
+
+![](images/9bab29808914586ba48762ad4e5e868d7e7e9cd322658ed2e5c8c30bb05a3df0.jpg)  
+Figure 4: Illustration of forwarding trajectories of DiffFlow, DDPM, and FFJORD. Each row shows two trajectories of transforming data distributions, four rings, and Olympics rings, to a base distribution. Different modes of densities are in different colors. Though FFJORD adjusts forward process based on data, its bijective property prevents the approach from expanding density support to the whole space. DDPM can transform data distributions into Gaussian distribution but a datainvariant way of adding noise can corrupt the details of densities, e.g., the densities at the intersections of the rings. DiffFlow not only transforms data into base distribution but also keeps the topological information of the original datasets. Points from the same ring are transformed into continental plates instead of being distributed randomly.
+
+The forward process not only is responsible for driving data into latent space, but also provides enough supervised information to learning backward process. Thanks to bijective property, NFs can reconstruct data exactly but there is no guarantee that it can reach the standard Gaussian. At the other extreme, Denoising diffusion probabilistic models (DDPM) [17] adopt a data-invariant forward diffusing schema, ensuring that $\mathbf { x } _ { N }$ is Gaussian. DDPM can even reach Gaussian in one step with $N = 1$ , which output noise disregarding data samples. However, backward process will be difficult to learn if data is destroyed in one step. Therefore, DDPM adds noise slowly and often needs more than one thousand steps for diffusion.
+
+The forward module of DiffFlow is a combination of normalizing flow and diffusion models. We show the comparision in fitting toy 2D datasets in Figure 4. We are especially interested in data with well-separated modes and sharp density boundaries. Those properties are believed to appear in various datasets. As stated by manifold hypothesis [36], real-world data lie on low-dimensional manifold [28] embedded in a high-dimensional space. To construct the distributions in Figure 4, we rotate the 1-d Gaussian distribution $\mathcal { N } ( 1 , 0 . 0 0 1 ^ { 2 } )$ around the center to form a ring and copy the rings to different locations.
+
+As a bijective model, FFJORD [14] struggles to diffuse the concentrated density mass into a Gaussian distribution. DiffFlow overcomes expressivity limitations of the bijective constraint by adding noise. As added noise shrinks to zero, the DiffFlow has no stochasticity and degrades to a flow-based model. Based on this fact, we present the following theorem with proof in Appendix A.
+
+Theorem 1. As diffusion coefficients $g _ { i } \to 0$ , DiffFlow reduces to Normalizing Flow. Moreover, minimizing the objective function in Equation (13) is equivalent to minimizing the negative loglikelihood as in Equation (4).
+
+DDPM [17] uses a fixed noising transformation. Due to the data-invariant approach $p ( \mathbf { x } _ { T } | \mathbf { x } _ { 0 } ) =$ $p ( \mathbf { x } _ { T } )$ , points are diffused in the same way even though they may appear in different modes or different datasets. We observe that sharp details are destroyed quickly in DDPM diffusion, such as the intersection regions between rings. However, with the help of learnable transformation, DiffFlow diffuses in a much efficient way. The data-dependent approach shows different diffusion strategies on different modes and different datasets. Meanwhile, similar to NFs, it keeps some topological information for learning backward processes. We include more details about the toy sample in Section 4.
+
+# 4 Experiments
+
+We evaluate the performance of DiffFlow in sample quality and likelihood on test data. To evaluate the likelihood, we adopt the marginals distribution equivalent SDEs
+
+$$
+d \mathbf { x } = [ \mathbf { f } ( \mathbf { x } , t , \theta ) - \frac { 1 + \lambda ^ { 2 } } { 2 } g ^ { 2 } ( t ) \mathbf { s } ( \mathbf { x } , t , \theta ) ] d t + \lambda g ( t ) d \mathbf { w } ,
+$$
+
+with $\lambda \geq 0$ (Proof see Appendix $\mathrm { H }$ ). When $\lambda = 0$ , it reduces to probability ODE [41]. The ODE provides an efficient way to evaluate the density and negative log-likelihood. For any $0 \leq \lambda \leq 1$ , the above SDE can be used for sampling. Empirically, we found $\lambda = 1$ has the best performance.
+
+# 4.1 Synthetic 2D examples
+
+We compare the performance of DiffFlow and existing diffusion models and NFs on estimating the density of 2-dimensional data. We compare the forward trajectories of DiffFlow, DDPM [17] and FFJORD $[ 1 4 ] ^ { 1 }$ in Figure 4 and its sampling performance in Figure 5. To make a fair comparison, we build models with comparable network sizes, around 90k learnable parameters. We include more training and model details in Appendix E.
+
+All three algorithms have good performance on datasets whose underlying distribution has smooth density, such as 2 spirals. However, when we shrink the support of samples or add complex patterns, performance varies significantly. We observe that FFJORD leaks many samples out of the main modes and datasets with complex details and sharp density exacerbates the disadvantage.
+
+DDPM has higher sample quality but blurs density details, such as intersections between rings, areas around leaves of the Fractal tree, and boxes in Sierpinski Carpet. The performance is within ´ expectation given that details are easy to be destroyed and ignored with the data-invariant noising schema. On the less sharp dataset, such as 2 Spirals and Checkerboard, its samples align with data almost perfectly.
+
+DiffFlow produces the best samples (according to a human observer). We owe the performance to the flexible noising forward process. As illustrated in Figure 4, DiffFlow provides more clues and retains detailed patterns longer for learning its reverse process. We also report a comprehensive comparison of the negative likelihood and more analysis in Appendix E. DiffFlow has a much lower negative likelihood, especially on sharp datasets.
+
+# 4.2 Density estimation on real data
+
+We perform density estimation experiments on five tabular datasets [33]. We employ the probability flow to evaluate the negative log-likelihood. We find that our algorithm has better performance in most datasets than most approaches trained by directly minimizing negative log-likelihood, including NFs and autoregressive models. DiffFlow outperforms FFJORD by a wide margin on all datasets except HEPMASS. Compared with autoregressive models, it excels NAF [18] on all but GAS. Those models require $\mathcal O ( d )$ computations to sample from. Meanwhile, DiffFlow is quite effective in achieving such performance with MLPs that have less than 5 layers. We include more details in Appendix F
+
+# 4.3 Image generation
+
+In this section, we report the quantitative comparison and qualitative performance of our method and existing methods on common image datasets, MNIST [24] and CIFAR-10 [23]. We use the same unconstrained U-net style model as used successfully by Ho et al. [17] for drift and score network. We reduce the network size to half of the original DDPM network so that the total number of trainable parameters of DiffFlow and DDPM are comparable. We use small $N = 1 0$ at the beginning of training and slowly increase to large $N$ as training proceeds. The schedule of $N$ reduces the training time greatly compared with using large $N$ all the time. We use constants $g _ { i } = 1$ and $T = 0 . 0 5$ for MNIST and CIFAR10, and $N = 3 0$ for sampling MNIST data and $N = 1 0 0$ for sampling CIFAR10. As it is reported by Jolicoeur-Martineau et al. [19], adding noise at the last step will significantly lower sampling quality, we use one single denoising step at the end of sampling with Tweedie’s formula [10].
+
+![](images/3f94f1fa1b4d8a3e74e2e06aadebd20e9a09d53e11aa21daa4ec58111acd8c97.jpg)  
+Figure 5: Samples from DiffFlow, DDPM and FFJORD on 2-D datasets. All three models have reasonable performance on datasets that have smooth underlying distributions. But only DiffFlow is capable to capture complex patterns and provides sharp samples when dealing with more challenging datasets.
+
+<table><tr><td>Dataset</td><td>POWER</td><td>GAS</td><td>HEPMASS</td><td>MINIBOONE</td><td>BSDS300</td></tr><tr><td>RealNVP [8]</td><td>-0.17</td><td>-8.33</td><td>18.71</td><td>13.55</td><td>-153.28</td></tr><tr><td>FFJORD[14]</td><td>-0.46</td><td>-8.59</td><td>14.92</td><td>10.43</td><td>-157.40</td></tr><tr><td>DiffFlow (ODE)</td><td>-1.04</td><td>-10.45</td><td>15.04</td><td>8.06</td><td>-157.80</td></tr><tr><td>MADE [11]</td><td>3.08</td><td>-3.56</td><td>20.98</td><td>15.59</td><td>-148.85</td></tr><tr><td>MAF [33]</td><td>-0.24</td><td>-10.08</td><td>17.70</td><td>11.75</td><td>-155.69</td></tr><tr><td>TAN [31]</td><td>-0.48</td><td>-11.19</td><td>15.12</td><td>11.01</td><td>-157.03</td></tr><tr><td>NAF[18]</td><td>-0.62</td><td>-11.96</td><td>15.09</td><td>8.86</td><td>-157.73</td></tr></table>
+
+Table 1: Average negative log-likelihood (in nats) on tabular datasets [33] for density estimation (lower is better).
+
+We report negative log-likelihood (NLL) in bits per dimension or negative ELBO if NLL is unavailable. On MNIST, we achieve competitive performance on NLL as in Table 2. We show the uncurated samples from DiffFlow in Figure 6 and Figure 7. On CIFAR-10, DiffFlow also achieves competitive NLL performance as shown in Table 3. DiffFlow performs better than normalizing flows and DDPM models, but is slightly worse than $\mathrm { { D D P M + + } }$ (sub, deep, sub-vp) and Improved DDPM. However, these approaches conduct multiple architectural improvements and use much deeper and wider networks. We also report the popular sample metric, Fenchel Inception Distance (FID) [15]. DiffFLow has a lower FID score than normalizing flows and has competitive performance compared with DDPM trained with unweighted variational bounds, DDPM and Improved DDPM. It is worse than DDPM trained with reweighted loss, DDPM $( L _ { s } )$ , DDPM cont, and DDPM $^ { + + }$ [17, 41, 30]. Besides, sampling quality with different sampling steps $N$ are compared in Table $4 ^ { 2 }$ . The advantage of DiffFlow is clear when we compare relative FIDs degeneracy ratio with $N = 1 0 0$ respectively. DiffFlow is able to retain better sampling quality when decreasing $N$ . Full details on architectures used, training setup details, and more samples can be found in Appendix G.
+
+![](images/be1945b782ae6b79cfd0a04a97a29817b733b952e4b732ca74ab132fb156609b.jpg)  
+Figure 6: MNIST Samples
+
+Table 2: NLL on MNIST   
+
+<table><tr><td>Model</td><td>NLL (↓)</td></tr><tr><td>RealNVP [8]</td><td>1.06</td></tr><tr><td>Glow [20]</td><td>1.05</td></tr><tr><td>FFJORD[14]</td><td>0.99</td></tr><tr><td>ResFlow [5]</td><td>0.97</td></tr><tr><td>DiffFlow</td><td>0.93</td></tr></table>
+
+![](images/c3bcfde04a840e25a86920a1df038b19101b23ae5c6fe2cb3f02e90c5c1b53ff.jpg)  
+Figure 7: CIFAR10 Samples
+
+Table 3: NLLs and FIDs on CIFAR-10.   
+
+<table><tr><td>Model</td><td>NLL(↓)</td><td>FID (↓</td></tr><tr><td>RealNVP[8]</td><td>3.49</td><td rowspan="4">46.90</td></tr><tr><td>Glow [20]</td><td>3.35</td></tr><tr><td>Flow++[16]</td><td>3.29 =</td></tr><tr><td>FFJORD [14]</td><td>3.40 1</td></tr><tr><td>ResFlow[5]</td><td>3.28</td><td rowspan="9">46.37 13.51 3.17</td></tr><tr><td>DDPM(L)[17]</td><td>≤3.70</td></tr><tr><td>DDPM(Ls)[17]</td><td>≤3.75</td></tr><tr><td>DDPM(Ls)(ODE) [41]</td><td>3.28 3.37 3.56</td></tr><tr><td>DDPM cont. (sub-VP) [41]</td><td>3.05</td></tr><tr><td>DDPM++ (sub-VP) [41]</td><td>3.02 3.16 2.99</td></tr><tr><td>DDPM++ (deep,sub-VP)[41]</td><td>2.94</td></tr><tr><td>Improved DDPM [30] ≤2.94</td><td>11.47</td></tr><tr><td>≤3.71</td><td>13.87</td></tr><tr><td>DiffFlow (L β) DiffFlow (L β)</td><td></td><td>13.43</td></tr><tr><td></td><td>≤3.67</td><td></td></tr><tr><td>DiffFlow (L β, ODE)</td><td>3.04</td><td>14.14</td></tr></table>
+
+Table 4: FIDs with various $N$   
+
+<table><tr><td>N DiffFlowDDPM(L)DDPM(Ls) DDIM</td><td colspan="2"></td></tr><tr><td>5 28.31</td><td>373.51</td><td>370.23 44.69</td></tr><tr><td>10 22.56</td><td>364.64</td><td>365.12 18.62</td></tr><tr><td>20 17.98</td><td>138.84 135.44</td><td>10.89</td></tr><tr><td>50 14.72</td><td>47.12</td><td>34.56 7.01</td></tr><tr><td>100 13.43</td><td>22.23</td><td>10.04 5.63</td></tr></table>
+
+Table 5: Relative FIDs degeneracy ratio   
+
+<table><tr><td colspan="2">N DiffFlowDDPM(L) DDPM(Ls)DDIM</td></tr><tr><td>5 2.12 16.80</td><td>37.02 7.94</td></tr><tr><td>10 1.68 16.40</td><td>36.12 3.31</td></tr><tr><td>20 1.34 6.24</td><td>13.54 1.93</td></tr><tr><td>50 1.10 2.12</td><td>3.45 1.24</td></tr><tr><td>100 1.0 1.0</td><td>1.0 1.0</td></tr></table>
+
+# 5 Related work
+
+Normalizing flows [8, 35] have recently received lots of attention due to its exact density evaluation and ability to model high dimensional data [20, 9]. However, the bijective requirement poses limitations on modeling complex data, both empirically and theoretically [42, 6]. Some works attempt to relax the bijective requirement; discretely index flows [9] use domain partitioning with only locally invertible functions. Continuously indexed flows [6] extend discretely indexing to a continuously indexing approach. As pointed out in Stochastic Normalizing Flows (SNF) [42], stochasticity can effectively improve the expressive power of the flow-based model in low dimension applications. The architecture used in SNF, which requires known underlying energy models, presents challenges for density learning tasks; SNF is designed for sampling from unnormalized probability distribution instead of density estimation. Besides, even with ideal networks and infinite amount of data, due to the predefined stochstic block being used, SNF cannot find models with aligned forward and backward distribution as DiffFlow.
+
+When it comes to stochastic trajectories, minimizing the distance between trajectory distributions has been explored in existing works. Denoising diffusion model [38] uses a fixed linear forward diffusion schema and reparameterizes the KL divergence such that minimizing loss is possible without computing whole trajectories. Diffusion models essentially corrupt real data iteratively and learn to remove the noise when sampling. Recently, Diffusion models have shown the capability to model high-dimensional data distribution, such as images [17, 40], shapes [3], text-to-speech [22]. Lately, the Score-based model [41] provides a unified framework for score-matching methods and diffusion models based on stochastic calculus. The diffusion processes and sampling processes can be viewed as forwarding SDE and reverse-time SDE. Thanks to the linear forward SDE being used in DDPM, the forward marginal distributions have a closed-form and are suitable for training score functions on large-scale datasets. Also, due to the reliance on fixed linear forward process, it takes thousands of steps to diffuse data and generate samples. DiffFlow considers general SDEs and nosing and sampling are more efficient.
+
+Existing Neural SDE approaches suffer from poor scaling properties. Backpropagating through solver [12] has a linear memory complexity with the number of steps. The pathwise approach [13] scales poorly in computation complexity. Our stochastic adjoint approach shares a similar spirit with SDE adjoint sensitivity [25]. The choice of caching noise requires high resolution of time discretization and prevents the approach from scaling to high dimension applications. By caching the trajectory states, DiffFlow can use a coarser discretization and deploy on larger dimension problems and problems with more challenging densities. The additional memory footprint is negligible compared with the other network memory consumption in DiffFlow.
+
+# 6 Limitations
+
+While DiffFlow gains more flexibility due to the introduction of a learnable forward process, it loses the analytical form for $p _ { F } ( \mathbf { x } _ { t } | \mathbf { x } _ { 0 } )$ and thus the training less efficient compared with score-based loss [41]. Training DiffFlow relies on backpropagation through trajectories and is thus significantly slower than diffusion models with affine drift. Empirically, we found DiffFlow is about 6 times slower than DDPM in 2d toy examples, 55 times in MNIST, and 160 times in CIFAR10 without progressive training in Section 3.3. Though the stochastic adjoint method and progressive training help save memory footprint and reduce training time, the training of DiffFlow is still more expensive than DDPM and its variants. On the other hand, compared with normalizing flows, the extra noise in DiffFlow boosts the expressive power of the model with little extra cost. Though DiffFlow trained based on SDE, its marginal distribution equivalent ODE 2 shows much better performance than its counterpart trained with ODE [14]. It is interesting to investigate, both empirically and theoretically, the benefit in terms of expressiveness improvement caused by stochastic noise for training normalizing flows.
+
+# 7 Conclusions
+
+We proposed a novel algorithm, the diffusion normalizing flow (DiffFlow), for generative modeling and density estimation. The proposed method extends both the normalizing flow models and the diffusion models. Our DiffFlow algorithm has two trainable diffusion processes modeled by neural SDEs, one forward and one backward. These two SDEs are trained jointly by minimizing the KL divergence between them. Compared with most normalizing flow models, the added noise in DiffFlow relaxes the bijectivity condition in deterministic flow-based models and improves their expressive power. Compared with diffusion models, DiffFlow learns a more flexible forward diffusion that is able to transform data into noise more effectively and adaptively. In our experiments, we observed that DiffFlow is able to model distributions with complex details that are not captured by representative normalizing flow models and diffusion models, including FFJORD, DDPM. For CIFAR10 dataset, our DiffFlow method has worse performance than DDPM in terms of FID score. We believe our DiffFlow algorithm can be improved further by using different neural network architectures, different time discretizing method and different choices of time interval. We plan to explore these options in the near future.
+
+Our algorithm is able to learn the distribution of high-dimensional data and then generate new samples from it. Like many other generative modeling algorithms, it may be potentially used to generate misleading data such as fake images or videos.
+
+# Acknowledgements
+
+The authors would like to thank the anonymous reviewers for useful comments. This work is supported in part by grants NSF CAREER ECCS-1942523 and NSF CCF-2008513.
+
+# References
+
+[1] Anderson, B. D. Reverse-time diffusion equation models. Stochastic Processes and their Applications, 12 (3):313–326, 1982.   
+[2] Bordes, F., Honari, S., and Vincent, P. Learning to generate samples from noise through infusion training. arXiv preprint arXiv:1703.06975, 2017.   
+[3] Cai, R., Yang, G., Averbuch-Elor, H., Hao, Z., Belongie, S., Snavely, N., and Hariharan, B. Learning gradient fields for shape generation. In Proceedings of the European Conference on Computer Vision (ECCV), 2020.   
+[4] Chen, R. T., Rubanova, Y., Bettencourt, J., and Duvenaud, D. Neural ordinary differential equations. arXiv preprint arXiv:1806.07366, 2018.   
+[5] Chen, R. T. Q., Behrmann, J., Duvenaud, D., and Jacobsen, J. Residual flows for invertible generative modeling. In Advances in Neural Information Processing Systems, 2019.   
+[6] Cornish, R., Caterini, A., Deligiannidis, G., and Doucet, A. Relaxing bijectivity constraints with continuously indexed normalising flows. In International Conference on Machine Learning, pp. 2133–2143. PMLR, 2020.   
+[7] Deng, Y., Bakhtin, A., Ott, M., Szlam, A., and Ranzato, M. Residual energy-based models for text generation. arXiv preprint arXiv:2004.11714, 2020.   
+[8] Dinh, L., Sohl-Dickstein, J., and Bengio, S. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.   
+[9] Dinh, L., Sohl-Dickstein, J., Larochelle, H., and Pascanu, R. A rad approach to deep mixture models. arXiv preprint arXiv:1903.07714, 2019.   
+[10] Efron, B. Tweedie’s formula and selection bias. Journal of the American Statistical Association, 106(496): 1602–1614, 2011.   
+[11] Germain, M., Gregor, K., Murray, I., and Larochelle, H. Made: Masked autoencoder for distribution estimation. In International Conference on Machine Learning, pp. 881–889. PMLR, 2015.   
+[12] Giles, M. and Glasserman, P. Smoking adjoints: Fast monte carlo greeks. Risk, 19(1):88–92, 2006.   
+[13] Gobet, E. and Munos, R. Sensitivity analysis using itô–malliavin calculus and martingales, and application to stochastic optimal control. SIAM Journal on control and optimization, 43(5):1676–1713, 2005.   
+[14] Grathwohl, W., Chen, R. T., Bettencourt, J., Sutskever, I., and Duvenaud, D. Ffjord: Free-form continuous dynamics for scalable reversible generative models. arXiv preprint arXiv:1810.01367, 2018.   
+[15] Heusel, M., Ramsauer, H., Unterthiner, T., Nessler, B., and Hochreiter, S. Gans trained by a two time-scale update rule converge to a local nash equilibrium. arXiv preprint arXiv:1706.08500, 2017.   
+[16] Ho, J., Chen, X., Srinivas, A., Duan, Y., and Abbeel, P. Flow $+ +$ : Improving flow-based generative models with variational dequantization and architecture design. In International Conference on Machine Learning, pp. 2722–2730. PMLR, 2019.   
+[17] Ho, J., Jain, A., and Abbeel, P. Denoising diffusion probabilistic models. arXiv preprint arXiv:2006.11239, 2020.   
+[18] Huang, C.-W., Krueger, D., Lacoste, A., and Courville, A. Neural autoregressive flows. In International Conference on Machine Learning, pp. 2078–2087. PMLR, 2018.   
+[19] Jolicoeur-Martineau, A., Piché-Taillefer, R., Combes, R. T. d., and Mitliagkas, I. Adversarial score matching and improved sampling for image generation. arXiv preprint arXiv:2009.05475, 2020.   
+[20] Kingma, D. P. and Dhariwal, P. Glow: Generative flow with invertible 1x1 convolutions. arXiv preprint arXiv:1807.03039, 2018.   
+[21] Kingma, D. P. and Welling, M. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   
+[22] Kong, Z., Ping, W., Huang, J., Zhao, K., and Catanzaro, B. Diffwave: A versatile diffusion model for audio synthesis. arXiv preprint arXiv:2009.09761, 2020.   
+[23] Krizhevsky, A., Hinton, G., et al. Learning multiple layers of features from tiny images. 2009.   
+[24] LeCun, Y. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.   
+[25] Li, X., Wong, T.-K. L., Chen, R. T., and Duvenaud, D. Scalable gradients for stochastic differential equations. In International Conference on Artificial Intelligence and Statistics, pp. 3870–3882. PMLR, 2020.   
+[26] Li, X., Wong, T.-K. L., Chen, R. T., and Duvenaud, D. Scalable gradients for stochastic differential equations. In International Conference on Artificial Intelligence and Statistics, pp. 3870–3882. PMLR, 2020.   
+[27] Meng, C., Song, J., Song, Y., Zhao, S., and Ermon, S. Improved autoregressive modeling with distribution smoothing. arXiv preprint arXiv:2103.15089, 2021.   
+[28] Narayanan, H. and Mitter, S. Sample complexity of testing the manifold hypothesis. In Proceedings of the 23rd International Conference on Neural Information Processing Systems-Volume 2, pp. 1786–1794, 2010.   
+[29] Nelson, E. Dynamical theories of Brownian motion. Princeton university press, 2020.   
+[30] Nichol, A. and Dhariwal, P. Improved denoising diffusion probabilistic models. arXiv preprint arXiv:2102.09672, 2021.   
+[31] Oliva, J., Dubey, A., Zaheer, M., Poczos, B., Salakhutdinov, R., Xing, E., and Schneider, J. Transformation autoregressive networks. In International Conference on Machine Learning, pp. 3898–3907. PMLR, 2018.   
+[32] Oord, A. v. d., Dieleman, S., Zen, H., Simonyan, K., Vinyals, O., Graves, A., Kalchbrenner, N., Senior, A., and Kavukcuoglu, K. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016.   
+[33] Papamakarios, G., Pavlakou, T., and Murray, I. Masked autoregressive flow for density estimation. arXiv preprint arXiv:1705.07057, 2017.   
+[34] Paszke, A., Gross, S., Massa, F., Lerer, A., Bradbury, J., Chanan, G., Killeen, T., Lin, Z., Gimelshein, N., Antiga, L., et al. Pytorch: An imperative style, high-performance deep learning library. arXiv preprint arXiv:1912.01703, 2019.   
+[35] Rezende, D. and Mohamed, S. Variational inference with normalizing flows. In International Conference on Machine Learning, pp. 1530–1538. PMLR, 2015.   
+[36] Roweis, S. T. and Saul, L. K. Nonlinear dimensionality reduction by locally linear embedding. science, 290(5500):2323–2326, 2000.   
+[37] Salimans, T., Karpathy, A., Chen, X., and Kingma, D. P. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. arXiv preprint arXiv:1701.05517, 2017.   
+[38] Sohl-Dickstein, J., Weiss, E., Maheswaranathan, N., and Ganguli, S. Deep unsupervised learning using nonequilibrium thermodynamics. In International Conference on Machine Learning, pp. 2256–2265. PMLR, 2015.   
+[39] Song, Y. and Ermon, S. Generative modeling by estimating gradients of the data distribution. In Advances in Neural Information Processing Systems, pp. 11895–11907, 2019.   
+[40] Song, Y. and Ermon, S. Improved techniques for training score-based generative models. arXiv preprint arXiv:2006.09011, 2020.   
+[41] Song, Y., Sohl-Dickstein, J., Kingma, D., Kumar, A., Ermon, S., and Poole, B. Score-based generative modeling through stochastic differential equations. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=PxTIG12RRHS.   
+[42] Wu, H., Köhler, J., and Noe, F. Stochastic normalizing flows. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H. (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 5933–5944. Curran Associates, Inc., 2020.

parse/train/x1Lp2bOlVIo/x1Lp2bOlVIo_content_list.json

@@ -0,0 +1,1408 @@
+[
+    {
+        "type": "text",
+        "text": "Diffusion Normalizing Flow ",
+        "text_level": 1,
+        "bbox": [
+            330,
+            122,
+            668,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Qinsheng Zhang Georgia Institute of Technology qzhang419@gatech.edu ",
+        "bbox": [
+            248,
+            200,
+            457,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yongxin Chen Georgia Institute of Technology yongchen@gatech.edu ",
+        "bbox": [
+            539,
+            200,
+            750,
+            243
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            279,
+            535,
+            295
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We present a novel generative modeling method called diffusion normalizing flow based on stochastic differential equations (SDEs). The algorithm consists of two neural SDEs: a forward SDE that gradually adds noise to the data to transform the data into Gaussian random noise, and a backward SDE that gradually removes the noise to sample from the data distribution. By jointly training the two neural SDEs to minimize a common cost function that quantifies the difference between the two, the backward SDE converges to a diffusion process the starts with a Gaussian distribution and ends with the desired data distribution. Our method is closely related to normalizing flow and diffusion probabilistic models and can be viewed as a combination of the two. Compared with normalizing flow, diffusion normalizing flow is able to learn distributions with sharp boundaries. Compared with diffusion probabilistic models, diffusion normalizing flow requires fewer discretization steps and thus has better sampling efficiency. Our algorithm demonstrates competitive performance in both high-dimension data density estimation and image generation tasks. ",
+        "bbox": [
+            233,
+            308,
+            766,
+            512
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            530,
+            312,
+            547
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative model is a class of machine learning models used to estimate data distributions and sometimes generate new samples from the distributions [8, 35, 16, 37, 7]. Many generative models learn the data distributions by transforming a latent variable $\\mathbf { z }$ with a tractable prior distribution to the data space [8, 35, 32]. To generate new samples, one can sample from the latent space and then follow the transformation to the data space. There exist a large class of generative models where the latent space and the data space are of the same dimension. The latent variable and the data are coupled through trajectories in the same space. These trajectories serve two purposes: in the forward direction $\\mathbf x \\to \\mathbf z$ , the trajectories infer the posterior distribution in the latent space associated with a given data sample $\\mathbf { x }$ , and in the backward direction $\\mathbf z \\to \\mathbf x$ , it generates new samples by simulating the trajectories starting from the latent space. This type of generative model can be roughly divided into two categories, depending on whether these trajectories connecting the latent space and the data space are deterministic or stochastic. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            722
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When deterministic trajectories are used, these generative models are known as flow-based models. The latent space and the data space are connected through an invertible map, which could either be realized by the composition of multiple invertible maps [35, 8, 20] or a differential equation [4, 14]. In these models, the probability density at each data point can be evaluated explicitly using the change of variable theorem, and thus the training can be carried out by minimizing the negative log-likelihood (NLL) directly. One limitation of the flow-based model is that the invertible map parameterized by neural networks used in it imposes topological constraints on the transformation from z to x. Such limitation affects the performance significantly when the prior distribution on $\\mathbf { z }$ is a simple unimodal distribution such as Gaussian while the target data distribution is a well-separated multi-modal distribution, i.e., its support has multiple isolated components. In [6], it is shown that there are some fundamental issues of using well-conditioned invertible functions to approximate such complicated multi-modal data distributions. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            897
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When stochastic trajectories are used, the generative models are often known as the diffusion model [38]. In a diffusion model, a prespecified stochastic forward process gradually adds noise into the data to transform the data samples into simple random variables. A separate backward process is trained to revert this process to gradually remove the noise from the data to recover the original data distributions. When the forward process is modeled by a stochastic differential equation (SDE), the optimal backward SDE [1] can be retrieved by learning the score function [39, 40, 17, 2]. When the noise is added to the data sufficiently slow in the forward process, the backward diffusion can often revert the forward one reasonably well and is able to generate high fidelity samples. However, this also means that the trajectories have to be sufficiently long with a large number of time-discretization steps, which leads to slow training and sampling. In addition, since the forward process is fixed, the way noise is added is independent of the data distribution. As a consequence, the learned model may miss some complex but important details in the data distribution, as we will explain later. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            257
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present a new generative modeling algorithm that resembles both the flow-based models and the diffusion models. It extends the normalizing flow method by gradually adding noise to the sampling trajectories to make them stochastic. It extends the diffusion model by making the forward process from $\\mathbf { x }$ to $\\mathbf { z }$ trainable. Our algorithm is thus termed Diffusion Normalizing Flow (DiffFlow). The comparisons and relations among DiffFlow, normalizing flow, and diffusion models are shown in Figure 1. When the noise in DiffFlow shrinks to zero, DiffFlow reduces to a standard normalizing flow. When the forward process is fixed to some specific type of diffusion, DiffFlow reduces to a diffusion model. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f41fd5e2cbf6a41d5a91af9d55ce17d5f4efe68c20cb429577ea460fd051ba0d.jpg",
+        "image_caption": [
+            "Figure 1: The schematic diagram for normalizing flows, diffusion models, and DiffFlow. In normalizing flow, both the forward and the backward processes are deterministic. They are the inverse of each other and thus collapse into a single process. The diffusion model has a fixed forward process and trainable backward process, both are stochastic. In DiffFlow, both the forward and the backward processes are trainable and stochastic. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            381,
+            797,
+            568
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In DiffFlow, the forward and backward diffusion processes are trained simultaneously by minimizing the distance between the forward and the backward process in terms of the Kullback-Leibler (KL) divergence of the induced probability measures [42]. This cost turns out to be equivalent to (see Section 3 for a derivation) the (amortized) negative evidence lower bound (ELBO) widely used in variational inference [21]. One advantage to use the KL divergence directly is that it can be estimated with no bias using sampled trajectories of the diffusion processes. The KL divergence in the trajectory space also bounds the KL divergence of the marginals, providing an alternative method to bound the likelihood (see Section 3 for details). To summarize, we have made the following contributions. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose a novel density estimation model termed diffusion normalizing flow (DiffFlow) that extends both the flow-based models and the diffusion models. The added stochasticity in DiffFlow boosts the expressive power of the normalizing flow and results in better performance in terms of sampling quality and likelihood. Compared with diffusion models, DiffFlow is able to learn a forward diffusion process to add noise to the data adaptively and more efficiently. This avoids adding noise to regions where noise is not so desirable. The learnable forward process also shortens the trajectory length, making the sampling much faster than standard diffusion models (We observe a 20 times speedup over diffusion models without decreasing sampling quality much). ",
+        "bbox": [
+            173,
+            773,
+            825,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. We develop a stochastic adjoint algorithm to train the DiffFlow model. This algorithm evaluates the objective function and its gradient sequentially along the trajectory. It avoids storing all the intermediate values in the computational graph, making it possible to train DiffFlow for highdimensional problems. ",
+        "bbox": [
+            173,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3. We apply the DiffFlow model to several generative modeling tasks with both synthetic and real datasets, and verify the performance of DiffFlow and its advantages over other methods. ",
+        "bbox": [
+            173,
+            119,
+            823,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Background ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            159,
+            310,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Below we provide a brief introduction to normalizing flows and diffusion models. In both of these models, we use $\\tau = \\{ \\mathbf { x } ( t ) , 0 \\leq t \\leq T \\}$ to denote trajectories from the data space to the latent space in the continuous-time setting, and $\\boldsymbol \\tau \\doteq \\{ \\mathbf { x } _ { 0 } , \\mathbf { x } _ { 1 } , \\cdot \\cdot \\cdot , \\mathbf { x } _ { N } \\}$ in the discrete-time setting. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            226
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Normalizing Flows: The trajectory in normalizing flows is modeled by a differential equation ",
+        "bbox": [
+            173,
+            229,
+            792,
+            246
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/25ba999abe7687f9c91fbac8ac44d1c500e22e7711c565a0dad28940f218e9d7.jpg",
+        "text": "$$\n\\begin{array} { r } { \\dot { \\mathbf { x } } = \\mathbf { f } ( \\mathbf { x } , t , \\theta ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            250,
+            547,
+            266
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "parameterized by $\\theta$ . This differential equation starts from random ${ \\bf x } ( 0 ) = { \\bf x }$ and ends at ${ \\mathbf x } ( T ) = { \\mathbf z }$ Denote by $p ( \\mathbf { x } ( t ) )$ the probability distribution of ${ \\bf x } ( t )$ , then under mild assumptions, it evolves following [4] ",
+        "bbox": [
+            174,
+            268,
+            826,
+            311
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/816da8c6798b8cd9dff87808ad841e0a0a99c40ba2f58473db6d37e068139b70.jpg",
+        "text": "$$\n\\frac { \\partial \\log p ( \\mathbf { x } ( t ) ) } { \\partial t } = - \\mathrm { t r } ( \\frac { \\partial \\mathbf { f } } { \\partial \\mathbf { x } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            309,
+            588,
+            340
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using this relation (1) (2) one can compute the likelihood of the model at any data point $\\mathbf { x }$ ",
+        "bbox": [
+            176,
+            340,
+            766,
+            356
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the discrete-time setting, the map from $\\mathbf { x }$ to $\\mathbf { z }$ in normalizing flows is a composition of a collection of bijective functions as $F = F _ { N } \\circ F _ { N - 1 } \\cdot \\cdot \\cdot F _ { 2 } \\circ F _ { 1 }$ . The trajectory $\\boldsymbol \\tau = \\{ \\mathbf { x } _ { 0 } , \\mathbf { x } _ { 1 } , \\cdot \\cdot \\cdot , \\mathbf { x } _ { N } \\}$ satisfies ",
+        "bbox": [
+            173,
+            361,
+            826,
+            390
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad7bed1532b7ecdf37918954c7b5f8eeb248cd24f052609e1ae35d38941b254d.jpg",
+        "text": "$$\n\\mathbf { x } _ { i } = F _ { i } ( \\mathbf { x } _ { i - 1 } , \\theta ) , \\quad \\mathbf { x } _ { i - 1 } = F _ { i } ^ { - 1 } ( \\mathbf { x } _ { i } , \\theta )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            400,
+            633,
+            419
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for all $i$ . Similar to Equation (2), based on the rule for change of variable, the log-likelihood of any data samples $\\mathbf { x } _ { 0 } = \\mathbf { x }$ can be evaluated as ",
+        "bbox": [
+            174,
+            420,
+            825,
+            448
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9e6636bde3c645375c90bc6bd5ac5163821ea947d58236f76c6ce0d7d7c76709.jpg",
+        "text": "$$\n\\log p ( \\mathbf { x } _ { 0 } ) = \\log p ( \\mathbf { x } _ { N } ) - \\sum _ { i = 1 } ^ { N } \\log | \\mathbf { d e t } ( \\frac { \\partial F _ { i } ^ { - 1 } ( \\mathbf { x } _ { i } ) } { \\partial \\mathbf { x } _ { i } } ) | .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            450,
+            669,
+            494
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Since the exact likelihood is accessible in normalizing flows, these models can be trained by minimizing the negative log-likelihood directly. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Diffusion Models: The trajectories in diffusion models are modeled by stochastic differential equations. More explicitly, the forward process is of the form ",
+        "bbox": [
+            171,
+            531,
+            821,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/823068a9212954e77abb084f2ad610a3c7cdc3cadc92701243ef9c5ba9b03899.jpg",
+        "text": "$$\n\\begin{array} { r } { d \\mathbf { x } = \\mathbf { f } ( \\mathbf { x } , t ) d t + g ( t ) d \\mathbf { w } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            564,
+            584,
+            580
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the drift term $\\textbf { f } : \\mathbb { R } ^ { d } \\times \\mathbb { R }  \\mathbb { R } ^ { d }$ is a vector-valued function, and the diffusion coefficient $g : \\mathbb { R }  \\mathbb { R }$ is a scalar function (in fact, $g$ is often chosen to be a constant). Here w denotes the standard Brownian motion. The forward process is normally a simple linear diffusion process [38, 16]. The forward trajectory $\\tau$ can be sampled using (5) initialized with the data distribution. Denote by $p _ { F }$ the resulting probability distribution over the trajectories. With a slight abuse of notation, we also use $p _ { F }$ to denote the marginal distribution of the forward process. ",
+        "bbox": [
+            173,
+            584,
+            826,
+            670
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The backward diffusion from ${ \\mathbf z } = { \\mathbf x } ( T )$ to ${ \\bf x } = { \\bf x } ( 0 )$ is of the form ",
+        "bbox": [
+            173,
+            674,
+            612,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dad8ce66fa302030306f67bb0fd3e3dbb6617c88bbc09c42884b21901dc516f1.jpg",
+        "text": "$$\nd \\mathbf { x } = [ \\mathbf { f } ( \\mathbf { x } , t ) - g ^ { 2 } ( t ) \\mathbf { s } ( \\mathbf { x } , t , \\theta ) ] d t + g ( t ) d \\mathbf { w } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            694,
+            647,
+            712
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is well-known that when s coincides with the score function $\\nabla \\log p _ { F }$ , and $\\mathbf { x } ( T )$ in the forward and backward processes share the same distribution, the distribution $p _ { B }$ induced by the backward process (6) is equal to $p _ { F }$ [1],[29, Chapter 13]. To train the score network $\\mathbf { s } ( \\mathbf { x } , t , \\theta )$ , one can use the KL divergence between $p _ { F }$ and $p _ { B }$ as an objective function to reduce the difference between $p _ { F }$ and $p _ { B }$ . When the difference is sufficiently small, $p _ { F }$ and $p _ { B }$ should have similar distribution over ${ \\bf x } ( 0 )$ , and one can then use the backward diffusion (6) to sample from the data distribution. ",
+        "bbox": [
+            173,
+            715,
+            826,
+            799
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the discrete setting, the trajectory distributions can be more explicitly written as ",
+        "bbox": [
+            173,
+            804,
+            714,
+            820
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a9fbc6773177d3522eefdf4713f35069b4a5aa131716499451d3a4a4f4b1da4a.jpg",
+        "text": "$$\np _ { F } ( \\tau ) = p _ { F } ( \\mathbf { x } _ { 0 } ) \\prod _ { i = 1 } ^ { N } p _ { F } ( \\mathbf { x } _ { i } | \\mathbf { x } _ { i - 1 } ) , \\quad p _ { B } ( \\tau ) = p _ { B } ( \\mathbf { x } _ { T } ) \\prod _ { i = 1 } ^ { N } p _ { B } ( \\mathbf { x } _ { i - 1 } | \\mathbf { x } _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            823,
+            738,
+            866
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The KL divergence between $p _ { F }$ and $p _ { B }$ can be decomposed according to this expression (7). Most diffusion models use this decomposition, and meanwhile take advantage of the simple structure of the forward process (5), to evaluate the objective function in training [39, 40, 41]. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Diffusion normalizing flow ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            428,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We next present our diffusion normalizing flow models. Similar to diffusion models, the DiffFlow models also has a forward process ",
+        "bbox": [
+            173,
+            112,
+            823,
+            141
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9825a138d6e82ce8899f1f93b88371b909e1601349aab2e070a70dc563016f92.jpg",
+        "text": "$$\n\\begin{array} { r } { d \\mathbf { x } = \\mathbf { f } ( \\mathbf { x } , t , \\theta ) d t + g ( t ) d \\mathbf { w } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            143,
+            593,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "and a backward process ",
+        "bbox": [
+            174,
+            164,
+            331,
+            178
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3114a6a69e6c193228eb0ffb6dae0927b454deb197f6a0867662167a4bb5268c.jpg",
+        "text": "$$\nd \\mathbf { x } = [ \\mathbf { f } ( \\mathbf { x } , t , \\theta ) - g ^ { 2 } ( t ) \\mathbf { s } ( \\mathbf { x } , t , \\theta ) ] d t + g ( t ) d \\mathbf { w } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            179,
+            655,
+            198
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The major difference is that, instead of being a fixed linear function as in most diffusion models, the drift term f is also learnable in DiffFlow. The forward process is initialized with the data samples at $t = 0$ and the backward process is initialized with a given noise distribution at $t = T$ . Our goal is to ensure the distribution of the backward process at time $t = 0$ is close to the real data distribution. That is, we would like the difference between $p _ { B } ( \\mathbf { x } ( 0 ) )$ and $p _ { F } ( \\mathbf { x } ( 0 ) )$ to be small. ",
+        "bbox": [
+            173,
+            200,
+            826,
+            271
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To this end, we use the KL divergence between $p _ { B } ( \\tau )$ and $p _ { F } ( \\tau )$ over the trajectory space as the training objective function. Since ",
+        "bbox": [
+            173,
+            276,
+            823,
+            304
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ea5994c719154630dbd2adb893d765af41ac2006402ecdb56e2b470170adadf7.jpg",
+        "text": "$$\nK L ( p _ { F } ( \\mathbf { x } ( t ) ) | p _ { B } ( \\mathbf { x } ( t ) ) ) \\leq K L ( p _ { F } ( \\tau ) | p _ { B } ( \\tau ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            308,
+            656,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "for any $0 \\leq t \\leq T$ by data processing inequality, small difference between $p _ { B } ( \\tau )$ and $p _ { F } ( \\tau )$ implies small difference between $\\bar { p } _ { B } ( \\mathbf { x } ( 0 ) )$ and $p _ { F } ( { \\bf \\bar { x } } ( 0 ) )$ in terms of KL divergence (more details are included in Appendix B). ",
+        "bbox": [
+            174,
+            327,
+            825,
+            369
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Implementation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            378,
+            326,
+            392
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In real implementation, we discretize the forward process (8) and the backward process (9) as ",
+        "bbox": [
+            169,
+            396,
+            785,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5acd902e774ba7c4610560567c5f6a388a6d15a83f19e5919f00aa9a6f3a5a32.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\mathbf { x } _ { i + 1 } } & { = } & { \\mathbf { x } _ { i } + \\mathbf { f } _ { i } ( \\mathbf { x } _ { i } ) \\Delta t _ { i } + g _ { i } \\delta _ { i } ^ { F } \\sqrt { \\Delta t _ { i } } } \\\\ { \\mathbf { x } _ { i } } & { = } & { \\mathbf { x } _ { i + 1 } - [ \\mathbf { f } _ { i + 1 } ( \\mathbf { x } _ { i + 1 } ) - g _ { i + 1 } ^ { 2 } \\mathbf { s } _ { i + 1 } ( \\mathbf { x } _ { i + 1 } ) ] \\Delta t _ { i } + g _ { i + 1 } \\delta _ { i } ^ { B } \\sqrt { \\Delta t _ { i } } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            259,
+            412,
+            736,
+            457
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta _ { i } ^ { F } , \\delta _ { i } ^ { B } \\sim \\mathcal { N } ( 0 , \\mathbf { I } )$ are unit Gaussian noise, $\\{ t _ { i } \\} _ { i = 0 } ^ { N }$ are the discretization time points, and $\\Delta t _ { i } = t _ { i + 1 } - t _ { i }$ is the step size at the $i$ -th step. Here we have dropped the dependence on the parameter $\\theta$ to simplify the notation. With this discretization, the KL divergence between trajectory distributions becomes ",
+        "bbox": [
+            174,
+            458,
+            823,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e7e439ece5909b3848725434e84dcec83511c72210f7b9bb823330069a1c0c47.jpg",
+        "text": "$$\n\\small \\mathrm { K } L ( p _ { F } ( \\tau ) | p _ { B } ( \\tau ) ) = \\underbrace { \\mathbb { E } _ { \\tau \\sim p _ { F } } [ \\log p _ { F } ( \\mathbf { x } _ { 0 } ) ] } _ { L _ { 0 } } + \\underbrace { \\mathbb { E } _ { \\tau \\sim p _ { F } } [ - \\log p _ { B } ( \\mathbf { x } _ { N } ) ] } _ { L _ { N } } + \\underbrace { \\sum _ { i = 1 } ^ { N - 1 } \\mathbb { E } _ { \\tau \\sim p _ { F } } [ \\log \\frac { p _ { F } ( \\mathbf { x } _ { i } | \\mathbf { x } _ { i - 1 } ) } { p _ { B } ( \\mathbf { x } _ { i - 1 } | \\mathbf { x } _ { i } ) } ] } _ { L _ { i } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            513,
+            826,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The term $L _ { 0 }$ in (13) is a constant determined by entropy of the dataset as ",
+        "bbox": [
+            174,
+            590,
+            651,
+            606
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65a187663b125f69167997e885bc91b1d83db433cbed5b42f90065487dad6f8b.jpg",
+        "text": "$$\n\\underset { \\tau \\sim p _ { F } } { \\mathbb { E } } [ \\log p _ { F } ( \\mathbf { x } _ { 0 } ) ] = \\underset { \\mathbf { x } _ { 0 } \\sim p _ { F } } { \\mathbb { E } } [ \\log p _ { F } ( \\mathbf { x } _ { 0 } ) ] = : - H ( p _ { F } ( x ( 0 ) ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            608,
+            696,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The term $L _ { N }$ is easy to calculate since $p _ { B } ( x _ { N } )$ is a simple distribution, typically standard Gaussian distribution. ",
+        "bbox": [
+            173,
+            636,
+            825,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To evaluate $L _ { 1 : N - 1 }$ , we estimate it over sampled trajectory from the forward process $p _ { F }$ . For a given trajectory $\\tau$ sampled from $p _ { F } ( \\tau )$ , we need to calculate $p _ { B } ( \\tau )$ along the same trajectory. To this end, a specific group of $\\{ \\delta _ { i } ^ { B } \\}$ is chosen such that the same trajectory can be reconstructed from the backward process. Thus, $\\delta _ { i } ^ { B }$ satisfies ",
+        "bbox": [
+            173,
+            670,
+            825,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a6e2de03b3262cdce1bda56eb838a428c1565f08b8900eb812ac5c45815fafd.jpg",
+        "text": "$$\n\\delta _ { i } ^ { B } ( \\tau ) = \\frac { 1 } { g _ { i + 1 } \\sqrt { \\Delta t } } \\Bigg [ \\mathbf { x } _ { i } - \\mathbf { x } _ { i + 1 } + [ \\mathbf { f } _ { i + 1 } ( \\mathbf { x } _ { i + 1 } ) - g _ { i + 1 } ^ { 2 } \\mathbf { s } _ { i + 1 } ( \\mathbf { x } _ { i + 1 } ) ] \\Delta t \\Bigg ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            731,
+            733,
+            772
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since $\\delta _ { i } ^ { B }$ is a Gaussian noise, the negative log-likelihood term $p _ { B } \\big ( \\mathbf { x } _ { i } \\big | \\mathbf { x } _ { i + 1 } \\big )$ is equal to $\\textstyle \\frac { 1 } { 2 } ( \\delta _ { i } ^ { B } ( \\tau ) ) ^ { 2 }$ after dropping constants (see more details in Appendix B). In view of the fact that the expectation of $\\begin{array} { r } { \\sum _ { i } \\frac { 1 } { 2 } \\bar { ( \\delta _ { i } ^ { F } ( \\tau ) ) } ^ { 2 } } \\end{array}$ remains a constant, minimizing Equation (13) is equivalent to minimizing the following loss (see Appendix $\\textrm { C }$ for the full derivation): ",
+        "bbox": [
+            173,
+            776,
+            825,
+            833
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7846120b7998d8b629de3d08584c8f9b76607d3b9e7143a4017a902ac998e81.jpg",
+        "text": "$$\nL : = \\mathbb { E } _ { \\tau \\sim p _ { F } } [ - \\log p _ { B } ( \\mathbf { x } _ { N } ) + \\sum _ { i } \\frac { 1 } { 2 } ( \\delta _ { i } ^ { B } ( \\tau ) ) ^ { 2 } ] = \\mathbb { E } _ { \\delta ^ { F } ; \\mathbf { x } _ { 0 } \\sim p _ { 0 } } [ - \\log p _ { B } ( \\mathbf { x } _ { N } ) + \\sum _ { i } \\frac { 1 } { 2 } ( \\delta _ { i } ^ { B } ( \\tau ) ) ^ { 2 } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            835,
+            808,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the last equality is based on a reparameterization trick [21]. We can minimize the loss in Equation (15) with Monto Carlo gradient estimation as in Algorithm 1. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Training ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            320,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a6b567f1a9f042258d051c4cc2ec861dfff2a8aa9f408de335dea534f88a1fce.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>repeat</td></tr><tr><td>Xq ~ Real data distribution EN~N(0,I)</td></tr><tr><td></td></tr><tr><td>Sample: T = {xi}o based on :N</td></tr><tr><td>Gradient descent step Vθ[-log pB(xN) +∑i 1(δB(τ))²]</td></tr><tr><td>until converged</td></tr></table>",
+        "bbox": [
+            176,
+            108,
+            612,
+            213
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Stochastic Adjoint Algorithm for DiffFlow ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            253,
+            545,
+            268
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Input: Forward trajectory $\\{ \\mathbf { x } _ { i } \\} _ { i = 0 } ^ { N }$   \n2: $\\begin{array} { r } { \\frac { \\partial L } { \\partial \\mathbf { x } _ { N } } = \\frac { 1 } { 2 } \\frac { \\partial ( \\delta _ { N } ^ { B } ( \\tau ) ) ^ { 2 } } { \\partial \\mathbf { x } _ { N } } - \\frac { \\partial \\log p _ { B } ( \\mathbf { x } _ { N } ) } { \\mathbf { x } _ { N } } } \\end{array}$   \n3: $\\begin{array} { r } { \\frac { \\partial L } { \\partial \\theta } = 0 } \\end{array}$   \n4: for $i = N , N - 1 , \\cdots , 1 \\mathbf { d } \\mathbf { c }$   \n5: $\\begin{array} { r } { \\frac { \\partial L } { \\partial \\mathbf { x } _ { i - 1 } } = \\bigl ( \\frac { \\partial L } { \\partial \\mathbf { x } _ { i } } + \\frac { 1 } { 2 } \\frac { \\partial ( \\delta _ { i } ^ { B } ( \\tau ) ) ^ { 2 } } { \\partial \\mathbf { x } _ { i } } \\bigr ) \\frac { \\partial \\mathbf { x } _ { i } } { \\partial \\mathbf { x } _ { i - 1 } } + \\frac { 1 } { 2 } \\frac { \\partial ( \\delta _ { i } ^ { B } ( \\tau ) ) ^ { 2 } } { \\partial \\mathbf { x } _ { i - 1 } } } \\end{array}$   \n6: $\\begin{array} { r } { \\frac { \\partial L } { \\partial \\theta } + = \\frac { 1 } { 2 } \\frac { \\partial ( \\delta _ { i } ^ { B } ( \\tau ) ) ^ { 2 } } { \\partial \\theta } + \\big ( \\frac { \\partial L } { \\partial \\mathbf { x } _ { i } } + \\frac { 1 } { 2 } \\frac { \\partial ( \\delta _ { i } ^ { B } ( \\tau ) ) ^ { 2 } } { \\partial \\mathbf { x } _ { i } } \\big ) \\frac { \\partial \\mathbf { x } _ { i } } { \\partial \\theta } } \\end{array}$   \n7: end for ",
+        "bbox": [
+            179,
+            273,
+            540,
+            396
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/49cd013ef89cc1946014c84d7ba2aee62ed71f6502db8b0ece59afa8b7288b38.jpg",
+        "image_caption": [
+            "Figure 2: Gradient Flowchart. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            549,
+            232,
+            843,
+            388
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Stochastic Adjoint method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            445,
+            398,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One challenge in training DiffFlow is memory consumption. When a naive backpropagation strategy is used, the memory consumption explodes quickly. Indeed, differentiating through the operations of the forward pass requires unrolling networks $N$ times and caching all network intermediate values for every step, which prevents this naive implementation of DiffFlow from being applied in high dimensional applications. Inspired by the adjoint method in Neural ODE [4], we propose the adjoint variable $\\frac { \\partial L } { \\partial \\mathbf { x } _ { i } }$ and a stochastic adjoint algorithm that allows training the DiffFlow model with reduced memory consumption. In this adjoint method, we cache intermediate states $\\mathbf { x } _ { i }$ and, based on these intermediate states, reproduce the whole process, including $\\delta _ { i } ^ { F } , \\delta _ { i } ^ { B }$ as well as $f _ { i } , s _ { i }$ exactly. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We note another similar approach [26] of training SDEs caches random noise dw and further takes advantage of the pseudo-random generator to save memory for the intermediate noises, resulting in constant memory consumption However, the approach can not reproduce exact trajectories due to time discretization error and requires extra computation to recover $d \\mathbf { w }$ from the pseudo-random generator. We found that in our image experiments in Section 4, the cached $\\left\\{ { { \\bf { x } } _ { i } } \\right\\}$ consumes only about $\\bar { 2 } \\%$ memory out of all the memory being used during training. Due to the accuracy and acceptable memory overhead, the introduced stochastic adjoint approach is a better choice for DiffFlow. We summarize the method in Algorithm 2 and Figure 2. We also include the PyTorch [34] implementation in the supplemental material. ",
+        "bbox": [
+            173,
+            593,
+            825,
+            718
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Time discretization and progressive training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            521,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We propose two time discretization schemes for training DiffFlow: fixed timestamps $L _ { \\beta }$ and flexible timestamps $\\hat { L } _ { \\beta }$ . For fixed timestamps, the time interval $[ 0 , T ]$ is discretized with fixed schedule $\\begin{array} { r } { t _ { i } = ( \\frac { i } { N } ) ^ { \\beta } T } \\end{array}$ . With such fixed time discretization over batches, we denote the loss function as $L _ { \\beta }$ . Empirically, we found $\\beta = 0 . 9$ works well. This choice of $\\beta$ increases stepsize $\\Delta t _ { i }$ when the forward process approaches $\\mathbf { z } = \\mathbf { x } _ { N }$ and provides higher resolution when the backward process is close to $\\mathbf { x } _ { \\mathrm { 0 } }$ . We found such discretization generates samples with good quality and high fidelity details. The choice of polynomial function is arbitrary; other functions of similar sharps may work as well. ",
+        "bbox": [
+            174,
+            756,
+            624,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/f6accf23b17a9bda034232201a1c3f3a701629c30d8d8cea68513827ba867368.jpg",
+        "image_caption": [
+            "Figure 3: $\\Delta t _ { i }$ of $L _ { \\beta }$ and $\\hat { L } _ { \\beta }$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            638,
+            761,
+            823,
+            905
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the flexiable timestamps scheme, we train different batches with different time discretization points. Specifically, $t _ { i }$ is sampled uniformly from the interval $\\begin{array} { r } { \\big [ \\big ( \\frac { i - 1 } { N - 1 } \\big ) ^ { \\beta } T , ( \\frac { i } { N - 1 } ) ^ { \\beta } T \\big ] } \\end{array}$ for each batch. We denote the training objective function with such random time discretization as $\\hat { L } _ { \\beta }$ . We empirically found such implementation results in lower loss and better stability when we conduct progressive training where we increase $N$ gradually as training progresses. In progressive training, we refine the forward and backward processes as $N$ increase. This training scheme can significantly save training time compared with the other method that uses a fixed large $N$ during the whole process. Empirically, we found that progressive training can speed up the training up to 16 times. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To understand why such random time discretization scheme is more stable, we hypothesis that this choice encourages a smoother f , s since it seeks functions f , s to reduce objective loss under different sets of $\\{ t _ { i } \\}$ instead of a specific $\\{ t _ { i } \\}$ . We illustrate fixed timestamps in $L _ { \\beta }$ and a realization of random discretization in $\\hat { L } _ { \\beta }$ in Figure 3 with $\\beta = 0 . 9$ . ",
+        "bbox": [
+            173,
+            215,
+            825,
+            275
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 Learnable forward process ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            286,
+            400,
+            300
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9bab29808914586ba48762ad4e5e868d7e7e9cd322658ed2e5c8c30bb05a3df0.jpg",
+        "image_caption": [
+            "Figure 4: Illustration of forwarding trajectories of DiffFlow, DDPM, and FFJORD. Each row shows two trajectories of transforming data distributions, four rings, and Olympics rings, to a base distribution. Different modes of densities are in different colors. Though FFJORD adjusts forward process based on data, its bijective property prevents the approach from expanding density support to the whole space. DDPM can transform data distributions into Gaussian distribution but a datainvariant way of adding noise can corrupt the details of densities, e.g., the densities at the intersections of the rings. DiffFlow not only transforms data into base distribution but also keeps the topological information of the original datasets. Points from the same ring are transformed into continental plates instead of being distributed randomly. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            311,
+            813,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The forward process not only is responsible for driving data into latent space, but also provides enough supervised information to learning backward process. Thanks to bijective property, NFs can reconstruct data exactly but there is no guarantee that it can reach the standard Gaussian. At the other extreme, Denoising diffusion probabilistic models (DDPM) [17] adopt a data-invariant forward diffusing schema, ensuring that $\\mathbf { x } _ { N }$ is Gaussian. DDPM can even reach Gaussian in one step with $N = 1$ , which output noise disregarding data samples. However, backward process will be difficult to learn if data is destroyed in one step. Therefore, DDPM adds noise slowly and often needs more than one thousand steps for diffusion. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            742
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The forward module of DiffFlow is a combination of normalizing flow and diffusion models. We show the comparision in fitting toy 2D datasets in Figure 4. We are especially interested in data with well-separated modes and sharp density boundaries. Those properties are believed to appear in various datasets. As stated by manifold hypothesis [36], real-world data lie on low-dimensional manifold [28] embedded in a high-dimensional space. To construct the distributions in Figure 4, we rotate the 1-d Gaussian distribution $\\mathcal { N } ( 1 , 0 . 0 0 1 ^ { 2 } )$ around the center to form a ring and copy the rings to different locations. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a bijective model, FFJORD [14] struggles to diffuse the concentrated density mass into a Gaussian distribution. DiffFlow overcomes expressivity limitations of the bijective constraint by adding noise. As added noise shrinks to zero, the DiffFlow has no stochasticity and degrades to a flow-based model. Based on this fact, we present the following theorem with proof in Appendix A. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. As diffusion coefficients $g _ { i } \\to 0$ , DiffFlow reduces to Normalizing Flow. Moreover, minimizing the objective function in Equation (13) is equivalent to minimizing the negative loglikelihood as in Equation (4). ",
+        "bbox": [
+            174,
+            90,
+            823,
+            133
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DDPM [17] uses a fixed noising transformation. Due to the data-invariant approach $p ( \\mathbf { x } _ { T } | \\mathbf { x } _ { 0 } ) =$ $p ( \\mathbf { x } _ { T } )$ , points are diffused in the same way even though they may appear in different modes or different datasets. We observe that sharp details are destroyed quickly in DDPM diffusion, such as the intersection regions between rings. However, with the help of learnable transformation, DiffFlow diffuses in a much efficient way. The data-dependent approach shows different diffusion strategies on different modes and different datasets. Meanwhile, similar to NFs, it keeps some topological information for learning backward processes. We include more details about the toy sample in Section 4. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            262,
+            313,
+            280
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the performance of DiffFlow in sample quality and likelihood on test data. To evaluate the likelihood, we adopt the marginals distribution equivalent SDEs ",
+        "bbox": [
+            173,
+            286,
+            821,
+            315
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/996c122a62ae1b645b68be15f935ea21b92107941c40ad16ce39c51c97ce60c7.jpg",
+        "text": "$$\nd \\mathbf { x } = [ \\mathbf { f } ( \\mathbf { x } , t , \\theta ) - \\frac { 1 + \\lambda ^ { 2 } } { 2 } g ^ { 2 } ( t ) \\mathbf { s } ( \\mathbf { x } , t , \\theta ) ] d t + \\lambda g ( t ) d \\mathbf { w } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            321,
+            683,
+            354
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "with $\\lambda \\geq 0$ (Proof see Appendix $\\mathrm { H }$ ). When $\\lambda = 0$ , it reduces to probability ODE [41]. The ODE provides an efficient way to evaluate the density and negative log-likelihood. For any $0 \\leq \\lambda \\leq 1$ , the above SDE can be used for sampling. Empirically, we found $\\lambda = 1$ has the best performance. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            402
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Synthetic 2D examples ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            370,
+            426
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare the performance of DiffFlow and existing diffusion models and NFs on estimating the density of 2-dimensional data. We compare the forward trajectories of DiffFlow, DDPM [17] and FFJORD $[ 1 4 ] ^ { 1 }$ in Figure 4 and its sampling performance in Figure 5. To make a fair comparison, we build models with comparable network sizes, around 90k learnable parameters. We include more training and model details in Appendix E. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All three algorithms have good performance on datasets whose underlying distribution has smooth density, such as 2 spirals. However, when we shrink the support of samples or add complex patterns, performance varies significantly. We observe that FFJORD leaks many samples out of the main modes and datasets with complex details and sharp density exacerbates the disadvantage. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DDPM has higher sample quality but blurs density details, such as intersections between rings, areas around leaves of the Fractal tree, and boxes in Sierpinski Carpet. The performance is within ´ expectation given that details are easy to be destroyed and ignored with the data-invariant noising schema. On the less sharp dataset, such as 2 Spirals and Checkerboard, its samples align with data almost perfectly. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            637
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DiffFlow produces the best samples (according to a human observer). We owe the performance to the flexible noising forward process. As illustrated in Figure 4, DiffFlow provides more clues and retains detailed patterns longer for learning its reverse process. We also report a comprehensive comparison of the negative likelihood and more analysis in Appendix E. DiffFlow has a much lower negative likelihood, especially on sharp datasets. ",
+        "bbox": [
+            174,
+            643,
+            825,
+            713
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Density estimation on real data ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            715,
+            429,
+            729
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We perform density estimation experiments on five tabular datasets [33]. We employ the probability flow to evaluate the negative log-likelihood. We find that our algorithm has better performance in most datasets than most approaches trained by directly minimizing negative log-likelihood, including NFs and autoregressive models. DiffFlow outperforms FFJORD by a wide margin on all datasets except HEPMASS. Compared with autoregressive models, it excels NAF [18] on all but GAS. Those models require $\\mathcal O ( d )$ computations to sample from. Meanwhile, DiffFlow is quite effective in achieving such performance with MLPs that have less than 5 layers. We include more details in Appendix F ",
+        "bbox": [
+            174,
+            734,
+            825,
+            832
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Image generation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            334,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we report the quantitative comparison and qualitative performance of our method and existing methods on common image datasets, MNIST [24] and CIFAR-10 [23]. We use the same unconstrained U-net style model as used successfully by Ho et al. [17] for drift and score network. We reduce the network size to half of the original DDPM network so that the total number of trainable parameters of DiffFlow and DDPM are comparable. We use small $N = 1 0$ at the beginning of training and slowly increase to large $N$ as training proceeds. The schedule of $N$ reduces the training time greatly compared with using large $N$ all the time. We use constants $g _ { i } = 1$ and $T = 0 . 0 5$ for MNIST and CIFAR10, and $N = 3 0$ for sampling MNIST data and $N = 1 0 0$ for sampling CIFAR10. As it is reported by Jolicoeur-Martineau et al. [19], adding noise at the last step will significantly lower sampling quality, we use one single denoising step at the end of sampling with Tweedie’s formula [10]. ",
+        "bbox": [
+            176,
+            859,
+            825,
+            887
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/3f94f1fa1b4d8a3e74e2e06aadebd20e9a09d53e11aa21daa4ec58111acd8c97.jpg",
+        "image_caption": [
+            "Figure 5: Samples from DiffFlow, DDPM and FFJORD on 2-D datasets. All three models have reasonable performance on datasets that have smooth underlying distributions. But only DiffFlow is capable to capture complex patterns and provides sharp samples when dealing with more challenging datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            87,
+            774,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c5e8f1e56409d254f46f703a24c6134d22d115c98100d6efc0f4ef750717090e.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Average negative log-likelihood (in nats) on tabular datasets [33] for density estimation (lower is better). "
+        ],
+        "table_body": "<table><tr><td>Dataset</td><td>POWER</td><td>GAS</td><td>HEPMASS</td><td>MINIBOONE</td><td>BSDS300</td></tr><tr><td>RealNVP [8]</td><td>-0.17</td><td>-8.33</td><td>18.71</td><td>13.55</td><td>-153.28</td></tr><tr><td>FFJORD[14]</td><td>-0.46</td><td>-8.59</td><td>14.92</td><td>10.43</td><td>-157.40</td></tr><tr><td>DiffFlow (ODE)</td><td>-1.04</td><td>-10.45</td><td>15.04</td><td>8.06</td><td>-157.80</td></tr><tr><td>MADE [11]</td><td>3.08</td><td>-3.56</td><td>20.98</td><td>15.59</td><td>-148.85</td></tr><tr><td>MAF [33]</td><td>-0.24</td><td>-10.08</td><td>17.70</td><td>11.75</td><td>-155.69</td></tr><tr><td>TAN [31]</td><td>-0.48</td><td>-11.19</td><td>15.12</td><td>11.01</td><td>-157.03</td></tr><tr><td>NAF[18]</td><td>-0.62</td><td>-11.96</td><td>15.09</td><td>8.86</td><td>-157.73</td></tr></table>",
+        "bbox": [
+            218,
+            444,
+            779,
+            575
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            631,
+            825,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We report negative log-likelihood (NLL) in bits per dimension or negative ELBO if NLL is unavailable. On MNIST, we achieve competitive performance on NLL as in Table 2. We show the uncurated samples from DiffFlow in Figure 6 and Figure 7. On CIFAR-10, DiffFlow also achieves competitive NLL performance as shown in Table 3. DiffFlow performs better than normalizing flows and DDPM models, but is slightly worse than $\\mathrm { { D D P M + + } }$ (sub, deep, sub-vp) and Improved DDPM. However, these approaches conduct multiple architectural improvements and use much deeper and wider networks. We also report the popular sample metric, Fenchel Inception Distance (FID) [15]. DiffFLow has a lower FID score than normalizing flows and has competitive performance compared with DDPM trained with unweighted variational bounds, DDPM and Improved DDPM. It is worse than DDPM trained with reweighted loss, DDPM $( L _ { s } )$ , DDPM cont, and DDPM $^ { + + }$ [17, 41, 30]. Besides, sampling quality with different sampling steps $N$ are compared in Table $4 ^ { 2 }$ . The advantage of DiffFlow is clear when we compare relative FIDs degeneracy ratio with $N = 1 0 0$ respectively. DiffFlow is able to retain better sampling quality when decreasing $N$ . Full details on architectures used, training setup details, and more samples can be found in Appendix G. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/be1945b782ae6b79cfd0a04a97a29817b733b952e4b732ca74ab132fb156609b.jpg",
+        "image_caption": [
+            "Figure 6: MNIST Samples "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            397,
+            111,
+            568,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/01048da17f52aac8e24892579312407936c41e045fdfd01c8de1bfa6baaa21f0.jpg",
+        "table_caption": [
+            "Table 2: NLL on MNIST "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>NLL (↓)</td></tr><tr><td>RealNVP [8]</td><td>1.06</td></tr><tr><td>Glow [20]</td><td>1.05</td></tr><tr><td>FFJORD[14]</td><td>0.99</td></tr><tr><td>ResFlow [5]</td><td>0.97</td></tr><tr><td>DiffFlow</td><td>0.93</td></tr></table>",
+        "bbox": [
+            178,
+            127,
+            364,
+            227
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/c3bcfde04a840e25a86920a1df038b19101b23ae5c6fe2cb3f02e90c5c1b53ff.jpg",
+        "image_caption": [
+            "Figure 7: CIFAR10 Samples "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            622,
+            111,
+            792,
+            242
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            268,
+            825,
+            325
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/7afda307b57cc8ab5483e2503b761a5cefff09540b50d59ba6951d6bce27657a.jpg",
+        "table_caption": [
+            "Table 3: NLLs and FIDs on CIFAR-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>NLL(↓)</td><td>FID (↓</td></tr><tr><td>RealNVP[8]</td><td>3.49</td><td rowspan=\"4\">46.90</td></tr><tr><td>Glow [20]</td><td>3.35</td></tr><tr><td>Flow++[16]</td><td>3.29 =</td></tr><tr><td>FFJORD [14]</td><td>3.40 1</td></tr><tr><td>ResFlow[5]</td><td>3.28</td><td rowspan=\"9\">46.37 13.51 3.17</td></tr><tr><td>DDPM(L)[17]</td><td>≤3.70</td></tr><tr><td>DDPM(Ls)[17]</td><td>≤3.75</td></tr><tr><td>DDPM(Ls)(ODE) [41]</td><td>3.28 3.37 3.56</td></tr><tr><td>DDPM cont. (sub-VP) [41]</td><td>3.05</td></tr><tr><td>DDPM++ (sub-VP) [41]</td><td>3.02 3.16 2.99</td></tr><tr><td>DDPM++ (deep,sub-VP)[41]</td><td>2.94</td></tr><tr><td>Improved DDPM [30] ≤2.94</td><td>11.47</td></tr><tr><td>≤3.71</td><td>13.87</td></tr><tr><td>DiffFlow (L β) DiffFlow (L β)</td><td></td><td>13.43</td></tr><tr><td></td><td>≤3.67</td><td></td></tr><tr><td>DiffFlow (L β, ODE)</td><td>3.04</td><td>14.14</td></tr></table>",
+        "bbox": [
+            179,
+            354,
+            519,
+            595
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/9f870ffa7eb17457f88e8be076c16fd8cca6d138221e609f79214d31e8efcd2d.jpg",
+        "table_caption": [
+            "Table 4: FIDs with various $N$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>N DiffFlowDDPM(L)DDPM(Ls) DDIM</td><td colspan=\"2\"></td></tr><tr><td>5 28.31</td><td>373.51</td><td>370.23 44.69</td></tr><tr><td>10 22.56</td><td>364.64</td><td>365.12 18.62</td></tr><tr><td>20 17.98</td><td>138.84 135.44</td><td>10.89</td></tr><tr><td>50 14.72</td><td>47.12</td><td>34.56 7.01</td></tr><tr><td>100 13.43</td><td>22.23</td><td>10.04 5.63</td></tr></table>",
+        "bbox": [
+            524,
+            359,
+            820,
+            460
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/769c9f1ba6d5a5b3a995da3f79d177ed343e7a49f9b4870ca831b8b07358684b.jpg",
+        "table_caption": [
+            "Table 5: Relative FIDs degeneracy ratio "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">N DiffFlowDDPM(L) DDPM(Ls)DDIM</td></tr><tr><td>5 2.12 16.80</td><td>37.02 7.94</td></tr><tr><td>10 1.68 16.40</td><td>36.12 3.31</td></tr><tr><td>20 1.34 6.24</td><td>13.54 1.93</td></tr><tr><td>50 1.10 2.12</td><td>3.45 1.24</td></tr><tr><td>100 1.0 1.0</td><td>1.0 1.0</td></tr></table>",
+        "bbox": [
+            522,
+            489,
+            818,
+            590
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            606,
+            318,
+            622
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Normalizing flows [8, 35] have recently received lots of attention due to its exact density evaluation and ability to model high dimensional data [20, 9]. However, the bijective requirement poses limitations on modeling complex data, both empirically and theoretically [42, 6]. Some works attempt to relax the bijective requirement; discretely index flows [9] use domain partitioning with only locally invertible functions. Continuously indexed flows [6] extend discretely indexing to a continuously indexing approach. As pointed out in Stochastic Normalizing Flows (SNF) [42], stochasticity can effectively improve the expressive power of the flow-based model in low dimension applications. The architecture used in SNF, which requires known underlying energy models, presents challenges for density learning tasks; SNF is designed for sampling from unnormalized probability distribution instead of density estimation. Besides, even with ideal networks and infinite amount of data, due to the predefined stochstic block being used, SNF cannot find models with aligned forward and backward distribution as DiffFlow. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "When it comes to stochastic trajectories, minimizing the distance between trajectory distributions has been explored in existing works. Denoising diffusion model [38] uses a fixed linear forward diffusion schema and reparameterizes the KL divergence such that minimizing loss is possible without computing whole trajectories. Diffusion models essentially corrupt real data iteratively and learn to remove the noise when sampling. Recently, Diffusion models have shown the capability to model high-dimensional data distribution, such as images [17, 40], shapes [3], text-to-speech [22]. Lately, the Score-based model [41] provides a unified framework for score-matching methods and diffusion models based on stochastic calculus. The diffusion processes and sampling processes can be viewed as forwarding SDE and reverse-time SDE. Thanks to the linear forward SDE being used in DDPM, the forward marginal distributions have a closed-form and are suitable for training score functions on large-scale datasets. Also, due to the reliance on fixed linear forward process, it takes thousands of steps to diffuse data and generate samples. DiffFlow considers general SDEs and nosing and sampling are more efficient. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            202
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Existing Neural SDE approaches suffer from poor scaling properties. Backpropagating through solver [12] has a linear memory complexity with the number of steps. The pathwise approach [13] scales poorly in computation complexity. Our stochastic adjoint approach shares a similar spirit with SDE adjoint sensitivity [25]. The choice of caching noise requires high resolution of time discretization and prevents the approach from scaling to high dimension applications. By caching the trajectory states, DiffFlow can use a coarser discretization and deploy on larger dimension problems and problems with more challenging densities. The additional memory footprint is negligible compared with the other network memory consumption in DiffFlow. ",
+        "bbox": [
+            174,
+            208,
+            823,
+            319
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            332,
+            302,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "While DiffFlow gains more flexibility due to the introduction of a learnable forward process, it loses the analytical form for $p _ { F } ( \\mathbf { x } _ { t } | \\mathbf { x } _ { 0 } )$ and thus the training less efficient compared with score-based loss [41]. Training DiffFlow relies on backpropagation through trajectories and is thus significantly slower than diffusion models with affine drift. Empirically, we found DiffFlow is about 6 times slower than DDPM in 2d toy examples, 55 times in MNIST, and 160 times in CIFAR10 without progressive training in Section 3.3. Though the stochastic adjoint method and progressive training help save memory footprint and reduce training time, the training of DiffFlow is still more expensive than DDPM and its variants. On the other hand, compared with normalizing flows, the extra noise in DiffFlow boosts the expressive power of the model with little extra cost. Though DiffFlow trained based on SDE, its marginal distribution equivalent ODE 2 shows much better performance than its counterpart trained with ODE [14]. It is interesting to investigate, both empirically and theoretically, the benefit in terms of expressiveness improvement caused by stochastic noise for training normalizing flows. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            547,
+            307,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We proposed a novel algorithm, the diffusion normalizing flow (DiffFlow), for generative modeling and density estimation. The proposed method extends both the normalizing flow models and the diffusion models. Our DiffFlow algorithm has two trainable diffusion processes modeled by neural SDEs, one forward and one backward. These two SDEs are trained jointly by minimizing the KL divergence between them. Compared with most normalizing flow models, the added noise in DiffFlow relaxes the bijectivity condition in deterministic flow-based models and improves their expressive power. Compared with diffusion models, DiffFlow learns a more flexible forward diffusion that is able to transform data into noise more effectively and adaptively. In our experiments, we observed that DiffFlow is able to model distributions with complex details that are not captured by representative normalizing flow models and diffusion models, including FFJORD, DDPM. For CIFAR10 dataset, our DiffFlow method has worse performance than DDPM in terms of FID score. We believe our DiffFlow algorithm can be improved further by using different neural network architectures, different time discretizing method and different choices of time interval. We plan to explore these options in the near future. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            765
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our algorithm is able to learn the distribution of high-dimensional data and then generate new samples from it. Like many other generative modeling algorithms, it may be potentially used to generate misleading data such as fake images or videos. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            814
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            827,
+            338,
+            843
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank the anonymous reviewers for useful comments. This work is supported in part by grants NSF CAREER ECCS-1942523 and NSF CCF-2008513. ",
+        "bbox": [
+            174,
+            852,
+            823,
+            878
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            267,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Anderson, B. D. Reverse-time diffusion equation models. Stochastic Processes and their Applications, 12 (3):313–326, 1982.   \n[2] Bordes, F., Honari, S., and Vincent, P. Learning to generate samples from noise through infusion training. arXiv preprint arXiv:1703.06975, 2017.   \n[3] Cai, R., Yang, G., Averbuch-Elor, H., Hao, Z., Belongie, S., Snavely, N., and Hariharan, B. Learning gradient fields for shape generation. In Proceedings of the European Conference on Computer Vision (ECCV), 2020.   \n[4] Chen, R. T., Rubanova, Y., Bettencourt, J., and Duvenaud, D. Neural ordinary differential equations. arXiv preprint arXiv:1806.07366, 2018.   \n[5] Chen, R. T. Q., Behrmann, J., Duvenaud, D., and Jacobsen, J. Residual flows for invertible generative modeling. In Advances in Neural Information Processing Systems, 2019.   \n[6] Cornish, R., Caterini, A., Deligiannidis, G., and Doucet, A. Relaxing bijectivity constraints with continuously indexed normalising flows. In International Conference on Machine Learning, pp. 2133–2143. PMLR, 2020.   \n[7] Deng, Y., Bakhtin, A., Ott, M., Szlam, A., and Ranzato, M. Residual energy-based models for text generation. arXiv preprint arXiv:2004.11714, 2020.   \n[8] Dinh, L., Sohl-Dickstein, J., and Bengio, S. Density estimation using real nvp. arXiv preprint arXiv:1605.08803, 2016.   \n[9] Dinh, L., Sohl-Dickstein, J., Larochelle, H., and Pascanu, R. A rad approach to deep mixture models. arXiv preprint arXiv:1903.07714, 2019.   \n[10] Efron, B. Tweedie’s formula and selection bias. Journal of the American Statistical Association, 106(496): 1602–1614, 2011.   \n[11] Germain, M., Gregor, K., Murray, I., and Larochelle, H. Made: Masked autoencoder for distribution estimation. In International Conference on Machine Learning, pp. 881–889. PMLR, 2015.   \n[12] Giles, M. and Glasserman, P. Smoking adjoints: Fast monte carlo greeks. Risk, 19(1):88–92, 2006.   \n[13] Gobet, E. and Munos, R. Sensitivity analysis using itô–malliavin calculus and martingales, and application to stochastic optimal control. SIAM Journal on control and optimization, 43(5):1676–1713, 2005.   \n[14] Grathwohl, W., Chen, R. T., Bettencourt, J., Sutskever, I., and Duvenaud, D. Ffjord: Free-form continuous dynamics for scalable reversible generative models. arXiv preprint arXiv:1810.01367, 2018.   \n[15] Heusel, M., Ramsauer, H., Unterthiner, T., Nessler, B., and Hochreiter, S. Gans trained by a two time-scale update rule converge to a local nash equilibrium. arXiv preprint arXiv:1706.08500, 2017.   \n[16] Ho, J., Chen, X., Srinivas, A., Duan, Y., and Abbeel, P. Flow $+ +$ : Improving flow-based generative models with variational dequantization and architecture design. In International Conference on Machine Learning, pp. 2722–2730. PMLR, 2019.   \n[17] Ho, J., Jain, A., and Abbeel, P. Denoising diffusion probabilistic models. arXiv preprint arXiv:2006.11239, 2020.   \n[18] Huang, C.-W., Krueger, D., Lacoste, A., and Courville, A. Neural autoregressive flows. In International Conference on Machine Learning, pp. 2078–2087. PMLR, 2018.   \n[19] Jolicoeur-Martineau, A., Piché-Taillefer, R., Combes, R. T. d., and Mitliagkas, I. Adversarial score matching and improved sampling for image generation. arXiv preprint arXiv:2009.05475, 2020.   \n[20] Kingma, D. P. and Dhariwal, P. Glow: Generative flow with invertible 1x1 convolutions. arXiv preprint arXiv:1807.03039, 2018.   \n[21] Kingma, D. P. and Welling, M. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.   \n[22] Kong, Z., Ping, W., Huang, J., Zhao, K., and Catanzaro, B. Diffwave: A versatile diffusion model for audio synthesis. arXiv preprint arXiv:2009.09761, 2020.   \n[23] Krizhevsky, A., Hinton, G., et al. Learning multiple layers of features from tiny images. 2009.   \n[24] LeCun, Y. The mnist database of handwritten digits. http://yann. lecun. com/exdb/mnist/, 1998.   \n[25] Li, X., Wong, T.-K. L., Chen, R. T., and Duvenaud, D. Scalable gradients for stochastic differential equations. In International Conference on Artificial Intelligence and Statistics, pp. 3870–3882. PMLR, 2020.   \n[26] Li, X., Wong, T.-K. L., Chen, R. T., and Duvenaud, D. Scalable gradients for stochastic differential equations. In International Conference on Artificial Intelligence and Statistics, pp. 3870–3882. PMLR, 2020.   \n[27] Meng, C., Song, J., Song, Y., Zhao, S., and Ermon, S. Improved autoregressive modeling with distribution smoothing. arXiv preprint arXiv:2103.15089, 2021.   \n[28] Narayanan, H. and Mitter, S. Sample complexity of testing the manifold hypothesis. In Proceedings of the 23rd International Conference on Neural Information Processing Systems-Volume 2, pp. 1786–1794, 2010.   \n[29] Nelson, E. Dynamical theories of Brownian motion. Princeton university press, 2020.   \n[30] Nichol, A. and Dhariwal, P. Improved denoising diffusion probabilistic models. arXiv preprint arXiv:2102.09672, 2021.   \n[31] Oliva, J., Dubey, A., Zaheer, M., Poczos, B., Salakhutdinov, R., Xing, E., and Schneider, J. Transformation autoregressive networks. In International Conference on Machine Learning, pp. 3898–3907. PMLR, 2018.   \n[32] Oord, A. v. d., Dieleman, S., Zen, H., Simonyan, K., Vinyals, O., Graves, A., Kalchbrenner, N., Senior, A., and Kavukcuoglu, K. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016.   \n[33] Papamakarios, G., Pavlakou, T., and Murray, I. Masked autoregressive flow for density estimation. arXiv preprint arXiv:1705.07057, 2017.   \n[34] Paszke, A., Gross, S., Massa, F., Lerer, A., Bradbury, J., Chanan, G., Killeen, T., Lin, Z., Gimelshein, N., Antiga, L., et al. Pytorch: An imperative style, high-performance deep learning library. arXiv preprint arXiv:1912.01703, 2019.   \n[35] Rezende, D. and Mohamed, S. Variational inference with normalizing flows. In International Conference on Machine Learning, pp. 1530–1538. PMLR, 2015.   \n[36] Roweis, S. T. and Saul, L. K. Nonlinear dimensionality reduction by locally linear embedding. science, 290(5500):2323–2326, 2000.   \n[37] Salimans, T., Karpathy, A., Chen, X., and Kingma, D. P. Pixelcnn $^ { + + }$ : Improving the pixelcnn with discretized logistic mixture likelihood and other modifications. arXiv preprint arXiv:1701.05517, 2017.   \n[38] Sohl-Dickstein, J., Weiss, E., Maheswaranathan, N., and Ganguli, S. Deep unsupervised learning using nonequilibrium thermodynamics. In International Conference on Machine Learning, pp. 2256–2265. PMLR, 2015.   \n[39] Song, Y. and Ermon, S. Generative modeling by estimating gradients of the data distribution. In Advances in Neural Information Processing Systems, pp. 11895–11907, 2019.   \n[40] Song, Y. and Ermon, S. Improved techniques for training score-based generative models. arXiv preprint arXiv:2006.09011, 2020.   \n[41] Song, Y., Sohl-Dickstein, J., Kingma, D., Kumar, A., Ermon, S., and Poole, B. Score-based generative modeling through stochastic differential equations. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id=PxTIG12RRHS.   \n[42] Wu, H., Köhler, J., and Noe, F. Stochastic normalizing flows. In Larochelle, H., Ranzato, M., Hadsell, R., Balcan, M. F., and Lin, H. (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 5933–5944. Curran Associates, Inc., 2020. ",
+        "bbox": [
+            171,
+            114,
+            830,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            828,
+            617
+        ],
+        "page_idx": 11
+    }
+]