Add files using upload-large-folder tool

parse/train/Hyg-JC4FDr/Hyg-JC4FDr.md

@@ -0,0 +1,315 @@
+# IMITATION LEARNING VIA OFF-POLICY DISTRIBUTION MATCHING
+
+Ilya Kostrikov∗, Ofir Nachum, Jonathan Tompson Google Research {kostrikov, ofirnachum, tompson}@google.com
+
+# ABSTRACT
+
+When performing imitation learning from expert demonstrations, distribution matching is a popular approach, in which one alternates between estimating distribution ratios and then using these ratios as rewards in a standard reinforcement learning (RL) algorithm. Traditionally, estimation of the distribution ratio requires on-policy data, which has caused previous work to either be exorbitantly datainefficient or alter the original objective in a manner that can drastically change its optimum. In this work, we show how the original distribution ratio estimation objective may be transformed in a principled manner to yield a completely off-policy objective. In addition to the data-efficiency that this provides, we are able to show that this objective also renders the use of a separate RL optimization unnecessary. Rather, an imitation policy may be learned directly from this objective without the use of explicit rewards. We call the resulting algorithm ValueDICE and evaluate it on a suite of popular imitation learning benchmarks, finding that it can achieve state-of-the-art sample efficiency and performance.1
+
+# 1 INTRODUCTION
+
+Reinforcement learning (RL) is typically framed as learning a behavior policy based on reward feedback from trial-and-error experience. Accordingly, many successful demonstrations of RL often rely on carefully handcrafted rewards with various bonuses and penalties designed to encourage intended behavior (Nachum et al., 2019a; Andrychowicz et al., 2018). In contrast, many real-world behaviors are easier to demonstrate rather than devise explicit rewards. This realization is at the heart of imitation learning (Ho & Ermon, 2016; Ng et al.; Pomerleau, 1989), in which one aims to learn a behavior policy from a set of expert demonstrations – logged experience data of a near-optimal policy interacting with the environment – without explicit knowledge of rewards.
+
+Distribution matching via adversarial learning, or Adversarial Imitation Learning (AIL), has recently become a popular approach for imitation learning (Ho & Ermon, 2016; Fu et al., 2017; Ke et al., 2019; Kostrikov et al., 2019). These methods interpret the states and actions provided in the expert demonstrations as a finite sample from a target distribution. Imitation learning can then be framed as learning a behavior policy which minimizes a divergence between this target distribution and the state-action distribution induced by the behavior policy interacting with the environment. As derived by Ho & Ermon (2016), this divergence minimization may be achieved by iteratively performing two alternating steps, reminiscent of GAN algorithms (Goodfellow et al., 2014). First, one estimates the density ratio of states and actions between the target distribution and the behavior policy. Then, these density ratios are used as rewards for a standard RL algorithm, and the behavior policy is updated to maximize these cumulative rewards (data distribution ratios).
+
+The main limitation of current distribution matching approaches is that estimating distribution density ratios (the first step of every iteration) typically requires samples from the behavior policy distribution. This means that every iteration – every update to the behavior policy – requires new interactions with the environment, precluding the use of these algorithms in settings where interactions with the environment are expensive and limited. Several papers attempt to relax this on-policy requirement and resolve the sample inefficiency problem by designing off-policy imitation learning algorithms, which may take advantage of past logged data, usually in the form of a replay buffer (Kostrikov et al., 2019; Sasaki et al., 2019). However, these methods do so by altering the original divergence minimization objective to measure a divergence between the target expert distribution and the replay buffer distribution. Accordingly, there is no guarantee that the learned policy will recover the desired target distribution.
+
+In this work, we introduce an algorithm for imitation learning that, on the one hand, performs divergence minimization as in the original AIL methods, while on the other hand, is completely off-policy. We begin by providing a new formulation of the minimum divergence objective that avoids the use of any explicit on-policy expectations. While this objective may be used in the traditional way to estimate data distribution ratios that are then input to an RL algorithm, we go further to show how the specific form of the derived objective renders the use of a separate RL optimization unnecessary. Rather, gradients of the minimum divergence objective with respect to behavior policy may be computed directly. This way, an imitating behavior policy may be learned to minimize the divergence without the use of explicit rewards. We call this stream-lined imitation learning algorithm ValueDICE. In addition to being simpler than standard imitation learning methods, we show that our proposed algorithm is able to achieve state-of-the-art performance on a suite of imitation learning benchmarks.
+
+# 2 BACKGROUND
+
+We consider environments represented as a Markov Decision Process (MDP) (Puterman, 2014), defined by the tuple, $( \mathcal { S } , \mathcal { A } , \bar { p _ { 0 } } ( s ) , p ( s ^ { \prime } | s , a ) , r ( s , a ) , \gamma )$ , where $s$ and $\mathcal { A }$ are the state and action space, respectively, $p _ { 0 } ( s )$ is an initial state distribution, $p ( s ^ { \prime } | s , a )$ defines environment dynamics represented as a conditional state distribution, $r ( s , a )$ is a reward function, and $\gamma$ is a return discount factor. A behavior policy $\pi ( \cdot | \cdot )$ interacts with the environment to yield experience $\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \right)$ , for $t = 0 , 1 , \ldots$ , where $s _ { 0 } \sim p _ { 0 } ( \cdot )$ , $a _ { t } \sim \pi ( \cdot | s _ { t } )$ , $s _ { t + 1 } \sim p \big ( \cdot | s _ { t } , \dot { a _ { t } } \big )$ , $r _ { t } = r ( s _ { t } , a _ { t } )$ . Without loss of generality, we consider infinite-horizon, non-terminating environments. In standard RL, one aims to learn a behavior policy $\pi ( \cdot | s )$ to maximize cumulative rewards, based on experience gained from interacting with the environment.
+
+In imitation learning (Pomerleau, 1989; Abbeel & $\mathrm { N g }$ , 2004; Ho & Ermon, 2016), the environment reward is not observed. Rather, one has access to a set of expert demonstrations $\mathcal { D } : =$ $\{ ( s _ { k } , a _ { k } , s _ { k } ^ { \prime } \} _ { k = 1 } ^ { N }$ given by state-action-next-state transitions in the environment induced by an unknown expert policy $\pi _ { \mathrm { e x p } }$ and the goal is to learn a behavior policy $\pi$ which recovers $\pi _ { \mathrm { e x p } }$ . During the learning process, in addition to the finite set of expert demonstrations $\mathcal { D }$ , one may also optionally interact with the environment (in these interactions, no rewards are observed). This setting describes a number of real-world applications where rewards are unknown, such as Pomerleau (1989); Muller et al. (2006); Bojarski et al. (2016).
+
+# 2.1 BEHAVIORAL CLONING (BC)
+
+Supervised behavioral cloning (BC) is a popular approach for imitation learning. Given a set of expert demonstrations, a mapping of state observations to actions is fit using regression or density estimation. In the simplest case, one simply trains the behavior policy $\pi$ to minimize the negative log-likelihood of the observed expert actions:
+
+$$
+\operatorname* { m i n } _ { \pi } J _ { \mathrm { B C } } ( \pi ) : = - \frac { 1 } { N } \sum _ { k = 1 } ^ { N } \log \pi ( a _ { k } | s _ { k } ) .
+$$
+
+Unlike Inverse Reinforcement Learning (IRL) algorithms (e.g. GAIL (Ho & Ermon, 2016)), BC does not perform any additional policy interactions with the learning environment and hence does not suffer from the same issue of policy sample complexity. However, behavioral cloning suffers from distributional drift (Ross et al., 2011); i.e., there is no way for $\pi$ to learn how to recover if it deviates from the expert behavior to a state $\tilde { s }$ not seen in the expert demonstrations.
+
+# 2.2 DISTRIBUTION MATCHING
+
+The distribution matching approach provides a family of methods that are robust to distributional shift. Rather than considering the policy directly as a conditional distribution $\pi ( \cdot | s )$ over actions, this approach considers the state-action distribution induced by a policy. In particular, under certain conditions (Puterman, 2014), there is a one-to-one correspondence between a policy and its stateaction distribution $d ^ { \pi }$ defined as,∞
+
+$$
+d ^ { \pi } ( s , a ) = ( 1 - \gamma ) \cdot \sum _ { t = 0 } ^ { } \gamma ^ { t } p ( s _ { t } = s , a _ { t } = a | s _ { 0 } \sim p _ { 0 } ( \cdot ) , s _ { t } \sim p ( \cdot | s _ { t - 1 } , a _ { t - 1 } ) , a _ { t } \sim \pi ( \cdot | s _ { t } ) ) .
+$$
+
+By the same token, the unknown expert policy also possesses a state-action distribution $d ^ { \mathrm { e x p } }$ , and one may usually assume that the expert demonstrations $\mathcal { D } : = \{ ( s _ { k } , a _ { k } , s _ { k } ^ { \prime } \} _ { k = 1 } ^ { N }$ are sampled as $( s _ { k } , a _ { k } ) \sim d ^ { \mathrm { e x p } } , s _ { k } ^ { \prime } \sim p ( \cdot | s _ { k } , a _ { k } )$ .
+
+Accordingly, the distribution matching approach proposes to learn $\pi$ to minimize the divergence between $d ^ { \pi }$ and $d ^ { \mathrm { e x p } }$ . The KL-divergence is typically used to measure the discrepancy between $d ^ { \pi }$ and $d ^ { \mathrm { e x p } }$ (Ho & Ermon, 2016; Ke et al., 2019):
+
+$$
+\begin{array} { r l } & { \mathrm { \angle U 1 U , \ n c \ e u \ a t . , \angle U 1 5 } ) . } \\ & { \mathrm { \phantom { { \sum } D _ { K L } } } \left( d ^ { \pi } | | d ^ { \mathrm { e x p } } \right) = \mathbb { E } _ { ( s , a ) \sim d ^ { \pi } } \left[ \log \frac { d ^ { \mathrm { e x p } } ( s , a ) } { d ^ { \pi } ( s , a ) } \right] . } \end{array}
+$$
+
+The use of the KL-divergence is convenient, as it may be expressed as an RL problem where rewards are given by log distribution ratios:
+
+$$
+\begin{array} { r l } & { \textrm { y } \log \mathrm { ~ d r s t r u t o u t o n ~ r i a u t o r s . } } \\ & { \quad - D _ { \mathrm { K L } } \left( d ^ { \pi } | | d ^ { \mathrm { e x p } } \right) = ( 1 - \gamma ) \cdot \underset { s _ { 0 } \sim p _ { 0 } ( \cdot ) , \ a _ { t } \sim \pi ( \cdot | s _ { t } ) } { \mathbb { E } } \left[ \displaystyle \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } \log \frac { d ^ { \mathrm { e x p } } \left( s _ { t } , a _ { t } \right) } { d ^ { \pi } \left( s _ { t } , a _ { t } \right) } \right] . } \end{array}
+$$
+
+In other words, if one has access to estimates of the distribution ratios of the two policies, then the minimum divergence problem reduces to a max-return RL problem with rewards $\tilde { r } ( s , a ) =$ lo g dexp(s,a)dπ(s,a) . Any on-policy or off-policy RL algorithm can be used to maximize the corresponding expected returns in Equation 4.
+
+Capitalizing on this observation, Ho & Ermon (2016) and Ke et al. (2019) propose algorithms (e.g., GAIL) in which the distribution ratio is estimated using a GAN-like objective:
+
+$$
+\operatorname* { m a x } _ { h \colon \mathcal { S } \times \mathcal { A } \to ( 0 , 1 ) } J _ { \mathrm { G A I L } } ( h ) : = \mathbb { E } _ { ( s , a ) \sim d ^ { \mathrm { e x p } } } [ \log h ( s , a ) ] + \mathbb { E } _ { ( s , a ) \sim d ^ { \tau } } [ \log ( 1 - h ( s , a ) ) ] .
+$$
+
+In this objective, the function $h$ acts as a discriminator, discriminating between samples $( s , a )$ from $d ^ { \mathrm { e x p } }$ and $d ^ { \pi }$ . The optimal discriminator satisfies,
+
+$$
+\begin{array} { r l } & { \mathrm { \ a t { 1 0 5 4 . 1 1 1 1 1 1 4 U 1 } \ s a t { 1 5 1 0 5 } } , } \\ & { \log { h ^ { \ast } ( s , a ) } - \log ( 1 - h ^ { \ast } ( s , a ) ) = \log \frac { d ^ { \mathrm { e x p } } ( s , a ) } { d ^ { \pi } ( s , a ) } , } \end{array}
+$$
+
+and so the distribution matching rewards may be computed as $\tilde { r } ( s , a ) = \log h ^ { * } ( s , a ) - \log ( 1 -$ $h ^ { * } ( s , a ) )$ . In practice, the discriminator is not fully optimized, and instead gradient updates to the discriminator and policy are alternated.
+
+These prior distribution matching approaches possess two limitations which we will resolve with our proposed ValueDICE algorithm:
+
+• On-policy. Arguably the main limitation of these prior approaches is that they require access to on-policy samples from $d ^ { \pi }$ . While off-policy RL can be used for learning $\pi$ , optimizing the discriminator $h$ necessitates having on-policy samples (the second expectation in Equation 5). Thus, in practice, GAIL requires a prohibitively large number of environment interactions, making it unfeasible for use in many real-world applications. Attempts to remedy this, such as DiscriminatorActor-Critic (DAC) (Kostrikov et al., 2019), often do so via ad-hoc methods; for example, changing the on-policy expectation $\mathbb { E } _ { ( s , a ) \sim d ^ { \pi } } [ \log ( 1 - h ( s , a ) ) ]$ in Equation 5 to an expectation over the replay buffer $\mathbb { E } _ { ( s , a ) \sim d ^ { \mathrm { R B } } } [ \log ( 1 - h ( s , a ) ) ]$ . While DAC achieves good empirical results, it does not guarantee distribution matching of $\pi$ to $\pi _ { \mathrm { e x p } }$ , especially when $d ^ { \mathrm { R B } }$ is far from $d ^ { \pi }$ .
+
+• Separate RL optimization. Prior approaches require iteratively taking alternating steps: first estimate the data distribution ratios using the GAN-like objective, then input these into an RL optimization and repeat. The use of a separate RL algorithm introduces complexity to any implementation of these approaches, with many additional design choices that need to be made and more function approximators to learn (e.g., value functions). Our introduced ValueDICE will be shown to not need a separate RL optimization.
+
+# 3 OFF-POLICY FORMULATION OF THE KL-DIVERGENCE
+
+As is standard in distribution matching, we begin with the KL-divergence between the policy stateaction occupancies and the expert. However, in contrast to the form used in Equation 4 or 5, we use the Donsker-Varadhan representation (Donsker & Varadhan, 1983) given by,
+
+$$
+- D _ { \mathrm { K L } } \left( d ^ { \pi } | | d ^ { \mathrm { e x p } } \right) = \operatorname* { m i n } _ { x : S \times \mathcal { A } \to \mathbb { R } } \log \mathbb { E } _ { ( s , a ) \sim d ^ { \mathrm { e x p } } } [ e ^ { x ( s , a ) } ] - \mathbb { E } _ { ( s , a ) \sim d ^ { \pi } } [ x ( s , a ) ] .
+$$
+
+Similar to Equation 5, this dual representation of the KL has a property that is important for imitation learning. The optimal $x ^ { * }$ is equal to the log distribution ratio (plus a constant):2
+
+$$
+x ^ { * } ( s , a ) = \log \frac { d ^ { \pi } ( s , a ) } { d ^ { \exp } ( s , a ) } + C .
+$$
+
+In our considered infinite-horizon setting, the constant does not affect optimality and so we will ignore it (take $C = 0$ ). If one were to take a GAIL-like approach, they could use this form of the KL to estimate distribution matching rewards given by $\tilde { r } ( \bar { s } , a ) = - x ^ { * } ( s , a )$ , and these could then be maximized by any standard RL algorithm. However, there is no clear advantage of this objective over GAIL since it still relies on an expectation with respect to on-policy samples from $d ^ { \pi }$ .
+
+To make this objective practical for off-policy learning, we take inspiration from derivations used in DualDICE (Nachum et al., 2019b), and perform the following change of variables:3
+
+$$
+\begin{array} { r } { x ( s , a ) = \nu ( s , a ) - B ^ { \pi } \nu ( s , a ) , } \end{array}
+$$
+
+where $B ^ { \pi }$ is the expected Bellman operator with respect to policy $\pi$ and zero reward:
+
+$$
+\begin{array} { r } { \mathcal { B } ^ { \pi } \nu ( s , a ) = \gamma \mathbb { E } _ { s ^ { \prime } \sim p ( \cdot \vert s , a ) , a ^ { \prime } \sim \pi ( \cdot \vert s ^ { \prime } ) } [ \nu ( s ^ { \prime } , a ^ { \prime } ) ] . } \end{array}
+$$
+
+This change of variables is explicitly chosen to take advantage of the linearity of the second expectation in Equation 7. Specifically, the representation becomes,
+
+$$
+- D _ { \mathrm { K L } } \left( d ^ { \pi } | | d ^ { \mathrm { e x p } } \right) = \operatorname* { m i n } _ { \substack { \nu : S \times A \to \mathbb { R } } } \log \underset { ( s , a ) \sim d ^ { \mathrm { e x p } } } { \mathbb { E } } [ e ^ { \nu ( s , a ) - B ^ { \pi } \nu ( s , a ) } ] - \underset { ( s , a ) \sim d ^ { \pi } } { \mathbb { E } } [ \nu ( s , a ) - B ^ { \pi } \nu ( s , a ) ] ,
+$$
+
+where the second expectation conveniently telescopes and reduces to an expectation over initial states (see Nachum et al. (2019b) for details):
+
+$$
+\operatorname* { m i n } _ { \substack { \nu : S \times A \to \mathbb { R } } } J _ { \mathrm { D I C E } } ( \nu ) : = \log \underset { ( s , a ) \sim d ^ { \mathrm { e x p } } } { \mathbb { E } } [ e ^ { \nu ( s , a ) - B ^ { \pi } \nu ( s , a ) } ] - ( 1 - \gamma ) \cdot \underset { \substack { s _ { 0 } \sim \pi p ( \cdot | s _ { 0 } ) } } { \mathbb { E } } [ \nu ( s _ { 0 } , a _ { 0 } ) ] .
+$$
+
+Thus we achieve our $V a l u e D I C E ^ { 4 }$ objective. It allows us to express the KL-divergence between $d ^ { \pi }$ and $d ^ { \mathrm { e x p } }$ in terms of an objective over a ‘value-function’ $\nu$ expressed in an off-policy manner, with expectations over expert demonstrations $d ^ { \mathrm { e x p } }$ and initial state distribution $p _ { 0 } ( \cdot )$ .
+
+It is clear that the derived objective in Equation 12 possesses two key characteristics missing from prior distribution matching algorithms: First, the objective does not rely on access to samples from the on-policy distribution $d ^ { \pi }$ , and so may be used in more realistic, off-policy settings. Second, the objective describes a proper divergence between $d ^ { \pi }$ and $d ^ { \mathrm { e x p } }$ , as opposed to estimating a divergence between $d ^ { \mathrm { R B } }$ and $d ^ { \mathrm { e x p } }$ , and thus avoids poor behavior when $d ^ { \mathrm { R B } }$ is far from $d ^ { \pi }$ . In the following section, we will go further to show how the objective in Equation 12 also renders the use of a separate RL optimization unnecessary.
+
+# 4 VALUEDICE: IMITATION LEARNING WITH IMPLICIT REWARDS
+
+Although it is standard in distribution matching to have separate optimizations for estimating the distribution ratios and learning a policy, in our case this can be mitigated. Indeed, looking at our
+
+formulation of the KL in Equation 12, we see that gradients of this objective with respect to $\pi$ may be easily computed. Specifically, we may express the distribution matching objective for $\pi$ as a max-min optimization:
+
+$$
+\operatorname* { m a x } _ { \pi } \operatorname* { m i n } _ { \nu : S \times A \to \mathbb { R } } J _ { \mathrm { D I C E } } ( \pi , \nu ) : = \log \underset { ( s , a ) \sim d ^ { \mathrm { e x p } } } { \mathbb { E } } [ e ^ { \nu ( s , a ) - B ^ { \pi } \nu ( s , a ) } ] - ( 1 - \gamma ) \cdot \underset { s _ { 0 } \sim p _ { 0 } ( \cdot ) _ { 0 } } { \mathbb { E } } [ \nu ( s _ { 0 } , a _ { 0 } ) ] .
+$$
+
+If the inner objective over $\nu$ is sufficiently optimized, the gradients of $\pi$ may be computed directly (Bertsekas, 1999), noting that,
+
+$$
+\frac { \partial } { \partial \pi } e ^ { \nu ( s , a ) - B ^ { \pi } \nu ( s , a ) } = - \gamma \cdot e ^ { \nu ( s , a ) - B ^ { \pi } \nu ( s , a ) } \cdot \mathbb { E } _ { s ^ { \prime } \sim T ( s , a ) , a ^ { \prime } \sim \pi ( s ^ { \prime } ) } [ \nu ( s ^ { \prime } , a ^ { \prime } ) \nabla \log \pi ( a ^ { \prime } | s ^ { \prime } ) ] ,
+$$
+
+$$
+\frac { \partial } { \partial \pi } \mathbb { E } _ { s _ { 0 } \sim p _ { 0 } ( \cdot ) , a _ { 0 } \sim \pi ( \cdot | s _ { 0 } ) } [ \nu ( s _ { 0 } , a _ { 0 } ) ] = \mathbb { E } _ { s _ { 0 } \sim p _ { 0 } ( \cdot ) , a _ { 0 } \sim \pi ( \cdot | s _ { 0 } ) } [ \nu ( s _ { 0 } , a _ { 0 } ) \nabla \log \pi ( a _ { 0 } | s _ { 0 } ) ] .
+$$
+
+In continuous control environments when $\pi$ is parameterized by a Gaussian and $\nu$ is a neural network, one may use the re-parameterization trick (Haarnoja et al., 2018) to compute gradients of the $\nu$ -values with respect to policy mean and variance directly as opposed to computing $\nabla \log \pi ( a | s )$ . Please see the appendix for a full pseudocode implementation of ValueDICE. We note that in practice, as in GAIL, we do not train $\nu$ until optimality but rather alternate $\nu$ and $\pi$ updates.
+
+The mechanics of learning $\pi$ according to the ValueDICE objective are straightforward, but what is the underlying reason for this more streamlined policy learning? How does it relate the standard protocol of alternating data distribution estimation with RL optimization? To better understand this, we consider the form of $\nu$ when it is completely optimized. If we consider the original change of variables (Equation 9) and optimality characterization (Equation 8) we have,
+
+$$
+\nu ^ { * } ( s , a ) - \bar { B ^ { \pi } } \nu ^ { * } ( s , a ) = x ^ { * } ( s , a ) = \log \frac { d ^ { \pi } ( s , a ) } { d ^ { \exp } ( s , a ) } .
+$$
+
+From this characterization of $\nu ^ { * }$ , we realize that $\nu ^ { * }$ is a sort of $\mathrm { Q }$ -value function: $\nu ^ { * } ( s , a )$ is the future discounted sum of rewards r˜(s, a) := log dπ(s,a)dexp(s,a) when acting according to $\pi$ . The gradients for $\pi$ then encourage the policy to choose actions which minimize $\nu ^ { * } ( s , a )$ , i.e., maximize future discounted log ratios dexp(s,a)dπ(s,a) . Thus we realize that the objective for π in ValueDICE performs exactly the RL optimization suggested by Equation 4. The streamlined nature of ValueDICE comes from the fact that the value function $\nu$ (which would traditionally need to be learned as a critic in a separate actor-critic RL algorithm) is learned directly from the same objective as that used for distribution matching.
+
+Thus, in addition to estimating a proper divergence between $d ^ { \pi }$ and $d ^ { \mathrm { e x p } }$ in an off-policy manner, ValueDICE also greatly simplifies the implementation of distribution matching algorithms. There is no longer a need to use a separate RL algorithm for learning $\pi$ , and moreover, the use of $\nu$ as a value function removes any use of explicit rewards. Instead, the objective and implementation are only in terms of policy $\pi$ and function $\nu$ .
+
+# 5 SOME PRACTICAL CONSIDERATIONS
+
+In order to make use of the ValueDICE objective (Equation 13) in practical scenarios, where one does not have access to $d ^ { \mathrm { e x p } }$ or $p _ { 0 } ( \cdot )$ but rather only limited finite samples, we perform several modifications.
+
+# 5.1 EMPIRICAL EXPECTATIONS
+
+The objective in Equation 13 contains three expectations:
+
+1. An expectation over $d ^ { \mathrm { e x p } }$ (the first term of the objective). Note that this expectation has a logarithm outside of it, which would make any mini-batch approximations of the gradient of this expectation biased.   
+2. An expectation over $p _ { 0 } ( \cdot )$ (the second term of the objective). This term is linear, and so is very amenable to mini-batch optimization.
+
+3. An expectation over the environment transition $p ( \cdot | s , a )$ used to compute $B ^ { \pi } \nu ( s , a )$ . This expectation has a log-expected-exponent applied to it, so its mini-batch approximated gradient would be biased in general.
+
+For the first expectation, previous works have suggested a number of remedies to reduce the bias of mini-batch gradients, such as maintaining moving averages of various quantities (Belghazi et al., 2018). In the setting we considered, we found this to have a negligible effect on performance. In fact, simply using the biased mini-batched gradients was sufficient for good performance, and so we used this for our experiments.
+
+For the second expectation, we use standard mini-batch gradients, which are unbiased. Although initial state distributions are usually not used in imitation learning, it is easy to record initial states as they are observed, and thus have access to an empirical sample from $p _ { 0 }$ . Furthermore, as detailed in Section 5.3, it is possible to modify the initial state distribution used in the objective without adverse effects.
+
+Finally, for the third expectation, previous works have suggested the use of Fenchel conjugates to remove the bias (Nachum et al., 2019b). In our case, we found this unnecessary and instead use a biased estimate based on the single sample $s ^ { \prime } \sim p ( \cdot | s , a )$ . This naive approach was enough to achieve good performance on the benchmark domains we considered.
+
+In summary, the empirical form of the objective is given by,
+
+$$
+\begin{array} { r l } & { \hat { J } _ { \mathrm { D I C E } } ( \pi , \nu ) = } \\ & { \qquad \quad \frac { \mathbb { E } } { \mathrm { b a t c h } ( \mathcal { D } ) \sim \mathcal { D } } \left[ \log \underset { s , a , s ^ { \prime } \sim \mathrm { b a t c h } ( \mathcal { D } ) } { \mathbb { E } } \left[ e ^ { \nu ( s , a ) - \gamma \nu ( s ^ { \prime } , a ^ { \prime } ) } \right] - ( 1 - \gamma ) \cdot \underset { s _ { 0 } \sim \mathrm { b a t c h } ( p _ { 0 } ) } { \mathbb { E } } \left[ \nu ( s _ { 0 } , a _ { 0 } ) \right] \right] , } \\ & { \quad \mathrm { b a t c h } ( p _ { 0 } ) \sim \hat { p } _ { 0 } \quad \quad a ^ { \prime } \sim \pi ( \cdot | s ^ { \prime } ) } \end{array}
+$$
+
+where batch $( \mathcal { D } )$ is a mini-batch from $\mathcal { D }$ and batch $\left( p _ { 0 } \right)$ is a mini-batch from the recorded initial states $\hat { p } _ { 0 }$ .
+
+# 5.2 REPLAY BUFFER REGULARIZATION
+
+The original ValueDICE objective uses only expert samples and the initial state distribution. In practice, the number of expert samples may be small and lack diversity, hampering learning. In order to increase the diversity of samples used for training, we consider an alternative objective, with a controllable regularization based on experience in the replay buffer:
+
+$$
+\begin{array} { r l } & { J _ { \mathrm { D I C E } } ^ { \mathrm { m i x } } ( \pi , \nu ) : = \log \underset { ( s , a ) \sim d ^ { \mathrm { m i x } } } { \mathbb { E } } [ e ^ { \nu ( s , a ) - \mathcal { B } ^ { \pi } \nu ( s , a ) } ] - ( 1 - \alpha ) ( 1 - \gamma ) \cdot \underset { \underset { a _ { 0 } \sim \pi ( \cdot ) , ( s _ { 0 } ) } { \sum _ { \substack { s _ { 0 } \sim \pi ( \cdot ) , ( s _ { 0 } ) } } } } { \mathbb { E } } [ \nu ( s _ { 0 } , a _ { 0 } ) ] } \\ & { \qquad - \underset { ( s , a ) \sim d ^ { \mathrm { R B } } } { \mathbb { E } } [ \nu ( s , a ) - \mathcal { B } ^ { \pi } \nu ( s , a ) ] , } \end{array}
+$$
+
+where $d ^ { \mathrm { m i x } } ( s , a ) = ( 1 - \alpha ) d ^ { \mathrm { e x p } } ( s , a ) + \alpha d ^ { \mathrm { R B } } ( s , a )$ .
+
+The main advantage of this formulation is that it introduces $\nu$ -values into the objective on samples that are outside the given expert demonstrations. Thus, if $\pi$ deviates from the expert trajectory, we will still be able to learn optimal actions that return the policy back to the expert behavior. At the same time, one can verify that in this formulation the optimal $\pi$ still matches $\pi _ { \mathrm { e x p } }$ , unlike other proposals for incorporating a replay buffer distribution (Kostrikov et al., 2019). Indeed, the objective in Equation 18 corresponds to the Donsker-Varadhan representation,
+
+$$
+\begin{array} { r l } & { \quad - D _ { \mathrm { K L } } ( ( 1 - \alpha ) d ^ { \pi } + \alpha d ^ { \mathrm { R B } } \parallel ( 1 - \alpha ) d ^ { \mathrm { e x p } } + \alpha d ^ { \mathrm { R B } } ) = } \\ & { \quad \underset { x : S \times A \to \mathbb { R } } { \operatorname* { m i n } } \log \mathbb { E } _ { ( s , a ) \sim d ^ { \operatorname* { m i n } } } [ e ^ { x ( s , a ) } ] - ( 1 - \alpha ) \cdot \mathbb { E } _ { ( s , a ) \sim d ^ { \pi } } \left[ x ( s , a ) \right] - \alpha \cdot \mathbb { E } _ { ( s , a ) \sim d ^ { \mathrm { R B } } } \left[ x ( s , a ) \right] , } \end{array}
+$$
+
+and so the optimal values of $\nu ^ { * }$ satisfy,
+
+$$
+\nu ^ { * } ( s , a ) - \mathcal { B } ^ { \pi } \nu ^ { * } ( s , a ) = x ^ { * } ( s , a ) = \log \frac { ( 1 - \alpha ) d ^ { \pi } ( s , a ) + \alpha d ^ { \mathrm { R B } } ( s , a ) } { ( 1 - \alpha ) d ^ { \exp } ( s , a ) + \alpha d ^ { \mathrm { R B } } ( s , a ) } .
+$$
+
+Therefore, the global optimality of $\pi = \pi _ { \mathrm { e x p } }$ is unaffected by any choice of $\alpha < 1$ . We note that in practice we use a small value $\alpha = 0 . 1$ for regularization.
+
+# 5.3 INITIAL STATE SAMPLING
+
+Recall that $d ^ { \mathrm { e x p } } , d ^ { \pi }$ traditionally refer to discounted state-action distributions. That is, sampling from them is equivalent to first sampling a trajectory $( s _ { 0 } , a _ { 0 } , s _ { 1 } , a _ { 1 } , . . . , s _ { T } )$ and then sampling a time index $t$ from a geometric distribution $\mathrm { G e o m } ( 1 - \gamma )$ (appropriately handling samples that are beyond $T$ ). This means that samples far into the trajectory do not contribute much to the objective. To remedy this, we propose treating every state in a trajectory as an ‘initial state.’ That is, we consider a single environment trajectory $( s _ { 0 } , a _ { 0 } , s _ { 1 } , a _ { 1 } , . . . , s _ { T } )$ as $T$ distinct virtual trajectories $\{ ( s _ { t } , a _ { t } , s _ { t + 1 } , a _ { t + 1 } , \ldots , s _ { T } ) \} _ { t = 0 } ^ { T - 1 }$ . We apply this to both $d ^ { \mathrm { e x p } }$ and $d ^ { \pi }$ , so that not only does it increase the diversity of samples from $d ^ { \mathrm { e x p } }$ , but it also expands the initial state distribution $p _ { 0 } ( \cdot )$ to encompass every state in a trajectory. We note that this does not affect the optimality of the objective with respect to $\pi$ , since in Markovian environments an expert policy should be expert regardless of the state at which it starts (Puterman, 2014).
+
+# 6 RELATED WORK
+
+In recent years, the development of Adversarial Imitation Learning has been mostly focused on on-policy algorithms. After Ho & Ermon (2016) proposed GAIL to perform imitation learning via adversarial training, a number of extensions has been introduced. Many of these applications of the AIL framework (Li et al., 2017; Hausman et al., 2017; Fu et al., 2017) maintain the same form of distribution ratio estimation as GAIL which necessitates on-policy samples. In contrast, our work presents an off-policy formulation of the same objective.
+
+Although several works have attempted to apply the AIL framework to off-policy settings, these previous approaches are markedly different from our own. For example, Kostrikov et al. (2019) proposed to train the discriminator in the GAN-like AIL objective using samples from a replay buffer instead of samples from a policy. This changes the distribution ratio estimation to measure a divergence between the expert and the replay. Although we introduce a controllable parameter $\alpha$ for incorporating samples from the replay buffer into the data distribution objective, we note that in practice we use a very small $\alpha = 0 . 1$ . Furthermore, by using samples from the replay buffer in both terms of the objective as opposed to just one, the global optimality of the expert policy is not affected.
+
+The off-policy formulation of the KL-divergence we derive is motivated by similar techniques in DualDICE (Nachum et al., 2019b). Still, our use of these techniques provides several novelties. First, Nachum et al. (2019b) only use the divergence formulation for data distribution estimation (which is used for off-policy evaluation), assuming a fixed policy. We use the formulation for learning a policy to minimize the divergence directly. Moreover, previous works have only applied these derivations to the $f$ -divergence form of the KL-divergence, while we are the first to utilize the Donsker-Varadhan form. Anecdotally in our initial experiments, we found that using the $f$ -divergence form leads to poor performance. We note that our proposed objective follows a form similar to REPS (Peters et al., 2010), which also utilizes a log-average-exp term. However, policy and value learning in REPS are performed via a bi-level optimization (i.e., the policy is learned with respect to a different objective), which is distinct from our algorithm, which trains values and policy with respect to the same objective. Our proposed ValueDICE is also significant for being able to incorporate arbitrary (non-expert) data into its learning.
+
+# 7 EXPERIMENTS
+
+We evaluate ValueDICE in a variety of settings, starting with a simple synthetic task before continuing to an evaluation on a suite of MuJoCo benchmarks.
+
+# 7.1 RING MDP
+
+We begin by analyzing the behavior of ValueDICE on a simple synthetic MDP (Figure 1). The states of the MDP are organized in a ring. At each state, two actions are possible: move clockwise or counter-clockwise. We first look at the performance of ValueDICE in a situation where the expert data is sparse and does not cover all states and actions. Specifically, we provide expert demonstrations which cover only states 0, 1, and 2 (see Figure 1 left). While the problem of recovering the true (unknown) expert is ill-defined, it is still possible to find a policy which recovers close to the same occupancies. Indeed, this is the policy found by ValueDICE, which chooses the appropriate actions at each state to optimally reach states 1 and 2 (and alternating between states 1 and 2 when at these states). In many practical scenarios, this is the desired outcome – if the imitating policy somehow encounters a situation which deviates from the expert demonstrations, we would like it to return to the expert behavior as fast as possible. Notably, a technique like behavioral cloning would fail to learn this optimal policy, since its learning is only based on observed expert data.
+
+![](images/2ff15254829b8cfb1c8cdb6e54c49f215f39c79c75058fb8ad858933a24fa0cd.jpg)  
+Figure 1: Results of ValueDICE on a simple Ring MDP. Left: The expert data is sparse and only covers states 0, 1, and 2. Nevertheless, ValueDICE is able to learn a policy on all states to best match the observed expert state-action occupancies (the policy learns to always go to states 1 and 2). Right: The expert is stochastic. ValueDICE is able to learn a policy which successfully minimizes the true KL computed between $d ^ { \pi }$ and $d ^ { \mathrm { e x p } }$ .
+
+![](images/e6aa314483fc0a1134e24081dcfdc01334e721b3d325da7bd3612178015a436a.jpg)  
+Figure 2: Comparison of algorithms given 1 expert trajectory. We use the original implementation of GAIL (Ho & Ermon, 2016) to produce GAIL and BC results.
+
+We also analyzed the behavior of ValueDICE with a stochastic expert (Figure 1 right). By using a synthetic MDP, we are able to measure the divergence $D _ { \mathrm { K L } } ( d ^ { \pi } | | d ^ { \exp } )$ during training. As expected, we find that this divergence decreases during ValueDICE training.
+
+# 7.2 MUJOCO BENCHMARKS
+
+We compare ValueDICE against Discriminator-Actor-Critic (DAC) (Kostrikov et al., 2019), which is the state-of-the-art in sample-efficient adversarial imitation learning, as well as GAIL (Ho & Ermon, 2016). We evaluate the algorithms on the standard MuJoCo environments using expert demonstrations from Ho & Ermon (2016). We plot the average returns for the learned policies (using a mean action for sampling) every 1000 environment steps using 10 episodes. We perform this procedure for 10 different seeds and compute means and standard deviations (see Fig. 2 and 3, we visualize a half of standard deviation on these plots).
+
+![](images/fa089b6dfddf0856cc431126a3f3e087e9b34a5e6583d32af94ed14eca9a456e.jpg)  
+Figure 3: Comparison of algorithms given 10 expert trajectories. ValueDICE outperforms other methods. However, given this amount of data, BC can recover the expert policy as well.
+
+We present the extremely low-data regime first. In Figure 2 we present the results of the imitation learning algorithms given only a single expert trajectory. We find that ValueDICE performs similar or better than DAC an all tasks, with the exception of Walker2d where it converges to a slightly worse policy. Notably, in this low-data regime, behavioral cloning (BC) usually cannot recover the expert policy. We also present the results of these algorithms on a larger number of expert demonstrations (Figure 3). We continue to observe strong performance of ValueDICE as well as faster convergence on all tasks. It is worth mentioning that in this large-data regime, Behavior Cloning can recover the expert performance as well. In all of these scenarios, GAIL is too sample-inefficient to make any progress.
+
+# 8 CONCLUSION
+
+We introduced ValueDICE, an algorithm for imitation learning that outperforms the state-of-the-art on standard MuJoCo tasks. In contrast to other algorithms for off-policy imitation learning, the algorithm introduced in this paper performs robust divergence minimization in a principled off-policy manner and a strong theoretical framework. To the best of our knowledge, this is also the first algorithm for adversarial imitation learning that omits learning or defining rewards explicitly and directly learns a Q-function in the distribution ratio objective directly. We demonstrate the robustness of ValueDICE in a challenging synthetic tabular MDP environment, as well as on standard MuJoCo continuous control benchmark environments, and we show increased performance over baselines in both the low and high data regimes.
+
+# REFERENCES
+
+Pieter Abbeel and Andrew Y Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of the twenty-first international conference on Machine learning, pp. 1. ACM, 2004.
+
+Marcin Andrychowicz, Bowen Baker, Maciek Chociej, Rafal Jozefowicz, Bob McGrew, Jakub Pachocki, Arthur Petron, Matthias Plappert, Glenn Powell, Alex Ray, et al. Learning dexterous in-hand manipulation. arXiv preprint arXiv:1808.00177, 2018.
+
+Mohamed Ishmael Belghazi, Aristide Baratin, Sai Rajeswar, Sherjil Ozair, Yoshua Bengio, Aaron Courville, and R Devon Hjelm. Mine: mutual information neural estimation. arXiv preprint arXiv:1801.04062, 2018.
+
+D. P. Bertsekas. Nonlinear Programming. Athena Scientific, Belmont, MA, second edition, 1999.
+
+Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016.
+
+Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018.
+
+Monroe D Donsker and SR Srinivasa Varadhan. Asymptotic evaluation of certain markov process expectations for large time. iv. Communications on Pure and Applied Mathematics, 36(2):183– 212, 1983.
+
+Justin Fu, Katie Luo, and Sergey Levine. Learning robust rewards with adversarial inverse reinforcement learning. arXiv preprint arXiv:1710.11248, 2017.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014.
+
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in neural information processing systems, pp. 5767–5777, 2017.
+
+Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, et al. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018.
+
+Karol Hausman, Yevgen Chebotar, Stefan Schaal, Gaurav Sukhatme, and Joseph J Lim. Multimodal imitation learning from unstructured demonstrations using generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 1235–1245, 2017.
+
+Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in neural information processing systems, pp. 4565–4573, 2016.
+
+Liyiming Ke, Matt Barnes, Wen Sun, Gilwoo Lee, Sanjiban Choudhury, and Siddhartha Srinivasa. Imitation learning as $f$ -divergence minimization. arXiv preprint arXiv:1905.12888, 2019.
+
+Ilya Kostrikov, Kumar Krishna Agrawal, Debidatta Dwibedi, Sergey Levine, and Jonathan Tompson. Discriminator-actor-critic: Addressing sample inefficiency and reward bias in adversarial imitation learning. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ Hk4fpoA5Km.
+
+Yunzhu Li, Jiaming Song, and Stefano Ermon. Infogail: Interpretable imitation learning from visual demonstrations. In Advances in Neural Information Processing Systems, pp. 3812–3822, 2017.
+
+Urs Muller, Jan Ben, Eric Cosatto, Beat Flepp, and Yann L Cun. Off-road obstacle avoidance through end-to-end learning. In Advances in neural information processing systems, pp. 739– 746, 2006.
+
+Ofir Nachum, Michael Ahn, Hugo Ponte, Shixiang Gu, and Vikash Kumar. Multi-agent manipulation via locomotion using hierarchical sim2real. arXiv preprint arXiv:1908.05224, 2019a.
+
+Ofir Nachum, Yinlam Chow, Bo Dai, and Lihong Li. Dualdice: Efficient estimation of off-policy stationary distribution corrections. 2019b.
+
+Andrew Y Ng, Stuart J Russell, et al. Algorithms for inverse reinforcement learning.
+
+Jan Peters, Katharina Mulling, and Yasemin Altun. Relative entropy policy search. In Twenty-Fourth AAAI Conference on Artificial Intelligence, 2010.
+
+Dean A Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In Advances in neural information processing systems, pp. 305–313, 1989.
+
+Martin L Puterman. Markov Decision Processes.: Discrete Stochastic Dynamic Programming. John Wiley & Sons, 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.
+
+Fumihiro Sasaki, Tetsuya Yohira, and Atsuo Kawaguchi. Sample efficient imitation learning for continuous control. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ BkN5UoAqF7.
+
+# A IMPLEMENTATION DETAILS
+
+All algorithms use networks with an MLP architecture with 2 hidden layers and 256 hidden units. For discriminators, critic, $\nu$ we use Adam optimizer with learning rate $1 0 ^ { - 3 }$ while for the actors we use the learning rate of $1 0 ^ { - 5 }$ . For the discriminator and $\nu$ networks we use gradient penalties from Gulrajani et al. (2017). We also regularize the actor network with the orthogonal regularization (Brock et al., 2018) with a coefficient $1 \bar { 0 } ^ { - 4 }$ . Also we perform 4 updates per 1 environment step. We handle absorbing states of the environments similarly to Kostrikov et al. (2019).
+
+# B ALGORITHMS
+
+In this section, we present pseudocode for the imitation learning algorithms based on DualDICE.
+
+Algorithm 1 ValueDICE   
+Input: expert replay buffer $\mathcal { R } _ { E }$ Initialize replay buffer $\mathcal { R }  \emptyset$ for $n = 1 , \ldots , \mathbf { d o }$ Sample $( s , a , s ^ { \prime } )$ with $\pi _ { \theta }$ Add $( s , a , s ^ { \prime } )$ to the replay buffer $\mathcal { R }$ $\{ ( s ^ { ( i ) } , a ^ { ( i ) } , s ^ { \prime ( i ) } ) \} _ { i = 1 } ^ { B } \sim \mathcal { R }$ . Geometric sampling, is a st $\triangleright$ Geometric samplingting episode state for $\{ ( s _ { 0 } ^ { ( i ) } , s _ { E } ^ { ( i ) } , a _ { E } ^ { ( i ) } , s _ { E } ^ { \prime ( i ) } ) \} _ { i = 1 } ^ { B } \sim \mathcal { R } _ { E }$ $s _ { 0 } ^ { ( i ) }$ s(i)E a(i ) ∼ πθ (·|s(i)0 ), for i = 1, . . . , B a0(i) ∼ πθ (·|s0(i)), for i = 1, . . . , B $a _ { E } ^ { \prime ( i ) } \sim \pi _ { \theta } ( \cdot | s _ { E } ^ { \prime ( i ) } )$ , for i = 1, . . . , B Compute loss on expert data: $\begin{array} { r } { \hat { J } _ { l o g } ^ { \mathrm { ~ ~ } } = \log \bigl ( \frac { 1 } { B } \sum _ { i = 1 } ^ { B } \bigl ( ( 1 - \alpha ) e ^ { \nu _ { \psi } ( s _ { E } ^ { ( i ) } , a _ { E } ^ { ( i ) } ) - \gamma \nu _ { \psi } ( s _ { E } ^ { \prime ( i ) } , a _ { E } ^ { \prime ( i ) } ) } + \alpha e ^ { \nu _ { \psi } ( s ^ { ( i ) } , a ^ { ( i ) } ) - \gamma \nu _ { \psi } ( s ^ { \prime ( i ) } , a ^ { \prime ( i ) } ) } \bigr ) \bigr ) } \end{array}$ Compute loss on the replay buffer: $\begin{array} { r } { \hat { J } _ { l i n e a r } = \frac { 1 } { B } \sum _ { i = 1 } ^ { B } ( ( 1 - \dot { \alpha } ) ( 1 - \gamma ) \nu _ { \psi } ( s _ { 0 } ^ { ( i ) } , a _ { 0 } ^ { ( i ) } ) + \alpha ( \nu _ { \psi } ( s ^ { ( i ) } , a ^ { ( i ) } ) - \gamma \nu _ { \psi } ( s ^ { \prime ( i ) } , a ^ { \prime ( i ) } ) ) ) } \end{array}$ Update $\psi  \psi - \eta _ { \nu } \nabla _ { \psi } ( \hat { J } _ { l o g } - \hat { J } _ { l i n e a r } )$ Update $\theta  \psi + \eta _ { \pi } \nabla _ { \theta } \big ( \hat { J } _ { l o g } - \hat { J } _ { l i n e a r } \big )$ end for
+
+# C ADDITIONAL EXPERIMENTS
+
+We also compared ValueDICE with behavioral cloning in the offline regime, when we sample no additional transitions from the learning environment (see Figure 4). Even given only offline data, ValueDICE outperforms behavioral cloning. For behavioral cloning we used the same regularization as for actor training in ValueDICE.
+
+![](images/c40b80cae8865eb5124efdc9cf33f4d8e08f441eaac4f78921409f7e9ee1c58c.jpg)  
+Figure 4: ValueDICE outperforms behavioral cloning given 1 trajectory even without replay regularization.

parse/train/Hyg-JC4FDr/Hyg-JC4FDr_content_list.json

@@ -0,0 +1,1597 @@
+[
+    {
+        "type": "text",
+        "text": "IMITATION LEARNING VIA OFF-POLICY DISTRIBUTION MATCHING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            650,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ilya Kostrikov∗, Ofir Nachum, Jonathan Tompson Google Research {kostrikov, ofirnachum, tompson}@google.com ",
+        "bbox": [
+            183,
+            170,
+            601,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When performing imitation learning from expert demonstrations, distribution matching is a popular approach, in which one alternates between estimating distribution ratios and then using these ratios as rewards in a standard reinforcement learning (RL) algorithm. Traditionally, estimation of the distribution ratio requires on-policy data, which has caused previous work to either be exorbitantly datainefficient or alter the original objective in a manner that can drastically change its optimum. In this work, we show how the original distribution ratio estimation objective may be transformed in a principled manner to yield a completely off-policy objective. In addition to the data-efficiency that this provides, we are able to show that this objective also renders the use of a separate RL optimization unnecessary. Rather, an imitation policy may be learned directly from this objective without the use of explicit rewards. We call the resulting algorithm ValueDICE and evaluate it on a suite of popular imitation learning benchmarks, finding that it can achieve state-of-the-art sample efficiency and performance.1 ",
+        "bbox": [
+            233,
+            280,
+            764,
+            473
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            497,
+            336,
+            513
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning (RL) is typically framed as learning a behavior policy based on reward feedback from trial-and-error experience. Accordingly, many successful demonstrations of RL often rely on carefully handcrafted rewards with various bonuses and penalties designed to encourage intended behavior (Nachum et al., 2019a; Andrychowicz et al., 2018). In contrast, many real-world behaviors are easier to demonstrate rather than devise explicit rewards. This realization is at the heart of imitation learning (Ho & Ermon, 2016; Ng et al.; Pomerleau, 1989), in which one aims to learn a behavior policy from a set of expert demonstrations – logged experience data of a near-optimal policy interacting with the environment – without explicit knowledge of rewards. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            640
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Distribution matching via adversarial learning, or Adversarial Imitation Learning (AIL), has recently become a popular approach for imitation learning (Ho & Ermon, 2016; Fu et al., 2017; Ke et al., 2019; Kostrikov et al., 2019). These methods interpret the states and actions provided in the expert demonstrations as a finite sample from a target distribution. Imitation learning can then be framed as learning a behavior policy which minimizes a divergence between this target distribution and the state-action distribution induced by the behavior policy interacting with the environment. As derived by Ho & Ermon (2016), this divergence minimization may be achieved by iteratively performing two alternating steps, reminiscent of GAN algorithms (Goodfellow et al., 2014). First, one estimates the density ratio of states and actions between the target distribution and the behavior policy. Then, these density ratios are used as rewards for a standard RL algorithm, and the behavior policy is updated to maximize these cumulative rewards (data distribution ratios). ",
+        "bbox": [
+            174,
+            647,
+            825,
+            799
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The main limitation of current distribution matching approaches is that estimating distribution density ratios (the first step of every iteration) typically requires samples from the behavior policy distribution. This means that every iteration – every update to the behavior policy – requires new interactions with the environment, precluding the use of these algorithms in settings where interactions with the environment are expensive and limited. Several papers attempt to relax this on-policy requirement and resolve the sample inefficiency problem by designing off-policy imitation learning algorithms, which may take advantage of past logged data, usually in the form of a replay buffer (Kostrikov et al., 2019; Sasaki et al., 2019). However, these methods do so by altering the original divergence minimization objective to measure a divergence between the target expert distribution and the replay buffer distribution. Accordingly, there is no guarantee that the learned policy will recover the desired target distribution. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            876
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce an algorithm for imitation learning that, on the one hand, performs divergence minimization as in the original AIL methods, while on the other hand, is completely off-policy. We begin by providing a new formulation of the minimum divergence objective that avoids the use of any explicit on-policy expectations. While this objective may be used in the traditional way to estimate data distribution ratios that are then input to an RL algorithm, we go further to show how the specific form of the derived objective renders the use of a separate RL optimization unnecessary. Rather, gradients of the minimum divergence objective with respect to behavior policy may be computed directly. This way, an imitating behavior policy may be learned to minimize the divergence without the use of explicit rewards. We call this stream-lined imitation learning algorithm ValueDICE. In addition to being simpler than standard imitation learning methods, we show that our proposed algorithm is able to achieve state-of-the-art performance on a suite of imitation learning benchmarks. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            361
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            392,
+            326,
+            409
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider environments represented as a Markov Decision Process (MDP) (Puterman, 2014), defined by the tuple, $( \\mathcal { S } , \\mathcal { A } , \\bar { p _ { 0 } } ( s ) , p ( s ^ { \\prime } | s , a ) , r ( s , a ) , \\gamma )$ , where $s$ and $\\mathcal { A }$ are the state and action space, respectively, $p _ { 0 } ( s )$ is an initial state distribution, $p ( s ^ { \\prime } | s , a )$ defines environment dynamics represented as a conditional state distribution, $r ( s , a )$ is a reward function, and $\\gamma$ is a return discount factor. A behavior policy $\\pi ( \\cdot | \\cdot )$ interacts with the environment to yield experience $\\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \\right)$ , for $t = 0 , 1 , \\ldots$ , where $s _ { 0 } \\sim p _ { 0 } ( \\cdot )$ , $a _ { t } \\sim \\pi ( \\cdot | s _ { t } )$ , $s _ { t + 1 } \\sim p \\big ( \\cdot | s _ { t } , \\dot { a _ { t } } \\big )$ , $r _ { t } = r ( s _ { t } , a _ { t } )$ . Without loss of generality, we consider infinite-horizon, non-terminating environments. In standard RL, one aims to learn a behavior policy $\\pi ( \\cdot | s )$ to maximize cumulative rewards, based on experience gained from interacting with the environment. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            555
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In imitation learning (Pomerleau, 1989; Abbeel & $\\mathrm { N g }$ , 2004; Ho & Ermon, 2016), the environment reward is not observed. Rather, one has access to a set of expert demonstrations $\\mathcal { D } : =$ $\\{ ( s _ { k } , a _ { k } , s _ { k } ^ { \\prime } \\} _ { k = 1 } ^ { N }$ given by state-action-next-state transitions in the environment induced by an unknown expert policy $\\pi _ { \\mathrm { e x p } }$ and the goal is to learn a behavior policy $\\pi$ which recovers $\\pi _ { \\mathrm { e x p } }$ . During the learning process, in addition to the finite set of expert demonstrations $\\mathcal { D }$ , one may also optionally interact with the environment (in these interactions, no rewards are observed). This setting describes a number of real-world applications where rewards are unknown, such as Pomerleau (1989); Muller et al. (2006); Bojarski et al. (2016). ",
+        "bbox": [
+            174,
+            561,
+            825,
+            674
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 BEHAVIORAL CLONING (BC) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            700,
+            418,
+            715
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Supervised behavioral cloning (BC) is a popular approach for imitation learning. Given a set of expert demonstrations, a mapping of state observations to actions is fit using regression or density estimation. In the simplest case, one simply trains the behavior policy $\\pi$ to minimize the negative log-likelihood of the observed expert actions: ",
+        "bbox": [
+            174,
+            731,
+            825,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4bbe2e9e2058a19c946206f2d19e81bda9ab96147eee9686a2922c660c9179d5.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\pi } J _ { \\mathrm { B C } } ( \\pi ) : = - \\frac { 1 } { N } \\sum _ { k = 1 } ^ { N } \\log \\pi ( a _ { k } | s _ { k } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            795,
+            630,
+            838
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Unlike Inverse Reinforcement Learning (IRL) algorithms (e.g. GAIL (Ho & Ermon, 2016)), BC does not perform any additional policy interactions with the learning environment and hence does not suffer from the same issue of policy sample complexity. However, behavioral cloning suffers from distributional drift (Ross et al., 2011); i.e., there is no way for $\\pi$ to learn how to recover if it deviates from the expert behavior to a state $\\tilde { s }$ not seen in the expert demonstrations. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 DISTRIBUTION MATCHING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            400,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The distribution matching approach provides a family of methods that are robust to distributional shift. Rather than considering the policy directly as a conditional distribution $\\pi ( \\cdot | s )$ over actions, this approach considers the state-action distribution induced by a policy. In particular, under certain conditions (Puterman, 2014), there is a one-to-one correspondence between a policy and its stateaction distribution $d ^ { \\pi }$ defined as,∞ ",
+        "bbox": [
+            173,
+            128,
+            825,
+            200
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a85d67e9bcc4c6752ff74cf8845cbf24d2f1e5c51e03b3e762f5b652072d6b9a.jpg",
+        "text": "$$\nd ^ { \\pi } ( s , a ) = ( 1 - \\gamma ) \\cdot \\sum _ { t = 0 } ^ { } \\gamma ^ { t } p ( s _ { t } = s , a _ { t } = a | s _ { 0 } \\sim p _ { 0 } ( \\cdot ) , s _ { t } \\sim p ( \\cdot | s _ { t - 1 } , a _ { t - 1 } ) , a _ { t } \\sim \\pi ( \\cdot | s _ { t } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            200,
+            792,
+            233
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By the same token, the unknown expert policy also possesses a state-action distribution $d ^ { \\mathrm { e x p } }$ , and one may usually assume that the expert demonstrations $\\mathcal { D } : = \\{ ( s _ { k } , a _ { k } , s _ { k } ^ { \\prime } \\} _ { k = 1 } ^ { N }$ are sampled as $( s _ { k } , a _ { k } ) \\sim d ^ { \\mathrm { e x p } } , s _ { k } ^ { \\prime } \\sim p ( \\cdot | s _ { k } , a _ { k } )$ . ",
+        "bbox": [
+            174,
+            234,
+            825,
+            280
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Accordingly, the distribution matching approach proposes to learn $\\pi$ to minimize the divergence between $d ^ { \\pi }$ and $d ^ { \\mathrm { e x p } }$ . The KL-divergence is typically used to measure the discrepancy between $d ^ { \\pi }$ and $d ^ { \\mathrm { e x p } }$ (Ho & Ermon, 2016; Ke et al., 2019): ",
+        "bbox": [
+            173,
+            285,
+            825,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cb8e7bd0dbfd7d9e7738c2254d13a713679664dd55e65f903ade59adf14f020.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { \\angle U 1 U , \\ n c \\ e u \\ a t . , \\angle U 1 5 } ) . } \\\\ & { \\mathrm { \\phantom { { \\sum } D _ { K L } } } \\left( d ^ { \\pi } | | d ^ { \\mathrm { e x p } } \\right) = \\mathbb { E } _ { ( s , a ) \\sim d ^ { \\pi } } \\left[ \\log \\frac { d ^ { \\mathrm { e x p } } ( s , a ) } { d ^ { \\pi } ( s , a ) } \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            319,
+            665,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The use of the KL-divergence is convenient, as it may be expressed as an RL problem where rewards are given by log distribution ratios: ",
+        "bbox": [
+            173,
+            356,
+            821,
+            383
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/65759ea29c46651ce64c70e1519f0757fe4f1269c2fd671583add1db2973d331.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\textrm { y } \\log \\mathrm { ~ d r s t r u t o u t o n ~ r i a u t o r s . } } \\\\ & { \\quad - D _ { \\mathrm { K L } } \\left( d ^ { \\pi } | | d ^ { \\mathrm { e x p } } \\right) = ( 1 - \\gamma ) \\cdot \\underset { s _ { 0 } \\sim p _ { 0 } ( \\cdot ) , \\ a _ { t } \\sim \\pi ( \\cdot | s _ { t } ) } { \\mathbb { E } } \\left[ \\displaystyle \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } \\log \\frac { d ^ { \\mathrm { e x p } } \\left( s _ { t } , a _ { t } \\right) } { d ^ { \\pi } \\left( s _ { t } , a _ { t } \\right) } \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            246,
+            376,
+            753,
+            426
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In other words, if one has access to estimates of the distribution ratios of the two policies, then the minimum divergence problem reduces to a max-return RL problem with rewards $\\tilde { r } ( s , a ) =$ lo g dexp(s,a)dπ(s,a) . Any on-policy or off-policy RL algorithm can be used to maximize the corresponding expected returns in Equation 4. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Capitalizing on this observation, Ho & Ermon (2016) and Ke et al. (2019) propose algorithms (e.g., GAIL) in which the distribution ratio is estimated using a GAN-like objective: ",
+        "bbox": [
+            168,
+            503,
+            825,
+            534
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1a0d6344e40f518fcd553e7957066631b82bc79c7ec94e7b8ccf9303af46a106.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { h \\colon \\mathcal { S } \\times \\mathcal { A } \\to ( 0 , 1 ) } J _ { \\mathrm { G A I L } } ( h ) : = \\mathbb { E } _ { ( s , a ) \\sim d ^ { \\mathrm { e x p } } } [ \\log h ( s , a ) ] + \\mathbb { E } _ { ( s , a ) \\sim d ^ { \\tau } } [ \\log ( 1 - h ( s , a ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            535,
+            767,
+            560
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this objective, the function $h$ acts as a discriminator, discriminating between samples $( s , a )$ from $d ^ { \\mathrm { e x p } }$ and $d ^ { \\pi }$ . The optimal discriminator satisfies, ",
+        "bbox": [
+            179,
+            564,
+            823,
+            592
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ee51da2ccbcaa0042978954f18ffca2ceb8ade2dece2807fb40035df5b8304f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { \\ a t { 1 0 5 4 . 1 1 1 1 1 1 4 U 1 } \\ s a t { 1 5 1 0 5 } } , } \\\\ & { \\log { h ^ { \\ast } ( s , a ) } - \\log ( 1 - h ^ { \\ast } ( s , a ) ) = \\log \\frac { d ^ { \\mathrm { e x p } } ( s , a ) } { d ^ { \\pi } ( s , a ) } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            585,
+            666,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "and so the distribution matching rewards may be computed as $\\tilde { r } ( s , a ) = \\log h ^ { * } ( s , a ) - \\log ( 1 -$ $h ^ { * } ( s , a ) )$ . In practice, the discriminator is not fully optimized, and instead gradient updates to the discriminator and policy are alternated. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            665
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "These prior distribution matching approaches possess two limitations which we will resolve with our proposed ValueDICE algorithm: ",
+        "bbox": [
+            174,
+            670,
+            821,
+            700
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• On-policy. Arguably the main limitation of these prior approaches is that they require access to on-policy samples from $d ^ { \\pi }$ . While off-policy RL can be used for learning $\\pi$ , optimizing the discriminator $h$ necessitates having on-policy samples (the second expectation in Equation 5). Thus, in practice, GAIL requires a prohibitively large number of environment interactions, making it unfeasible for use in many real-world applications. Attempts to remedy this, such as DiscriminatorActor-Critic (DAC) (Kostrikov et al., 2019), often do so via ad-hoc methods; for example, changing the on-policy expectation $\\mathbb { E } _ { ( s , a ) \\sim d ^ { \\pi } } [ \\log ( 1 - h ( s , a ) ) ]$ in Equation 5 to an expectation over the replay buffer $\\mathbb { E } _ { ( s , a ) \\sim d ^ { \\mathrm { R B } } } [ \\log ( 1 - h ( s , a ) ) ]$ . While DAC achieves good empirical results, it does not guarantee distribution matching of $\\pi$ to $\\pi _ { \\mathrm { e x p } }$ , especially when $d ^ { \\mathrm { R B } }$ is far from $d ^ { \\pi }$ . ",
+        "bbox": [
+            174,
+            705,
+            825,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Separate RL optimization. Prior approaches require iteratively taking alternating steps: first estimate the data distribution ratios using the GAN-like objective, then input these into an RL optimization and repeat. The use of a separate RL algorithm introduces complexity to any implementation of these approaches, with many additional design choices that need to be made and more function approximators to learn (e.g., value functions). Our introduced ValueDICE will be shown to not need a separate RL optimization. ",
+        "bbox": [
+            174,
+            837,
+            825,
+            921
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 OFF-POLICY FORMULATION OF THE KL-DIVERGENCE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            101,
+            656,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As is standard in distribution matching, we begin with the KL-divergence between the policy stateaction occupancies and the expert. However, in contrast to the form used in Equation 4 or 5, we use the Donsker-Varadhan representation (Donsker & Varadhan, 1983) given by, ",
+        "bbox": [
+            173,
+            132,
+            825,
+            176
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/22437e94c7eb099eb853cf99768266544ee2d314444fb56c29a0456a7147b594.jpg",
+        "text": "$$\n- D _ { \\mathrm { K L } } \\left( d ^ { \\pi } | | d ^ { \\mathrm { e x p } } \\right) = \\operatorname* { m i n } _ { x : S \\times \\mathcal { A } \\to \\mathbb { R } } \\log \\mathbb { E } _ { ( s , a ) \\sim d ^ { \\mathrm { e x p } } } [ e ^ { x ( s , a ) } ] - \\mathbb { E } _ { ( s , a ) \\sim d ^ { \\pi } } [ x ( s , a ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            183,
+            751,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to Equation 5, this dual representation of the KL has a property that is important for imitation learning. The optimal $x ^ { * }$ is equal to the log distribution ratio (plus a constant):2 ",
+        "bbox": [
+            174,
+            214,
+            823,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0dd145ff69c8593736b139d7d7396c9d83dae6ab968267a1ed45c9e988e00a76.jpg",
+        "text": "$$\nx ^ { * } ( s , a ) = \\log \\frac { d ^ { \\pi } ( s , a ) } { d ^ { \\exp } ( s , a ) } + C .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            248,
+            602,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our considered infinite-horizon setting, the constant does not affect optimality and so we will ignore it (take $C = 0$ ). If one were to take a GAIL-like approach, they could use this form of the KL to estimate distribution matching rewards given by $\\tilde { r } ( \\bar { s } , a ) = - x ^ { * } ( s , a )$ , and these could then be maximized by any standard RL algorithm. However, there is no clear advantage of this objective over GAIL since it still relies on an expectation with respect to on-policy samples from $d ^ { \\pi }$ . ",
+        "bbox": [
+            173,
+            289,
+            825,
+            359
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To make this objective practical for off-policy learning, we take inspiration from derivations used in DualDICE (Nachum et al., 2019b), and perform the following change of variables:3 ",
+        "bbox": [
+            173,
+            364,
+            823,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5cddfbbd32a2b1fb396da1b07a15c933f07facd1b9367aa89f5561db83cec78.jpg",
+        "text": "$$\n\\begin{array} { r } { x ( s , a ) = \\nu ( s , a ) - B ^ { \\pi } \\nu ( s , a ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            400,
+            601,
+            417
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $B ^ { \\pi }$ is the expected Bellman operator with respect to policy $\\pi$ and zero reward: ",
+        "bbox": [
+            174,
+            424,
+            730,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4f02c4c5c38a442a62abf8e5eaa75a7e355f73bf82b26e95fc246636d9e5f5ff.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { B } ^ { \\pi } \\nu ( s , a ) = \\gamma \\mathbb { E } _ { s ^ { \\prime } \\sim p ( \\cdot \\vert s , a ) , a ^ { \\prime } \\sim \\pi ( \\cdot \\vert s ^ { \\prime } ) } [ \\nu ( s ^ { \\prime } , a ^ { \\prime } ) ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            445,
+            651,
+            464
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This change of variables is explicitly chosen to take advantage of the linearity of the second expectation in Equation 7. Specifically, the representation becomes, ",
+        "bbox": [
+            173,
+            469,
+            821,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d67a86b88b6ce34d40afdb5da59ad0c9cb95133dc0919a4cd9fed31ae813a212.jpg",
+        "text": "$$\n- D _ { \\mathrm { K L } } \\left( d ^ { \\pi } | | d ^ { \\mathrm { e x p } } \\right) = \\operatorname* { m i n } _ { \\substack { \\nu : S \\times A \\to \\mathbb { R } } } \\log \\underset { ( s , a ) \\sim d ^ { \\mathrm { e x p } } } { \\mathbb { E } } [ e ^ { \\nu ( s , a ) - B ^ { \\pi } \\nu ( s , a ) } ] - \\underset { ( s , a ) \\sim d ^ { \\pi } } { \\mathbb { E } } [ \\nu ( s , a ) - B ^ { \\pi } \\nu ( s , a ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            503,
+            789,
+            532
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the second expectation conveniently telescopes and reduces to an expectation over initial states (see Nachum et al. (2019b) for details): ",
+        "bbox": [
+            173,
+            539,
+            823,
+            566
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf554ca9f2ab5dd2436d552e94293e091d34868549629f6ceb697d8429a86e99.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\substack { \\nu : S \\times A \\to \\mathbb { R } } } J _ { \\mathrm { D I C E } } ( \\nu ) : = \\log \\underset { ( s , a ) \\sim d ^ { \\mathrm { e x p } } } { \\mathbb { E } } [ e ^ { \\nu ( s , a ) - B ^ { \\pi } \\nu ( s , a ) } ] - ( 1 - \\gamma ) \\cdot \\underset { \\substack { s _ { 0 } \\sim \\pi p ( \\cdot | s _ { 0 } ) } } { \\mathbb { E } } [ \\nu ( s _ { 0 } , a _ { 0 } ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            197,
+            571,
+            776,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus we achieve our $V a l u e D I C E ^ { 4 }$ objective. It allows us to express the KL-divergence between $d ^ { \\pi }$ and $d ^ { \\mathrm { e x p } }$ in terms of an objective over a ‘value-function’ $\\nu$ expressed in an off-policy manner, with expectations over expert demonstrations $d ^ { \\mathrm { e x p } }$ and initial state distribution $p _ { 0 } ( \\cdot )$ . ",
+        "bbox": [
+            176,
+            619,
+            821,
+            662
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "It is clear that the derived objective in Equation 12 possesses two key characteristics missing from prior distribution matching algorithms: First, the objective does not rely on access to samples from the on-policy distribution $d ^ { \\pi }$ , and so may be used in more realistic, off-policy settings. Second, the objective describes a proper divergence between $d ^ { \\pi }$ and $d ^ { \\mathrm { e x p } }$ , as opposed to estimating a divergence between $d ^ { \\mathrm { R B } }$ and $d ^ { \\mathrm { e x p } }$ , and thus avoids poor behavior when $d ^ { \\mathrm { R B } }$ is far from $d ^ { \\pi }$ . In the following section, we will go further to show how the objective in Equation 12 also renders the use of a separate RL optimization unnecessary. ",
+        "bbox": [
+            173,
+            669,
+            825,
+            767
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 VALUEDICE: IMITATION LEARNING WITH IMPLICIT REWARDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            728,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Although it is standard in distribution matching to have separate optimizations for estimating the distribution ratios and learning a policy, in our case this can be mitigated. Indeed, looking at our ",
+        "bbox": [
+            176,
+            819,
+            821,
+            848
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "formulation of the KL in Equation 12, we see that gradients of this objective with respect to $\\pi$ may be easily computed. Specifically, we may express the distribution matching objective for $\\pi$ as a max-min optimization: ",
+        "bbox": [
+            176,
+            103,
+            825,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a5c5dcc68e8c674b9993b833475699c96fa7fd06c012e73c84addfec844dcd33.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi } \\operatorname* { m i n } _ { \\nu : S \\times A \\to \\mathbb { R } } J _ { \\mathrm { D I C E } } ( \\pi , \\nu ) : = \\log \\underset { ( s , a ) \\sim d ^ { \\mathrm { e x p } } } { \\mathbb { E } } [ e ^ { \\nu ( s , a ) - B ^ { \\pi } \\nu ( s , a ) } ] - ( 1 - \\gamma ) \\cdot \\underset { s _ { 0 } \\sim p _ { 0 } ( \\cdot ) _ { 0 } } { \\mathbb { E } } [ \\nu ( s _ { 0 } , a _ { 0 } ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            183,
+            143,
+            790,
+            184
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If the inner objective over $\\nu$ is sufficiently optimized, the gradients of $\\pi$ may be computed directly (Bertsekas, 1999), noting that, ",
+        "bbox": [
+            173,
+            190,
+            823,
+            219
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd33fda80140225d917258b8ba632560234967d7516a8e90fe05f61ff4a82f90.jpg",
+        "text": "$$\n\\frac { \\partial } { \\partial \\pi } e ^ { \\nu ( s , a ) - B ^ { \\pi } \\nu ( s , a ) } = - \\gamma \\cdot e ^ { \\nu ( s , a ) - B ^ { \\pi } \\nu ( s , a ) } \\cdot \\mathbb { E } _ { s ^ { \\prime } \\sim T ( s , a ) , a ^ { \\prime } \\sim \\pi ( s ^ { \\prime } ) } [ \\nu ( s ^ { \\prime } , a ^ { \\prime } ) \\nabla \\log \\pi ( a ^ { \\prime } | s ^ { \\prime } ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            194,
+            223,
+            776,
+            252
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/13713bfea58f205525e167d1afcf8cfb647cd40ab52c2077cb7c3b28d89c0dcf.jpg",
+        "text": "$$\n\\frac { \\partial } { \\partial \\pi } \\mathbb { E } _ { s _ { 0 } \\sim p _ { 0 } ( \\cdot ) , a _ { 0 } \\sim \\pi ( \\cdot | s _ { 0 } ) } [ \\nu ( s _ { 0 } , a _ { 0 } ) ] = \\mathbb { E } _ { s _ { 0 } \\sim p _ { 0 } ( \\cdot ) , a _ { 0 } \\sim \\pi ( \\cdot | s _ { 0 } ) } [ \\nu ( s _ { 0 } , a _ { 0 } ) \\nabla \\log \\pi ( a _ { 0 } | s _ { 0 } ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            214,
+            258,
+            759,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In continuous control environments when $\\pi$ is parameterized by a Gaussian and $\\nu$ is a neural network, one may use the re-parameterization trick (Haarnoja et al., 2018) to compute gradients of the $\\nu$ -values with respect to policy mean and variance directly as opposed to computing $\\nabla \\log \\pi ( a | s )$ . Please see the appendix for a full pseudocode implementation of ValueDICE. We note that in practice, as in GAIL, we do not train $\\nu$ until optimality but rather alternate $\\nu$ and $\\pi$ updates. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            362
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The mechanics of learning $\\pi$ according to the ValueDICE objective are straightforward, but what is the underlying reason for this more streamlined policy learning? How does it relate the standard protocol of alternating data distribution estimation with RL optimization? To better understand this, we consider the form of $\\nu$ when it is completely optimized. If we consider the original change of variables (Equation 9) and optimality characterization (Equation 8) we have, ",
+        "bbox": [
+            174,
+            367,
+            825,
+            438
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac9dc5c44924d3ad3c713ca3b3ab19a0e00ffbb40c0abf22071c834c4744c541.jpg",
+        "text": "$$\n\\nu ^ { * } ( s , a ) - \\bar { B ^ { \\pi } } \\nu ^ { * } ( s , a ) = x ^ { * } ( s , a ) = \\log \\frac { d ^ { \\pi } ( s , a ) } { d ^ { \\exp } ( s , a ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            438,
+            671,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "From this characterization of $\\nu ^ { * }$ , we realize that $\\nu ^ { * }$ is a sort of $\\mathrm { Q }$ -value function: $\\nu ^ { * } ( s , a )$ is the future discounted sum of rewards r˜(s, a) := log dπ(s,a)dexp(s,a) when acting according to $\\pi$ . The gradients for $\\pi$ then encourage the policy to choose actions which minimize $\\nu ^ { * } ( s , a )$ , i.e., maximize future discounted log ratios dexp(s,a)dπ(s,a) . Thus we realize that the objective for π in ValueDICE performs exactly the RL optimization suggested by Equation 4. The streamlined nature of ValueDICE comes from the fact that the value function $\\nu$ (which would traditionally need to be learned as a critic in a separate actor-critic RL algorithm) is learned directly from the same objective as that used for distribution matching. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, in addition to estimating a proper divergence between $d ^ { \\pi }$ and $d ^ { \\mathrm { e x p } }$ in an off-policy manner, ValueDICE also greatly simplifies the implementation of distribution matching algorithms. There is no longer a need to use a separate RL algorithm for learning $\\pi$ , and moreover, the use of $\\nu$ as a value function removes any use of explicit rewards. Instead, the objective and implementation are only in terms of policy $\\pi$ and function $\\nu$ . ",
+        "bbox": [
+            174,
+            609,
+            825,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 SOME PRACTICAL CONSIDERATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            513,
+            718
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to make use of the ValueDICE objective (Equation 13) in practical scenarios, where one does not have access to $d ^ { \\mathrm { e x p } }$ or $p _ { 0 } ( \\cdot )$ but rather only limited finite samples, we perform several modifications. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            776
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 EMPIRICAL EXPECTATIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            794,
+            405,
+            808
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The objective in Equation 13 contains three expectations: ",
+        "bbox": [
+            174,
+            820,
+            549,
+            835
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. An expectation over $d ^ { \\mathrm { e x p } }$ (the first term of the objective). Note that this expectation has a logarithm outside of it, which would make any mini-batch approximations of the gradient of this expectation biased.   \n2. An expectation over $p _ { 0 } ( \\cdot )$ (the second term of the objective). This term is linear, and so is very amenable to mini-batch optimization. ",
+        "bbox": [
+            209,
+            847,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3. An expectation over the environment transition $p ( \\cdot | s , a )$ used to compute $B ^ { \\pi } \\nu ( s , a )$ . This expectation has a log-expected-exponent applied to it, so its mini-batch approximated gradient would be biased in general. ",
+        "bbox": [
+            212,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the first expectation, previous works have suggested a number of remedies to reduce the bias of mini-batch gradients, such as maintaining moving averages of various quantities (Belghazi et al., 2018). In the setting we considered, we found this to have a negligible effect on performance. In fact, simply using the biased mini-batched gradients was sufficient for good performance, and so we used this for our experiments. ",
+        "bbox": [
+            173,
+            159,
+            825,
+            228
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the second expectation, we use standard mini-batch gradients, which are unbiased. Although initial state distributions are usually not used in imitation learning, it is easy to record initial states as they are observed, and thus have access to an empirical sample from $p _ { 0 }$ . Furthermore, as detailed in Section 5.3, it is possible to modify the initial state distribution used in the objective without adverse effects. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, for the third expectation, previous works have suggested the use of Fenchel conjugates to remove the bias (Nachum et al., 2019b). In our case, we found this unnecessary and instead use a biased estimate based on the single sample $s ^ { \\prime } \\sim p ( \\cdot | s , a )$ . This naive approach was enough to achieve good performance on the benchmark domains we considered. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            368
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In summary, the empirical form of the objective is given by, ",
+        "bbox": [
+            173,
+            375,
+            565,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9e4aa466bab7791fe8b346d18a98611bb674ee8aff90077512c3414522c01b42.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\hat { J } _ { \\mathrm { D I C E } } ( \\pi , \\nu ) = } \\\\ & { \\qquad \\quad \\frac { \\mathbb { E } } { \\mathrm { b a t c h } ( \\mathcal { D } ) \\sim \\mathcal { D } } \\left[ \\log \\underset { s , a , s ^ { \\prime } \\sim \\mathrm { b a t c h } ( \\mathcal { D } ) } { \\mathbb { E } } \\left[ e ^ { \\nu ( s , a ) - \\gamma \\nu ( s ^ { \\prime } , a ^ { \\prime } ) } \\right] - ( 1 - \\gamma ) \\cdot \\underset { s _ { 0 } \\sim \\mathrm { b a t c h } ( p _ { 0 } ) } { \\mathbb { E } } \\left[ \\nu ( s _ { 0 } , a _ { 0 } ) \\right] \\right] , } \\\\ & { \\quad \\mathrm { b a t c h } ( p _ { 0 } ) \\sim \\hat { p } _ { 0 } \\quad \\quad a ^ { \\prime } \\sim \\pi ( \\cdot | s ^ { \\prime } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            395,
+            781,
+            460
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where batch $( \\mathcal { D } )$ is a mini-batch from $\\mathcal { D }$ and batch $\\left( p _ { 0 } \\right)$ is a mini-batch from the recorded initial states $\\hat { p } _ { 0 }$ . ",
+        "bbox": [
+            174,
+            469,
+            823,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 REPLAY BUFFER REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            460,
+            534
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The original ValueDICE objective uses only expert samples and the initial state distribution. In practice, the number of expert samples may be small and lack diversity, hampering learning. In order to increase the diversity of samples used for training, we consider an alternative objective, with a controllable regularization based on experience in the replay buffer: ",
+        "bbox": [
+            174,
+            545,
+            825,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3b91bf8ba6bb7adb77c87020c672d6e05d0eefcd1481b8097d58e5ad5a7e6127.jpg",
+        "text": "$$\n\\begin{array} { r l } & { J _ { \\mathrm { D I C E } } ^ { \\mathrm { m i x } } ( \\pi , \\nu ) : = \\log \\underset { ( s , a ) \\sim d ^ { \\mathrm { m i x } } } { \\mathbb { E } } [ e ^ { \\nu ( s , a ) - \\mathcal { B } ^ { \\pi } \\nu ( s , a ) } ] - ( 1 - \\alpha ) ( 1 - \\gamma ) \\cdot \\underset { \\underset { a _ { 0 } \\sim \\pi ( \\cdot ) , ( s _ { 0 } ) } { \\sum _ { \\substack { s _ { 0 } \\sim \\pi ( \\cdot ) , ( s _ { 0 } ) } } } } { \\mathbb { E } } [ \\nu ( s _ { 0 } , a _ { 0 } ) ] } \\\\ & { \\qquad - \\underset { ( s , a ) \\sim d ^ { \\mathrm { R B } } } { \\mathbb { E } } [ \\nu ( s , a ) - \\mathcal { B } ^ { \\pi } \\nu ( s , a ) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            603,
+            781,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $d ^ { \\mathrm { m i x } } ( s , a ) = ( 1 - \\alpha ) d ^ { \\mathrm { e x p } } ( s , a ) + \\alpha d ^ { \\mathrm { R B } } ( s , a )$ . ",
+        "bbox": [
+            176,
+            681,
+            529,
+            696
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The main advantage of this formulation is that it introduces $\\nu$ -values into the objective on samples that are outside the given expert demonstrations. Thus, if $\\pi$ deviates from the expert trajectory, we will still be able to learn optimal actions that return the policy back to the expert behavior. At the same time, one can verify that in this formulation the optimal $\\pi$ still matches $\\pi _ { \\mathrm { e x p } }$ , unlike other proposals for incorporating a replay buffer distribution (Kostrikov et al., 2019). Indeed, the objective in Equation 18 corresponds to the Donsker-Varadhan representation, ",
+        "bbox": [
+            174,
+            696,
+            826,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/378de2f49d49370ad18918518d36a5199b18b6f458755ff257eb9856ba9c9091.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\quad - D _ { \\mathrm { K L } } ( ( 1 - \\alpha ) d ^ { \\pi } + \\alpha d ^ { \\mathrm { R B } } \\parallel ( 1 - \\alpha ) d ^ { \\mathrm { e x p } } + \\alpha d ^ { \\mathrm { R B } } ) = } \\\\ & { \\quad \\underset { x : S \\times A \\to \\mathbb { R } } { \\operatorname* { m i n } } \\log \\mathbb { E } _ { ( s , a ) \\sim d ^ { \\operatorname* { m i n } } } [ e ^ { x ( s , a ) } ] - ( 1 - \\alpha ) \\cdot \\mathbb { E } _ { ( s , a ) \\sim d ^ { \\pi } } \\left[ x ( s , a ) \\right] - \\alpha \\cdot \\mathbb { E } _ { ( s , a ) \\sim d ^ { \\mathrm { R B } } } \\left[ x ( s , a ) \\right] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            178,
+            781,
+            781,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "and so the optimal values of $\\nu ^ { * }$ satisfy, ",
+        "bbox": [
+            174,
+            838,
+            429,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5be9ab3dfd30e96feb36cc543b49dfb0566d577a9ef5c7dc7135b0f70c301b59.jpg",
+        "text": "$$\n\\nu ^ { * } ( s , a ) - \\mathcal { B } ^ { \\pi } \\nu ^ { * } ( s , a ) = x ^ { * } ( s , a ) = \\log \\frac { ( 1 - \\alpha ) d ^ { \\pi } ( s , a ) + \\alpha d ^ { \\mathrm { R B } } ( s , a ) } { ( 1 - \\alpha ) d ^ { \\exp } ( s , a ) + \\alpha d ^ { \\mathrm { R B } } ( s , a ) } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            852,
+            743,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Therefore, the global optimality of $\\pi = \\pi _ { \\mathrm { e x p } }$ is unaffected by any choice of $\\alpha < 1$ . We note that in practice we use a small value $\\alpha = 0 . 1$ for regularization. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 INITIAL STATE SAMPLING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            397,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Recall that $d ^ { \\mathrm { e x p } } , d ^ { \\pi }$ traditionally refer to discounted state-action distributions. That is, sampling from them is equivalent to first sampling a trajectory $( s _ { 0 } , a _ { 0 } , s _ { 1 } , a _ { 1 } , . . . , s _ { T } )$ and then sampling a time index $t$ from a geometric distribution $\\mathrm { G e o m } ( 1 - \\gamma )$ (appropriately handling samples that are beyond $T$ ). This means that samples far into the trajectory do not contribute much to the objective. To remedy this, we propose treating every state in a trajectory as an ‘initial state.’ That is, we consider a single environment trajectory $( s _ { 0 } , a _ { 0 } , s _ { 1 } , a _ { 1 } , . . . , s _ { T } )$ as $T$ distinct virtual trajectories $\\{ ( s _ { t } , a _ { t } , s _ { t + 1 } , a _ { t + 1 } , \\ldots , s _ { T } ) \\} _ { t = 0 } ^ { T - 1 }$ . We apply this to both $d ^ { \\mathrm { e x p } }$ and $d ^ { \\pi }$ , so that not only does it increase the diversity of samples from $d ^ { \\mathrm { e x p } }$ , but it also expands the initial state distribution $p _ { 0 } ( \\cdot )$ to encompass every state in a trajectory. We note that this does not affect the optimality of the objective with respect to $\\pi$ , since in Markovian environments an expert policy should be expert regardless of the state at which it starts (Puterman, 2014). ",
+        "bbox": [
+            174,
+            130,
+            825,
+            285
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            306,
+            344,
+            321
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In recent years, the development of Adversarial Imitation Learning has been mostly focused on on-policy algorithms. After Ho & Ermon (2016) proposed GAIL to perform imitation learning via adversarial training, a number of extensions has been introduced. Many of these applications of the AIL framework (Li et al., 2017; Hausman et al., 2017; Fu et al., 2017) maintain the same form of distribution ratio estimation as GAIL which necessitates on-policy samples. In contrast, our work presents an off-policy formulation of the same objective. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            421
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although several works have attempted to apply the AIL framework to off-policy settings, these previous approaches are markedly different from our own. For example, Kostrikov et al. (2019) proposed to train the discriminator in the GAN-like AIL objective using samples from a replay buffer instead of samples from a policy. This changes the distribution ratio estimation to measure a divergence between the expert and the replay. Although we introduce a controllable parameter $\\alpha$ for incorporating samples from the replay buffer into the data distribution objective, we note that in practice we use a very small $\\alpha = 0 . 1$ . Furthermore, by using samples from the replay buffer in both terms of the objective as opposed to just one, the global optimality of the expert policy is not affected. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The off-policy formulation of the KL-divergence we derive is motivated by similar techniques in DualDICE (Nachum et al., 2019b). Still, our use of these techniques provides several novelties. First, Nachum et al. (2019b) only use the divergence formulation for data distribution estimation (which is used for off-policy evaluation), assuming a fixed policy. We use the formulation for learning a policy to minimize the divergence directly. Moreover, previous works have only applied these derivations to the $f$ -divergence form of the KL-divergence, while we are the first to utilize the Donsker-Varadhan form. Anecdotally in our initial experiments, we found that using the $f$ -divergence form leads to poor performance. We note that our proposed objective follows a form similar to REPS (Peters et al., 2010), which also utilizes a log-average-exp term. However, policy and value learning in REPS are performed via a bi-level optimization (i.e., the policy is learned with respect to a different objective), which is distinct from our algorithm, which trains values and policy with respect to the same objective. Our proposed ValueDICE is also significant for being able to incorporate arbitrary (non-expert) data into its learning. ",
+        "bbox": [
+            173,
+            560,
+            825,
+            741
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            762,
+            326,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate ValueDICE in a variety of settings, starting with a simple synthetic task before continuing to an evaluation on a suite of MuJoCo benchmarks. ",
+        "bbox": [
+            174,
+            795,
+            823,
+            823
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7.1 RING MDP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            294,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We begin by analyzing the behavior of ValueDICE on a simple synthetic MDP (Figure 1). The states of the MDP are organized in a ring. At each state, two actions are possible: move clockwise or counter-clockwise. We first look at the performance of ValueDICE in a situation where the expert data is sparse and does not cover all states and actions. Specifically, we provide expert demonstrations which cover only states 0, 1, and 2 (see Figure 1 left). While the problem of recovering the true (unknown) expert is ill-defined, it is still possible to find a policy which recovers close to the same occupancies. Indeed, this is the policy found by ValueDICE, which chooses the appropriate actions at each state to optimally reach states 1 and 2 (and alternating between states 1 and 2 when at these states). In many practical scenarios, this is the desired outcome – if the imitating policy somehow encounters a situation which deviates from the expert demonstrations, we would like it to return to the expert behavior as fast as possible. Notably, a technique like behavioral cloning would fail to learn this optimal policy, since its learning is only based on observed expert data. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2ff15254829b8cfb1c8cdb6e54c49f215f39c79c75058fb8ad858933a24fa0cd.jpg",
+        "image_caption": [
+            "Figure 1: Results of ValueDICE on a simple Ring MDP. Left: The expert data is sparse and only covers states 0, 1, and 2. Nevertheless, ValueDICE is able to learn a policy on all states to best match the observed expert state-action occupancies (the policy learns to always go to states 1 and 2). Right: The expert is stochastic. ValueDICE is able to learn a policy which successfully minimizes the true KL computed between $d ^ { \\pi }$ and $d ^ { \\mathrm { e x p } }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            99,
+            800,
+            212
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e6aa314483fc0a1134e24081dcfdc01334e721b3d325da7bd3612178015a436a.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of algorithms given 1 expert trajectory. We use the original implementation of GAIL (Ho & Ermon, 2016) to produce GAIL and BC results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            310,
+            759,
+            414
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            484,
+            825,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We also analyzed the behavior of ValueDICE with a stochastic expert (Figure 1 right). By using a synthetic MDP, we are able to measure the divergence $D _ { \\mathrm { K L } } ( d ^ { \\pi } | | d ^ { \\exp } )$ during training. As expected, we find that this divergence decreases during ValueDICE training. ",
+        "bbox": [
+            176,
+            603,
+            821,
+            646
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.2 MUJOCO BENCHMARKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            664,
+            383,
+            678
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare ValueDICE against Discriminator-Actor-Critic (DAC) (Kostrikov et al., 2019), which is the state-of-the-art in sample-efficient adversarial imitation learning, as well as GAIL (Ho & Ermon, 2016). We evaluate the algorithms on the standard MuJoCo environments using expert demonstrations from Ho & Ermon (2016). We plot the average returns for the learned policies (using a mean action for sampling) every 1000 environment steps using 10 episodes. We perform this procedure for 10 different seeds and compute means and standard deviations (see Fig. 2 and 3, we visualize a half of standard deviation on these plots). ",
+        "bbox": [
+            174,
+            690,
+            825,
+            746
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa089b6dfddf0856cc431126a3f3e087e9b34a5e6583d32af94ed14eca9a456e.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of algorithms given 10 expert trajectories. ValueDICE outperforms other methods. However, given this amount of data, BC can recover the expert policy as well. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            771,
+            761,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We present the extremely low-data regime first. In Figure 2 we present the results of the imitation learning algorithms given only a single expert trajectory. We find that ValueDICE performs similar or better than DAC an all tasks, with the exception of Walker2d where it converges to a slightly worse policy. Notably, in this low-data regime, behavioral cloning (BC) usually cannot recover the expert policy. We also present the results of these algorithms on a larger number of expert demonstrations (Figure 3). We continue to observe strong performance of ValueDICE as well as faster convergence on all tasks. It is worth mentioning that in this large-data regime, Behavior Cloning can recover the expert performance as well. In all of these scenarios, GAIL is too sample-inefficient to make any progress. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            279
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            297,
+            318,
+            314
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We introduced ValueDICE, an algorithm for imitation learning that outperforms the state-of-the-art on standard MuJoCo tasks. In contrast to other algorithms for off-policy imitation learning, the algorithm introduced in this paper performs robust divergence minimization in a principled off-policy manner and a strong theoretical framework. To the best of our knowledge, this is also the first algorithm for adversarial imitation learning that omits learning or defining rewards explicitly and directly learns a Q-function in the distribution ratio objective directly. We demonstrate the robustness of ValueDICE in a challenging synthetic tabular MDP environment, as well as on standard MuJoCo continuous control benchmark environments, and we show increased performance over baselines in both the low and high data regimes. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            285,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pieter Abbeel and Andrew Y Ng. Apprenticeship learning via inverse reinforcement learning. In Proceedings of the twenty-first international conference on Machine learning, pp. 1. ACM, 2004. ",
+        "bbox": [
+            176,
+            497,
+            823,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Bowen Baker, Maciek Chociej, Rafal Jozefowicz, Bob McGrew, Jakub Pachocki, Arthur Petron, Matthias Plappert, Glenn Powell, Alex Ray, et al. Learning dexterous in-hand manipulation. arXiv preprint arXiv:1808.00177, 2018. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            575
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mohamed Ishmael Belghazi, Aristide Baratin, Sai Rajeswar, Sherjil Ozair, Yoshua Bengio, Aaron Courville, and R Devon Hjelm. Mine: mutual information neural estimation. arXiv preprint arXiv:1801.04062, 2018. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            626
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "D. P. Bertsekas. Nonlinear Programming. Athena Scientific, Belmont, MA, second edition, 1999. ",
+        "bbox": [
+            173,
+            633,
+            813,
+            650
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016. ",
+        "bbox": [
+            174,
+            656,
+            821,
+            700
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv preprint arXiv:1809.11096, 2018. ",
+        "bbox": [
+            173,
+            707,
+            821,
+            736
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Monroe D Donsker and SR Srinivasa Varadhan. Asymptotic evaluation of certain markov process expectations for large time. iv. Communications on Pure and Applied Mathematics, 36(2):183– 212, 1983. ",
+        "bbox": [
+            173,
+            743,
+            823,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Fu, Katie Luo, and Sergey Levine. Learning robust rewards with adversarial inverse reinforcement learning. arXiv preprint arXiv:1710.11248, 2017. ",
+        "bbox": [
+            171,
+            794,
+            821,
+            824
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in neural information processing systems, pp. 5767–5777, 2017. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Aurick Zhou, Kristian Hartikainen, George Tucker, Sehoon Ha, Jie Tan, Vikash Kumar, Henry Zhu, Abhishek Gupta, Pieter Abbeel, et al. Soft actor-critic algorithms and applications. arXiv preprint arXiv:1812.05905, 2018. ",
+        "bbox": [
+            178,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karol Hausman, Yevgen Chebotar, Stefan Schaal, Gaurav Sukhatme, and Joseph J Lim. Multimodal imitation learning from unstructured demonstrations using generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 1235–1245, 2017. ",
+        "bbox": [
+            178,
+            155,
+            820,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ho and Stefano Ermon. Generative adversarial imitation learning. In Advances in neural information processing systems, pp. 4565–4573, 2016. ",
+        "bbox": [
+            174,
+            207,
+            820,
+            236
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Liyiming Ke, Matt Barnes, Wen Sun, Gilwoo Lee, Sanjiban Choudhury, and Siddhartha Srinivasa. Imitation learning as $f$ -divergence minimization. arXiv preprint arXiv:1905.12888, 2019. ",
+        "bbox": [
+            174,
+            243,
+            821,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ilya Kostrikov, Kumar Krishna Agrawal, Debidatta Dwibedi, Sergey Levine, and Jonathan Tompson. Discriminator-actor-critic: Addressing sample inefficiency and reward bias in adversarial imitation learning. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ Hk4fpoA5Km. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yunzhu Li, Jiaming Song, and Stefano Ermon. Infogail: Interpretable imitation learning from visual demonstrations. In Advances in Neural Information Processing Systems, pp. 3812–3822, 2017. ",
+        "bbox": [
+            173,
+            347,
+            821,
+            376
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Urs Muller, Jan Ben, Eric Cosatto, Beat Flepp, and Yann L Cun. Off-road obstacle avoidance through end-to-end learning. In Advances in neural information processing systems, pp. 739– 746, 2006. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            428
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ofir Nachum, Michael Ahn, Hugo Ponte, Shixiang Gu, and Vikash Kumar. Multi-agent manipulation via locomotion using hierarchical sim2real. arXiv preprint arXiv:1908.05224, 2019a. ",
+        "bbox": [
+            173,
+            436,
+            823,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ofir Nachum, Yinlam Chow, Bo Dai, and Lihong Li. Dualdice: Efficient estimation of off-policy stationary distribution corrections. 2019b. ",
+        "bbox": [
+            173,
+            473,
+            823,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew Y Ng, Stuart J Russell, et al. Algorithms for inverse reinforcement learning. ",
+        "bbox": [
+            173,
+            511,
+            730,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jan Peters, Katharina Mulling, and Yasemin Altun. Relative entropy policy search. In Twenty-Fourth AAAI Conference on Artificial Intelligence, 2010. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dean A Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In Advances in neural information processing systems, pp. 305–313, 1989. ",
+        "bbox": [
+            173,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin L Puterman. Markov Decision Processes.: Discrete Stochastic Dynamic Programming. John Wiley & Sons, 2014. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            640
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            648,
+            821,
+            693
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Fumihiro Sasaki, Tetsuya Yohira, and Atsuo Kawaguchi. Sample efficient imitation learning for continuous control. In International Conference on Learning Representations, 2019. URL https://openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ BkN5UoAqF7. ",
+        "bbox": [
+            176,
+            700,
+            821,
+            743
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            441,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "All algorithms use networks with an MLP architecture with 2 hidden layers and 256 hidden units. For discriminators, critic, $\\nu$ we use Adam optimizer with learning rate $1 0 ^ { - 3 }$ while for the actors we use the learning rate of $1 0 ^ { - 5 }$ . For the discriminator and $\\nu$ networks we use gradient penalties from Gulrajani et al. (2017). We also regularize the actor network with the orthogonal regularization (Brock et al., 2018) with a coefficient $1 \\bar { 0 } ^ { - 4 }$ . Also we perform 4 updates per 1 environment step. We handle absorbing states of the environments similarly to Kostrikov et al. (2019). ",
+        "bbox": [
+            173,
+            133,
+            825,
+            218
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            238,
+            325,
+            253
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present pseudocode for the imitation learning algorithms based on DualDICE. ",
+        "bbox": [
+            169,
+            268,
+            807,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 ValueDICE   \nInput: expert replay buffer $\\mathcal { R } _ { E }$ Initialize replay buffer $\\mathcal { R }  \\emptyset$ for $n = 1 , \\ldots , \\mathbf { d o }$ Sample $( s , a , s ^ { \\prime } )$ with $\\pi _ { \\theta }$ Add $( s , a , s ^ { \\prime } )$ to the replay buffer $\\mathcal { R }$ $\\{ ( s ^ { ( i ) } , a ^ { ( i ) } , s ^ { \\prime ( i ) } ) \\} _ { i = 1 } ^ { B } \\sim \\mathcal { R }$ . Geometric sampling, is a st $\\triangleright$ Geometric samplingting episode state for $\\{ ( s _ { 0 } ^ { ( i ) } , s _ { E } ^ { ( i ) } , a _ { E } ^ { ( i ) } , s _ { E } ^ { \\prime ( i ) } ) \\} _ { i = 1 } ^ { B } \\sim \\mathcal { R } _ { E }$ $s _ { 0 } ^ { ( i ) }$ s(i)E a(i ) ∼ πθ (·|s(i)0 ), for i = 1, . . . , B a0(i) ∼ πθ (·|s0(i)), for i = 1, . . . , B $a _ { E } ^ { \\prime ( i ) } \\sim \\pi _ { \\theta } ( \\cdot | s _ { E } ^ { \\prime ( i ) } )$ , for i = 1, . . . , B Compute loss on expert data: $\\begin{array} { r } { \\hat { J } _ { l o g } ^ { \\mathrm { ~ ~ } } = \\log \\bigl ( \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } \\bigl ( ( 1 - \\alpha ) e ^ { \\nu _ { \\psi } ( s _ { E } ^ { ( i ) } , a _ { E } ^ { ( i ) } ) - \\gamma \\nu _ { \\psi } ( s _ { E } ^ { \\prime ( i ) } , a _ { E } ^ { \\prime ( i ) } ) } + \\alpha e ^ { \\nu _ { \\psi } ( s ^ { ( i ) } , a ^ { ( i ) } ) - \\gamma \\nu _ { \\psi } ( s ^ { \\prime ( i ) } , a ^ { \\prime ( i ) } ) } \\bigr ) \\bigr ) } \\end{array}$ Compute loss on the replay buffer: $\\begin{array} { r } { \\hat { J } _ { l i n e a r } = \\frac { 1 } { B } \\sum _ { i = 1 } ^ { B } ( ( 1 - \\dot { \\alpha } ) ( 1 - \\gamma ) \\nu _ { \\psi } ( s _ { 0 } ^ { ( i ) } , a _ { 0 } ^ { ( i ) } ) + \\alpha ( \\nu _ { \\psi } ( s ^ { ( i ) } , a ^ { ( i ) } ) - \\gamma \\nu _ { \\psi } ( s ^ { \\prime ( i ) } , a ^ { \\prime ( i ) } ) ) ) } \\end{array}$ Update $\\psi  \\psi - \\eta _ { \\nu } \\nabla _ { \\psi } ( \\hat { J } _ { l o g } - \\hat { J } _ { l i n e a r } )$ Update $\\theta  \\psi + \\eta _ { \\pi } \\nabla _ { \\theta } \\big ( \\hat { J } _ { l o g } - \\hat { J } _ { l i n e a r } \\big )$ end for ",
+        "bbox": [
+            174,
+            300,
+            826,
+            604
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            633,
+            442,
+            648
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We also compared ValueDICE with behavioral cloning in the offline regime, when we sample no additional transitions from the learning environment (see Figure 4). Even given only offline data, ValueDICE outperforms behavioral cloning. For behavioral cloning we used the same regularization as for actor training in ValueDICE. ",
+        "bbox": [
+            173,
+            664,
+            826,
+            719
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/c40b80cae8865eb5124efdc9cf33f4d8e08f441eaac4f78921409f7e9ee1c58c.jpg",
+        "image_caption": [
+            "Figure 4: ValueDICE outperforms behavioral cloning given 1 trajectory even without replay regularization. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            734,
+            759,
+            837
+        ],
+        "page_idx": 10
+    }
+]

parse/train/HygsfnR9Ym/HygsfnR9Ym_content_list.json

@@ -0,0 +1,2351 @@
+[
+    {
+        "type": "text",
+        "text": "RECALL TRACES: BACKTRACKING MODELS FOR EFFICIENT REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            759,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anirudh Goyal1, Philemon Brakel2, William Fedus1, Soumye Singhal1,4, Timothy Lillicrap2, Sergey Levine5, Hugo Larochelle3, Yoshua Bengio1 ",
+        "bbox": [
+            183,
+            167,
+            683,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In many environments only a tiny subset of all states yield high reward. In these cases, few of the interactions with the environment provide a relevant learning signal. Hence, we may want to preferentially train on those high-reward states and the probable trajectories leading to them. To this end, we advocate for the use of a backtracking model that predicts the preceding states that terminate at a given high-reward state. We can train a model which, starting from a high value state (or one that is estimated to have high value), predicts and samples which (state, action)-tuples may have led to that high value state. These traces of (state, action) pairs, which we refer to as Recall Traces, sampled from this backtracking model starting from a high value state, are informative as they terminate in good states, and hence we can use these traces to improve a policy. We provide a variational interpretation for this idea and a practical algorithm in which the backtracking model samples from an approximate posterior distribution over trajectories which lead to large rewards. Our method improves the sample efficiency of both on- and off-policy RL algorithms across several environments and tasks. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            501,
+            336,
+            516
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Training control algorithms efficiently from interactions with the environment is a central issue in reinforcement learning (RL). Model-free RL methods, combined with deep neural networks, have achieved impressive results across a wide range of domains (Lillicrap et al., 2015; Mnih et al., 2016; Silver et al., 2016). However, existing model-free solutions lack sample efficiency, meaning that they require extensive interaction with the environment to achieve these levels of performance. ",
+        "bbox": [
+            174,
+            531,
+            823,
+            601
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Model-based methods in RL can mitigate this issue. These approaches learn an unsupervised model of the underlying dynamics of the environment, which does not necessarily require rewards, as the model observes and predicts state-to-state transitions. With a well-trained model, the algorithm can then simulate the environment and look ahead to future events to establish better value estimates, without requiring expensive interactions with the environment. Model-based methods can thus be more sample efficient than their model-free counterparts, but often do not achieve the same asymptotic performance (Deisenroth & Rasmussen, 2011a; Nagabandi et al., 2017). ",
+        "bbox": [
+            174,
+            608,
+            825,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a method that takes advantage of unsupervised observations of state-to-state transitions for increasing the sample efficiency of current model-free RL algorithms, as measured by the number of interactions with the environment required to learn a successful policy. Our idea stems from a simple observation: given a world model, finding a path between a starting state and a goal state can be done either forward from the start or backward from the goal. Here, we explore an idea for leveraging the latter approach and combining it with model-free algorithms. This idea is particularly useful when rewards are sparse. High-value states are rare and trajectories leading to them are particularly useful for a learner. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            824
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The availability of an exact backward dynamics model of the environment is a strong and often unrealistic requirement for most domains. Therefore, we propose learning a backward dynamics model, which we refer to as a backtracking model, from the experiences performed by the agent. This backtracking model $p ( s _ { t } , a _ { t } | s _ { t + 1 } )$ , is trained to predict, given a state $s _ { t + 1 }$ , which state $s _ { t }$ the agent visited before $s _ { t + 1 }$ and what action $a _ { t } \\sim \\pi$ was performed in $s _ { t }$ to reach $s _ { t + 1 }$ . Specifically, this is a model which, starting from a future high-value state, can be used to recall traces that have ended at this high value state, that is sequences of (state, action)-tuples. This allows the agent to simulate and be exposed to alternative possible paths to reach a high value state. A final state may be a previously experienced high-value state or a goal state may be explicitly given, or even produced by the agent using a generative model of high-value states (Held et al., 2017). ",
+        "bbox": [
+            174,
+            832,
+            823,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our hypothesis is that using a backtracking model in this way should benefit learning, especially in the context of weak or sparse rewards. Indeed, in environments or tasks where the agent receives rewards infrequently, it must leverage this information effectively and efficiently. Exploration methods have been employed successfully (Bellemare et al., 2016; Held et al., 2017; Ostrovski et al., 2017) to increase the frequency at which novel states are discovered. Our proposal can be viewed as a special kind of simulated exploration proceeding backward from presumed high-value states, in order to discover trajectories that may lead to high rewards. A backtracking model aims to augment the experience of the trajectory $\\tau$ leading to a high-value state by generating other ",
+        "bbox": [
+            174,
+            194,
+            485,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/290cd08fc780f2c7ceeb861c49733079b2326965b620a12e4d0da4afced490e3.jpg",
+        "image_caption": [
+            "Figure 1: The policy explores the state space $s$ from an initial state. Discovered high value states are then passed to the backtracking model (dashed-lines) to generate new traces that may have led to this high value state. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            516,
+            214,
+            799,
+            329
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "possible traces $\\tilde { \\tau }$ that could have also caused it. To summarize: the main contribution of this paper is an RL method based on the use of a backtracking model, which can easily be integrated with existing on- and off-policy techniques for reducing sample complexity. Empirically, we show with experiments on eight RL environments that the proposed approach is more sample efficient. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            506,
+            339,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider a Markov decision process (MDP) defined by the tuple $( S , { \\mathcal { A } } , P , r , \\gamma )$ , where the state space $s$ and the action space $\\mathcal { A }$ may be discrete or continuous. The learner is not explicitly given the environment transition probability $p ( s _ { t + 1 } | s _ { t } , a _ { t } )$ for going from $s _ { t } \\in S$ to $s _ { t + 1 } \\in S$ given $a _ { t } \\in { \\mathcal { A } }$ , but samples from this distribution are observed. The environment emits a bounded reward $r : S \\times$ $\\mathcal { A }  [ r _ { m i n } , r _ { m a x } ]$ on each transition and $\\gamma \\in ( 0 , 1 )$ is the discount factor. Let $\\pi$ denote a stochastic policy over actions given states, and let $R ( \\pi ) ~ = ~ \\mathbb { E } _ { \\pi } \\left[ \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } r ( s _ { t } ) \\right]$ denote the expected total return when policy $\\pi$ is followed.The standard objective in reinforcement learning is to maximize the discounted total return $R ( \\pi )$ . Throughout the text we will refer to experienced trajectories as $\\tau = ( s _ { 1 } , a _ { 1 } , \\cdot \\cdot \\cdot , s _ { T } , a _ { T } )$ and we will refer to simulated experiences as traces $\\tilde { \\tau }$ . ",
+        "bbox": [
+            173,
+            536,
+            825,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 BACKTRACKING MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            688,
+            385,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We introduce the backtracking model $B _ { \\phi } = q _ { \\phi } ( s _ { t } , a _ { t } | s _ { t + 1 } )$ , which is a density estimator of the joint probability distribution over the previous $\\left( { { s _ { t } } , { a _ { t } } } \\right)$ -tuple parameterized by $\\phi$ . This distribution is produced by both a learned backward policy $\\pi _ { b } = q ( a _ { t } | s _ { t + 1 } )$ and a state generator $q ( s _ { t } | a _ { t } , s _ { t + 1 } )$ . The backward policy predicts the previous action $a _ { t }$ given the resulting state $s _ { t + 1 }$ . The state generator estimates the probability of a previous state $s _ { t }$ given the tuple $\\left( a _ { t } , s _ { t + 1 } \\right)$ . With these models, we may decompose $q _ { \\phi } { \\left( s _ { t } , a _ { t } \\vert s _ { t + 1 } \\right) }$ as $q ( s _ { t } | a _ { t } , s _ { t + 1 } ) q ( a _ { t } | s _ { t + 1 } )$ . ",
+        "bbox": [
+            173,
+            713,
+            825,
+            799
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "However, for training stability with continuous-valued states, we model the density of state variation $\\Delta s _ { t } = s _ { t } - s _ { t + 1 }$ rather than the raw $s _ { t }$ . Therefore, our density models are given by ",
+        "bbox": [
+            169,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4568434f7201eb28adae1c2854ce03c7bdfd24acd30882192d3f3e96f5903435.jpg",
+        "text": "$$\nq _ { \\phi } ( \\Delta _ { t } , a _ { t } | s _ { t + 1 } ) = q ( \\Delta s _ { t } | a _ { t } , s _ { t + 1 } ) q ( a _ { t } | s _ { t + 1 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            838,
+            651,
+            856
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Note that for readability, we will drop the $\\phi$ -subscript unless it is necessary for clarity. ",
+        "bbox": [
+            171,
+            859,
+            736,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Generating Recall Traces. Analogous to the use of forward models in (Oh et al., 2015; Chiappa et al., 2017; Weber et al., 2017), we may generate a recall trace auto-regressively. To do so, we begin with a state $s _ { t + 1 }$ and sample $a _ { t } \\sim q ( a _ { t } | s _ { t + 1 } )$ . The state generator can then be sampled to produce the change in state $\\Delta s _ { t } \\sim q ( \\Delta s _ { t } | a _ { t } , s _ { t + 1 } )$ . We can continue to unroll this process, repeating with state $s _ { t } = \\Delta s _ { t } + s _ { t + 1 }$ for a desired number of steps. These generated transitions are then stored as a potential trace $\\tilde { \\tau }$ which terminates at some final state. The backtracking model $B _ { \\phi }$ is learned by maximum likelihood, using the policy’s trajectories as observations, as described in Section 3.1. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Producing Intended High Value States. Before recursively sampling from the backtracking model, we need to obtain presumed high-value states. Generally, such states will not be known in advance. However, as the agent learns, it will visit states $s _ { t }$ with increasingly high value $\\begin{array} { r } { V ^ { \\pi } ( s _ { t } = s ) = E _ { \\pi } \\left[ \\sum _ { t } \\gamma ^ { t } r ( s _ { t } ) | \\bar { s _ { t } } = s \\right] . } \\end{array}$ The agent’s full experience is maintained in a replay buffer $\\boldsymbol { B }$ , in the form of tuples of $( s _ { t } , a _ { t } , s _ { t + 1 } , r _ { t } )$ . Filtering of trajectories based on the returns is done, so that only top $k _ { t r a j }$ are added to the buffer. In this work, we will investigate our approach with two methods for generating the initial high-value states. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            265
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The first method relies on picking the most valuable states stored in the replay buffer $\\boldsymbol { B }$ . As before, a valuable state may be defined by its estimated expected return $V ^ { \\pi } ( s )$ as computed by a critic (our off-policy method) or state that received a high reward (our on-policy method). ",
+        "bbox": [
+            174,
+            271,
+            825,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The second method is based on Goal GAN, recently introduced by (Held et al., 2017) where goal states $g$ are produced via a Generative Adversarial Network (Goodfellow et al., 2014). In our variant, we map the goal state $g$ to a valid point in state space $s$ using a ’decoder’ $D$ . For the point-mass, the goal and state are identical; for Ant, we use a valid random joint-angle configuration at that goal position. The backtracking model is then used to find plausible trajectories that terminate at that state. For both methods, as the learner improves, one would expect that on average, higher value states are used to seed the recall traces. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 IMPROVING POLICIES WITH BACKTRACKING MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            645,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe how to train the backtracking model and how it can be used to improve the efficiency of the agent’s policy and aid with exploration. ",
+        "bbox": [
+            173,
+            468,
+            823,
+            497
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 TRAINING THE BACKTRACKING MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            493,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use a maximum likelihood training loss for training of the backtracking model $B _ { \\phi }$ on the top $k \\%$ of the agent’s trajectories stored in the state buffer $\\boldsymbol { B }$ . At each iteration, we perform stochastic gradient updates based on agent trajectories $\\tau$ , with respect to the following objective: ",
+        "bbox": [
+            176,
+            540,
+            825,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da4ef053f85bedae3b4ca9beca8275e47cd83163179f92d4a3e6dd0b27187af8.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathcal { L } _ { \\boldsymbol { B } } = \\log q _ { \\phi } ( \\tau ) = \\log \\displaystyle \\prod _ { t = 0 } ^ { T } q ( \\Delta s _ { t } , a _ { t } | s _ { t + 1 } ) } & { { } = \\displaystyle \\sum _ { t = 0 } ^ { T } \\log q ( a _ { t } | s _ { t + 1 } ) + \\log q ( \\Delta s _ { t } | a _ { t } , s _ { t + 1 } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            196,
+            587,
+            781,
+            631
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $s _ { t } = \\Delta s _ { t } + s _ { t + 1 }$ and $T$ is the episode length. For our chosen backtracking model, this implies a mean-squared error loss (i.e. corresponding to a conditional Gaussian for $\\Delta s _ { t }$ ) for continuous action tasks and a cross-entropy loss (i.e. corresponding to a conditional Multinoulli for $s _ { t }$ given $a _ { t }$ and $s _ { t + 1 }$ ) for discrete action tasks. The buffer is constantly updated with recent experiences and the backtracking model is trained online in order to encourage generalization as the distribution of trajectories in the buffer evolves. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 IMPROVING THE POLICY FROM THE RECALL TRACES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            734,
+            583,
+            750
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now describe how we use the recall traces $\\tilde { \\tau }$ to improve the agent’s policy $\\pi _ { \\theta }$ . In brief, the traces $\\tilde { \\tau }$ generated by the backtracking model are used as observations for imitation learning (Pomerleau, 1989; ros, 2011; Bojarski et al., 2016) by the agent. The backtracking model will be continuously updated as new actual experiences are generated, as described in Section 3.1. Imitation learning of the policy is performed simply by maximizing the log-probability of the agent’s action $a _ { t }$ given $s _ { t }$ given by ",
+        "bbox": [
+            173,
+            760,
+            825,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a156ba88c9320878df9d3c847a8aaf9a1a0f3b1aade7025329b839ac335a6b8b.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathcal { T } } = \\sum _ { t = 0 } ^ { T } \\log p ( a _ { t } | s _ { t } ) = \\sum _ { t = 0 } ^ { T } \\log \\pi _ { \\theta } ( a _ { t } | s _ { t } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            842,
+            642,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\left( { { s _ { t } } , { a _ { t } } } \\right)$ -tuples come from a generated trace $\\tilde { \\tau }$ . ",
+        "bbox": [
+            173,
+            887,
+            519,
+            902
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our motivation for having the agent imitate trajectories from the backtracking model is two-fold: ",
+        "bbox": [
+            169,
+            909,
+            805,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Improve Policy via Recall Traces and Backtracking Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            647,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Require: RL algorithm with parameterized policy (i.e. TRPO, Actor-Critic)   \nRequire: Agent policy $\\pi _ { \\boldsymbol { \\theta } } ( a | \\boldsymbol { s } )$   \nRequire: Backtracking model $B _ { \\phi } = q _ { \\phi } ( \\Delta s _ { t } , a _ { t } | s _ { t + 1 } )$   \nRequire: Critic $V ( s )$ ",
+        "bbox": [
+            174,
+            122,
+            686,
+            179
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Require: $k$ quantile of best state values used to train backtracking model, $k _ { t r a j }$ number of trajectories filtered by returns. ",
+        "bbox": [
+            176,
+            179,
+            821,
+            205
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Require: $N$ ; number of backward trajectories per target state ",
+        "bbox": [
+            174,
+            207,
+            581,
+            220
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Require: $\\alpha , \\beta$ ; forward, backward learning rates   \n1: Randomly initialize agent policy parameters $\\theta$   \n2: Randomly initialize backtracking model parameters $\\phi$   \n3: for $t = 1$ to $K$ do   \n4: Execute policy to produce trajectory $\\tau$   \n5: Add trajectory $\\tau = ( s _ { 1 } , a _ { 1 } , r _ { 1 } , \\cdot \\cdot \\cdot , s _ { T } , a _ { T } , r _ { T } )$ in $\\boldsymbol { B }$   \n6: Estimate $\\nabla _ { \\boldsymbol { \\theta } } R ( \\pi _ { \\boldsymbol { \\theta } } )$ from RL algorithm   \n7: $\\theta  \\theta + \\alpha \\nabla _ { \\theta } \\dot { R } ( \\dot { \\pi } _ { \\theta } )$   \n8: Compute $\\mathcal { L } _ { B }$ via Equation 2, using top $k \\%$ valuable states from top $k _ { t r a j }$ trajectories in $\\boldsymbol { B }$   \n9: $\\phi  \\phi + \\beta \\nabla _ { \\phi } \\mathcal { L } _ { B }$   \n10: Obtain target high value state $s$ (see Algorithm 2 for details)   \n11: Generate $N$ recall traces $\\tilde { \\tau }$ for $s$ using $B _ { \\phi } ( s )$   \n12: Compute imitation loss $\\mathcal { L } _ { \\mathcal { I } }$ via Equation 3   \n13: $\\theta  \\theta + \\alpha \\nabla _ { \\theta } \\mathcal { L } _ { \\mathcal { Z } }$   \n14: end for ",
+        "bbox": [
+            178,
+            220,
+            813,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Dealing with sparse rewards States with significant return are emphasized by the backtracking model, since the traces it generates are initialized at high value states. We expect this behaviour to help in the context of sparse or weak rewards. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            500
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Aiding in exploration The backtracking model can also generate new ways to reach high-value states. So even if it cannot directly discover new high-value states, it can at least point to new ways to reach known high value states, thus aiding with exploration. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 VARIATIONAL INTERPRETATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            472,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Thus far, we have motivated the use of a backtracking model intuitively. In this section, we provide a motivation relying on a variational perspective of RL and ideas from the wake-sleep algorithm Hinton et al. (1995). ",
+        "bbox": [
+            174,
+            601,
+            825,
+            643
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $R$ be the return of a policy trajectory $\\tau$ , i.e. the sum of discounted rewards under this trajectory. Consider the event of the return $R$ being larger than some threshold $L$ . The probability of that event under the agent’s policy is $\\begin{array} { r } { p ( R > \\bar { L } ) \\stackrel { - } { = } \\sum _ { \\tau } p ( R > L | \\tau ) p ( \\tau ) } \\end{array}$ , where $p ( \\tau )$ is distribution of trajectories under policy $\\pi$ , $p ( R > L | \\tau ) = 1 _ { R > L }$ and $1 _ { A }$ is the indicator function that is equal to 1 if $A$ is true and is otherwise 0. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $q ( \\tau )$ be any other distribution over trajectories, then we have the following classic relationship between the marginal log-probability of an observation $( R > L$ ) and the KL-divergence between $q$ and the posterior over a latent variable $( \\tau )$ : ",
+        "bbox": [
+            174,
+            727,
+            823,
+            770
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9e0ae12a1a9719573083455b28b21f2c940a798db1f064e8491977ba849be488.jpg",
+        "text": "$$\n\\log p ( R > L ) = \\mathcal { L } + \\mathrm { K L } ( q ( \\tau ) | | p ( \\tau | R > L ) ) \\geq \\mathcal { L }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            776,
+            669,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            174,
+            803,
+            215,
+            815
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/027af9dec62a6ad2ef2eecd4b182dc20c83a4943c51f665026def6826db47d03.jpg",
+        "text": "$$\n\\mathcal { L } = \\sum _ { \\tau } q ( \\tau ) \\log \\left( p ( R > L | \\tau ) p ( \\tau ) / q ( \\tau ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            803,
+            642,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This suggests an EM-style training procedure, that alternates between training the variational distribution $q ( \\tau )$ towards the posterior $p ( \\tau | R > L )$ and training the policy to maximize $\\mathcal { L }$ . In this context, we view the backtracking model and the high-value states sampler as providing $q ( \\tau )$ implicitly. Specifically, we assume that $q$ factorizes temporally as in Equation 2 with the backtracking model providing $q ( a _ { t } | s _ { t + 1 } )$ and $q ( \\Delta s _ { t } | a _ { t } , s _ { s + 1 } )$ . We parameterize the approximate posterior in this way so that we can take advantage of a model of the backwards transitions to conveniently sample from $q$ starting from a high-value final state $s _ { T }$ . This makes sense in the context of sparse rewards, where few states have significant reward. If we have a way to identify these high-reward states, then it is much easier to obtain these posterior trajectories by starting from them. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Training $q ( \\tau )$ by minimizing the $\\mathrm { K L } ( q ( \\tau ) | | p ( \\tau | R > L ) )$ term is hard due to the direction of the KL-divergence. Taking inspiration from the wake-sleep algorithm (Hinton et al., 1995), we instead minimize the KL in the opposite direction, $\\mathrm { K L } ( p ( \\tau | R > L ) | | q ( \\tau ) )$ . This can be done by sampling trajectories from $p ( \\tau | R > \\overline { { L } } )$ (e.g. by rejection sampling, keeping only the forward-generated trajectories which lead to $R > L$ ) and maximizing their log-probability under $q ( \\tau )$ . This recovers our algorithm, which trains the backtracking model on high-return trajectories generated by the agent. ",
+        "bbox": [
+            174,
+            151,
+            825,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "So far we have assumed a known threshold $L$ . However, in practice the choice of $L$ is important. While ultimately we would want $L$ to be close to the highest possible return, at the early stages of training it cannot be, as trajectories from the agent are unlikely to reach that threshold. A better strategy is to gradually increase $L$ . One natural way of doing this is to use the top few percentile trajectories sampled by the agent for training $q ( \\tau )$ , instead of explicitly setting $L$ . This approach can be thought of as providing a curriculum for training the agent that is adapted to its performance. This is also related to evolutionary methods (Hansen, 2016; Baluja, 1994), which keep the “fittest” samples from a population in order to re-estimate a model, from which new samples are generated. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            354
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This variational point of view also tells us how the prior over the last state should be constructed. The ideal prior $q ( s _ { T } )$ is simply a generative model of the final states leading to $R > L$ . Both methods proposed to estimate $q ( s _ { T } )$ with this purpose, either non-parametrically (with the forward samples for which $R > L$ ) or parametrically (with generative model trained from those samples). Also, if goal states are known ahead of time, then we can set $L$ as the reward of those states (minus a small quantity) and we can seed the backwards trajectories from these goal states. In that case the variational objective used to train the policy is a proxy for log-likelihood of reaching a goal state. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            459
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            344,
+            489
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Control as inference The idea of treating control problems as inference has been around for many years (Stengel, 1986; Kappen et al., 2012; Todorov, 2007; Toussaint, 2009; Rawlik et al., 2012). A good example of this idea is to use Expectation Maximization (EM) for RL (Dayan & Hinton, 1997), of which the PoWER algorithm (Kober et al., 2013) is one well-known practical implementation. In EM algorithms for RL, learning is divided between the estimation of the expectation over the trajectories conditioned on the reward observations and estimation of a new policy based on these expectation estimates. While we don’t explicitly try to estimate these expectations, one could argue that the samples from the backtracking model serve a similar purpose. Variational inference has also been proposed for policy search (Neumann et al., 2011; Levine & Koltun, 2013). Probabilistic views of the RL problem have also been used to construct maximum entropy methods for both regular and inverse RL (Haarnoja et al., 2017; Ziebart et al., 2008). ",
+        "bbox": [
+            173,
+            498,
+            825,
+            652
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using off-policy trajectories By incorporating the trajectories of a separate backtracking model, our method is similar in spirit to approaches which combine on-policy learning algorithms with off-policy samples. Recent examples of this, like the interpolated policy gradient (Gu et al., 2017), PGQ (O’Donoghue et al., 2016) and ACER (Wang et al., 2016), combine policy gradient learning with ideas for off-policy learning and methodology inspired by Q-learning. Our method differs by using the backtracking model to obtain off-policy trajectories and is, as an idea, independent of the specific model-free RL method it is combined with. Our work to effectively propagate value updates backwards is also related to the seminal work of prioritized sweeping (Moore & Atkeson, 1993). ",
+        "bbox": [
+            174,
+            659,
+            825,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Model-based methods A wide range of model-based RL and control methods have been proposed in the literature (Deisenroth et al., 2013). PILCO (Deisenroth & Rasmussen, 2011b), is a model-based policy search method to learn a probabilistic model of dynamics and incorporate model uncertainty into long-term planning. The classic Dyna (Sutton) algorithm was proposed to take advantage of a model to generate simulated experiences, which could be included in the training data for a modelfree algorithm. This method was extended to work with deep neural network policies, but performed best with models that were not neural networks (Gu et al., 2016b). Other extensions to Dyna have also been proposed (Silver et al., 2008; Kalweit & Boedecker; Heess et al., 2015). ",
+        "bbox": [
+            174,
+            776,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Other approaches have also been proposed to combine advantages of both value and policy-based approaches (Nachum et al., 2017; Sukhbaatar et al., 2017). Finally, (Edwards et al., 2018) is concurrent work to this and also proposes training on imagined reversal steps from known goal states. (Goyal et al., 2017) proposed to use similar learning rule in the context of generative models to modify the parameters of transition operator to make the reverse of this heated trajectory more likely under a reverse cooling process. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/eefea3db8f94db0088a9a43f7a5a807952871a1389f3002804e8641052c90207.jpg",
+        "image_caption": [
+            "Figure 2: Training curves from the Four Room Environment for the Actor-Critic baseline (blue) and the backtracking model augmented Actor-Critic (orange). For the size-19 environment, several of the Actor-Critic baselines failed to converge, whereas the augmented recall trace model always succeeded in the number of training steps considered. For additional results see Figure 9 in Appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            106,
+            766,
+            247
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            344,
+            825,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            419,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our experimental evaluation aims to understand whether our method can improve the sample complexity of off-policy as well as on-policy RL algorithms. Practically, we must choose the length of generated backward traces. Longer traces become increasingly likely to deviate significantly from the traces that the agent can generate from its initial state. Therefore, in our experiments, we sample fairly short traces $\\tilde { \\tau }$ from the backtracking model, where the length is adjusted manually based on the time-scale of each task. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            539
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We empirically show the following results across different experimental settings: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            545,
+            732,
+            560
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Samples from the true backtracking model can be used to improve sample efficiency. • Using a learned backtracking model starting from high value states accelerates learning for off-policy as well as on-policy experiments. • Modeling parametrically and generating high value states (using GoalGAN) also helps. ",
+        "bbox": [
+            212,
+            570,
+            825,
+            633
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 ACCESS TO TRUE BACKTRACKING MODEL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            651,
+            511,
+            666
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, we aim to check if in the ideal case when the true backtracking model is known, the proposed approach works. To investigate this, we use the four-room environment from Schaul et al. (2015) of various dimensions. The 4-room grid world is a simple environment where the agent must navigate to a goal position to receive a positive reward through bottleneck states (doorways). We compare the proposed method to the scenario where the policy is trained through the actor-critic method Konda (2002) with generalized advantage estimation (GAE) Schulman et al. (2015b) ",
+        "bbox": [
+            174,
+            678,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finding the goal state becomes more challenging as the dimension increases due to sparsity of rewards. Therefore, we expect that the backtracking model would be a more effective tool in larger environments. Confirming this hypothesis, we see in Figure 2 that, as we increase the dimensionality of the maze, sample efficiency increases thanks to recall traces, compared to our baseline. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            825
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.2 COMPARISON WITH PRIORITIZED EXPERIENCE REPLAY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            844,
+            599,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we aim to compare the performance of recall traces with Prioritized Experience Replay (PER). PER stores the past experiences in a buffer and then selectively trains on high value experiences. We again use the Four-room Environment. PER gives an optimistic bias to the critic, and while it allows the reinforcement of sparse rewards, it also converges too quickly to an exploitation mode, which can be difficult to get out of. In order to show this, we plot the state visitation counts of a policies trained with PER and recall traces and see that the latter visit more states. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/16904e4d69cdc495b305097ef7fc9f8953482a4c5bf15fda554ad0ab1918f903.jpg",
+        "image_caption": [
+            "Figure 3: Visitation count visualization of trained policies for PER (left) and Recall Traces (right) for two 4-room grid sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            318,
+            99,
+            679,
+            183
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            247,
+            823,
+            275
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cfbc408eb978e61773fbef4dc973e3dfbdf4be94733efa8523371b9c37ed7847.jpg",
+        "image_caption": [
+            "Figure 4: Plots for reward vs. time steps, comparing the performance of recall traces (labeled BacktrackingModel), PER and baseline Actor Critic (AC). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            285,
+            769,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show in Figure 4 that while PER is competitive in the smaller 11x11 environment, recall traces outperform it in the larger 15x15 environment. Figure 3 also shows how the use of a backtracking model and recall traces pushes the policy to visit a wider variety of grid positions than PER. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            503
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.3 LEARNED BACKTRACKING MODEL FROM GENERATED STATES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            521,
+            648,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One situation in which states to start the backtracking model at are naturally available, is when the method is combined with an algorithm for sub-goal selection. We chose to investigate how well the backtracking model can be used in conjunction with the automatic goal generation algorithm from Held et al. (2017), Goal GAN. It uses a Generative Adversarial Network to produce sub-goals at the appropriate level of difficulty for the agent to reach. As the agent learns, new sub-goals of increasing difficulty are generated. This way, the agent is pressured to explore and learn to be able to reach any location in the state space. We hypothesize that the backtracking model should help the agent to reach the sub-goals faster and explore more efficiently. ",
+        "bbox": [
+            174,
+            546,
+            825,
+            659
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hence, in this learning scenario, what changes is that high value states are now generated by Goal GAN instead of being selected by a critic from a replay buffer. ",
+        "bbox": [
+            173,
+            665,
+            823,
+            693
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We performed experiments on the U-Maze Ant task described in Held et al. (2017). It is a challenging robotic locomotion task where a quadruped robot has to navigate its center of mass within some particular distance of a target goal. The objective is to cover as much of the space of the U-shaped maze as possible. We find that using the backtracking model improves data efficiency, by reaching a coverage of more than $63 \\%$ in 155 steps, instead of 275 steps without it (Fig 5). More visualizations and learning curves for U-Maze Ant task as well as the N-Dimensional Point Mass task can be found in Appendix (Figs. 11, 12 and 13). ",
+        "bbox": [
+            174,
+            699,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.4 LEARNED BACKTRACKING MODEL - ON-POLICY CASE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            814,
+            598,
+            828
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conducted robotic locomotion experiments using the MuJoCo simulator (Todorov et al., 2012). We use the same setup as (Nagabandi et al., 2017). We compare our approach with a pure model-free method on standard benchmark locomotion tasks, to learn the fastest forward-moving gait possible. The model-free approach we consider is the rllab implementation of trust region policy optimization (TRPO) Schulman et al. (2015a). For the TRPO baseline we use the same setup as Nagabandi et al. (2017). See the appendix for the model implementation details. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b169c2be83e36aa4be472bee8085e14f1730dca1ed186e974ea6708c8bd23b6.jpg",
+        "image_caption": [
+            "Figure 5: Visualization of GoalGAN baseline (b) vs backtracking model (c) policy performance for different parts of the state space for Ant Maze task. Red indicates complete success; blue indicates failure. Backtracking model achieves equal coverage rates in fewer steps of training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            101,
+            789,
+            207
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance across tasks: The results in Figure 6 show that our method consistently outperforms TRPO on all of the benchmark tasks in terms of final performance, and learns substantially faster. ",
+        "bbox": [
+            174,
+            286,
+            825,
+            315
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/875638c64e7dda53f3ad3a9db7338b2219a3121cda68c8d620aecd1412d1f5b5.jpg",
+        "image_caption": [
+            "Figure 6: Our model as compared to TRPO. For TRPO baselines, except walker, we ran with 5 different random seeds. For our model, we ran with 5 different random seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            327,
+            838,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.5 LEARNED BACKTRACKING MODEL - OFF POLICY CASE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            488,
+            602,
+            503
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here, we evaluate on the same range of challenging continuous control tasks from the OpenAI gym benchmark suite. We compare to Soft Actor Critic (SAC) (Haarnoja et al., 2018), shown to be more sample efficient compared to other off-policy algorithms such as DDPG (Lillicrap et al., 2015) and which consistently outperforms DDPG. Part of the reason for choosing SAC instead of DDPG was that the latter is also known to be more sensitive to hyper-parameter settings, limiting its effectiveness on complex tasks Henderson et al. (2017). For SAC, we use the same hyper-parameters reported in Haarnoja et al. (2018). Implementation details for our model are listed in the Appendix. ",
+        "bbox": [
+            173,
+            515,
+            825,
+            613
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Performance across tasks - The results in Figure 7 show that our method consistently improves the performance of SAC on all of the benchmark tasks, leading to faster learning. In fact, the largest improvement is observed on the hardest task, Ant. ",
+        "bbox": [
+            174,
+            619,
+            826,
+            661
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa977aca2b3a0e6eedfa7c38633d2d6447fb877a9108781a0e86ef394a9801f8.jpg",
+        "image_caption": [
+            "Figure 7: Our model as compared to SAC. We ran SAC baselines with 2 different random seeds. For our model, we ran with 5 different random seeds. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            672,
+            830,
+            772
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            840,
+            310,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We advocate for the use of a backtracking model for improving sample efficiency and exploration in RL. The method can easily be combined with popular RL algorithms like TRPO and soft actorcritic. Our results indicate that the recall traces generated by such models are able to accelerate learning on a variety of tasks. We also show that the method can be combined with automatic goal generation. The Appendix provides more analysis on the sensitivity of our method to various factors and ablations. We show that a random model is outperformed by a trained backtracking model, confirming its usefulness and present plots showing the effect of varying the length of recall traces. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For future work, while we observed empirically that the method has practical value and could relate its workings from a variational perspective, but more could be done to improve our theoretical understanding of its convergence behavior and what kind of assumptions need to hold about the environment. It would also be interesting to investigate how the backtracking model can be combined with forward models from a more conventional model-based system. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "8 ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            243,
+            397,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The authors acknowledge the important role played by their colleagues at Mila throughout the duration of this work. The authors would like to thank Alessandro Sordoni for being involved in the earlier phase of the project, and for the Four Room Code. AG would like to thank Doina Precup, Matthew Botvinick, Konrad Kording for useful discussions. William Fedus would like to thank Evan Racah and Valentin Thomas for useful discussions and edits. The authors would also like to thank Nicolas Le Roux, Rahul Sukthankar, Gatan Marceau Caron, Maxime Chevalier-Boisvert, Justin Fu, Nasim Rahaman for the feedback on the draft. The authors would also like to thank NSERC, CIFAR, Google Research, Samsung, Nuance, IBM and Canada Research Chairs, Nvidia for funding, and Compute Canada for computing resources. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            396
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            416,
+            285,
+            431
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A reduction of imitation learning and structured prediction to no-regret online learning. In Proceedings of the fourteenth international conference on artificial intelligence and statistics, 2011. ",
+        "bbox": [
+            173,
+            439,
+            823,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shumeet Baluja. Population-based incremental learning: A method for integrating genetic search based function optimization and competitive learning. Technical report, 1994. ",
+        "bbox": [
+            173,
+            477,
+            823,
+            506
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc Bellemare, Sriram Srinivasan, Georg Ostrovski, Tom Schaul, David Saxton, and Remi Munos. Unifying count-based exploration and intrinsic motivation. In NIPS, 2016. ",
+        "bbox": [
+            171,
+            513,
+            821,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mariusz Bojarski, Davide Del Testa, Daniel Dworakowski, Bernhard Firner, Beat Flepp, Prasoon Goyal, Lawrence D Jackel, Mathew Monfort, Urs Muller, Jiakai Zhang, et al. End to end learning for self-driving cars. arXiv preprint arXiv:1604.07316, 2016. ",
+        "bbox": [
+            178,
+            551,
+            823,
+            594
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Silvia Chiappa, Sebastien Racaniere, Daan Wierstra, and Shakir Mohamed. Recurrent environment ´ simulators. arXiv preprint arXiv:1704.02254, 2017. ",
+        "bbox": [
+            171,
+            602,
+            823,
+            631
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter Dayan and Geoffrey E Hinton. Using expectation-maximization for reinforcement learning. Neural Computation, 9(2):271–278, 1997. ",
+        "bbox": [
+            173,
+            640,
+            821,
+            667
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pp. 465–472, 2011a. ",
+        "bbox": [
+            176,
+            676,
+            821,
+            719
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc Peter Deisenroth and Carl Edward Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on International Conference on Machine Learning, ICML’11, pp. 465–472, USA, 2011b. Omnipress. ISBN 978- 1-4503-0619-5. URL http://dl.acm.org/citation.cfm?id $=$ 3104482.3104541. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            785
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marc Peter Deisenroth, Gerhard Neumann, and Jan Peters. A survey on policy search for robotics. Foundations and Trends in Robotics, 2(12):1–142, 2013. ISSN 1935-8253. doi: 10.1561/2300000021. URL http://dx.doi.org/10.1561/2300000021. ",
+        "bbox": [
+            174,
+            792,
+            823,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ashley D Edwards, Laura Downs, and James C Davidson. Forward-backward reinforcement learning. arXiv preprint arXiv:1803.10227, 2018. ",
+        "bbox": [
+            168,
+            843,
+            823,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Anirudh Goyal Alias Parth Goyal, Nan Rosemary Ke, Surya Ganguli, and Yoshua Bengio. Variational walkback: Learning a transition operator as a stochastic recurrent net. In Advances in Neural Information Processing Systems, pp. 4392–4402, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Timothy P. Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. CoRR, abs/1603.00748, 2016b. ",
+        "bbox": [
+            173,
+            208,
+            821,
+            237
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Tim Lillicrap, Richard E Turner, Zoubin Ghahramani, Bernhard Scholkopf, and Sergey ¨ Levine. Interpolated policy gradient: Merging on-policy and off-policy gradient estimation for deep reinforcement learning. In NIPS, 2017. ",
+        "bbox": [
+            173,
+            246,
+            825,
+            290
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Haoran Tang, Pieter Abbeel, and Sergey Levine. Reinforcement learning with deep energy-based policies. arXiv preprint arXiv:1702.08165, 2017. ",
+        "bbox": [
+            174,
+            299,
+            823,
+            329
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tuomas Haarnoja, Aurick Zhou, Pieter Abbeel, and Sergey Levine. Soft actor-critic: Off-policy maximum entropy deep reinforcement learning with a stochastic actor. CoRR, abs/1801.01290, 2018. ",
+        "bbox": [
+            174,
+            337,
+            823,
+            380
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nikolaus Hansen. The CMA evolution strategy: A tutorial. CoRR, abs/1604.00772, 2016. URL http://arxiv.org/abs/1604.00772. ",
+        "bbox": [
+            169,
+            390,
+            825,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Greg Wayne, David Silver, Timothy P. Lillicrap, Yuval Tassa, and Tom Erez. Learning continuous control policies by stochastic value gradients. abs/1510.09142, 2015. ",
+        "bbox": [
+            173,
+            428,
+            821,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Held, Xinyang Geng, Carlos Florensa, and Pieter Abbeel. Automatic goal generation for reinforcement learning agents. arXiv preprint arXiv:1705.06366, 2017. ",
+        "bbox": [
+            171,
+            467,
+            823,
+            497
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Henderson, Riashat Islam, Philip Bachman, Joelle Pineau, Doina Precup, and David Meger. Deep reinforcement learning that matters. abs/1709.06560, 2017. ",
+        "bbox": [
+            173,
+            506,
+            821,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton, Peter Dayan, Brendan J Frey, and Radford M Neal. The” wake-sleep” algorithm for unsupervised neural networks. Science, 268(5214):1158–1161, 1995. ",
+        "bbox": [
+            176,
+            544,
+            821,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gabriel Kalweit and Joschka Boedecker. Uncertainty-driven imagination for continuous deep reinforcement learning. In Proceedings of the 1st Annual Conference on Robot Learning, volume 78 of Proceedings of Machine Learning Research. ",
+        "bbox": [
+            173,
+            583,
+            825,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hilbert J Kappen, Vicenc¸ Gomez, and Manfred Opper. Optimal control as a graphical model infer- ´ ence problem. Machine learning, 87(2):159–182, 2012. ",
+        "bbox": [
+            173,
+            636,
+            821,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jens Kober, J Andrew Bagnell, and Jan Peters. Reinforcement learning in robotics: A survey. The International Journal of Robotics Research, 32(11):1238–1274, 2013. ",
+        "bbox": [
+            173,
+            674,
+            823,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vijaymohan Konda. Actor-critic Algorithms. PhD thesis, Cambridge, MA, USA, 2002. AAI0804543. ",
+        "bbox": [
+            174,
+            712,
+            823,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine and Vladlen Koltun. Variational policy search via trajectory optimization. In NIPS, 2013. ",
+        "bbox": [
+            171,
+            751,
+            825,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            176,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In ICML, 2016. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrew W Moore and Christopher G Atkeson. Prioritized sweeping: Reinforcement learning with less data and less time. Machine learning, 13(1):103–130, 1993. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ofir Nachum, Mohammad Norouzi, Kelvin Xu, and Dale Schuurmans. Bridging the gap between value and policy based reinforcement learning. In NIPS, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Anusha Nagabandi, Gregory Kahn, Ronald S Fearing, and Sergey Levine. Neural network dynamics for model-based deep reinforcement learning with model-free fine-tuning. arXiv preprint arXiv:1708.02596, 2017. ",
+        "bbox": [
+            173,
+            142,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gerhard Neumann et al. Variational inference for policy search in changing situations. In ICML 2011, 2011. ",
+        "bbox": [
+            173,
+            194,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brendan O’Donoghue, Remi Munos, Koray Kavukcuoglu, and Volodymyr Mnih. Pgq: Combining policy gradient and q-learning. arXiv preprint arXiv:1611.01626, 2016. ",
+        "bbox": [
+            173,
+            233,
+            823,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In NIPS, 2015. ",
+        "bbox": [
+            173,
+            272,
+            825,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Georg Ostrovski, Marc G Bellemare, Aaron van den Oord, and Remi Munos. Count-based explo- ´ ration with neural density models. arXiv preprint arXiv:1703.01310, 2017. ",
+        "bbox": [
+            173,
+            310,
+            823,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dean A Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In Advances in neural information processing systems, pp. 305–313, 1989. ",
+        "bbox": [
+            173,
+            349,
+            823,
+            380
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Konrad Rawlik, Marc Toussaint, and Sethu Vijayakumar. On stochastic optimal control and reinforcement learning by approximate inference. In Robotics: science and systems, volume 13, pp. 3052–3056, 2012. ",
+        "bbox": [
+            173,
+            387,
+            823,
+            431
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tom Schaul, Daniel Horgan, Karol Gregor, and David Silver. Universal value function approximators. In ICML, 2015. ",
+        "bbox": [
+            171,
+            440,
+            823,
+            470
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region policy optimization. CoRR, abs/1502.05477, 2015a. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            508
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael I. Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. CoRR, abs/1506.02438, 2015b. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            560
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Richard S. Sutton, and Martin Muller. Sample-based learning and search with perma- ¨ nent and transient memories. In Proceedings of the 25th International Conference on Machine Learning, ICML ’08, 2008. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            613
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            666
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robert F Stengel. Optimal control and estimation. Courier Corporation, 1986. ",
+        "bbox": [
+            173,
+            676,
+            689,
+            691
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Ilya Kostrikov, Arthur Szlam, and Rob Fergus. Intrinsic motivation and automatic curricula via asymmetric self-play. arXiv preprint arXiv:1703.05407, 2017. ",
+        "bbox": [
+            173,
+            700,
+            823,
+            731
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton. Dyna, an integrated architecture for learning, planning, and reacting. SIGART Bull. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "E. Todorov, T. Erez, and Y. Tassa. Mujoco: A physics engine for model-based control. In IROS, 2012. ",
+        "bbox": [
+            176,
+            779,
+            825,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Emanuel Todorov. Linearly-solvable markov decision problems. In NIPS, 2007. ",
+        "bbox": [
+            174,
+            818,
+            700,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marc Toussaint. Robot trajectory optimization using approximate inference. In Proceedings of the 26th annual international conference on machine learning, 2009. ",
+        "bbox": [
+            169,
+            842,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Wang, Victor Bapst, Nicolas Heess, Volodymyr Mnih, Remi Munos, Koray Kavukcuoglu, and Nando de Freitas. Sample efficient actor-critic with experience replay. arXiv preprint arXiv:1611.01224, 2016. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Theophane Weber, Sebastien Racani ´ ere, David P. Reichert, Lars Buesing, Arthur Guez, \\` Danilo Jimenez Rezende, Adria Puigdom \\` enech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, \\` Razvan Pascanu, Peter Battaglia, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. CoRR, abs/1707.06203, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brian D Ziebart, Andrew L Maas, J Andrew Bagnell, and Anind K Dey. Maximum entropy inverse reinforcement learning. In AAAI, 2008. ",
+        "bbox": [
+            169,
+            169,
+            823,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A PSEUDO CODE FOR GAN BASED MODEL ",
+        "bbox": [
+            176,
+            102,
+            549,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Produce High Value States ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            140,
+            437,
+            155
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Require: Critic $V ( s )$   \nRequire: $D$ ; transformation ’decoder’ from $g$ to $s$   \nRequire: Experience buffer $\\boldsymbol { B }$ with tuples $\\left( { { s _ { t } } , { a _ { t } } , { r _ { t } } , { s _ { t + 1 } } } \\right)$   \nRequire: gen state; boolean whether to generate states   \nRequire: $G A N$ , some generative model trained to model high-value goal states   \n1: if gen state then   \n2: $g \\sim G A N$   \n3: $D : g \\mapsto s$   \n4: Return $s$   \n5: else   \n6: Return argmax ${ \\mathrm { : } } ( V ( s ) ) \\ \\forall s \\in B$   \n7: end if ",
+        "bbox": [
+            174,
+            159,
+            704,
+            328
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B PERFORMANCE BY VARYING LENGTH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            521,
+            376
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Figure 8 we show the performance in learning efficiency when the length of the backward traces is varied. ",
+        "bbox": [
+            169,
+            390,
+            825,
+            420
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/4cbdae02d8b7c74ee8f08da2d651f18271753ec52476874e17bfea3939e7074e.jpg",
+        "image_caption": [
+            "Figure 8: Performance of our model (with TRPO) by varying the length of traces from backtracking model. All the time-steps are in thousands i.e $( \\mathbf { x } 1 0 0 0 )$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            430,
+            784,
+            719
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C ARCHITECTURE AND IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            619,
+            797
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The backtracking model we used for all the experiments consisted of two multi-layer perceptrons: one for the backward action predictor $Q ( a _ { t } | s _ { t + 1 } )$ and one for the backward state predictor $Q ( s _ { t } | a _ { t } , s _ { t + 1 } )$ . Both MLPs had two hidden layers of 128 units. The action predictor used hyperbolic tangent units while the inverse state predictor used ReLU units. Each network produced as output the mean and variance parameters of a Gaussian distribution. For the action predictor the output variance was fixed to 1. For the state predictor this value was learned for each dimension. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            896
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We do about a hundred training-steps of the backtracking model for every 5 training-steps of the RL algorithm. For training the backtracking model we maintain a buffer which stores states (state, action, nextstate, reward) yielding high rewards. We sample a batch from the buffer and then normalize the states, actions before training the backtracking model on them. ",
+        "bbox": [
+            173,
+            909,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "During the sampling phase we feed in the normalized nextstate in the backward action predictor $Q ( a _ { t } | s _ { t + 1 } )$ to get normalized action. Then we input this normalized action in the backward state predictor $Q ( s _ { t } | a _ { t } , s _ { t + 1 } )$ to get normalized previous state. We then un-normalize the obtained previous states and action using the corresponding mean and variance to compute the Imitation loss. This is required for stability during sampling. ",
+        "bbox": [
+            174,
+            146,
+            825,
+            215
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            241,
+            400,
+            257
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "FOUR ROOM ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            276,
+            374,
+            290
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/09743a08e364150927a6aa7be84b01ba8cc7daec12d4f13ba72a09f8e14aa2dd.jpg",
+        "image_caption": [
+            "Figure 9: Training curves from the Four Room Environment for the Actor-Critic baseline (blue) and the backtracking model augmented Actor-Critic (orange). As the size of the environment increases, the benefit of the backtracking model increases for the policy. For the size-19 environment, several of the Actor-Critic baselines failed to converge, whereas the augmented recall trace model always succeeded in the number of training steps considered. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            318,
+            779,
+            460
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "COMPARISON WITH PER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            348,
+            594
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We show additional results for 13 Dimensional Environment. ",
+        "bbox": [
+            173,
+            609,
+            575,
+            625
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/5f20b21a9b4e2692d1f0c9882b70552984a8b86f870ff82ca03354e587f06ef0.jpg",
+        "image_caption": [
+            "Figure 10: Plot(a) for Reward(y) vs Timesteps $\\mathbf { \\tau } ( \\mathbf { x } )$ comparing the performance of backtracking model, PER and baseline Actor Critic. We can see that backtracking model consistently beats PER and the gap increases for increasing dimension. Heatmaps(b,c) indicating the visitation count on various positions of the grid on trained policies for the 13-Dimensional environment. We can see that the Backtracking visits a lot more states that PER does. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            640,
+            807,
+            818
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "U-MAZE NAVIGATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            331,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "An agent has to navigate within $\\epsilon -$ distance of the goal position at the end of a U-shaped maze. ",
+        "bbox": [
+            173,
+            130,
+            800,
+            145
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For the Point Mass U-Maze navigation, we use high return trajectories for training the parameters of backtracking model (i.e those trajectories which reach sub-goals defined by Goal GAN). We sample a trajectory of length 20 from our backtracking model and the recall traces are used to improve the policy via imitation learning. ",
+        "bbox": [
+            173,
+            151,
+            826,
+            207
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For the Ant U-Maze navigation, we train identically, only with length-50 traces. ",
+        "bbox": [
+            171,
+            213,
+            696,
+            229
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/b78722a6896dfa20ea01b2ca545cbafb94a59d0b9bc9dc0414d25015b12e58cb.jpg",
+        "image_caption": [
+            "Figure 11: Visualization of Goal GAN baseline (top row) versus backtracking model (bottom row) for different parts of the state space for the N-Dimensional Point Mass task. Red indicates complete success; blue indicates failure. Using the backtracking model achieves greater coverage rates for the same or fewer steps of training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            244,
+            792,
+            497
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/dec55ba58a5188d0926ed0268a0b778e4ed85cceb16cd4298443cfa9b51674e8.jpg",
+        "image_caption": [
+            "Figure 12: Visualization of Goal GAN baseline (top row) versus backtracking model (bottom row) policy performance for different parts of the state space for Ant Maze task. Red indicates complete success; blue indicates failure. Using the backtracking model achieves equal coverage rates in fewer steps of training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            590,
+            789,
+            843
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/db42253b4d38cc46437d958badf97da719ba6533e8fc315ec625bf1c70cf500f.jpg",
+        "image_caption": [
+            "Figure 13: Learning curves comparing the training efficiency of our method and the baseline for both the point mass as well as ant maze task. The y-axis indicates the average return over all goal positions in the maze, and the $\\mathbf { X }$ -axis corresponds to the number of iterations which are used for sampling goals. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            101,
+            828,
+            255
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            347,
+            379,
+            363
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E.1 ON-POLICY. TRPO ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            377,
+            352,
+            393
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For training the backtracking model, we used an explicit buffer to store states(state, action, nextstate, reward) which yields high rewards. Since, we don’t have an explicit value function, we use high reward states as a proxy for high value states. We tried training the backtracking model directly from the trajectories, but it was unstable, due to changing distributions of trajectories. ",
+        "bbox": [
+            176,
+            404,
+            823,
+            460
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/3e7185cfd375525323dc26c3a4401a72a3856d1dd0b80e6edecf25b7f2384e87.jpg",
+        "table_caption": [
+            "Table 1: On-Policy TRPO Hyper-params:- Length of the trajectory sampled from our backtracking model "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Agent</td><td>Length of trajectory Sampled from Backtracking model</td></tr><tr><td>Half-Cheetah</td><td>20</td></tr><tr><td>Walker</td><td>20</td></tr><tr><td>Hopper</td><td>10</td></tr><tr><td>Ant</td><td>50</td></tr></table>",
+        "bbox": [
+            251,
+            473,
+            745,
+            549
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E.2 OFF-POLICY. SAC ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            613,
+            346,
+            627
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "For training the backtracking model, we used the high value states (under the current value function) from the buffer $\\boldsymbol { B }$ . We sample a batch of 20K high value tuples from the experience replay buffer. The length of trajectory sampled from backtracking model for each agent is shown in Table 1. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            681
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/1862e2d543cda2e929415d4b5313d7508f8c85db7ba9d5d1fdde2add538a49db.jpg",
+        "table_caption": [
+            "The rest of the model hyperparameters are identical to those used in Soft Actor Critic Held et al. (2017). ",
+            "Table 2: Off Policy SAC Hyperparams:- Length of the trajectory sampled from our backtracking model "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Agent</td><td>Length of trajectory Sampled from Backtracking model</td></tr><tr><td>Half-Cheetah</td><td>20</td></tr><tr><td>Walker</td><td>20</td></tr><tr><td>Hopper</td><td>20</td></tr><tr><td>Ant</td><td>50</td></tr><tr><td>Humanoid</td><td>50</td></tr></table>",
+        "bbox": [
+            251,
+            728,
+            745,
+            819
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "E.3 PRIORITIZED EXPERIENCE REPLAY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            882,
+            460,
+            897
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "The Experience Replay Buffer capacity was fixed at $1 0 0 \\mathrm { k }$ . No entropy regularization was used. ",
+        "bbox": [
+            173,
+            909,
+            795,
+            925
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/7512e6f4cb1f5a5067cda7cb6f6b3bf9564b0cd280a417066212cd23a89cc62a.jpg",
+        "table_caption": [
+            "Table 3: Hyperparameters for the PER Implementation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Environment Size</td><td>Batch-size</td><td>Num. of Actor Critic steps per PER step</td><td>PER-α</td><td>PER β</td></tr><tr><td>11x11</td><td>200</td><td>3</td><td>0.8</td><td>0.1</td></tr><tr><td>13x13</td><td>2000</td><td>3</td><td>0.8</td><td>0.1</td></tr><tr><td>15x15</td><td>1000</td><td>3</td><td>0.95</td><td>0.1</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            823,
+            160
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "F RANDOM SEARCH WITH BACKWARD MODEL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            219,
+            580,
+            236
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We test the performance of backtracking model when it is not learned i.e the backtracking model is a random model, in the Four Room Environment. In this experiment, we compare the scenario when the backward action predictor $Q ( a _ { t } | s _ { t + 1 } )$ is learned and when it is random. Since in the Four Room Environment, we have access to the true backward state predictor $Q ( s _ { t } | a _ { t } , s _ { t + 1 } )$ we use that for this experiment. The comparison is shown in the figure 14. It is clear from the figure that it is helpful to learn the backward action predictor $Q \\big ( a _ { t } | s _ { t + 1 } \\big )$ . ",
+        "bbox": [
+            173,
+            256,
+            826,
+            342
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea74d0cb96855ca9c9b6544c67337796f29b048aa68dd758dab9878dbe77ce83.jpg",
+        "image_caption": [
+            "Figure 14: Training curves from the Four Room Environment for the Actor-Critic baseline (blue), the backtracking model augmented Actor-Critic (red), and the random search (blue). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            336,
+            363,
+            707,
+            529
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Figure 15 shows the same comparison for Ant-v1, and Walker2d-v1 where the baseline is Soft Actor Critic (SAC). For our baseline i.e the scenario when backtracking model is not learned, we experimented with all the lengths 1,2,3,4,5, 10 and we choose the best one as our baseline. As you can see in the Figure 15, backtracking model performs best as compared to SAC baseline as well as to the scenario when backtracking model is not trained. Hence proving that backtracking model is not just doing random search. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            676
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/b42b9d4ddaf88f8a8435604795ff5967eabae29950911b090243a97fe8efd84b.jpg",
+        "image_caption": [
+            "Figure 15: Training curves for the Walker2d and Ant agent. Comparing when the backtracking model is learned v/s when it’s not learned. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            698,
+            807,
+            863
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "G COMPARISON TO MODEL BASED RL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            513,
+            118
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Dyna algorithm uses a forward model to generate simulated experience that could be included in a model-free algorithm. This method can be used to work with deep neural network policies, but performed best with models which are not neural networks (Gu et al., 2016a). Our intuition says that it might be better to generate simulated experience from backtracking model (starting from a high value state) as compared to forward model, just because we know that traces from backtracking model are good, as they lead to high value state, which is not really the case for the simulated experience from a forward model. In Fig 16, we evaluate the Forward model with On-Policy TRPO on Ant and Humanoid Mujoco tasks. We were not able to get any better results on with forward model as compared to the Baseline TRPO, which is consistent with the findings from (Gu et al., 2016a). ",
+        "bbox": [
+            173,
+            136,
+            825,
+            275
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/057d6cc25fd96ff975e278b44720002a6806ad6662bb9a5cf89bbf2e64ee1e12.jpg",
+        "image_caption": [
+            "Figure 16: Forward Model compared with Baseline TRPO. We can clearly see that on Ant and Humanoid Mujoco tasks using a forward Model-based approach doesn’t help. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            292,
+            821,
+            402
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Building the backward model is necessarily neither harder nor easier. Realistically, building any kind of model and having it be accurate for more than, say, 10 time steps is pretty hard. But if we only have 10 time steps of accurate transitions, it is probably better to take them backward model from different states as compared to from forward model from the same initial state. (as corroborated by our experiments). ",
+        "bbox": [
+            174,
+            463,
+            823,
+            532
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Something which remains as a part of future investigation is to train the forward model and backtracking model jointly. As backtracking model is tied to high value state, the forward model could extract the goal value from the high value state. When trained jointly, this should help the forward model learn some reduced representation of the state that is necessary to evaluate the reward. Ultimately, when planning, we want the model to predict the goal accurately, which helps to optimize for this ”goal-oriented” behaviour directly. This also avoids the need to model irrelevant aspects of the environment. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            637
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "H LEARNING THE TRUE ENVIRONMENT VS LEARNING FROM RECALL TRACES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            662,
+            769,
+            695
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Here, we show the results of various ablations in the four-room environment which highlight the effect various hyperparameters have on performance. ",
+        "bbox": [
+            174,
+            714,
+            823,
+            742
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "In Fig 17 we train on the recall traces after a fixed number of iterations of learning in the true environment. For all of the environments, as we increase the ratio of updates in the true environment to updates using recall traces from backward model, the performance decreases significantly. This again highlights the advantages of learning from recall traces. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            805
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 18, we see the effects of training from the recall traces multiple times for every iteration of training in the true environment. We can see that as we increase the number of iteration of learning from recall traces, we correspondingly need to choose smaller trace length. For each update in the real environment, making more number of updates helps if the trace length is smaller, and if the trace length is larger, it has a detrimental effect on the learning process as is seen in 18. Also as observed in the cases of $1 2 \\mathrm { x } 1 2$ and 14x14 environment, it may happen that for an increased ratio of learning from recall traces and high trace length, the model achieves the maximum reward initially but after sometime the average reward plummets. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/1516aac4eb9b061f278485bc1bafd0f9a7a37c4fda916c3b354950ec349bfe32.jpg",
+        "image_caption": [
+            "Figure 17: Legend indicates the ratio of updates in the true environment to updates using recall traces. Here we learn more in the true environment than using traces. We can see that not learning regularly from recall traces gives decreased performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            101,
+            805,
+            388
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/a49e244caa64990da77e888e6cd6b2fc5f5e7dcfe914b3c148d3fe9c74da71ba.jpg",
+        "image_caption": [
+            "Figure 18: Legend indicates the ratio of updates in the true environment to updates using recall traces with the trajectory length of traces in parenthesis. Here we learn more using recall traces than actual environment. This tells that more updates using recall traces helps if we have a correspondingly lower trajectory length "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            457,
+            805,
+            746
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "OFF POLICY CASE FOR MUJOCO ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            406,
+            856
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "text",
+        "text": "We investigate the effect of doing more updates from the generated recall traces on some Mujoco tasks using Off-Policy SAC. As can be seen from 19, we find that using more traces helps and that for an increased number of updates we need to correspondingly shorten the trajectory length of the sampled traces. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/11a11f30b732120634bc0a832b845bd06da09fd7d44a5b1864ad8e5bb983ee0d.jpg",
+        "image_caption": [
+            "Figure 19: Legend indicates the number of updates from recall traces(per 5 updates of SAC) with the trajectory length in parentheses. In both the environments doing 10 or 20 updates is better than 5 updates. Also for 20 updates we need to choose a smaller trajectory of length 10 as compared to length 20 for 10(and 5) updates. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            101,
+            807,
+            244
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "text",
+        "text": "These experiments show that there is a balance between how much we should train in the actual environment and how much we should learn from the traces generated from the backward model. In the smaller four room-environment, 1:1 balance performed the best. In Mujoco tasks and larger four room environments, doing more updates from the backward model helps, but in the smaller four room maze, doing more updates is detrimental. So depending upon the complexity of the task, we need to decide this ratio. ",
+        "bbox": [
+            173,
+            340,
+            825,
+            424
+        ],
+        "page_idx": 19
+    }
+]

parse/train/SkhU2fcll/SkhU2fcll.md

@@ -0,0 +1,240 @@
+# DEEP MULTI-TASK REPRESENTATION LEARNING: A TENSOR FACTORISATION APPROACH
+
+Yongxin Yang, Timothy M. Hospedales Queen Mary, University of London {yongxin.yang, t.hospedales}@qmul.ac.uk
+
+# ABSTRACT
+
+Most contemporary multi-task learning methods assume linear models. This setting is considered shallow in the era of deep learning. In this paper, we present a new deep multi-task representation learning framework that learns cross-task sharing structure at every layer in a deep network. Our approach is based on generalising the matrix factorisation techniques explicitly or implicitly used by many conventional MTL algorithms to tensor factorisation, to realise automatic learning of end-to-end knowledge sharing in deep networks. This is in contrast to existing deep learning approaches that need a user-defined multi-task sharing strategy. Our approach applies to both homogeneous and heterogeneous MTL. Experiments demonstrate the efficacy of our deep multi-task representation learning in terms of both higher accuracy and fewer design choices.
+
+# 1 INTRODUCTION
+
+The paradigm of multi-task learning is to learn multiple related tasks simultaneously so that knowledge obtained from each task can be re-used by the others. Early work in this area focused on neural network models (Caruana, 1997), while more recent methods have shifted focus to kernel methods, sparsity and low-dimensional task representations of linear models (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012). Nevertheless given the impressive practical efficacy ´ of contemporary deep neural networks (DNN)s in many important applications, we are motivated to revisit MTL from a deep learning perspective.
+
+While the machine learning community has focused on MTL for shallow linear models recently, applications have continued to exploit neural network MTL (Zhang et al., 2014; Liu et al., 2015). The typical design pattern dates back at least 20 years (Caruana, 1997): define a DNN with shared lower representation layers, which then forks into separate layers and losses for each task. The sharing structure is defined manually: full-sharing up to the fork, and full separation after the fork. However this complicates DNN architecture design because the user must specify the sharing structure: How many task specific layers? How many task independent layers? How to structure sharing if there are many tasks of varying relatedness?
+
+In this paper we present a method for end-to-end multi-task learning in DNNs. This contribution can be seen as generalising shallow MTL methods (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012) to learning how to share ´ at every layer of a deep network; or as learning the sharing structure for deep MTL (Caruana, 1997; Zhang et al., 2014; Spieckermann et al., 2014; Liu et al., 2015) which currently must be defined manually on a problem-by-problem basis.
+
+Before proceeding it is worth explicitly distinguishing some different problem settings, which have all been loosely referred to as MTL in the literature. Homogeneous MTL: Each task corresponds to a single output. For example, MNIST digit recognition is commonly used to evaluate MTL algorithms by casting it as 10 binary classification tasks (Kumar & Daume III, 2012). ´ Heterogeneous MTL: Each task corresponds to a unique set of output(s) (Zhang et al., 2014). For example, one may want simultaneously predict a person’s age (task one: multi-class classification or regression) as well as identify their gender (task two: binary classification) from a face image.
+
+In this paper, we propose a multi-task learning method that works on all these settings. The key idea is to use tensor factorisation to divide each set of model parameters (i.e., both FC weight matrices, and convolutional kernel tensors) into shared and task-specific parts. It is a natural generalisation of shallow MTL methods that explicitly or implicitly are based on matrix factorisation (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012; Daum ´ e III, 2007). As linear methods, ´ these typically require pre-engineered features. In contrast, as a deep network, our generalisation can learn directly from raw image data, determining sharing structure in a layer-wise fashion. For the simplest NN architecture – no hidden layer, single output – our method reduces to matrix-based ones, therefore matrix-based methods including (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012; Daum ´ e III, 2007) are special cases of ours. ´
+
+# 2 RELATED WORK
+
+Multi-Task Learning Most contemporary MTL algorithms assume that the input and model are both $D$ -dimensional vectors. The models of $T$ tasks can then be stacked into a $D \times T$ sized matrix $W$ . Despite different motivations and implementations, many matrix-based MTL methods work by placing constrains on $W$ . For example, posing an $\ell _ { 2 , 1 }$ norm on $W$ to encourage low-rank $W$ (Argyriou et al., 2008). Similarly, (Kumar & Daume III, 2012) factorises ´ $W$ as $W = L S$ , i.e., it assigns a lower rank as a hyper-parameter. An earlier work (Evgeniou & Pontil, 2004) proposes that the linear model for each task $t$ can be written as $w _ { t } = \hat { w } _ { t } + \hat { w } _ { 0 }$ . This is the factorisation $L = [ \hat { w } _ { 0 } , \hat { w } _ { 1 } , \dots , \hat { w } _ { T } ]$ and ${ \cal S } = [ { \bf 1 } _ { 1 \times T } ; { \bf I } _ { T } ]$ . In fact, such matrix factorisation encompasses many MTL methods. E.g., (Xue et al., 2007) assumes $S _ { \cdot , i }$ (the ith column of $S$ ) is a unit vector generated by a Dirichlet Process and (Passos et al., 2012) models $W$ using linear factor analysis with Indian Buffet Process (Griffiths & Ghahramani, 2011) prior on $S$ .
+
+Tensor Factorisation In deep learning, tensor factorisation has been used to exploit factorised tensors’ fewer parameters than the original (e.g., 4-way convolutional kernel) tensor, and thus compress and/or speed up the model, e.g., (Lebedev et al., 2015; Novikov et al., 2015). For shallow linear MTL, tensor factorisation has been used to address problems where tasks are described by multiple independent factors rather than merely indexed by a single factor (Yang & Hospedales, 2015). Here the $D$ -dimensional linear models for all unique tasks stack into a tensor $\mathcal { W }$ , of e.g. $D \times T _ { 1 } \times T _ { 2 }$ in the case of two task factors. Knowledge sharing is then achieved by imposing tensor norms on $\mathcal { W }$ (Romera-paredes et al., 2013; Wimalawarne et al., 2014). Our framework factors tensors for the different reason that for DNN models, parameters include convolutional kernels ( $N$ -way tensors) or $D _ { 1 } \times D _ { 2 }$ FC layer weight matrices (2-way tensors). Stacking up these parameters for many tasks results in $D _ { 1 } \times \cdots \times D _ { N } \times T$ tensors within which we share knowledge through factorisation.
+
+Heterogeneous MTL and DNNs Some studies consider heterogeneous MTL, where tasks may have different numbers of outputs (Caruana, 1997). This differs from the previously discussed studies (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Bonilla et al., 2007; Jacob et al., 2009; Kumar & Daume III, 2012; Romera-paredes et al., 2013; Wimalawarne et al., 2014) which implicitly as- ´ sume that each task has a single output. Heterogeneous MTL typically uses neural networks with multiple sets of outputs and losses. E.g., Huang et al. (2013) proposes a shared-hidden-layer DNN model for multilingual speech processing, where each task corresponds to an individual language. Zhang et al. (2014) uses a DNN to find facial landmarks (regression) as well as recognise facial attributes (classification); while Liu et al. (2015) proposes a DNN for query classification and information retrieval (ranking for web search). A key commonality of these studies is that they all require a user-defined parameter sharing strategy. A typical design pattern is to use shared layers (same parameters) for lower layers of the DNN and then split (independent parameters) for the top layers. However, there is no systematic way to make such design choices, so researchers usually rely on trial-and-error, further complicating the already somewhat dark art of DNN design. In contrast, our method learns where and how much to share representation parameters across the tasks, hence significantly reducing the space of DNN design choices.
+
+Parametrised DNNs Our MTL approach is a parameterised DNN (Sigaud et al., 2015), in that DNN weights are dynamically generated given some side information – in the case of MTL, given the task identity. In a related example of speaker-adaptive speech recognition (Tan et al., 2016) there may be several clusters in the data (e.g., gender, acoustic conditions), and each speaker’s model could be a linweight matrix mbination oas a sum of h e latent taase models cluste, i.e., each speaker . The differe $i$ ’se $W ^ { ( i ) }$ $K$ $\tilde { W }$ $\begin{array} { r } { W ^ { ( i ) } = \sum _ { k = 1 } ^ { K } \lambda _ { p } ^ { ( i ) } \tilde { W } ^ { ( p ) } } \end{array}$ between speakers/tasks comes from $\lambda$ and the base models are shared. An advantage of this is that, when new data come, one can choose to re-train $\lambda$ parameters only, and keep $\tilde { W }$ fixed. This will significantly reduce the number of parameters to learn, and consequently the required training data. Beyond this, Yang & Hospedales (2015) show that it is possible to train another neural network to predict those $\lambda$ values from some abstract metadata. Thus a model for an unseen task can be generated on-the-fly with no training instances given an abstract description of the task. The techniques developed here are compatible with both these ideas of generating models with minimal or no effort.
+
+# 3 METHODOLOGY
+
+# 3.1 PRELIMINARIES
+
+We first recap some tensor factorisation basics before explaining how to factorise DNN weight tensors for multi-task representation learning. An $N$ -way tensor $\mathcal { W }$ with shape $D _ { 1 } \times D _ { 2 } \times \cdot \cdot \cdot D _ { N }$ is an $N$ -dimensional array containing $\textstyle \prod _ { n = 1 } ^ { N } D _ { n }$ elements. Scalars, vectors, and matrices can be seen as $0 , 1$ , and 2-way tensors respectively, although the term tensor is usually used for 3-way or higher. A mode- $\boldsymbol { n }$ fibre of $\mathcal { W }$ is a $D _ { n }$ -dimensional vector obtained by fixing all but the nth index. The mode- $\boldsymbol { n }$ flattening $W _ { ( n ) }$ of $\mathcal { W }$ is the matrix of size $\begin{array} { r } { D _ { n } \times \prod _ { i = n } D _ { i } } \end{array}$ constructed by concatenating all of the $\Pi _ { i \lnot n } D _ { i }$ mode- $\mathbf { \nabla } \cdot n$ fibres along columns.
+
+The dot product of two tensors is a natural extension of matrix dot product, e.g., if we have a tensor $\mathcal { A }$ of size $M _ { 1 } \times M _ { 2 } \times \cdot \cdot \cdot P$ and a tensor $\boldsymbol { B }$ of size $P \times N _ { 1 } \times N _ { 2 } \dots$ , the tensor dot product $\mathcal { A } \bullet \mathcal { B }$ will be a tensor of size $M _ { 1 } \times M _ { 2 } \times \cdots N _ { 1 } \times N _ { 2 } \cdot \cdot \cdot$ by matrix dot product $A _ { ( - 1 ) } ^ { T } B _ { ( 1 ) }$ and reshaping1. More generally, tensor dot product can be performed along specified axes, $\mathcal { A } \bullet _ { ( i , j ) } \mathcal { B } = A _ { ( i ) } ^ { T } B _ { ( j ) }$ and reshaping. Here the subscripts indicate the axes of $\mathcal { A }$ and $\boldsymbol { B }$ at which dot product is performed. E.g., when $\mathcal { A }$ is of size $M _ { 1 } \times P \times M _ { 3 } \times \cdot \cdot \cdot M _ { I }$ and $\boldsymbol { B }$ is of size $N _ { 1 } \times N _ { 2 } \times P \times \cdot \cdot \cdot N _ { J }$ , then $\mathbf { \mathcal { A } } \bullet _ { ( 2 , 3 ) } B$ is a tensor of size $M _ { 1 } \times M _ { 3 } \times \cdots M _ { I } \times N _ { 1 } \times N _ { 2 } \times \cdots N _ { J }$ .
+
+Matrix-based Knowledge Sharing Assume we have $T$ linear models (tasks) parametrised by $D$ - dimensional weight vectors, so the collection of all models forms a size $D \times T$ matrix $W$ . One commonly used MTL approach (Kumar & Daume III, 2012) is to place a structure constraint on ´ $W$ , e.g., $W = L S$ , where $L$ is a $D \times K$ matrix and $S$ is a $K \times T$ matrix. This factorisation recovers a shared factor $L$ and a task-specific factor $S$ . One can see the columns of $L$ as latent basis tasks, and the model $w ^ { ( i ) }$ for the $i$ th task is the linear combination of those latent basis tasks with task-specific information $S _ { \cdot , i }$ .
+
+$$
+w ^ { ( i ) } : = W _ { \cdot , i } = L S _ { \cdot , i } = \sum _ { k = 1 } ^ { K } L _ { \cdot , k } S _ { k , i }
+$$
+
+From Single to Multiple Outputs Consider extending this matrix factorisation approach to the case of multiple outputs. The model for each task is then a $D _ { 1 } \times D _ { 2 }$ matrix, for $D _ { 1 }$ input and $D _ { 2 }$ output dimensions. The collection of all those matrices constructs a $D _ { 1 } \times D _ { 2 } \times T$ tensor. A straightforward extension of Eq. 1 to this case is
+
+$$
+W ^ { ( i ) } : = \mathcal { W } _ { \cdot , \cdot , i } = \sum _ { k = 1 } ^ { K } \mathcal { L } _ { \cdot , \cdot , k } S _ { k , i }
+$$
+
+This is equivalent to imposing the same structural constraint on $W _ { ( 3 ) } ^ { T }$ (transposed mode-3 flattening of $\mathcal { W }$ ). It is important to note that this allows knowledge sharing across the tasks only. I.e., knowledge sharing is only across-tasks not across dimensions within a task. However it may be that the knowledge learned in the mapping to one output dimension may be useful to the others within one task. E.g., consider recognising photos of handwritten and print digits – it may be useful to share across handwritten-print; as well as across different digits within each. In order to support general knowledge sharing across both tasks and outputs within tasks, we propose to use more general tensor factorisation techniques. Unlike for matrices, there are multiple definitions of tensor factorisation, and we use Tucker (Tucker, 1966) and Tensor Train (TT) (Oseledets, 2011) decompositions.
+
+# 3.2 TENSOR FACTORISATION FOR KNOWLEDGE SHARING
+
+Tucker Decomposition Given an $N$ -way tensor of size $D _ { 1 } \times D _ { 2 } \cdot \cdot \cdot \times D _ { N }$ , Tucker decomposition outputs a core tensor $s$ of size $K _ { 1 } \times K _ { 2 } \cdot \cdot \cdot \times K _ { N }$ , and $N$ matrices $U ^ { ( n ) }$ of size $D _ { n } \times K _ { n }$ , such that,
+
+$$
+\begin{array} { r c l } { { \mathcal { W } _ { d _ { 1 } , d _ { 2 } , \dots , d _ { N } } } } & { { = } } & { { \displaystyle \sum _ { k _ { 1 } = 1 } ^ { K _ { 1 } } \sum _ { k _ { 2 } = 1 } ^ { K _ { 2 } } \cdots \sum _ { k _ { N } = 1 } ^ { K _ { N } } S _ { k _ { 1 } , k _ { 2 } , \dots , k _ { N } } U _ { d _ { 1 } , k _ { 1 } } ^ { ( 1 ) } U _ { d _ { 2 } , k _ { 2 } } ^ { ( 2 ) } \cdots U _ { d _ { N } , k _ { N } } ^ { ( N ) } } } \\ { { \mathcal { W } } } & { { = } } & { { \displaystyle \mathcal { S } \bullet _ { ( _ { 1 , 2 } ) } U ^ { ( 1 ) } \bullet _ { ( _ { 1 , 2 } ) } U ^ { ( 2 ) } \cdots \bullet _ { ( _ { 1 , 2 } ) } U ^ { ( N ) } } } \end{array}
+$$
+
+Tucker decomposition is usually implemented by an alternating least squares (ALS) method (Kolda & Bader, 2009). However (Lathauwer et al., 2000) treat it as a higher-order singular value decomposition (HOSVD), which is more efficient to solve: $U ^ { ( n ) }$ is exactly the $U$ matrix from the SVD of mode- $n$ flattening $W _ { ( n ) }$ of $\mathcal { W }$ , and the core tensor $s$ is obtained by,
+
+$$
+\begin{array} { r } { \pmb { \mathscr { S } } = \mathscr { W } \bullet _ { ( 1 , 1 ) } \boldsymbol { U } ^ { ( 1 ) } \bullet _ { ( 1 , 1 ) } \boldsymbol { U } ^ { ( 2 ) } \cdots \bullet _ { ( 1 , 1 ) } \boldsymbol { U } ^ { ( N ) } } \end{array}
+$$
+
+Tensor Train Decomposition Tensor Train (TT) Decomposition outputs 2 matrices $U ^ { ( 1 ) }$ and $U ^ { ( N ) }$ of size $D _ { 1 } \times K _ { 1 }$ and $K _ { N - 1 } \times D _ { N }$ respectively, and $( N - 2 )$ 3-way tensors $\mathcal { U } ^ { ( n ) }$ of size $K _ { n - 1 } \times D _ { n } \times K _ { n }$ . The elements of $\mathcal { W }$ can be computed by,
+
+$$
+\begin{array} { l c l } { { \displaystyle \mathcal { W } _ { d _ { 1 } , d _ { 2 } , \dots , d _ { N } } } } & { { = } } & { { \displaystyle \sum _ { k _ { 1 } = 1 } ^ { K _ { 1 } } \sum _ { k _ { 2 } = 1 } ^ { K _ { 2 } } \cdots \sum _ { k _ { N - 1 } = 1 } ^ { K _ { N - 1 } } U _ { d _ { 1 } , k _ { 1 } } ^ { ( 1 ) } \mathcal { U } _ { k _ { 1 } , d _ { 2 } , k _ { 2 } } ^ { ( 2 ) } \mathcal { U } _ { k _ { 2 } , d _ { 3 } , k _ { 3 } } ^ { ( 3 ) } \cdots U _ { k _ { N - 1 } , d _ { N } } ^ { ( N ) } } } \\ { { } } & { { = } } & { { \displaystyle U _ { d _ { 1 } , l } ^ { ( 1 ) } \mathcal { U } _ { , d _ { 2 } , l } ^ { ( 2 ) } \mathcal { U } _ { , d _ { 3 } , \cdot } ^ { ( 3 ) } \cdots U _ { \cdot , d _ { N } } ^ { ( d ) } } } \\ { { \displaystyle \mathcal { W } } } & { { = } } & { { \displaystyle U ^ { ( 1 ) } \bullet \mathcal { U } ^ { ( 2 ) } \cdot \cdots \bullet U ^ { ( N ) } } } \end{array}
+$$
+
+where U (n)·,d ,· is a matrix of size $K _ { n - 1 } \times K _ { n }$ sliced from $\mathcal { U } ^ { ( n ) }$ with the second axis fixed at $d _ { n }$ . The TT decomposition is typically realised with a recursive SVD-based solution (Oseledets, 2011).
+
+Knowledge Sharing If the final axis of the input tensor above indexes tasks, i.e. if $D _ { N } = T$ then the last factor $U ^ { ( N ) }$ in both decompositions encodes a matrix of task specific knowledge, and the other factors encode shared knowledge.
+
+# 3.3 DEEP MULTI-TASK REPRESENTATION LEARNING
+
+To realise deep multi-task representation learning (DMTRL), we learn one DNN per-task each with the same architecture2. However each corresponding layer’s weights are generated with one of the knowledge sharing structures in Eq. 2, Eq. 4 or Eq. 8. It is important to note that we apply these ‘right-to-left’ in order to generate weight tensors with the specified sharing structure, rather than actually applying Tucker or TT to decompose an input tensor. In the forward pass, we synthesise weight tensors $\mathcal { W }$ and perform inference as usual, so the method can be thought of as tensor composition rather than decomposition.
+
+Our weight generation (construct tensors from smaller pieces) does not introduce non-differentiable terms, so our deep multi-task representation learner is trainable via standard backpropagation. Specifically, in the backward pass over FC layers, rather than directly learning the 3-way tensor $\mathcal { W }$ , our methods learn either $\{ S , U _ { 1 } , U _ { 2 } , U _ { 3 } \}$ (DMTRL-Tucker, Eq. 4), $\{ U _ { 1 } , \mathcal { U } _ { 2 } , U _ { 3 } \}$ (DMTRL-TT, Eq. 8), or in the simplest case $\{ \mathcal { L } , S \}$ (DMTRL- $\mathrm { . L A F ^ { 3 } }$ , Eq. 2). Besides FC layers, contemporary
+
+![](images/bbff1fe62fcb72612a1068843c26d12df81ac25b5a13fefd9886eeb50c6f4718.jpg)  
+Figure 1: Illustrative example with two tasks corresponding to two neural networks in homogeneous (single output) and heterogeneous (different output dimension) cases. Weight layers grouped by solid rectangles are tied across networks. Weight layers grouped by dashed rectangles are softly shared across networks with our method. Ungrouped weights are independent.   
+Homogeneous MTL Shallow: Left is STL (two independent networks); right is MTL. In the case of vector input and no hidden layer, our method is equivalent to conventional matrix-based MTL methods. Homogeneous MTL Deep: STL (Left) is independent networks. User-defined-MTL (UDMTL) selects layers to share/separate. Our DMTRL learns sharing at every layer. Heterogeneous MTL: UD-MTL selects layers to share/separate. DMTRL learns sharing at every shareable layer.
+
+DNN designs often exploit convolutional layers. Those layers usually contain kernel filter parameters that are 3-way tensors of size $H \times W \times C$ , (where $H$ is height, $W$ is width, and $C$ is the number of input channels) or 4-way tensors of size $H \times W \times C \times M$ , where $M$ is the number of filters in this layer (i.e., the number of output channels). The proposed methods naturally extend to convolution layers as convolution just adds more axes on the left-hand side. E.g., the collection of parameters from a given convolutional layer of $T$ neural networks forms a tensor of shape $H \times W \times C \times M \times T$ .
+
+These knowledge sharing strategies provide a way to softly share parameters across the corresponding layers of each task’s DNN: where, what, and how much to share are learned from data. This is in contrast to the conventional Deep-MTL approach of manually selecting a set of layers to undergo hard parameter sharing: by tying weights so each task uses exactly the same weight matrix/tensor for the corresponding layer (Zhang et al., 2014; Liu et al., 2015); and a set of layers to be completely separate: by using independent weight matrices/tensors. In contrast our approach benefits from: (i) automatically learning this sharing structure from data rather than requiring user trial and error, and (ii) smoothly interpolating between fully shared and fully segregated layers, rather than a hard switching between these states. An illustration of the proposed framework for different problem settings can be found in Fig. 1.
+
+# 4 EXPERIMENTS
+
+Implementation Details Our method is implemented with TensorFlow (Abadi et al., 2015). The code is released on $\mathrm { G i t H u b ^ { 4 } }$ . For DMTRL-Tucker, DMTRL-TT, and DMTRL-LAF, we need to assign the rank of each weight tensor. The DNN architecture itself may be complicated and so can benefit from different ranks at different layers, but grid-search is impractical. However, since both Tucker and TT decomposition methods have SVD-based solutions, and vanilla SVD is directly applicable to DMTRL-LAF, we can initialise the model and set the ranks as follows: First train the DNNs independently in single task learning mode. Then pack the layer-wise parameters as the input for tensor decomposition. When SVD is applied, set a threshold for relative error so SVD will pick the appropriate rank. Thus our method needs only a single hyper parameter of max reconstruction error (we set to $\epsilon = 1 0 \%$ throughout) that indirectly specifies the ranks of every layer. Note that training from random initialisation also works, but the STL-based initialisation makes rank selection easy and transparent. Nevertheless, like (Kumar & Daume III, 2012) the framework is not sensitive ´ to rank choice so long as they are big enough. If random initialisation is desired to eliminate the pre-training requirement, good practice is to initialise parameter tensors by a suitable random weight distribution first, then do decomposition, and use the decomposed values for initialising the factors (the real learnable parameters in our framework). In this way, the resulting re-composed tensors will have approximately the intended distribution. Our sharing is applied to weight parameters only, bias terms are not shared. Apart from initialisation, decomposition is not used anywhere.
+
+# 4.1 HOMOGENEOUS MTL
+
+Dataset, Settings and Baselines We use MNIST handwritten digits. The task is to recognise digit images zero to nine. When this dataset is used for the evaluation of MTL methods, ten 1-vs-all binary classification problems usually define ten tasks (Kumar & Daume III, 2012). The dataset has ´ a given train (60,000 images) and test (10,000 images) split. Each instance is a monochrome image of size $2 8 \times 2 8 \times 1$ .
+
+We use a modified LeNet (LeCun et al., 1998) as the CNN architecture. The first convolutional layer has 32 filters of size $5 \times 5$ , followed by $2 \times 2$ max pooling. The second convolutional layer has 64 filters of size $4 \times 4$ , and again a $2 \times 2$ max pooling. After these two convolutional layers, two fully connected layers with 512 and 1 output(s) are placed sequentially. The convolutional and first FC layer use RELU $f ( x ) = \operatorname* { m a x } ( x , 0 )$ activation function. We use hinge loss, $\ell ( y ) = \operatorname* { m a x } ( 0 , 1 - \hat { y } \cdot y )$ , where $y \in \pm 1$ is the true label and $\hat { y }$ is the output of each task’s neural network.
+
+Conventional matrix-based MTL methods (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012; Romera-paredes et al., 2013; Wimalawarne et al., 2014) are linear models taking ´ vector input only, so they need a preprocessing that flattens the image into a vector, and typically reduce dimension by PCA. As per our motivation for studying Deep MTL, our methods decisively outperform such shallow linear baselines. Thus to find a stronger MTL competitor, we instead search user defined architectures for Deep-MTL parameter sharing (cf (Zhang et al., 2014; Liu et al., 2015; Caruana, 1997)). In all of the four parametrised layers (pooling has no parameters), we set the first $N$ $\left( 1 \leq N \leq 3 \right)$ ) to be hard shared5. We then use cross-validation to select among the three userdefined MTL architectures and the best option is $N = 3$ , i.e., the first three layers are fully shared (we denote this model UD-MTL). For our methods, all four parametrised layers are softly shared with the different factorisation approaches. To evaluate different MTL methods and a baseline of single task learning (STL), we take ten different fractions of the given 60K training split, train the model, and test on the 10K testing split. For each fraction, we repeat the experiment 5 times with randomly sampled training data. We report two performance metrics: (1) the mean error rate of the ten binary classification problems and (2) the error rate of recognising a digit by ranking each task’s 1-vs-all output (multi-class classification error).
+
+Results As we can see in Fig. 2, all MTL approaches outperform STL, and the advantage is more significant when the training data is small. The proposed methods, DMTRL-TT and DMTRLTucker outperform the best user-defined MTL when the training data is very small, and their performance is comparable when the training data is large.
+
+Further Discussion For a slightly unfair comparison, in the case of binary classification with 1000 training data, shallow matrix-based MTL methods with PCA feature (Kang et al., 2011; Kumar & Daume III, 2012) reported ´ $1 4 . 0 \% / \ 1 3 . 4 \%$ error rate. With the same amount of data, our methods have error rate below $6 \%$ . This shows the importance of our deep end-to-end multi-task representation learning contribution versus conventional shallow MTL. Since the error rates in (Kang et al., 2011; Kumar & Daume III, 2012) were produced on a private subset of MNIST dataset with PCA ´ representations only, to ensure a direct comparison, we implement several classic MTL methods and compare them in Appendix A.
+
+![](images/4b3890f21ecf8c5319aa5bc69860e1ea77bf2f965ce0b0fb0495902f41401c7c.jpg)  
+Figure 2: Homogeneous MTL: digit recognition on MNIST dataset. Each digit provides a task.
+
+For readers interested in the connection to model capacity (number of parameters), we present further analysis in Appendix B.
+
+# 4.2 HETEROGENEOUS MTL: FACE ANALYSIS
+
+Dataset, Settings and Baselines The AdienceFaces (Eidinger et al., 2014) is a large-scale face images dataset with the labels of each person’s gender and age group. We use this dataset for the evaluation of heterogeneous MTL with two tasks: (i) gender classification (two classes) and (ii) age group classification (eight classes). Two independent CNN models for this benchmark are introduced in (Levi & Hassncer, 2015). The two CNNs have the same architecture except for the last fully-connected layer, since the heterogeneous tasks have different number of outputs (two $/$ eight). We take these CNNs from (Levi & Hassncer, 2015) as the STL baseline. We again search for the best possible user-defined MTL architecture as a strong competitor: the proposed CNN has six layers – three convolutional and three fully-connected layers. The last fully-connected layer has non-shareable parameters because they are of different size. To search the MTL design-space, we try setting the first $N$ $\mathrm { ~ 1 ~ } \leq N \leq \mathrm { ~ 5 ~ }$ ) layers to be hard shared between the tasks. Running 5-fold cross-validation on the train set to evaluate the architectures, we find the best choice is $N = 5$ (i.e., all layers fully shared before the final heterogeneous outputs). For our proposed methods, all the layers before the last heterogeneous dimensionality FC layers are softly shared.
+
+We select increasing fractions of the AdienceFaces train split randomly, train the model, and evaluate on the same test set. For reference, there are 12245 images with gender labelled for training, 4007 ones for testing, and 11823 images with age group labelled for training, and 4316 ones for testing.
+
+Results Fig. 3 shows the error rate for each task. For the gender recognition task, we find that: (i) User-defined MTL is not consistently better than STL, but (ii) our methods, esp., DMTRLTucker, consistently outperform both STL and the best user-defined MTL. For the harder age group classification task, our methods generally improve on STL. However UD-MTL does not consistently improve on STL, and even reduces performance when the training set is bigger. This is the negative transfer phenomenon (Rosenstein et al., 2005), where using a transfer learning algorithm is worse than not using it. This difference in outcomes is attributed to sufficient data eventually providing some effective task-specific representation. Our methods can discover and exploit this, but UDMTL’s hard switch between sharing and not sharing can not represent or exploit such increasing task-specificity of representation.
+
+![](images/cb0b2ea66c83cfafe25a3bd6b663ffeb9e04a95ebdb2fde22b382108561d05b8.jpg)  
+Figure 3: Heterogeneous MTL: Age and Gender recognition in AdienceFace dataset.
+
+# 4.3 HETEROGENEOUS MTL: MULTI-ALPHABET RECOGNITION
+
+Dataset, Settings and Baselines We next consider the task of learning to recognise handwritten letters in multiple languages using the Omniglot (Lake et al., 2015) dataset. Omniglot contains handwritten characters in 50 different alphabets (e.g., Cyrillic, Korean, Tengwar), each with its own number of unique characters $1 4 \sim 5 5$ ). In total, there are 1623 unique characters, and each has exactly 20 instances. Here each task corresponds to an alphabet, and the goal is to recognise its characters. MTL has a clear motivation here, as cross-alphabet knowledge sharing is likely to be useful as one is unlikely to have extensive training data for a wide variety of less common alphabets.
+
+The images are monochrome of size $1 0 5 \times 1 0 5$ . We design a CNN with 3 convolutional and $2 \ : \mathrm { F C }$ layers. The first conv layer has 8 filters of size $5 \times 5$ ; the second conv layer has 12 filters of size $3 \times 3$ , and the third convolutional layer has 16 filters of size $3 \times 3$ . Each convolutional layer is followed by a $2 \times 2$ max-pooling. The first FC layer has 64 neurons, and the second FC layer has size corresponding to the number of unique classes in the alphabet. The activation function is tanh.
+
+We use a similar strategy to find the best user-defined MTL model: the CNN has 5 parametrised layers, of which 4 layers are potentially shareable. So we tried hard-sharing the first $N$ $1 \leq N \leq 4 ,$ ) layers. Evaluating these options by 5-fold cross-validation, the best option turned out to be $N = 3$ , i.e., the first three layers are hard shared. For our methods, all four shareable layers are softly shared.
+
+Since there is no standard train/test split for this dataset, we use the following setting: We repeatedly pick at random $5 , \ldots 9 0 \%$ of images per class for training. Note that $5 \%$ is the minimum, corresponding to one-shot learning. The remaining data are used for evaluation.
+
+Results Fig. 4 reports the average error rate across all 50 tasks (alphabets). Our proposed MTL methods surpass the STL baseline in all cases. User-defined MTL does not work well when the training data is very small, but does help when training fraction is larger than $5 0 \%$ .
+
+Measuring the Learned Sharing Compared to the conventional user-defined sharing architectures, our method learns how to share from data. We next try to quantify the amount of sharing estimated by our model on the Omniglot data. Returning to the key factorisation $\mathscr { W } = \mathscr { L } S$ , we can find that $S$ -like matrix appears in all variants of proposed method. It is $S$ in DMTRL-LAF, the transposed $U ^ { ( N ) }$ in DMTRL-Tucker, and $U ^ { ( N ) }$ in DMTRL-TT $N$ is the last axis of $\mathcal { W }$ ). $S$ is a $K \times T$ size matrix, where $T$ is the number of tasks, and $K$ is the number of latent tasks (Kumar & Daume III, 2012) or the dimension of task coding (Yang & Hospedales, 2015). Each column ´ of $S$ is a set of coefficients that produce the final weight matrix/tensor by linear combination. If we put STL and user-defined MTL (for a certain shared layer) in this framework, we see that STL is to assign (rather than learn) $S$ to be an identity matrix $I _ { T }$ . Similarly, user-defined MTL (for a certain shared layer) is to assign $S$ to be a matrix with all zeros but one particular row is all ones, e.g., $S = [ \mathbf { 1 } _ { 1 \times T } ; \mathbf { 0 } ]$ . Between these two extremes, our method learns the sharing structure in $S$ . We propose the following equation to measure the learned sharing strength:
+
+$$
+\rho = \frac { 1 } { { \binom { T } { 2 } } } \sum _ { i < j } \Omega ( S _ { \cdot , i } , S _ { \cdot , j } ) = \frac { 2 } { T ( T - 1 ) } \sum _ { i < j } \Omega ( S _ { \cdot , i } , S _ { \cdot , j } )
+$$
+
+![](images/b4e9921c310609c64d55abce2351e70d7c7124ec9b4585bed886236cdd6c9de3.jpg)  
+Figure 4: Results of multi-task learning of multilingual character recognition (Omniglot dataset). Below: Illustration of the language pairs estimated to be the most related (left - Georgian Mkhedruli and Inuktitut) and most unrelated (right - Balinese and ULOG) character recognition tasks.
+
+Here $\Omega ( a , b )$ is a similarity measure for two vectors $a$ and $b$ and we use cosine similarity. $\rho$ is the average on all combinations of column-wise similarity. So $\rho$ measures how much sharing is encoded by $S$ between $\rho = 0$ for STL (nothing to share) and $\rho = 1$ for user-defined MTL (completely shared). Since $S$ is a real-valued matrix in our scenario, we normalise it before applying Eq. 9: First we take absolute values, because large either positive or negative value suggests a significant coefficient. Second we normalise each column of $S$ by applying a softmax function, so the sum of every column is 1. The motivation behind the second step is to make a matched range of our $S$ with $S = I _ { T }$ or $S = [ \mathbf { 1 } _ { 1 \times T } ; \mathbf { 0 } ]$ , as for those two cases, the sum of each column is 1 and the range is [0, 1].
+
+For the Omniglot experiment, we plot the measured sharing amount for training fraction $1 0 \%$ . Fig. 4 reveals that three proposed methods tend to share more for bottom layers (‘Conv1’, ‘Conv2’, and ‘Conv3’) and share less for top layer (‘FC1’). This is qualitatively similar to the best user-defined MTL, where the first three layers are fully shared $( \rho = 1 )$ ) and the 4th layer is completely not shared $\rho = 0 ,$ ). However, our methods: (i) learn this structure in a purely data-driven way and (ii) benefits from the ability to smoothly interpolate between high and low degrees of sharing as depth increases. As an illustration, Fig. 4 also shows example text from the most and least similar language pairs as estimated at our multilingual character recogniser’s FC1 layer (the result can vary across layers).
+
+# 5 CONCLUSION
+
+In this paper, we propose a novel framework for end-to-end multi-task representation learning in contemporary deep neural networks. The key idea is to generalise matrix factorisation-based multitask ideas to tensor factorisation, in order to flexibly share knowledge in fully connected and convolutional DNN layers. Our method provides consistently better performance than single task learning and comparable or better performance than the best results from exhaustive search of user-defined MTL architectures. It reduces the design choices and architectural search space that must be explored in the workflow of Deep MTL architecture design (Caruana, 1997; Zhang et al., 2014; Liu et al., 2015), relieving researchers of the need to decide how to structure layer sharing/segregation. Instead sharing structure is determined in a data-driven way on a layer-by-layer basis that moreover allows a smooth interpolation between sharing and not sharing in progressively deeper layers.
+
+Acknowledgements This work was supported by EPSRC (EP/L023385/1), and the European Union’s Horizon 2020 research and innovation program under grant agreement No 640891.
+
+# REFERENCES
+
+Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org.
+
+Andreas Argyriou, Theodoros Evgeniou, and Massimiliano Pontil. Convex multi-task feature learning. Machine Learning, 2008.
+
+Edwin V Bonilla, Kian M Chai, and Christopher Williams. Multi-task gaussian process prediction. In Neural Information Processing Systems (NIPS), 2007.
+
+Rich Caruana. Multitask learning. Machine Learning, 1997.
+
+Hal Daume III. Frustratingly easy domain adaptation. In ´ ACL, 2007.
+
+Eran Eidinger, Roee Enbar, and Tal Hassner. Age and gender estimation of unfiltered faces. IEEE Transactions on Information Forensics and Security, 2014.
+
+Theodoros Evgeniou and Massimiliano Pontil. Regularized multi–task learning. In Knowledge Discovery and Data Mining (KDD), 2004.
+
+Thomas L. Griffiths and Zoubin Ghahramani. The indian buffet process: An introduction and review. Journal of Machine Learning Research (JMLR), 2011.
+
+Jui-Ting Huang, Jinyu Li, Dong Yu, Li Deng, and Yifan Gong. Cross-language knowledge transfer using multilingual deep neural network with shared hidden layers. In International Conference on Acoustics, Speech, and Signal Processing (ICASSP), 2013.
+
+Laurent Jacob, Jean-philippe Vert, and Francis R Bach. Clustered multi-task learning: A convex formulation. In Neural Information Processing Systems (NIPS), 2009.
+
+Zhuoliang Kang, Kristen Grauman, and Fei Sha. Learning with whom to share in multi-task feature learning. In International Conference on Machine Learning (ICML), 2011.
+
+Tamara G. Kolda and Brett W. Bader. Tensor decompositions and applications. SIAM Review, 2009.
+
+Abhishek Kumar and Hal Daume III. Learning task grouping and overlap in multi-task learning. In ´ International Conference on Machine Learning (ICML), 2012.
+
+Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 2015.
+
+Lieven De Lathauwer, Bart De Moor, and Joos Vandewalle. A multilinear singular value decomposition. SIAM Journal on Matrix Analysis and Applications, 2000.
+
+Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan V. Oseledets, and Victor S. Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. In International Conference on Learning Representations (ICLR), 2015.
+
+Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 1998.
+
+G. Levi and T. Hassncer. Age and gender classification using convolutional neural networks. In Computer Vision and Pattern Recognition Workshops (CVPRW), 2015.
+
+Xiaodong Liu, Jianfeng Gao, Xiaodong He, Li Deng, Kevin Duh, and Ye-Yi Wang. Representation learning using multi-task deep neural networks for semantic classification and information retrieval. NAACL, 2015.
+
+Alexander Novikov, Dmitry Podoprikhin, Anton Osokin, and Dmitry Vetrov. Tensorizing neural networks. In Neural Information Processing Systems (NIPS), 2015.
+
+I. V. Oseledets. Tensor-train decomposition. SIAM Journal on Scientific Computing, 2011.
+
+Alexandre Passos, Piyush Rai, Jacques Wainer, and Hal Daume III. Flexible modeling of latent task ´ structures in multitask learning. In International Conference on Machine Learning (ICML), 2012.
+
+Bernardino Romera-paredes, Hane Aung, Nadia Bianchi-berthouze, and Massimiliano Pontil. Multilinear multitask learning. In International Conference on Machine Learning (ICML), 2013.
+
+Michael T. Rosenstein, Zvika Marx, Leslie Pack Kaelbling, and Thomas G. Dietterich. To transfer or not to transfer. In In NIPS Workshop, Inductive Transfer: 10 Years Later, 2005.
+
+Olivier Sigaud, Clement Masson, David Filliat, and Freek Stulp. Gated networks: an inventory. arXiv, 2015.
+
+Sigurd Spieckermann, Steffen Udluft, and Thomas Runkler. Data-effiicient temporal regression with multitask recurrent neural networks. In NIPS Workshop on Transfer and Multi-Task Learning, 2014.
+
+Tian Tan, Yanmin Qian, and Kai Yu. Cluster adaptive training for deep neural network based acoustic model. IEEE/ACM Trans. Audio, Speech & Language Processing, 24(3):459–468, 2016.
+
+L. R. Tucker. Some mathematical notes on three-mode factor analysis. Psychometrika, 1966.
+
+Kishan Wimalawarne, Masashi Sugiyama, and Ryota Tomioka. Multitask learning meets tensor factorization: task imputation via convex optimization. In Neural Information Processing Systems (NIPS), 2014.
+
+Ya Xue, Xuejun Liao, Lawrence Carin, and Balaji Krishnapuram. Multi-task learning for classification with dirichlet process priors. Journal of Machine Learning Research (JMLR), 2007.
+
+Yongxin Yang and Timothy M. Hospedales. A unified perspective on multi-domain and multi-task learning. In International Conference on Learning Representations (ICLR), 2015.
+
+Zhanpeng Zhang, Ping Luo, Chen Change Loy, and Xiaoou Tang. Facial landmark detection by deep multi-task learning. In European Conference on Computer Vision (ECCV), 2014.
+
+# A COMPARISON WITH CLASSIC (SHALLOW) MTL METHODS
+
+We provide a comparison with classic (shallow, matrix-based) MTL methods for the first experiment (MNIST, binary one-vs-rest classification, $1 \%$ training data, mean of error rates for 10-fold CV). A subtlety in making this comparison is what feature should the classic methods use? Conventionally they use a PCA feature (obtained by flattening the image, then dimension reduction by PCA). However for visual recognition tasks, performance is better with deep features – a key motivation for our focus on deep approaches to MTL. We therefore also compare the classic methods when using a feature extracted from the penultimate layer of the CNN network used in our experiment.
+
+<table><tr><td>Model</td><td>PCAFeature</td><td>CNNFeature</td></tr><tr><td>Single Task Learning</td><td>16.89</td><td>11.52</td></tr><tr><td>Evgeniou &amp; Pontil (2004)</td><td>15.27</td><td>10.32</td></tr><tr><td>Argyriou et al. (2008)</td><td>15.64</td><td>9.56</td></tr><tr><td>Kumar &amp; Daumé I (2012)</td><td>14.08</td><td>9.41</td></tr><tr><td>DMTRL-LAF</td><td>-</td><td>8.25</td></tr><tr><td>DMTRL-Tucker</td><td></td><td>9.24</td></tr><tr><td>DMTRL-TT</td><td></td><td>7.31</td></tr><tr><td>UD-MTL</td><td></td><td>9.34</td></tr></table>
+
+Table 1: Comparison with classic MTL methods. MNIST binary classification error rate $( \% )$
+
+As expected, the classic methods improve on STL, and they perform significantly better with CNN than PCA features. However, our DMTRL methods still outperform the best classic methods, even when they are enhanced by CNN features. This is due to soft (cf hard) sharing of the feature extraction layers and the ability of end-to-end training of both the classifier and feature extractor. Finally, we note that more fundamentally, the classic methods are restricted to binary problems (due to their matrix-based nature) and so, unlike our tensor-based approach, they are unsuitable for multi-class problems like omniglot and age-group classification.
+
+# B MODEL CAPACITY AND PERFORMANCE
+
+We list the number of parameters for each model in the first experiment (MNIST, binary one-vs-rest classification) and the performance ( $1 \%$ training data, mean of error rate for 10-fold CV).   
+
+<table><tr><td>Model</td><td>Error Rate (%)</td><td>Number of parameters</td><td>Ratio</td></tr><tr><td>STL</td><td>11.52</td><td>4351K</td><td>1.00</td></tr><tr><td>DMTRL-LAF</td><td>8.25</td><td>1632K</td><td>0.38</td></tr><tr><td>DMTRL-Tucker</td><td>9.24</td><td>1740K</td><td>0.40</td></tr><tr><td>DMTRL-TT</td><td>7.31</td><td>2187K</td><td>0.50</td></tr><tr><td>UD-MTL</td><td>9.34</td><td>436K</td><td>0.10</td></tr><tr><td>UD-MTL-Large</td><td>9.39</td><td>1644K</td><td>0.38</td></tr></table>
+
+Table 2: Comparison of deep models: Error rate and number of parameters.
+
+The conventional hard-sharing method (UD-MTL) design is to share all layers except the top layer. Its number of parameter is roughly $1 0 \%$ of the single task learning method (STL), as most parameters are shared across the 10 tasks corresponding to 10 digits. Our soft-sharing methods also significantly reduce the number of parameters compared to STL, but are larger than UD-MTL’s hard sharing.
+
+To compare our method to UD-MTL, while controlling for network capacity, we expanded UDMDL by adding more hidden neurons so its number of parameter is close to our methods (denoted UD-MTL-Large). However UD-MDL performance does not increase. This is evidence that our model’s good performance is not simply due to greater capacity than UD-MTL.

parse/train/SkhU2fcll/SkhU2fcll_content_list.json

@@ -0,0 +1,1320 @@
+[
+    {
+        "type": "text",
+        "text": "DEEP MULTI-TASK REPRESENTATION LEARNING: A TENSOR FACTORISATION APPROACH ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            769,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yongxin Yang, Timothy M. Hospedales Queen Mary, University of London {yongxin.yang, t.hospedales}@qmul.ac.uk ",
+        "bbox": [
+            183,
+            170,
+            563,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            248,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most contemporary multi-task learning methods assume linear models. This setting is considered shallow in the era of deep learning. In this paper, we present a new deep multi-task representation learning framework that learns cross-task sharing structure at every layer in a deep network. Our approach is based on generalising the matrix factorisation techniques explicitly or implicitly used by many conventional MTL algorithms to tensor factorisation, to realise automatic learning of end-to-end knowledge sharing in deep networks. This is in contrast to existing deep learning approaches that need a user-defined multi-task sharing strategy. Our approach applies to both homogeneous and heterogeneous MTL. Experiments demonstrate the efficacy of our deep multi-task representation learning in terms of both higher accuracy and fewer design choices. ",
+        "bbox": [
+            233,
+            281,
+            764,
+            433
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            336,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The paradigm of multi-task learning is to learn multiple related tasks simultaneously so that knowledge obtained from each task can be re-used by the others. Early work in this area focused on neural network models (Caruana, 1997), while more recent methods have shifted focus to kernel methods, sparsity and low-dimensional task representations of linear models (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012). Nevertheless given the impressive practical efficacy ´ of contemporary deep neural networks (DNN)s in many important applications, we are motivated to revisit MTL from a deep learning perspective. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While the machine learning community has focused on MTL for shallow linear models recently, applications have continued to exploit neural network MTL (Zhang et al., 2014; Liu et al., 2015). The typical design pattern dates back at least 20 years (Caruana, 1997): define a DNN with shared lower representation layers, which then forks into separate layers and losses for each task. The sharing structure is defined manually: full-sharing up to the fork, and full separation after the fork. However this complicates DNN architecture design because the user must specify the sharing structure: How many task specific layers? How many task independent layers? How to structure sharing if there are many tasks of varying relatedness? ",
+        "bbox": [
+            174,
+            595,
+            825,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we present a method for end-to-end multi-task learning in DNNs. This contribution can be seen as generalising shallow MTL methods (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012) to learning how to share ´ at every layer of a deep network; or as learning the sharing structure for deep MTL (Caruana, 1997; Zhang et al., 2014; Spieckermann et al., 2014; Liu et al., 2015) which currently must be defined manually on a problem-by-problem basis. ",
+        "bbox": [
+            174,
+            714,
+            823,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Before proceeding it is worth explicitly distinguishing some different problem settings, which have all been loosely referred to as MTL in the literature. Homogeneous MTL: Each task corresponds to a single output. For example, MNIST digit recognition is commonly used to evaluate MTL algorithms by casting it as 10 binary classification tasks (Kumar & Daume III, 2012). ´ Heterogeneous MTL: Each task corresponds to a unique set of output(s) (Zhang et al., 2014). For example, one may want simultaneously predict a person’s age (task one: multi-class classification or regression) as well as identify their gender (task two: binary classification) from a face image. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a multi-task learning method that works on all these settings. The key idea is to use tensor factorisation to divide each set of model parameters (i.e., both FC weight matrices, and convolutional kernel tensors) into shared and task-specific parts. It is a natural generalisation of shallow MTL methods that explicitly or implicitly are based on matrix factorisation (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012; Daum ´ e III, 2007). As linear methods, ´ these typically require pre-engineered features. In contrast, as a deep network, our generalisation can learn directly from raw image data, determining sharing structure in a layer-wise fashion. For the simplest NN architecture – no hidden layer, single output – our method reduces to matrix-based ones, therefore matrix-based methods including (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012; Daum ´ e III, 2007) are special cases of ours. ´ ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            239,
+            343,
+            256
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-Task Learning Most contemporary MTL algorithms assume that the input and model are both $D$ -dimensional vectors. The models of $T$ tasks can then be stacked into a $D \\times T$ sized matrix $W$ . Despite different motivations and implementations, many matrix-based MTL methods work by placing constrains on $W$ . For example, posing an $\\ell _ { 2 , 1 }$ norm on $W$ to encourage low-rank $W$ (Argyriou et al., 2008). Similarly, (Kumar & Daume III, 2012) factorises ´ $W$ as $W = L S$ , i.e., it assigns a lower rank as a hyper-parameter. An earlier work (Evgeniou & Pontil, 2004) proposes that the linear model for each task $t$ can be written as $w _ { t } = \\hat { w } _ { t } + \\hat { w } _ { 0 }$ . This is the factorisation $L = [ \\hat { w } _ { 0 } , \\hat { w } _ { 1 } , \\dots , \\hat { w } _ { T } ]$ and ${ \\cal S } = [ { \\bf 1 } _ { 1 \\times T } ; { \\bf I } _ { T } ]$ . In fact, such matrix factorisation encompasses many MTL methods. E.g., (Xue et al., 2007) assumes $S _ { \\cdot , i }$ (the ith column of $S$ ) is a unit vector generated by a Dirichlet Process and (Passos et al., 2012) models $W$ using linear factor analysis with Indian Buffet Process (Griffiths & Ghahramani, 2011) prior on $S$ . ",
+        "bbox": [
+            173,
+            273,
+            825,
+            428
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Tensor Factorisation In deep learning, tensor factorisation has been used to exploit factorised tensors’ fewer parameters than the original (e.g., 4-way convolutional kernel) tensor, and thus compress and/or speed up the model, e.g., (Lebedev et al., 2015; Novikov et al., 2015). For shallow linear MTL, tensor factorisation has been used to address problems where tasks are described by multiple independent factors rather than merely indexed by a single factor (Yang & Hospedales, 2015). Here the $D$ -dimensional linear models for all unique tasks stack into a tensor $\\mathcal { W }$ , of e.g. $D \\times T _ { 1 } \\times T _ { 2 }$ in the case of two task factors. Knowledge sharing is then achieved by imposing tensor norms on $\\mathcal { W }$ (Romera-paredes et al., 2013; Wimalawarne et al., 2014). Our framework factors tensors for the different reason that for DNN models, parameters include convolutional kernels ( $N$ -way tensors) or $D _ { 1 } \\times D _ { 2 }$ FC layer weight matrices (2-way tensors). Stacking up these parameters for many tasks results in $D _ { 1 } \\times \\cdots \\times D _ { N } \\times T$ tensors within which we share knowledge through factorisation. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Heterogeneous MTL and DNNs Some studies consider heterogeneous MTL, where tasks may have different numbers of outputs (Caruana, 1997). This differs from the previously discussed studies (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Bonilla et al., 2007; Jacob et al., 2009; Kumar & Daume III, 2012; Romera-paredes et al., 2013; Wimalawarne et al., 2014) which implicitly as- ´ sume that each task has a single output. Heterogeneous MTL typically uses neural networks with multiple sets of outputs and losses. E.g., Huang et al. (2013) proposes a shared-hidden-layer DNN model for multilingual speech processing, where each task corresponds to an individual language. Zhang et al. (2014) uses a DNN to find facial landmarks (regression) as well as recognise facial attributes (classification); while Liu et al. (2015) proposes a DNN for query classification and information retrieval (ranking for web search). A key commonality of these studies is that they all require a user-defined parameter sharing strategy. A typical design pattern is to use shared layers (same parameters) for lower layers of the DNN and then split (independent parameters) for the top layers. However, there is no systematic way to make such design choices, so researchers usually rely on trial-and-error, further complicating the already somewhat dark art of DNN design. In contrast, our method learns where and how much to share representation parameters across the tasks, hence significantly reducing the space of DNN design choices. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Parametrised DNNs Our MTL approach is a parameterised DNN (Sigaud et al., 2015), in that DNN weights are dynamically generated given some side information – in the case of MTL, given the task identity. In a related example of speaker-adaptive speech recognition (Tan et al., 2016) there may be several clusters in the data (e.g., gender, acoustic conditions), and each speaker’s model could be a linweight matrix mbination oas a sum of h e latent taase models cluste, i.e., each speaker . The differe $i$ ’se $W ^ { ( i ) }$ $K$ $\\tilde { W }$ $\\begin{array} { r } { W ^ { ( i ) } = \\sum _ { k = 1 } ^ { K } \\lambda _ { p } ^ { ( i ) } \\tilde { W } ^ { ( p ) } } \\end{array}$ between speakers/tasks comes from $\\lambda$ and the base models are shared. An advantage of this is that, when new data come, one can choose to re-train $\\lambda$ parameters only, and keep $\\tilde { W }$ fixed. This will significantly reduce the number of parameters to learn, and consequently the required training data. Beyond this, Yang & Hospedales (2015) show that it is possible to train another neural network to predict those $\\lambda$ values from some abstract metadata. Thus a model for an unseen task can be generated on-the-fly with no training instances given an abstract description of the task. The techniques developed here are compatible with both these ideas of generating models with minimal or no effort. ",
+        "bbox": [
+            174,
+            823,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHODOLOGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            210,
+            341,
+            227
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            243,
+            326,
+            258
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first recap some tensor factorisation basics before explaining how to factorise DNN weight tensors for multi-task representation learning. An $N$ -way tensor $\\mathcal { W }$ with shape $D _ { 1 } \\times D _ { 2 } \\times \\cdot \\cdot \\cdot D _ { N }$ is an $N$ -dimensional array containing $\\textstyle \\prod _ { n = 1 } ^ { N } D _ { n }$ elements. Scalars, vectors, and matrices can be seen as $0 , 1$ , and 2-way tensors respectively, although the term tensor is usually used for 3-way or higher. A mode- $\\boldsymbol { n }$ fibre of $\\mathcal { W }$ is a $D _ { n }$ -dimensional vector obtained by fixing all but the nth index. The mode- $\\boldsymbol { n }$ flattening $W _ { ( n ) }$ of $\\mathcal { W }$ is the matrix of size $\\begin{array} { r } { D _ { n } \\times \\prod _ { i = n } D _ { i } } \\end{array}$ constructed by concatenating all of the $\\Pi _ { i \\lnot n } D _ { i }$ mode- $\\mathbf { \\nabla } \\cdot n$ fibres along columns. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            373
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The dot product of two tensors is a natural extension of matrix dot product, e.g., if we have a tensor $\\mathcal { A }$ of size $M _ { 1 } \\times M _ { 2 } \\times \\cdot \\cdot \\cdot P$ and a tensor $\\boldsymbol { B }$ of size $P \\times N _ { 1 } \\times N _ { 2 } \\dots$ , the tensor dot product $\\mathcal { A } \\bullet \\mathcal { B }$ will be a tensor of size $M _ { 1 } \\times M _ { 2 } \\times \\cdots N _ { 1 } \\times N _ { 2 } \\cdot \\cdot \\cdot$ by matrix dot product $A _ { ( - 1 ) } ^ { T } B _ { ( 1 ) }$ and reshaping1. More generally, tensor dot product can be performed along specified axes, $\\mathcal { A } \\bullet _ { ( i , j ) } \\mathcal { B } = A _ { ( i ) } ^ { T } B _ { ( j ) }$ and reshaping. Here the subscripts indicate the axes of $\\mathcal { A }$ and $\\boldsymbol { B }$ at which dot product is performed. E.g., when $\\mathcal { A }$ is of size $M _ { 1 } \\times P \\times M _ { 3 } \\times \\cdot \\cdot \\cdot M _ { I }$ and $\\boldsymbol { B }$ is of size $N _ { 1 } \\times N _ { 2 } \\times P \\times \\cdot \\cdot \\cdot N _ { J }$ , then $\\mathbf { \\mathcal { A } } \\bullet _ { ( 2 , 3 ) } B$ is a tensor of size $M _ { 1 } \\times M _ { 3 } \\times \\cdots M _ { I } \\times N _ { 1 } \\times N _ { 2 } \\times \\cdots N _ { J }$ . ",
+        "bbox": [
+            173,
+            378,
+            825,
+            484
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Matrix-based Knowledge Sharing Assume we have $T$ linear models (tasks) parametrised by $D$ - dimensional weight vectors, so the collection of all models forms a size $D \\times T$ matrix $W$ . One commonly used MTL approach (Kumar & Daume III, 2012) is to place a structure constraint on ´ $W$ , e.g., $W = L S$ , where $L$ is a $D \\times K$ matrix and $S$ is a $K \\times T$ matrix. This factorisation recovers a shared factor $L$ and a task-specific factor $S$ . One can see the columns of $L$ as latent basis tasks, and the model $w ^ { ( i ) }$ for the $i$ th task is the linear combination of those latent basis tasks with task-specific information $S _ { \\cdot , i }$ . ",
+        "bbox": [
+            173,
+            494,
+            825,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5b8ee652294c847b2431b22fe1f7d9c8f40b2f901cc59791208337af60d171ef.jpg",
+        "text": "$$\nw ^ { ( i ) } : = W _ { \\cdot , i } = L S _ { \\cdot , i } = \\sum _ { k = 1 } ^ { K } L _ { \\cdot , k } S _ { k , i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            594,
+            620,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From Single to Multiple Outputs Consider extending this matrix factorisation approach to the case of multiple outputs. The model for each task is then a $D _ { 1 } \\times D _ { 2 }$ matrix, for $D _ { 1 }$ input and $D _ { 2 }$ output dimensions. The collection of all those matrices constructs a $D _ { 1 } \\times D _ { 2 } \\times T$ tensor. A straightforward extension of Eq. 1 to this case is ",
+        "bbox": [
+            174,
+            643,
+            825,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7fb02959fdc6351b2ebdb7bc54a4fd50a4d09a07363755bb6e60978d312fa3c9.jpg",
+        "text": "$$\nW ^ { ( i ) } : = \\mathcal { W } _ { \\cdot , \\cdot , i } = \\sum _ { k = 1 } ^ { K } \\mathcal { L } _ { \\cdot , \\cdot , k } S _ { k , i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            713,
+            604,
+            757
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This is equivalent to imposing the same structural constraint on $W _ { ( 3 ) } ^ { T }$ (transposed mode-3 flattening of $\\mathcal { W }$ ). It is important to note that this allows knowledge sharing across the tasks only. I.e., knowledge sharing is only across-tasks not across dimensions within a task. However it may be that the knowledge learned in the mapping to one output dimension may be useful to the others within one task. E.g., consider recognising photos of handwritten and print digits – it may be useful to share across handwritten-print; as well as across different digits within each. In order to support general knowledge sharing across both tasks and outputs within tasks, we propose to use more general tensor factorisation techniques. Unlike for matrices, there are multiple definitions of tensor factorisation, and we use Tucker (Tucker, 1966) and Tensor Train (TT) (Oseledets, 2011) decompositions. ",
+        "bbox": [
+            173,
+            765,
+            825,
+            895
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 TENSOR FACTORISATION FOR KNOWLEDGE SHARING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            588,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Tucker Decomposition Given an $N$ -way tensor of size $D _ { 1 } \\times D _ { 2 } \\cdot \\cdot \\cdot \\times D _ { N }$ , Tucker decomposition outputs a core tensor $s$ of size $K _ { 1 } \\times K _ { 2 } \\cdot \\cdot \\cdot \\times K _ { N }$ , and $N$ matrices $U ^ { ( n ) }$ of size $D _ { n } \\times K _ { n }$ , such that, ",
+        "bbox": [
+            174,
+            132,
+            825,
+            178
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/58784d828622e9c555ebcf8d3c4b15b9dc9cd4670d87e1d8bd5899c1d2045b92.jpg",
+        "text": "$$\n\\begin{array} { r c l } { { \\mathcal { W } _ { d _ { 1 } , d _ { 2 } , \\dots , d _ { N } } } } & { { = } } & { { \\displaystyle \\sum _ { k _ { 1 } = 1 } ^ { K _ { 1 } } \\sum _ { k _ { 2 } = 1 } ^ { K _ { 2 } } \\cdots \\sum _ { k _ { N } = 1 } ^ { K _ { N } } S _ { k _ { 1 } , k _ { 2 } , \\dots , k _ { N } } U _ { d _ { 1 } , k _ { 1 } } ^ { ( 1 ) } U _ { d _ { 2 } , k _ { 2 } } ^ { ( 2 ) } \\cdots U _ { d _ { N } , k _ { N } } ^ { ( N ) } } } \\\\ { { \\mathcal { W } } } & { { = } } & { { \\displaystyle \\mathcal { S } \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( 1 ) } \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( 2 ) } \\cdots \\bullet _ { ( _ { 1 , 2 } ) } U ^ { ( N ) } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            203,
+            743,
+            276
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Tucker decomposition is usually implemented by an alternating least squares (ALS) method (Kolda & Bader, 2009). However (Lathauwer et al., 2000) treat it as a higher-order singular value decomposition (HOSVD), which is more efficient to solve: $U ^ { ( n ) }$ is exactly the $U$ matrix from the SVD of mode- $n$ flattening $W _ { ( n ) }$ of $\\mathcal { W }$ , and the core tensor $s$ is obtained by, ",
+        "bbox": [
+            173,
+            287,
+            825,
+            347
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/46c9d60fdb02c762e1783427318bb210d5aec8d640b28d1cd8d90e3ac324a4f2.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { \\mathscr { S } } = \\mathscr { W } \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( 1 ) } \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( 2 ) } \\cdots \\bullet _ { ( 1 , 1 ) } \\boldsymbol { U } ^ { ( N ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            362,
+            648,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Tensor Train Decomposition Tensor Train (TT) Decomposition outputs 2 matrices $U ^ { ( 1 ) }$ and $U ^ { ( N ) }$ of size $D _ { 1 } \\times K _ { 1 }$ and $K _ { N - 1 } \\times D _ { N }$ respectively, and $( N - 2 )$ 3-way tensors $\\mathcal { U } ^ { ( n ) }$ of size $K _ { n - 1 } \\times D _ { n } \\times K _ { n }$ . The elements of $\\mathcal { W }$ can be computed by, ",
+        "bbox": [
+            176,
+            404,
+            825,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aaad1a1718515311ee6d1f0a1eda7d952ddd0f7a518c89592faad850694e83d0.jpg",
+        "text": "$$\n\\begin{array} { l c l } { { \\displaystyle \\mathcal { W } _ { d _ { 1 } , d _ { 2 } , \\dots , d _ { N } } } } & { { = } } & { { \\displaystyle \\sum _ { k _ { 1 } = 1 } ^ { K _ { 1 } } \\sum _ { k _ { 2 } = 1 } ^ { K _ { 2 } } \\cdots \\sum _ { k _ { N - 1 } = 1 } ^ { K _ { N - 1 } } U _ { d _ { 1 } , k _ { 1 } } ^ { ( 1 ) } \\mathcal { U } _ { k _ { 1 } , d _ { 2 } , k _ { 2 } } ^ { ( 2 ) } \\mathcal { U } _ { k _ { 2 } , d _ { 3 } , k _ { 3 } } ^ { ( 3 ) } \\cdots U _ { k _ { N - 1 } , d _ { N } } ^ { ( N ) } } } \\\\ { { } } & { { = } } & { { \\displaystyle U _ { d _ { 1 } , l } ^ { ( 1 ) } \\mathcal { U } _ { , d _ { 2 } , l } ^ { ( 2 ) } \\mathcal { U } _ { , d _ { 3 } , \\cdot } ^ { ( 3 ) } \\cdots U _ { \\cdot , d _ { N } } ^ { ( d ) } } } \\\\ { { \\displaystyle \\mathcal { W } } } & { { = } } & { { \\displaystyle U ^ { ( 1 ) } \\bullet \\mathcal { U } ^ { ( 2 ) } \\cdot \\cdots \\bullet U ^ { ( N ) } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            238,
+            474,
+            758,
+            565
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where U (n)·,d ,· is a matrix of size $K _ { n - 1 } \\times K _ { n }$ sliced from $\\mathcal { U } ^ { ( n ) }$ with the second axis fixed at $d _ { n }$ . The TT decomposition is typically realised with a recursive SVD-based solution (Oseledets, 2011). ",
+        "bbox": [
+            174,
+            582,
+            823,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Knowledge Sharing If the final axis of the input tensor above indexes tasks, i.e. if $D _ { N } = T$ then the last factor $U ^ { ( N ) }$ in both decompositions encodes a matrix of task specific knowledge, and the other factors encode shared knowledge. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 DEEP MULTI-TASK REPRESENTATION LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            557,
+            696
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To realise deep multi-task representation learning (DMTRL), we learn one DNN per-task each with the same architecture2. However each corresponding layer’s weights are generated with one of the knowledge sharing structures in Eq. 2, Eq. 4 or Eq. 8. It is important to note that we apply these ‘right-to-left’ in order to generate weight tensors with the specified sharing structure, rather than actually applying Tucker or TT to decompose an input tensor. In the forward pass, we synthesise weight tensors $\\mathcal { W }$ and perform inference as usual, so the method can be thought of as tensor composition rather than decomposition. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            806
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our weight generation (construct tensors from smaller pieces) does not introduce non-differentiable terms, so our deep multi-task representation learner is trainable via standard backpropagation. Specifically, in the backward pass over FC layers, rather than directly learning the 3-way tensor $\\mathcal { W }$ , our methods learn either $\\{ S , U _ { 1 } , U _ { 2 } , U _ { 3 } \\}$ (DMTRL-Tucker, Eq. 4), $\\{ U _ { 1 } , \\mathcal { U } _ { 2 } , U _ { 3 } \\}$ (DMTRL-TT, Eq. 8), or in the simplest case $\\{ \\mathcal { L } , S \\}$ (DMTRL- $\\mathrm { . L A F ^ { 3 } }$ , Eq. 2). Besides FC layers, contemporary ",
+        "bbox": [
+            174,
+            814,
+            825,
+            883
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/bbff1fe62fcb72612a1068843c26d12df81ac25b5a13fefd9886eeb50c6f4718.jpg",
+        "image_caption": [
+            "Figure 1: Illustrative example with two tasks corresponding to two neural networks in homogeneous (single output) and heterogeneous (different output dimension) cases. Weight layers grouped by solid rectangles are tied across networks. Weight layers grouped by dashed rectangles are softly shared across networks with our method. Ungrouped weights are independent. ",
+            "Homogeneous MTL Shallow: Left is STL (two independent networks); right is MTL. In the case of vector input and no hidden layer, our method is equivalent to conventional matrix-based MTL methods. Homogeneous MTL Deep: STL (Left) is independent networks. User-defined-MTL (UDMTL) selects layers to share/separate. Our DMTRL learns sharing at every layer. Heterogeneous MTL: UD-MTL selects layers to share/separate. DMTRL learns sharing at every shareable layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            102,
+            789,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "DNN designs often exploit convolutional layers. Those layers usually contain kernel filter parameters that are 3-way tensors of size $H \\times W \\times C$ , (where $H$ is height, $W$ is width, and $C$ is the number of input channels) or 4-way tensors of size $H \\times W \\times C \\times M$ , where $M$ is the number of filters in this layer (i.e., the number of output channels). The proposed methods naturally extend to convolution layers as convolution just adds more axes on the left-hand side. E.g., the collection of parameters from a given convolutional layer of $T$ neural networks forms a tensor of shape $H \\times W \\times C \\times M \\times T$ . ",
+        "bbox": [
+            174,
+            555,
+            825,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "These knowledge sharing strategies provide a way to softly share parameters across the corresponding layers of each task’s DNN: where, what, and how much to share are learned from data. This is in contrast to the conventional Deep-MTL approach of manually selecting a set of layers to undergo hard parameter sharing: by tying weights so each task uses exactly the same weight matrix/tensor for the corresponding layer (Zhang et al., 2014; Liu et al., 2015); and a set of layers to be completely separate: by using independent weight matrices/tensors. In contrast our approach benefits from: (i) automatically learning this sharing structure from data rather than requiring user trial and error, and (ii) smoothly interpolating between fully shared and fully segregated layers, rather than a hard switching between these states. An illustration of the proposed framework for different problem settings can be found in Fig. 1. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            326,
+            823
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Implementation Details Our method is implemented with TensorFlow (Abadi et al., 2015). The code is released on $\\mathrm { G i t H u b ^ { 4 } }$ . For DMTRL-Tucker, DMTRL-TT, and DMTRL-LAF, we need to assign the rank of each weight tensor. The DNN architecture itself may be complicated and so can benefit from different ranks at different layers, but grid-search is impractical. However, since both Tucker and TT decomposition methods have SVD-based solutions, and vanilla SVD is directly applicable to DMTRL-LAF, we can initialise the model and set the ranks as follows: First train the DNNs independently in single task learning mode. Then pack the layer-wise parameters as the input for tensor decomposition. When SVD is applied, set a threshold for relative error so SVD will pick the appropriate rank. Thus our method needs only a single hyper parameter of max reconstruction error (we set to $\\epsilon = 1 0 \\%$ throughout) that indirectly specifies the ranks of every layer. Note that training from random initialisation also works, but the STL-based initialisation makes rank selection easy and transparent. Nevertheless, like (Kumar & Daume III, 2012) the framework is not sensitive ´ to rank choice so long as they are big enough. If random initialisation is desired to eliminate the pre-training requirement, good practice is to initialise parameter tensors by a suitable random weight distribution first, then do decomposition, and use the decomposed values for initialising the factors (the real learnable parameters in our framework). In this way, the resulting re-composed tensors will have approximately the intended distribution. Our sharing is applied to weight parameters only, bias terms are not shared. Apart from initialisation, decomposition is not used anywhere. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            896
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            297
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 HOMOGENEOUS MTL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            316,
+            366,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Dataset, Settings and Baselines We use MNIST handwritten digits. The task is to recognise digit images zero to nine. When this dataset is used for the evaluation of MTL methods, ten 1-vs-all binary classification problems usually define ten tasks (Kumar & Daume III, 2012). The dataset has ´ a given train (60,000 images) and test (10,000 images) split. Each instance is a monochrome image of size $2 8 \\times 2 8 \\times 1$ . ",
+        "bbox": [
+            174,
+            344,
+            823,
+            412
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use a modified LeNet (LeCun et al., 1998) as the CNN architecture. The first convolutional layer has 32 filters of size $5 \\times 5$ , followed by $2 \\times 2$ max pooling. The second convolutional layer has 64 filters of size $4 \\times 4$ , and again a $2 \\times 2$ max pooling. After these two convolutional layers, two fully connected layers with 512 and 1 output(s) are placed sequentially. The convolutional and first FC layer use RELU $f ( x ) = \\operatorname* { m a x } ( x , 0 )$ activation function. We use hinge loss, $\\ell ( y ) = \\operatorname* { m a x } ( 0 , 1 - \\hat { y } \\cdot y )$ , where $y \\in \\pm 1$ is the true label and $\\hat { y }$ is the output of each task’s neural network. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Conventional matrix-based MTL methods (Evgeniou & Pontil, 2004; Argyriou et al., 2008; Kumar & Daume III, 2012; Romera-paredes et al., 2013; Wimalawarne et al., 2014) are linear models taking ´ vector input only, so they need a preprocessing that flattens the image into a vector, and typically reduce dimension by PCA. As per our motivation for studying Deep MTL, our methods decisively outperform such shallow linear baselines. Thus to find a stronger MTL competitor, we instead search user defined architectures for Deep-MTL parameter sharing (cf (Zhang et al., 2014; Liu et al., 2015; Caruana, 1997)). In all of the four parametrised layers (pooling has no parameters), we set the first $N$ $\\left( 1 \\leq N \\leq 3 \\right)$ ) to be hard shared5. We then use cross-validation to select among the three userdefined MTL architectures and the best option is $N = 3$ , i.e., the first three layers are fully shared (we denote this model UD-MTL). For our methods, all four parametrised layers are softly shared with the different factorisation approaches. To evaluate different MTL methods and a baseline of single task learning (STL), we take ten different fractions of the given 60K training split, train the model, and test on the 10K testing split. For each fraction, we repeat the experiment 5 times with randomly sampled training data. We report two performance metrics: (1) the mean error rate of the ten binary classification problems and (2) the error rate of recognising a digit by ranking each task’s 1-vs-all output (multi-class classification error). ",
+        "bbox": [
+            174,
+            511,
+            825,
+            733
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Results As we can see in Fig. 2, all MTL approaches outperform STL, and the advantage is more significant when the training data is small. The proposed methods, DMTRL-TT and DMTRLTucker outperform the best user-defined MTL when the training data is very small, and their performance is comparable when the training data is large. ",
+        "bbox": [
+            174,
+            741,
+            823,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Further Discussion For a slightly unfair comparison, in the case of binary classification with 1000 training data, shallow matrix-based MTL methods with PCA feature (Kang et al., 2011; Kumar & Daume III, 2012) reported ´ $1 4 . 0 \\% / \\ 1 3 . 4 \\%$ error rate. With the same amount of data, our methods have error rate below $6 \\%$ . This shows the importance of our deep end-to-end multi-task representation learning contribution versus conventional shallow MTL. Since the error rates in (Kang et al., 2011; Kumar & Daume III, 2012) were produced on a private subset of MNIST dataset with PCA ´ representations only, to ensure a direct comparison, we implement several classic MTL methods and compare them in Appendix A. ",
+        "bbox": [
+            176,
+            803,
+            823,
+            845
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b3890f21ecf8c5319aa5bc69860e1ea77bf2f965ce0b0fb0495902f41401c7c.jpg",
+        "image_caption": [
+            "Figure 2: Homogeneous MTL: digit recognition on MNIST dataset. Each digit provides a task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            98,
+            776,
+            272
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            349,
+            825,
+            419
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For readers interested in the connection to model capacity (number of parameters), we present further analysis in Appendix B. ",
+        "bbox": [
+            174,
+            426,
+            823,
+            454
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 HETEROGENEOUS MTL: FACE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            497,
+            501,
+            512
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Dataset, Settings and Baselines The AdienceFaces (Eidinger et al., 2014) is a large-scale face images dataset with the labels of each person’s gender and age group. We use this dataset for the evaluation of heterogeneous MTL with two tasks: (i) gender classification (two classes) and (ii) age group classification (eight classes). Two independent CNN models for this benchmark are introduced in (Levi & Hassncer, 2015). The two CNNs have the same architecture except for the last fully-connected layer, since the heterogeneous tasks have different number of outputs (two $/$ eight). We take these CNNs from (Levi & Hassncer, 2015) as the STL baseline. We again search for the best possible user-defined MTL architecture as a strong competitor: the proposed CNN has six layers – three convolutional and three fully-connected layers. The last fully-connected layer has non-shareable parameters because they are of different size. To search the MTL design-space, we try setting the first $N$ $\\mathrm { ~ 1 ~ } \\leq N \\leq \\mathrm { ~ 5 ~ }$ ) layers to be hard shared between the tasks. Running 5-fold cross-validation on the train set to evaluate the architectures, we find the best choice is $N = 5$ (i.e., all layers fully shared before the final heterogeneous outputs). For our proposed methods, all the layers before the last heterogeneous dimensionality FC layers are softly shared. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We select increasing fractions of the AdienceFaces train split randomly, train the model, and evaluate on the same test set. For reference, there are 12245 images with gender labelled for training, 4007 ones for testing, and 11823 images with age group labelled for training, and 4316 ones for testing. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results Fig. 3 shows the error rate for each task. For the gender recognition task, we find that: (i) User-defined MTL is not consistently better than STL, but (ii) our methods, esp., DMTRLTucker, consistently outperform both STL and the best user-defined MTL. For the harder age group classification task, our methods generally improve on STL. However UD-MTL does not consistently improve on STL, and even reduces performance when the training set is bigger. This is the negative transfer phenomenon (Rosenstein et al., 2005), where using a transfer learning algorithm is worse than not using it. This difference in outcomes is attributed to sufficient data eventually providing some effective task-specific representation. Our methods can discover and exploit this, but UDMTL’s hard switch between sharing and not sharing can not represent or exploit such increasing task-specificity of representation. ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb0b2ea66c83cfafe25a3bd6b663ffeb9e04a95ebdb2fde22b382108561d05b8.jpg",
+        "image_caption": [
+            "Figure 3: Heterogeneous MTL: Age and Gender recognition in AdienceFace dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            98,
+            776,
+            272
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 HETEROGENEOUS MTL: MULTI-ALPHABET RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            328,
+            625,
+            343
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Dataset, Settings and Baselines We next consider the task of learning to recognise handwritten letters in multiple languages using the Omniglot (Lake et al., 2015) dataset. Omniglot contains handwritten characters in 50 different alphabets (e.g., Cyrillic, Korean, Tengwar), each with its own number of unique characters $1 4 \\sim 5 5$ ). In total, there are 1623 unique characters, and each has exactly 20 instances. Here each task corresponds to an alphabet, and the goal is to recognise its characters. MTL has a clear motivation here, as cross-alphabet knowledge sharing is likely to be useful as one is unlikely to have extensive training data for a wide variety of less common alphabets. ",
+        "bbox": [
+            173,
+            356,
+            825,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The images are monochrome of size $1 0 5 \\times 1 0 5$ . We design a CNN with 3 convolutional and $2 \\ : \\mathrm { F C }$ layers. The first conv layer has 8 filters of size $5 \\times 5$ ; the second conv layer has 12 filters of size $3 \\times 3$ , and the third convolutional layer has 16 filters of size $3 \\times 3$ . Each convolutional layer is followed by a $2 \\times 2$ max-pooling. The first FC layer has 64 neurons, and the second FC layer has size corresponding to the number of unique classes in the alphabet. The activation function is tanh. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            530
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use a similar strategy to find the best user-defined MTL model: the CNN has 5 parametrised layers, of which 4 layers are potentially shareable. So we tried hard-sharing the first $N$ $1 \\leq N \\leq 4 ,$ ) layers. Evaluating these options by 5-fold cross-validation, the best option turned out to be $N = 3$ , i.e., the first three layers are hard shared. For our methods, all four shareable layers are softly shared. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            593
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since there is no standard train/test split for this dataset, we use the following setting: We repeatedly pick at random $5 , \\ldots 9 0 \\%$ of images per class for training. Note that $5 \\%$ is the minimum, corresponding to one-shot learning. The remaining data are used for evaluation. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results Fig. 4 reports the average error rate across all 50 tasks (alphabets). Our proposed MTL methods surpass the STL baseline in all cases. User-defined MTL does not work well when the training data is very small, but does help when training fraction is larger than $5 0 \\%$ . ",
+        "bbox": [
+            174,
+            648,
+            825,
+            691
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Measuring the Learned Sharing Compared to the conventional user-defined sharing architectures, our method learns how to share from data. We next try to quantify the amount of sharing estimated by our model on the Omniglot data. Returning to the key factorisation $\\mathscr { W } = \\mathscr { L } S$ , we can find that $S$ -like matrix appears in all variants of proposed method. It is $S$ in DMTRL-LAF, the transposed $U ^ { ( N ) }$ in DMTRL-Tucker, and $U ^ { ( N ) }$ in DMTRL-TT $N$ is the last axis of $\\mathcal { W }$ ). $S$ is a $K \\times T$ size matrix, where $T$ is the number of tasks, and $K$ is the number of latent tasks (Kumar & Daume III, 2012) or the dimension of task coding (Yang & Hospedales, 2015). Each column ´ of $S$ is a set of coefficients that produce the final weight matrix/tensor by linear combination. If we put STL and user-defined MTL (for a certain shared layer) in this framework, we see that STL is to assign (rather than learn) $S$ to be an identity matrix $I _ { T }$ . Similarly, user-defined MTL (for a certain shared layer) is to assign $S$ to be a matrix with all zeros but one particular row is all ones, e.g., $S = [ \\mathbf { 1 } _ { 1 \\times T } ; \\mathbf { 0 } ]$ . Between these two extremes, our method learns the sharing structure in $S$ . We propose the following equation to measure the learned sharing strength: ",
+        "bbox": [
+            173,
+            698,
+            825,
+            880
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/954950dce55c861123763a36980f4e93559d92ef06137de75f0103e94e11fa67.jpg",
+        "text": "$$\n\\rho = \\frac { 1 } { { \\binom { T } { 2 } } } \\sum _ { i < j } \\Omega ( S _ { \\cdot , i } , S _ { \\cdot , j } ) = \\frac { 2 } { T ( T - 1 ) } \\sum _ { i < j } \\Omega ( S _ { \\cdot , i } , S _ { \\cdot , j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            888,
+            684,
+            928
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4e9921c310609c64d55abce2351e70d7c7124ec9b4585bed886236cdd6c9de3.jpg",
+        "image_caption": [
+            "Figure 4: Results of multi-task learning of multilingual character recognition (Omniglot dataset). Below: Illustration of the language pairs estimated to be the most related (left - Georgian Mkhedruli and Inuktitut) and most unrelated (right - Balinese and ULOG) character recognition tasks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            99,
+            777,
+            328
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Here $\\Omega ( a , b )$ is a similarity measure for two vectors $a$ and $b$ and we use cosine similarity. $\\rho$ is the average on all combinations of column-wise similarity. So $\\rho$ measures how much sharing is encoded by $S$ between $\\rho = 0$ for STL (nothing to share) and $\\rho = 1$ for user-defined MTL (completely shared). Since $S$ is a real-valued matrix in our scenario, we normalise it before applying Eq. 9: First we take absolute values, because large either positive or negative value suggests a significant coefficient. Second we normalise each column of $S$ by applying a softmax function, so the sum of every column is 1. The motivation behind the second step is to make a matched range of our $S$ with $S = I _ { T }$ or $S = [ \\mathbf { 1 } _ { 1 \\times T } ; \\mathbf { 0 } ]$ , as for those two cases, the sum of each column is 1 and the range is [0, 1]. ",
+        "bbox": [
+            174,
+            429,
+            825,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For the Omniglot experiment, we plot the measured sharing amount for training fraction $1 0 \\%$ . Fig. 4 reveals that three proposed methods tend to share more for bottom layers (‘Conv1’, ‘Conv2’, and ‘Conv3’) and share less for top layer (‘FC1’). This is qualitatively similar to the best user-defined MTL, where the first three layers are fully shared $( \\rho = 1 )$ ) and the 4th layer is completely not shared $\\rho = 0 ,$ ). However, our methods: (i) learn this structure in a purely data-driven way and (ii) benefits from the ability to smoothly interpolate between high and low degrees of sharing as depth increases. As an illustration, Fig. 4 also shows example text from the most and least similar language pairs as estimated at our multilingual character recogniser’s FC1 layer (the result can vary across layers). ",
+        "bbox": [
+            173,
+            547,
+            825,
+            659
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            699,
+            318,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a novel framework for end-to-end multi-task representation learning in contemporary deep neural networks. The key idea is to generalise matrix factorisation-based multitask ideas to tensor factorisation, in order to flexibly share knowledge in fully connected and convolutional DNN layers. Our method provides consistently better performance than single task learning and comparable or better performance than the best results from exhaustive search of user-defined MTL architectures. It reduces the design choices and architectural search space that must be explored in the workflow of Deep MTL architecture design (Caruana, 1997; Zhang et al., 2014; Liu et al., 2015), relieving researchers of the need to decide how to structure layer sharing/segregation. Instead sharing structure is determined in a data-driven way on a layer-by-layer basis that moreover allows a smooth interpolation between sharing and not sharing in progressively deeper layers. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            881
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements This work was supported by EPSRC (EP/L023385/1), and the European Union’s Horizon 2020 research and innovation program under grant agreement No 640891. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mane, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, ´ Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viegas, Oriol Vinyals, Pete Warden, Martin Watten- ´ berg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL http://tensorflow.org/. Software available from tensorflow.org. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andreas Argyriou, Theodoros Evgeniou, and Massimiliano Pontil. Convex multi-task feature learning. Machine Learning, 2008. ",
+        "bbox": [
+            174,
+            260,
+            821,
+            289
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Edwin V Bonilla, Kian M Chai, and Christopher Williams. Multi-task gaussian process prediction. In Neural Information Processing Systems (NIPS), 2007. ",
+        "bbox": [
+            173,
+            296,
+            821,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rich Caruana. Multitask learning. Machine Learning, 1997. ",
+        "bbox": [
+            173,
+            334,
+            571,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hal Daume III. Frustratingly easy domain adaptation. In ´ ACL, 2007. ",
+        "bbox": [
+            174,
+            358,
+            624,
+            373
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Eran Eidinger, Roee Enbar, and Tal Hassner. Age and gender estimation of unfiltered faces. IEEE Transactions on Information Forensics and Security, 2014. ",
+        "bbox": [
+            173,
+            381,
+            820,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Theodoros Evgeniou and Massimiliano Pontil. Regularized multi–task learning. In Knowledge Discovery and Data Mining (KDD), 2004. ",
+        "bbox": [
+            173,
+            419,
+            823,
+            448
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas L. Griffiths and Zoubin Ghahramani. The indian buffet process: An introduction and review. Journal of Machine Learning Research (JMLR), 2011. ",
+        "bbox": [
+            174,
+            455,
+            821,
+            486
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jui-Ting Huang, Jinyu Li, Dong Yu, Li Deng, and Yifan Gong. Cross-language knowledge transfer using multilingual deep neural network with shared hidden layers. In International Conference on Acoustics, Speech, and Signal Processing (ICASSP), 2013. ",
+        "bbox": [
+            173,
+            493,
+            825,
+            536
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Laurent Jacob, Jean-philippe Vert, and Francis R Bach. Clustered multi-task learning: A convex formulation. In Neural Information Processing Systems (NIPS), 2009. ",
+        "bbox": [
+            174,
+            544,
+            823,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhuoliang Kang, Kristen Grauman, and Fei Sha. Learning with whom to share in multi-task feature learning. In International Conference on Machine Learning (ICML), 2011. ",
+        "bbox": [
+            174,
+            582,
+            821,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tamara G. Kolda and Brett W. Bader. Tensor decompositions and applications. SIAM Review, 2009. ",
+        "bbox": [
+            173,
+            619,
+            821,
+            635
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Kumar and Hal Daume III. Learning task grouping and overlap in multi-task learning. In ´ International Conference on Machine Learning (ICML), 2012. ",
+        "bbox": [
+            173,
+            642,
+            823,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brenden M. Lake, Ruslan Salakhutdinov, and Joshua B. Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 2015. ",
+        "bbox": [
+            171,
+            680,
+            823,
+            709
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lieven De Lathauwer, Bart De Moor, and Joos Vandewalle. A multilinear singular value decomposition. SIAM Journal on Matrix Analysis and Applications, 2000. ",
+        "bbox": [
+            173,
+            718,
+            823,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Vadim Lebedev, Yaroslav Ganin, Maksim Rakhuba, Ivan V. Oseledets, and Victor S. Lempitsky. Speeding-up convolutional neural networks using fine-tuned cp-decomposition. In International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            176,
+            755,
+            823,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 1998. ",
+        "bbox": [
+            176,
+            806,
+            821,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "G. Levi and T. Hassncer. Age and gender classification using convolutional neural networks. In Computer Vision and Pattern Recognition Workshops (CVPRW), 2015. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaodong Liu, Jianfeng Gao, Xiaodong He, Li Deng, Kevin Duh, and Ye-Yi Wang. Representation learning using multi-task deep neural networks for semantic classification and information retrieval. NAACL, 2015. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexander Novikov, Dmitry Podoprikhin, Anton Osokin, and Dmitry Vetrov. Tensorizing neural networks. In Neural Information Processing Systems (NIPS), 2015. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "I. V. Oseledets. Tensor-train decomposition. SIAM Journal on Scientific Computing, 2011. ",
+        "bbox": [
+            171,
+            140,
+            769,
+            157
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexandre Passos, Piyush Rai, Jacques Wainer, and Hal Daume III. Flexible modeling of latent task ´ structures in multitask learning. In International Conference on Machine Learning (ICML), 2012. ",
+        "bbox": [
+            171,
+            165,
+            821,
+            194
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bernardino Romera-paredes, Hane Aung, Nadia Bianchi-berthouze, and Massimiliano Pontil. Multilinear multitask learning. In International Conference on Machine Learning (ICML), 2013. ",
+        "bbox": [
+            173,
+            202,
+            823,
+            232
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael T. Rosenstein, Zvika Marx, Leslie Pack Kaelbling, and Thomas G. Dietterich. To transfer or not to transfer. In In NIPS Workshop, Inductive Transfer: 10 Years Later, 2005. ",
+        "bbox": [
+            171,
+            239,
+            823,
+            270
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olivier Sigaud, Clement Masson, David Filliat, and Freek Stulp. Gated networks: an inventory. arXiv, 2015. ",
+        "bbox": [
+            173,
+            277,
+            821,
+            308
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sigurd Spieckermann, Steffen Udluft, and Thomas Runkler. Data-effiicient temporal regression with multitask recurrent neural networks. In NIPS Workshop on Transfer and Multi-Task Learning, 2014. ",
+        "bbox": [
+            174,
+            315,
+            825,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tian Tan, Yanmin Qian, and Kai Yu. Cluster adaptive training for deep neural network based acoustic model. IEEE/ACM Trans. Audio, Speech & Language Processing, 24(3):459–468, 2016. ",
+        "bbox": [
+            173,
+            367,
+            823,
+            397
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "L. R. Tucker. Some mathematical notes on three-mode factor analysis. Psychometrika, 1966. ",
+        "bbox": [
+            173,
+            405,
+            784,
+            420
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kishan Wimalawarne, Masashi Sugiyama, and Ryota Tomioka. Multitask learning meets tensor factorization: task imputation via convex optimization. In Neural Information Processing Systems (NIPS), 2014. ",
+        "bbox": [
+            173,
+            429,
+            823,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ya Xue, Xuejun Liao, Lawrence Carin, and Balaji Krishnapuram. Multi-task learning for classification with dirichlet process priors. Journal of Machine Learning Research (JMLR), 2007. ",
+        "bbox": [
+            171,
+            479,
+            823,
+            510
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yongxin Yang and Timothy M. Hospedales. A unified perspective on multi-domain and multi-task learning. In International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            173,
+            517,
+            821,
+            547
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zhanpeng Zhang, Ping Luo, Chen Change Loy, and Xiaoou Tang. Facial landmark detection by deep multi-task learning. In European Conference on Computer Vision (ECCV), 2014. ",
+        "bbox": [
+            174,
+            555,
+            821,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A COMPARISON WITH CLASSIC (SHALLOW) MTL METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            687,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We provide a comparison with classic (shallow, matrix-based) MTL methods for the first experiment (MNIST, binary one-vs-rest classification, $1 \\%$ training data, mean of error rates for 10-fold CV). A subtlety in making this comparison is what feature should the classic methods use? Conventionally they use a PCA feature (obtained by flattening the image, then dimension reduction by PCA). However for visual recognition tasks, performance is better with deep features – a key motivation for our focus on deep approaches to MTL. We therefore also compare the classic methods when using a feature extracted from the penultimate layer of the CNN network used in our experiment. ",
+        "bbox": [
+            173,
+            133,
+            826,
+            231
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/a1ef0d76eea7bf0386e1248977bb3ffdda8efc45672ac4bfa9ef8491df23dd39.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>PCAFeature</td><td>CNNFeature</td></tr><tr><td>Single Task Learning</td><td>16.89</td><td>11.52</td></tr><tr><td>Evgeniou &amp; Pontil (2004)</td><td>15.27</td><td>10.32</td></tr><tr><td>Argyriou et al. (2008)</td><td>15.64</td><td>9.56</td></tr><tr><td>Kumar &amp; Daumé I (2012)</td><td>14.08</td><td>9.41</td></tr><tr><td>DMTRL-LAF</td><td>-</td><td>8.25</td></tr><tr><td>DMTRL-Tucker</td><td></td><td>9.24</td></tr><tr><td>DMTRL-TT</td><td></td><td>7.31</td></tr><tr><td>UD-MTL</td><td></td><td>9.34</td></tr></table>",
+        "bbox": [
+            290,
+            243,
+            707,
+            372
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Comparison with classic MTL methods. MNIST binary classification error rate $( \\% )$ ",
+        "bbox": [
+            186,
+            382,
+            802,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "As expected, the classic methods improve on STL, and they perform significantly better with CNN than PCA features. However, our DMTRL methods still outperform the best classic methods, even when they are enhanced by CNN features. This is due to soft (cf hard) sharing of the feature extraction layers and the ability of end-to-end training of both the classifier and feature extractor. Finally, we note that more fundamentally, the classic methods are restricted to binary problems (due to their matrix-based nature) and so, unlike our tensor-based approach, they are unsuitable for multi-class problems like omniglot and age-group classification. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B MODEL CAPACITY AND PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            530,
+            537,
+            546
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/4f1ee70ad07989a347e57668ffe84fc239a5c6dcf46e8f69cc375648f9fca301.jpg",
+        "table_caption": [
+            "We list the number of parameters for each model in the first experiment (MNIST, binary one-vs-rest classification) and the performance ( $1 \\%$ training data, mean of error rate for 10-fold CV). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Error Rate (%)</td><td>Number of parameters</td><td>Ratio</td></tr><tr><td>STL</td><td>11.52</td><td>4351K</td><td>1.00</td></tr><tr><td>DMTRL-LAF</td><td>8.25</td><td>1632K</td><td>0.38</td></tr><tr><td>DMTRL-Tucker</td><td>9.24</td><td>1740K</td><td>0.40</td></tr><tr><td>DMTRL-TT</td><td>7.31</td><td>2187K</td><td>0.50</td></tr><tr><td>UD-MTL</td><td>9.34</td><td>436K</td><td>0.10</td></tr><tr><td>UD-MTL-Large</td><td>9.39</td><td>1644K</td><td>0.38</td></tr></table>",
+        "bbox": [
+            263,
+            602,
+            733,
+            704
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Comparison of deep models: Error rate and number of parameters. ",
+        "bbox": [
+            253,
+            713,
+            745,
+            728
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The conventional hard-sharing method (UD-MTL) design is to share all layers except the top layer. Its number of parameter is roughly $1 0 \\%$ of the single task learning method (STL), as most parameters are shared across the 10 tasks corresponding to 10 digits. Our soft-sharing methods also significantly reduce the number of parameters compared to STL, but are larger than UD-MTL’s hard sharing. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            799
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To compare our method to UD-MTL, while controlling for network capacity, we expanded UDMDL by adding more hidden neurons so its number of parameter is close to our methods (denoted UD-MTL-Large). However UD-MDL performance does not increase. This is evidence that our model’s good performance is not simply due to greater capacity than UD-MTL. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            862
+        ],
+        "page_idx": 11
+    }
+]

parse/train/XjYgR6gbCEc/XjYgR6gbCEc.md

@@ -0,0 +1,367 @@
+# MODALS: MODALITY-AGNOSTIC AUTOMATED DATAAUGMENTATION IN THE LATENT SPACE
+
+Tsz-Him Cheung & Dit-Yan Yeung Department of Computer Science and Engineering The Hong Kong University of Science and Technology {thcheungae,dyyeung}@cse.ust.hk
+
+# ABSTRACT
+
+Data augmentation is an efficient way to expand a training dataset by creating additional artificial data. While data augmentation is found to be effective in improving the generalization capabilities of models for various machine learning tasks, the underlying augmentation methods are usually manually designed and carefully evaluated for each data modality separately. These include image processing functions for image data and word-replacing rules for text data. In this work, we propose an automated data augmentation approach called MODALS (Modalityagnostic Automated Data Augmentation in the Latent Space) to augment data for any modality in a generic way. MODALS exploits automated data augmentation to fine-tune four universal data transformation operations in the latent space to adapt the transform to data of different modalities. Through comprehensive experiments, we demonstrate the effectiveness of MODALS on multiple datasets for text, tabular, time-series and image modalities.1
+
+# 1 INTRODUCTION
+
+Deep learning models tend to perform better with more labeled training data. However, labeled data are usually scarce and expensive to collect. Data augmentation is a promising means to extend the training dataset with new artificial data. In image recognition, image processing functions, like randomized cropping, horizontal flipping, and color shifting, are commonly adopted in modern image recognition models (Krizhevsky et al., 2012; Shorten & Khoshgoftaar, 2019). Following the success of image augmentation, it is becoming increasingly common to apply data augmentation in natural language processing tasks, like machine translation, text classification, and semantic parsing. Various word-based transformations have been proposed to perturb word tokens, such as replacing similar words or phrases, swapping word orders, and inserting or dropping random words (Cheng et al., 2018; S¸ ahin & Steedman, 2018; Wei & Zou, 2019).
+
+Over the years, more transformation functions have been proposed to augment different datasets. Cutout randomly occludes a part of an image to avoid overfitting (Devries & Taylor, 2017b). For label-mixing methods, CutMix replaces the occluded part in Cutout by a different image (Yun et al., 2019) and Mixup interpolates two images with their corresponding one-hot encoded labels (Zhang et al., 2018). These methods have been tested and found to be effective in multiple image datasets. Alternatively, new data can be created using deep generative models, for example, using GAN-based approaches to generate new images (Antoniou et al., 2017; Sandfort et al., 2019), conditional pretrained language models to generate training sentences (Kumar et al., 2020), and back-translation to paraphrase sentences by translating sentences to another language and back to the original language (Xie et al., 2020). While these generative approaches are found to be useful, the generators or language models are often hard to implement and are expensive to train. Apart from advancing individual transformations, another line of research studies their optimal composition. As the choice and order of the transformations are decided and tested manually, the success of an augmentation scheme in one dataset may not generalize well to other datasets. To tackle this problem, AutoAugment as an automated data augmentation method was proposed to automate this process by learning an optimal augmentation policy, which decides the probability and magnitude to apply pre-defined transformations (Cubuk et al., 2019).
+
+Whether it is for standard augmentation or automated augmentation, the transformation functions are often designed and tested carefully for each data modality separately. While it may be intuitive to create new and valid images using image processing techniques, it is non-trivial to define such label-preserving transformations on discrete data like text data. This prohibits the reuse of augmentation schemes across different data modalities. Beyond supervised learning, there is an increasing trend of utilizing data augmentation to extract information from unlabelled data in unsupervised (Xie et al., 2020) or self-supervised learning tasks (Chen et al., 2020; Grill et al., 2020). These current methods are heavily dependent on existing augmentations in vision applications. In order to generalize these methods to other modalities like text and graph data, there is a need for robust data augmentation for each modality. Therefore, we propose MODALS to apply modality-agnostic automated data augmentation in the latent space. The idea of transforming latent features is inspired by representation learning. For image generation, the work of Upchurch et al. (2017) interpolates images along specific directions in the latent space to add new semantics without changing the class identity, such as adding facial hair to the image of a male face by translating the corresponding latent representation towards the direction of male faces with facial hair. This suggests that augmenting data in the latent space can capture diverse semantic transformations which are usually hard to define in the input space.
+
+Augmentation in the latent space poses two main challenges: learning a latent space that is continuous for transformation, and finding the effective directions to traverse. Failing to address them properly may cause an augmented example to lose its original class identity. In the previous work by Devries & Taylor (2017a), the latent space is learned by training an autoencoder, which encodes the input data into a latent vector and decodes it back to the original data. The learned latent representations are then transformed by interpolation, extrapolation, or adding Gaussian noise and decoded as synthetic examples for the downstream tasks. For image data, ISDA estimates the semantic directions by inspecting the feature covariance (Wang et al., 2019). LSI and Manifold Mixup apply Mixup to the latent feature vectors (Liu et al., 2018; Verma et al., 2019).
+
+We develop our framework as MODALS. At a high level, MODALS applies latent space augmentation to address the data augmentation problem in multiple data modalities. Instead of improving the model performance in a specific domain or modality, the major focus and novelty of this work is to propose a general automated data augmentation framework that can work for multiple data modalities in a generic way. To the best of our knowledge, such an attempt has not been made by others in the research community. MODALS also differs from the previous approaches in three ways. First, as opposed to other operation-based latent space transformation methods, MODALS is jointly trained with augmentation. As it involves no auxiliary models or additional processes to generate examples, it can be efficiently integrated into the popular deep learning frameworks. Second, we observe that examples that are more uncertain to predict, or considered to be hard in the active learning literature, tend to carry richer information for model training. Therefore, we modify standard latent space transformations to create harder examples in MODALS. Third, MODALS introduces additional loss terms to improve the quality of augmentation in the latent space. In summary, we make four major contributions in this paper:
+
+• Propose a framework to apply automated augmentation in the latent space.   
+• Propose a novel and effective way to create hard examples.   
+• Study additional loss terms to improve label-preserving transformations in the latent space.   
+• Evaluate MODALS extensively on classification datasets across multiple data modalities using various deep learning models.
+
+# 2 RELATED WORK
+
+# 2.1 AUTOMATED DATA AUGMENTATION
+
+In practice, multiple transformations are used compositely to augment a dataset. The choice and strength of the transformations affect the model performance on different datasets. Motivated by neural architecture search and reinforcement learning, automated data augmentation formulates the tuning of augmentation parameters as a learning task. AutoAugment trains a child model with the augmentation transformations generated by a controller, which is updated by reinforcement learning using the downstream validation accuracy as the reward signals (Cubuk et al., 2019). To reduce the search effort in AutoAugment, various approaches have been proposed. Population Based Augmentation (PBA) adopts an evolution-based search strategy to simultaneously train and perturb a policy with multiple child models (Ho et al., 2019). RandAugment replaces the augmentation parameters in AutoAugment by uniform values across all transformations and searches for the magnitude and the number of transformations to apply (Cubuk et al., 2020). Adversarial AutoAugment finds an adversarial policy that creates difficult examples (Zhang et al., 2020). Luo et al. (2020) considered a text image recognition task and trained a model to distort the text images to create more difficult examples. In our work, we adopt PBA as the search strategy due to its computation being more efficient than AutoAugment and having a larger parameter space than RandAugment.
+
+# 2.2 LATENT SPACE DATA AUGMENTATION
+
+Interpolation is a simple but effective way to create new data from existing examples. Mixup can operate on general numerical data by interpolating two training examples and their corresponding one-hot encoded labels (Zhang et al., 2018). Manifold Mixup applies Mixup to the outputs from different hidden layers (Verma et al., 2019); LSI applies Mixup in the latent space for image classification (Liu et al., 2018). Previously, Devries & Taylor (2017a) found that extrapolation between features learned by an autoencoder generates more effective synthetic examples than adding Gaussian noise and interpolation. In their experiments, they suspected that interpolation tightens the class boundaries, which leads to overfitting and harms the performance. For text data, Kumar et al. (2019) explored simple latent space transformations and autoencoder-based methods in few-shot intent classification tasks. In general, it remains an open question which transformation in the latent space creates better augmented examples. We leverage automated data augmentation to find the optimal composition of latent space transformations for a variety of datasets of multiple data modalities.
+
+# 2.3 HARD EXAMPLE AUGMENTATION
+
+Kuchnik & Smith (2019) show that not all training examples are equally useful for augmentation and propose methods to find a subset of useful data to augment. Similar methods are also proposed by the recent augmentation algorithms, which aim to find the composition of transformations that create difficult examples (Luo et al., 2020; Wu et al., 2020; Zhang et al., 2020). In our work, we propose a novel and simple way to create hard examples using latent space transformation.
+
+# 3 METHODOLOGY
+
+# 3.1 BRIEF OVERVIEW OF POPULATION BASED AUGMENTATION
+
+We first briefly review the policy search procedure of PBA (Ho et al., 2019). In PBA, each augmentation function is associated with its probability and magnitude, for example, the tuple (op: rotation, $p = 0 . 4$ , $\lambda = 0 . 5$ ) specifies that the rotation operation is applied with a probability of 0.4 and a magnitude of 0.5. A policy is a set of such operation tuples. When a policy is applied to a mini-batch, 0, 1 or 2 operation tuples are randomly sampled from the policy and applied to the batch of data with their corresponding probability and magnitude.
+
+PBA formulates the augmentation policy search as hyperparameter schedule learning. Instead of a fixed policy, it learns a policy schedule that specifies the augmentation parameters at different stages of training. In particular, PBA exploits population-based training (PBT) to optimize the model weights of multiple child models jointly with their policy parameters that maximize the performance. It starts by simultaneously training a fixed number of randomly-initialized child models, each with its own policy. After certain fixed intervals, the child models are evaluated using the validation set. The worst models clone the weights and policies from the best models. The parameters of the cloned policies are either resampled from all possible values or perturbed from the cloned values. The process repeats until the training of the child models completes. The final output of PBA is a schedule of policies unrolled from the best child model. The policy schedule can be applied to augment the dataset when training with more data or larger models. As there is no need to retrain any child model, PBA is considered to be an efficient automated augmentation algorithm. Our method follows the policy formulation and the search strategy used in PBA.
+
+# 3.2 MODALS
+
+Our main assumption is that, if learned properly, the region corresponding to a class in the latent space learned by a deep neural network is mostly convex and isotropic. Consequently, linear transformation in such a space would result in a smooth transition from real data to artificial data without altering their class identity. Among other non-trivial properties, data points are often sparsely distributed in high-dimensional spaces such that distance-based methods that work well in lower-dimensional spaces fail to take advantage of the distance metrics (Donoho, 2000). In the supplemental materials, we provide empirical evidence to show that the relatively low-dimensional latent spaces used in our experiments are not anisotropic, especially within the local class regions (see Appendix A.1). In what follows, we introduce the latent space transformations and the training objectives of our model.
+
+# 3.2.1 TRANSFORMATIONS
+
+Hard example interpolation. Given a seed latent representation $\boldsymbol { z } _ { i } ^ { c }$ , which is the latent representation of the $i$ -th example in class $c$ , we interpolate $\boldsymbol { z } _ { i } ^ { c }$ to a hard example. The hard example is taken as the latent representation nearest to $\boldsymbol { z } _ { i } ^ { c }$ among $q$ hard example candidates sampled according to the classification loss. This favours the creation of harder examples and prevents $\boldsymbol { z } _ { i } ^ { c }$ from being aggressively interpolated to distant locations or regions that are close to the class center. In our implementation, we take $q$ as $5 \%$ of the number of examples in class $c$ . Formally, let ${ \cal S } = \{ s _ { i } \} _ { i = 1 } ^ { q }$ denote the set of hard latent representations sampled according to the magnitude of the loss in class c, s = arg mins∈S ikskkzck denote the closest hard example (red circle in Figure 1a), and $\lambda _ { 1 }$ denote a scaling factor. Hard example interpolation is expressed as:
+
+$$
+\hat { z _ { i } ^ { c } } = z _ { i } ^ { c } + \lambda _ { 1 } ( \pmb { s } - \pmb { z } _ { i } ^ { c } )
+$$
+
+Hard example extrapolation. The data nearer the class boundaries are more difficult to classify. Instead of extrapolating from random examples, we extrapolate $\boldsymbol { z } _ { i } ^ { c }$ from the class center $\begin{array} { r l } { \pmb { \mu } _ { c } } & { { } = } \end{array}$ $\begin{array} { r } { \frac { 1 } { m } \sum _ { j = 1 } ^ { m } z _ { j } ^ { c } } \end{array}$ with $\lambda _ { 2 }$ as the scaling factor. Hard example extrapolation is thus given by:
+
+$$
+\hat { z _ { i } ^ { c } } = z _ { i } ^ { c } + \lambda _ { 2 } ( z _ { i } ^ { c } - \pmb { \mu _ { c } } )
+$$
+
+Gaussian Noise. We also perturb $\boldsymbol { z } _ { i } ^ { c }$ by adding Gaussian noise with zero mean and per-element standard deviation computed across the examples in the same class. Let $\epsilon \sim \mathcal { N } ( \mathbf { 0 } , \sigma _ { c } ^ { 2 } \mathbf { \bar { I } } )$ and $\lambda _ { 3 }$ be the scaling factor, we have:
+
+$$
+\hat { z _ { i } ^ { c } } = z _ { i } ^ { c } + \lambda _ { 3 } \epsilon
+$$
+
+Difference Transform. Difference transform is an alternative way to perturb $\boldsymbol { z } _ { i } ^ { c }$ by translating $\boldsymbol { z } _ { i } ^ { c }$ along the direction between two random latent vectors sampled from the same class. Denoting the scaling factor as $\lambda _ { 4 }$ , the difference transform can be written as:
+
+$$
+\hat { z _ { i } ^ { c } } = z _ { i } ^ { c } + \lambda _ { 4 } ( z _ { j } ^ { c } - z _ { k } ^ { c } )
+$$
+
+These four latent space transformations are illustrated in Figure 1.
+
+# 3.2.2 MODEL
+
+Instead of training an autoencoder to learn the latent space and generate additional synthetic data for training, we train a classification model jointly with different compositions of latent space augmentations. Given an input space $\mathbb { X }$ , a latent space $\mathbb { Z }$ , and a label space $\mathbb { Y }$ , MODALS trains a feature extraction model $F ( \pmb { x } ; \pmb { \theta } ) : \mathbb { X }  \mathbb { Z }$ and a dense layer to map $\mathbb { Z } \to \mathbb { Y }$ . The $i$ -th example $\mathbf { \Delta } _ { \mathbf { \mathcal { X } } _ { i } }$ is mapped to its latent representation $z _ { i } = F ( \pmb { x } _ { i } )$ and further augmented by a composition of label-preserving transform functions to obtain the augmented latent representation $\hat { z } _ { i } \in \mathbb { Z }$ . We optimize the softmax cross-entropy loss among $k$ classes with $\pmb { W } = [ \pmb { w } _ { 1 } , . . . , \pmb { w } _ { k } ]$ as the weights of the final dense layer and $M$ as the batch size. The classification loss is given by:
+
+![](images/9eabc981aacd27da22da178278bc5abdca6d6be754fb0f78e62d1338f14c0463.jpg)  
+Figure 1: Illustration of (a) hard example interpolation, (b) hard example extrapolation, (c) Gaussian noise, and (d) difference transform (triangle: seed latent representation; circle outline: class boundary; black circle: sampled feature; red circle: nearest sampled hard example; square: class mean; dotted line: range of augmented example)
+
+$$
+L _ { c l f } ( W , \pmb \theta ) = - \frac { 1 } { M } \sum _ { i = 1 } ^ { M } \log \frac { \exp ( \pmb w _ { y _ { i } } ^ { \top } \hat { z } _ { i } ) } { \sum _ { j = 1 } ^ { k } \exp ( \pmb w _ { j } ^ { \top } \hat { z } _ { i } ) }
+$$
+
+In addition to the classification loss, we further employ two additional loss terms to improve the augmentation results. The effect of these two losses will be discussed in Appendix A.2.
+
+Adversarial Loss. Sampling in a high-dimensional latent space may fall into invalid regions that are not on the data manifold. In order to produce smooth morphing between sampled latent codes, there are well-studied techniques to enforce a posterior distribution over the latent variables using VAE or GAN-based methods (Kingma & Welling, 2014; Goodfellow et al., 2014). In MODALS, we regularize the latent space by imposing an adversarial loss similar to Adversarial Autoencoder (Makhzani et al., 2016). In particular, we employ a discriminator $D ( z ; \phi )$ to distinguish the latent code generated by the feature extraction model and sampled from the Gaussian distribution. The feature extraction model has to generate latent representations that are similar to the Gaussian distribution to fool the discriminator. This leads to the adversarial objective $L _ { a d v } ( \pmb { \theta } )$ for the feature extraction model and the discriminator loss $L _ { D } ( \phi )$ for the discriminator:
+
+$$
+L _ { a d v } ( \pmb \theta ) = - \frac { 1 } { M } \sum _ { i = 1 } ^ { M } \log D ( z _ { i } )
+$$
+
+$$
+L _ { D } ( \phi ) = - \frac { 1 } { M } \sum _ { i = 1 } ^ { M } \left( \log D ( \epsilon _ { i } ) + \log [ 1 - D ( z _ { i } ) ] \right) ; \forall i , \epsilon _ { i } \sim \mathcal { N } ( \mathbf { 0 } , \mathbf { I } )
+$$
+
+Triplet Loss. Triplet loss is often used in metric learning to learn the latent representations of different classes (Schroff et al., 2015). Triplet loss pulls together the representations from the same class and repels the ones from different classes. We argue that this characteristic facilitates labelpreserving augmentation in the latent space. Intuitively, the data outside the convex hull of the training samples are less likely to correspond to valid data of the same class. As a result of using the triplet loss, the distribution of the latent representations in the same class will be more compact. Interpolating, extrapolating or perturbing latent representations in this denser region is more likely to result in an augmented example sharing the same class identity. In theory, alternative measures, e.g., center loss (Wen et al., 2016), large margin softmax loss (Liu et al., 2016), or other contrastive losses, can also produce similar effects. For simplicity, we use the triplet loss in our implementation: for each anchor latent representation $_ z$ , we randomly sample a positive latent representation $z ^ { + }$ from the same class and a negative representation $z ^ { - }$ from a different class in the same mini-batch. We denote the margin as $\gamma$ and the cosine distance function as $d ( \cdot )$ . The triplet loss $L _ { t r i } ( \pmb { \theta } )$ is given by:
+
+$$
+L _ { t r i } ( \pmb \theta ) = \frac { 1 } { M } \sum _ { i = 1 } ^ { M } \left[ d ( z _ { i } , z _ { i } ^ { + } ) - d ( z _ { i } , z _ { i } ^ { - } ) + \gamma \right] _ { + }
+$$
+
+![](images/a58a8486263a6a0b1e9d46324637b2d7c1d641d49fbe2277954f9a67fdb9fea9.jpg)  
+Figure 2: MODALS ( $z .$ : seed latent representation; $\hat { z }$ : augmented latent representation; black line: forward propagation; red line: gradient flow from $\boldsymbol { L _ { c l f } }$ ; green line: gradient flow from $L _ { t r i }$ ; orange line: gradient flow from $L _ { a d v }$ ; blue line: reward signal; grey line: gradient flow from $L _ { D }$ .)
+
+MODALS is trained by minimizing the combined loss ${ \cal L } = { \cal L } _ { c l f } + \alpha { \cal L } _ { a d v } + \beta { \cal L } _ { t r i }$ , where $\alpha$ and $\beta$ are predefined hyperparameters. Figure 2 shows the overall architecture of MODALS : For each mini-batch, a feature extraction model maps the input data to their latent representations. The representations are used to compute the adversarial and triplet losses, and also augmented to obtain the classification loss and validation accuracy. The combined loss $L$ is back-propagated to the feature extraction network while the validation accuracy is treated as the reward signal to update the policy.
+
+# 3.2.3 POLICY SEARCH
+
+We apply the PBA policy search strategy to the latent representations with the four proposed transformations. We define four latent space transformations with probability ranging from 0 to 1 and magnitude $\lambda$ ranging from 0 to 0.9, both in intervals of 0.1. As the same operation can be applied twice, the search space is of size $( 1 0 \times 1 1 ) ^ { 8 } \approx 2 . 1 4 \times 1 0 ^ { 1 6 }$ . The total computation cost is the cost to train a single model multiplied by the number of parallel models.
+
+# 4 EXPERIMENTS
+
+To demonstrate the modality-agnostic property of MODALS, we evaluate it using datasets from four different data modalities: text, tabular, time-series, and image data. For each dataset, we search for the optimal augmentation schedule using PBT with 16 parallel models perturbing every three epochs. The searched policy schedule is applied to the dataset with different numbers of training examples. We implement the discriminator as a 2-layer multilayer perceptron (MLP) model with 256 hidden units in each layer. In all experiments, we set $\alpha = 1$ , $\beta = 0 . 0 3$ and search for the metric margin value from $\{ \ r _ { 0 . 5 , 1 , 2 , 4 , 8 } \}$ . We compare our method with baseline methods that do not involve training an auxiliary model. In particular, we construct the baseline models trained with well-defined input-space augmentation in the data modality and label-mixing augmentation. We report the average classification accuracy from three trials with the baselines. The detailed configuration and policy of each experiment are provided in Appendix A.3.
+
+# 4.1 TEXT DATA
+
+We test MODALS on the SST2 (Socher et al., 2013) and TREC6 (Li & Roth, 2002) datasets, which are popular benchmarks for binary and multi-class text classification tasks. SST2 is a binary sentiment classification dataset with 6,920 training examples, while TREC6 is a question classification dataset with 5,452 training examples from six question classes. We employ a 2-layer bidirectional
+
+LSTM using fixed pre-trained 300-dimensional GloVe as the word embedding (Pennington et al., 2014). The hidden state dimensionality of the model is 256. The first baseline is trained without augmentation. We construct the second baseline by applying manually designed input-space augmentations proposed as easy data augmentation (EDA) techniques in (Wei & Zou, 2019). In this baseline, seed sentences are cloned multiple times, where each cloned sentence is transformed by replacing synonyms, inserting synonyms, deleting random word, or swapping word order. The baseline follows the configurations suggested by EDA for datasets of different sizes. We construct the third baseline using senMixup, which applies mixup augmentation in the last hidden layer before the softmax layer (Guo et al., 2019). We also include the fourth and fifth baselines which use back-translation augmentation. The back-translation baselines are implemented using the Google Translate API to translate the original text to German (DE) or Spanish (ES) and back to English. Then, the model is trained on the back-translated text with the original text. Our experiments show that MODALS outperforms the other baseline methods in five of the settings and is comparable with back-translation (ES) in the TREC6 dataset. While EDA, senMixup and back-translation also show improvement on the full datasets, senMixup and back-translation sometimes slightly underperform the first baseline when the dataset size is small (see Table 1).
+
+Table 1: Comparison of five baselines (training without augmentation, EDA, senMixup, backtranslation from German and back-translation from Spanish) with MODALS on two text datasets for different amounts of training examples (s: $10 \%$ , m: $50 \%$ )   
+
+<table><tr><td></td><td>w/o Aug.</td><td>EDA</td><td>senMixup</td><td>BT (DE)</td><td>BT (ES)</td><td>MODALS</td></tr><tr><td>SST2 (s)</td><td>73.01</td><td>74.52</td><td>73.27</td><td>73.49</td><td>73.04</td><td>75.67</td></tr><tr><td>SST2 (m)</td><td>79.70</td><td>79.77</td><td>79.50</td><td>79.52</td><td>79.48</td><td>81.35</td></tr><tr><td>SST2</td><td>81.91</td><td>82.97</td><td>82.85</td><td>82.90</td><td>83.32</td><td>84.14</td></tr><tr><td>TREC6 (s)</td><td>81.10</td><td>81.10</td><td>78.06</td><td>81.20</td><td>80.40</td><td>83.20</td></tr><tr><td>TREC6 (m)</td><td>90.44</td><td>91.13</td><td>88.67</td><td>92.47</td><td>92.27</td><td>93.00</td></tr><tr><td>TREC6</td><td>92.67</td><td>93.26</td><td>93.07</td><td>93.60</td><td>94.00</td><td>94.00</td></tr></table>
+
+# 4.2 TABULAR DATA
+
+We also perform an experiment with multiple tabular datasets from the UCI repository (Dua & Graff, 2017), including the Iris, Breast Cancer, Arcene (Guyon et al., 2005), Abalone, and HTRU2 (Lyon et al., 2016) datasets. The data are standardized and trained with a 2-layer MLP that encodes the inputs to 128-dimensional latent codes. We compare the accuracy with baseline methods using no augmentation and using Mixup. The experiment is repeated with different numbers of training examples. Table 2 shows that MODALS outperforms the baseline methods in 13 out of 15 settings. In the remaining two settings, MODALS achieves the same performance as Mixup augmentation.
+
+Table 2: Comparison of two baselines (training without augmentation and Mixup) with MODALS on five tabular datasets for different amounts of training examples (s: $20 \%$ , m: $50 \%$ )   
+
+<table><tr><td>Dataset</td><td>w/o Aug.</td><td>Mixup</td><td>MODALS</td></tr><tr><td>Iris (s)</td><td>86.67</td><td>86.67</td><td>96.67</td></tr><tr><td>Iris (m)</td><td>96.67</td><td>98.00</td><td>98.67</td></tr><tr><td>Iris</td><td>96.67</td><td>98.89</td><td>98.89</td></tr><tr><td>B.Cancer (s)</td><td>95.32</td><td>95.61</td><td>96.67</td></tr><tr><td>B.Cancer (m)</td><td>96.78</td><td>97.08</td><td>97.37</td></tr><tr><td>B.Cancer</td><td>96.78</td><td>97.66</td><td>99.41</td></tr><tr><td>Arcene (s)</td><td>64.33</td><td>69.67</td><td>71.00</td></tr><tr><td>Arcene (m)</td><td>78.00</td><td>78.00</td><td>79.33</td></tr><tr><td>Arcene</td><td>83.33</td><td>83.33</td><td>83.67</td></tr></table>
+
+<table><tr><td>Dataset</td><td>w/o Aug.</td><td>Mixup</td><td>MODALS</td></tr><tr><td>Abalone (s)</td><td>62.80</td><td>62.84</td><td>63.40</td></tr><tr><td>Abalone (m)</td><td>64.04</td><td>64.67</td><td>64.95</td></tr><tr><td>Abalone</td><td>64.59</td><td>65.67</td><td>65.71</td></tr><tr><td>HTRU2 (s)</td><td>97.78</td><td>97.85</td><td>98.10</td></tr><tr><td>HTRU2 (m)</td><td>98.01</td><td>98.03</td><td>98.14</td></tr><tr><td>HTRU2</td><td>98.04</td><td>98.16</td><td>98.16</td></tr></table>
+
+# 4.3 TIME-SERIES DATA
+
+For time-series data, we use the HAR (Anguita et al., 2013) and Malware (Catak, 2019) datasets. HAR and Malware belong to continuous and discrete time-series data, respectively. The input of the HAR dataset consists of multiple continuous smartphone accelerometer and gyroscope readings for six human activities. The input of the Malware dataset consists of sequences of discrete events, specifically, the API call sequences of eight malwares. For both datasets, we train an LSTM model to encode the time-series data as 128-dimensional feature vectors and apply MODALS. MODALS performs the best in all cases (see Table 3).
+
+Table 3: Comparison of two baselines (training without augmentation and Mixup) with MODALS on two tabular datasets for different amounts of training examples (s: $10 \%$ , m: $50 \%$ )   
+
+<table><tr><td>Dataset</td><td>w/o Aug.</td><td>Mixup</td><td>MODALS</td></tr><tr><td>HAR (s)</td><td>49.93</td><td>52.20</td><td>57.71</td></tr><tr><td>HAR (m)</td><td>85.44</td><td>86.05</td><td>89.06</td></tr><tr><td>HAR</td><td>88.64</td><td>91.60</td><td>91.87</td></tr></table>
+
+<table><tr><td>Dataset</td><td>w/o Aug.</td><td>Mixup</td><td>MODALS</td></tr><tr><td>Malware (s)</td><td>79.24</td><td>81.14</td><td>84.07</td></tr><tr><td>Malware (m)</td><td>84.76</td><td>85.57</td><td>86.24</td></tr><tr><td>Malware</td><td>86.40</td><td>87.01</td><td>87.12</td></tr></table>
+
+# 4.4 IMAGE DATA
+
+For image data, we apply MODALS to CIFAR-10, SVHN, and the reduced versions of these two datasets, as in (Ho et al., 2019). CIFAR-10 and its reduced version contain 50,000 and 4,000 training images, respectively, while SVHN and its reduced version contain 73,537 and 1,000 training images, respectively. We use Wide-ResNet-40-2 as the feature extraction model in all experiments (Zagoruyko & Komodakis, 2016). We compare our method against three baselines. For the first baseline, we apply randomized cropping, horizontal flipping, and color normalization. For the second baseline, Cutout randomly occludes a patch of size $1 6 \times 1 6$ from the image on top of the simple augmentation in the first baseline. The third baseline is PBA, which uses the same search strategy as MODALS. Both PBA and MODALS are deployed with their corresponding searched policy schedules on top of Cutout. On the two original and the two reduced datasets, MODALS outperforms simple augmentation and Cutout but underperforms PBA (see Table 4). We suspect that the input-space augmentations used in PBA are able to cover most variations in these datasets due to the continuous nature of image data. As the input-space augmentations are independent of the latent space augmentations, it is possible to combine PBA with MODALS by jointly searching the optimal augmentation policy parameters to further improve the results.
+
+Table 4: Comparison of three baselines (training with simple augmentation, Cutout, and PBA) with MODALS on two image datasets for different amounts of training examples   
+
+<table><tr><td>Dataset</td><td> Simple Aug.</td><td>Cutout</td><td>PBA</td><td>MODALS</td></tr><tr><td>Reduced CIFAR-10</td><td>75.62</td><td>78.90</td><td>81.00</td><td>79.36</td></tr><tr><td>CIFAR-10</td><td>92.04</td><td>92.48</td><td>92.72</td><td>92.51</td></tr><tr><td>Reduced SVHN</td><td>76.17</td><td>76.83</td><td>83.52</td><td>81.23</td></tr><tr><td>SVHN</td><td>96.37</td><td>96.14</td><td>96.54</td><td>96.46</td></tr></table>
+
+# 5 ABLATION STUDY
+
+Latent space augmentation. We study the effect of latent space augmentation techniques in MODALS. We remove the latent space augmentation to isolate the effect from applying the triplet loss and adversarial loss. Table 5 summarizes the performance of MODALS across eight datasets from different modalities. Our study shows that the use of latent space augmentation contributes to additional performance gain when trained with different loss objectives. The detailed breakdown is listed in Appendix A.2.
+
+Additional losses. We perform an ablation study against the baseline models trained with different loss settings on eight datasets. Both the triplet loss and adversarial loss improves the performance when training with latent space augmentation (see Table 5). In Appendix A.2.1, we provide the details and evidence showing that the triplet loss enforces more compact local class regions to preserve the class labels when applying latent space augmentation.
+
+Table 5: Comparison of average accuracy when trained under different loss settings and augmentation techniques   
+
+<table><tr><td></td><td>Lclf</td><td>Lclf+Ladu</td><td>Lclf+Ltri</td><td>Lclf +Ladu+Ltri</td></tr><tr><td>w/ Aug.</td><td>86.35</td><td>88.18</td><td>88.37</td><td>89.12 (MODALS)</td></tr><tr><td>w/o Aug.</td><td>84.71</td><td>86.64</td><td>86.74</td><td>87.69</td></tr></table>
+
+Hard examples. We study the effectiveness of our proposed hard augmentation in creating uncertain examples on eight datasets. Taking the difference of the predicted probability between the most likely and second most likely labels as a measurement of prediction certainty, our study shows that the proposed hard example interpolation and extrapolation create $7 . 2 3 \%$ and $2 . 3 4 \%$ , respectively, less certain examples on average (see Table 6). We further validate that the augmented examples improve the classification performance on hard examples (see Appendix A.2.2, A.2.3).
+
+Table 6: Comparison of average change in prediction certainty when applied with and without hard augmentation   
+
+<table><tr><td>w/o Aug.</td><td>+Hard Interpolation</td><td>+Hard Extrapolation</td></tr><tr><td>0.7093</td><td>0.6581 (-7.22%)</td><td>0.6927 (-2.34%)</td></tr></table>
+
+# 6 CONCLUSION
+
+In this paper, we introduce MODALS to apply automated data augmentation in the latent space using four proposed modality-agnostic transformations trained with additional loss metrics and hard example augmentation techniques. Our method is tested on text, tabular, time-series, and image data and can be readily integrated with popular deep learning models. Beyond the data modalities tested, MODALS also work on all other data modalities given proper feature extraction models. We believe that MODALS makes larger improvements to data modalities in which the input space augmentation is less trivial to be defined, like text data, video data or even graph data in low-resource regimes.
+
+# ACKNOWLEDGMENTS
+
+This research has been made possible by the Hong Kong PhD Fellowship provided to the first author and research grants (General Research Fund project 16204720 and Collaborative Research Fund project C6030-18GF from the Research Grants Council of Hong Kong; Amazon Web Services Machine Learning Research Award 2020) provided to the second author.
+
+# REFERENCES
+
+Davide Anguita, Alessandro Ghio, Luca Oneto, Xavier Parra, and Jorge Luis Reyes-Ortiz. A public domain dataset for human activity recognition using smartphones. In 21st European Symposium on Artificial Neural Networks, 2013.
+
+Antreas Antoniou, Amos J. Storkey, and Harrison Edwards. Data augmentation generative adversarial networks. arXiv preprint arXiv: 1711.04340, 2017.
+
+Ferhat Ozgur Catak. Malware API call dataset, 2019. URL http://dx.doi.org/10.21227/ crfp-kd68.
+
+Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey E. Hinton. A simple framework for contrastive learning of visual representations. In Proceedings of the 37th International Conference on Machine Learning, volume 119 of Proceedings of Machine Learning Research, pp. 1597– 1607, 2020.
+
+Yong Cheng, Zhaopeng Tu, Fandong Meng, Junjie Zhai, and Yang Liu. Towards robust neural machine translation. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), volume 1, pp. 1756–1766, 2018.
+
+Ekin D. Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V. Le. AutoAugment: Learning augmentation strategies from data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 113–123, 2019.
+
+Ekin D. Cubuk, Barret Zoph, Jonathon Shlens, and Quoc V. Le. RandAugment: Practical automated data augmentation with a reduced search space. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pp. 3008–3017, 2020.
+
+Terrance Devries and Graham W. Taylor. Dataset augmentation in feature space. arXiv preprint arXiv:1702.05538, 2017a.
+
+Terrance Devries and Graham W. Taylor. Improved regularization of convolutional neural networks with cutout. arXiv preprint arXiv:1708.04552, 2017b.
+
+David L. Donoho. High-dimensional data analysis: The curses and blessings of dimensionality. In AMS Conference on Math Challenges of the 21st Century, 2000.
+
+Dheeru Dua and Casey Graff. UCI machine learning repository, 2017. URL http://archive. ics.uci.edu/ml.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems 27, pp. 2672–2680. 2014.
+
+Jean-Bastien Grill, Florian Strub, Florent Altche, Corentin Tallec, Pierre H. Richemond, Elena ´ Buchatskaya, Carl Doersch, Bernardo Avila Pires, Zhaohan Guo, Mohammad Gheshlaghi Azar, ´ Bilal Piot, Koray Kavukcuoglu, Remi Munos, and Michal Valko. Bootstrap your own latent - ´ A new approach to self-supervised learning. In Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria-Florina Balcan, and Hsuan-Tien Lin (eds.), Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, 2020.
+
+Hongyu Guo, Yongyi Mao, and Richong Zhang. Augmenting data with Mixup for sentence classification: An empirical study. arXiv preprint arXiv:1905.08941, 2019.
+
+Isabelle Guyon, Steve Gunn, Asa Ben-Hur, and Gideon Dror. Result analysis of the NIPS 2003 feature selection challenge. In Advances in Neural Information Processing Systems 17, pp. 545– 552. 2005.
+
+Daniel Ho, Eric Liang, Xi Chen, Ion Stoica, and Pieter Abbeel. Population based augmentation: Efficient learning of augmentation policy schedules. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 2731–2741, 2019.
+
+Diederik P. Kingma and M. Welling. Auto-encoding variational bayes. International Conference on Learning Representations, 2014.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pp. 1097– 1105. 2012.
+
+Michael Kuchnik and Virginia Smith. Efficient augmentation via data subsampling. In International Conference on Learning Representations, 2019.
+
+Varun Kumar, Hadrien Glaude, Cyprien de Lichy, and William Campbell. A closer look at feature space data augmentation for few-shot intent classification. In Proceedings of the 2nd Workshop on Deep Learning Approaches for Low-Resource NLP, DeepLo@EMNLP-IJCNLP 2019, pp. 1–10, 2019.
+
+Varun Kumar, Ashutosh Choudhary, and Eunah Cho. Data augmentation using pre-trained transformer models. arXiv preprint arXiv:2003.02245, 2020.
+
+Xin Li and Dan Roth. Learning question classifiers. In The 19th International Conference on Computational Linguistics, 2002.
+
+Weiyang Liu, Yandong Wen, Zhiding Yu, and Meng Yang. Large-margin softmax loss for convolutional neural networks. In Proceedings of the 33nd International Conference on Machine Learning, 2016, volume 48 of JMLR Workshop and Conference Proceedings, pp. 507–516, 2016.
+
+Xiaofeng Liu, Yang Zou, Lingsheng Kong, Zhihui Diao, Junliang Yan, Jun Wang, Site Li, Ping Jia, and Jane You. Data augmentation via latent space interpolation for image classification. In 2018 24th International Conference on Pattern Recognition, pp. 728–733, 2018.
+
+Canjie Luo, Yuanzhi Zhu, Lianwen Jin, and Yongpan Wang. Learn to augment: Joint data augmentation and network optimization for text recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 13743–13752, 2020.
+
+R. J. Lyon, B. Stappers, S. Cooper, J. M. Brooke, and Joshua D. Knowles. Fifty years of pulsar candidate selection: from simple filters to a new principled real-time classification approach. Monthly Notices of the Royal Astronomical Society, 459(1):1104–1123, 2016.
+
+Alireza Makhzani, Jonathon Shlens, Navdeep Jaitly, and Ian J. Goodfellow. Adversarial Autoencoders. International Conference on Learning Representations, 2016.
+
+Jeffrey Pennington, Richard Socher, and Christopher Manning. GloVe: Global vectors for word representation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing, pp. 1532–1543, 2014.
+
+Gozde G ¨ ul S¸ ahin and Mark Steedman. Data augmentation via dependency tree morphing for low- ¨ resource languages. In Proceedings of the 2018 Conference on Empirical Methods in Natural Language Processing, pp. 5004–5009, 2018.
+
+Veit Sandfort, Ke Yan, Perry J. Pickhardt, and Ronald M. Summers. Data augmentation using generative adversarial networks (CycleGAN) to improve generalizability in CT segmentation tasks. Scientific Reports, 9(1), 2019.
+
+Tobias Scheffer, Christian Decomain, and Stefan Wrobel. Active hidden Markov models for information extraction. In Proceedings of the 4th International Conference on Advances in Intelligent Data Analysis, IDA’01, pp. 309–318, 2001.
+
+Florian Schroff, Dmitry Kalenichenko, and James Philbin. FaceNet: A unified embedding for face recognition and clustering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 815–823, 2015.
+
+Connor Shorten and Taghi M. Khoshgoftaar. A survey on image data augmentation for deep learning. Journal of Big Data, 6(1):60, 2019.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D. Manning, Andrew Ng, and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 Conference on Empirical Methods in Natural Language Processing, pp. 1631–1642, 2013.
+
+Paul Upchurch, Jacob R. Gardner, Geoff Pleiss, Kavita Bala, Robert Pless, Noah Snavely, and Kilian Q. Weinberger. Deep feature interpolation for image content changes. 2017 IEEE Conference on Computer Vision and Pattern Recognition, pp. 6090–6099, 2017.
+
+Vikas Verma, Alex Lamb, Christopher Beckham, Amir Najafi, Ioannis Mitliagkas, David LopezPaz, and Yoshua Bengio. Manifold Mixup: Better representations by interpolating hidden states. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of $P r o$ - ceedings of Machine Learning Research, pp. 6438–6447, 2019.
+
+Yulin Wang, Xuran Pan, Shiji Song, Hong Zhang, Gao Huang, and Cheng Wu. Implicit semantic data augmentation for deep networks. In Advances in Neural Information Processing Systems 32, pp. 12635–12644. 2019.
+
+Jason Wei and Kai Zou. EDA: Easy data augmentation techniques for boosting performance on text classification tasks. In Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing, pp. 6382–6388, 2019.
+
+Yandong Wen, Kaipeng Zhang, Zhifeng Li, and Yu Qiao. A discriminative feature learning approach for deep face recognition. In Computer Vision - ECCV 2016 - 14th European Conference, volume 9911 of Lecture Notes in Computer Science, pp. 499–515, 2016.
+
+Sen Wu, Hongyang Zhang, Gregory Valiant, and Christopher Re. On the generalization effects of linear transformations in data augmentation. In Proceedings of Machine Learning and Systems 2020, pp. 3493–3503. 2020.
+
+Qizhe Xie, Zihang Dai, Eduard H. Hovy, Thang Luong, and Quoc Le. Unsupervised data augmentation for consistency training. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, 2020.
+
+Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. arXiv preprint arXiv:1905.04899, 2019.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. In Proceedings of the British Machine Vision Conference, pp. 87.1–87.12, 2016.
+
+Hongyi Zhang, Moustapha Cisse, Yann N. Dauphin, and David Lopez-Paz. Mixup: Beyond empirical risk minimization. In International Conference on Learning Representations, 2018.
+
+Xinyu Zhang, Qiang Wang, Jian Zhang, and Zhao Zhong. Adversarial AutoAugment. In International Conference on Learning Representations, 2020.
+
+# A APPENDIX
+
+# A.1 VALIDITY OF ISOTROPIC ASSUMPTION IN THE LATENT SPACE
+
+Due to the curse of dimensionality, high-dimensional vectors are usually sparsely distributed. Let us consider a high-dimensional hypersphere with data points evenly distributed inside the hypersphere. As the dimensionality increases, it can be shown that the percentage of data points residing near the surface of the hypersphere will increase significantly. This contradicts our common perception for low-dimensional spaces, such as two- or three-dimensional spaces. Worse still, in case the phenomenon indeed holds, the isotropic assumption about the region of a class will be violated. As such, we want to conduct an experiment to see if there is evidence revealing the occurrence of this unusual phenomenon. Specifically, we study the spread of data points in the latent spaces of different dimensionality used. For each class $c$ of size $m$ , we compute the normalized distances $\{ r _ { i } ^ { c } \} _ { i = 1 } ^ { m }$ from the class mean $\pmb { \mu } _ { c }$ to the latent representations $\{ z _ { i } ^ { c } \} _ { i = 1 } ^ { m }$ :
+
+$$
+r _ { i } ^ { c } = \frac { \ell _ { 2 } ( z _ { i } ^ { c } , \pmb { \mu } _ { c } ) } { \frac { 1 } { m } \sum _ { j = 1 } ^ { m } \ell _ { 2 } ( z _ { j } ^ { c } , \pmb { \mu } _ { c } ) }
+$$
+
+We repeat the experiment on one dataset for each of the four data modalities. Table 7 reports the average standard deviation of the normalized distances for all classes. The average standard deviation in all datasets shows a decreasing trend as the dimensionality increases, falling between 0.25 to 0.75 for a dimensionality of 128 or 256. In case the unusual phenomenon as described above really holds so that most of the data points have similar distances from their class center, we would expect the standard deviation to be very small or even close to zero. Our experiment shows that this is not the case especially for lower latent space dimensionality.
+
+Table 7: Average standard deviation of the normalized distances for all classes as the latent space dimensionality $d$ varies   
+
+<table><tr><td>d</td><td>SST2</td><td>TREC6</td><td>CIFAR-10</td><td>SVHN</td><td>IRIS</td><td>B. Cancer</td><td>HAR</td><td>Malware</td></tr><tr><td>2</td><td>0.7801</td><td>0.8684</td><td>0.6068</td><td>0.6273</td><td>0.6688</td><td>0.8229</td><td>1.0847</td><td>0.6233</td></tr><tr><td>4</td><td>0.7592</td><td>0.7664</td><td>0.4286</td><td>0.5458</td><td>0.6507</td><td>0.6229</td><td>1.1415</td><td>0.4831</td></tr><tr><td>8</td><td>0.7688</td><td>0.6725</td><td>0.4059</td><td>0.6125</td><td>0.8674</td><td>0.6289</td><td>0.9768</td><td>0.3983</td></tr><tr><td>16</td><td>0.7774</td><td>0.6600</td><td>0.3789</td><td>0.5639</td><td>0.5668</td><td>0.5267</td><td>0.8000</td><td>0.3409</td></tr><tr><td>32</td><td>0.7812</td><td>0.6161</td><td>0.3783</td><td>0.5496</td><td>0.5642</td><td>0.5286</td><td>1.0814</td><td>0.3078</td></tr><tr><td>64</td><td>0.7747</td><td>0.5743</td><td>0.3829</td><td>0.5007</td><td>0.5526</td><td>0.4694</td><td>0.6396</td><td>0.2793</td></tr><tr><td>128</td><td>0.7534</td><td>0.5206</td><td>0.3799</td><td>0.4639</td><td>0.5568</td><td>0.3329</td><td>0.8639</td><td>0.2590</td></tr><tr><td>256</td><td>0.7297</td><td>0.4791</td><td>0.3709</td><td>0.4681</td><td>0.5407</td><td>0.4826</td><td>0.6127</td><td>0.2500</td></tr></table>
+
+# A.2 ABLATION STUDY
+
+Table 8: Summary of the performance under different settings (Aug.: latent space augmentation; $\boldsymbol { L _ { a d v } }$ : adversarial loss; $L _ { t r i }$ : triplet loss)   
+
+<table><tr><td>Datasets</td><td>MODALS</td><td>- Aug.</td><td>-Ladu</td><td>-Ltri</td><td>-Ladu -Ltri</td></tr><tr><td>TREC6</td><td>94.00</td><td>92.33</td><td>93.60</td><td>93.20</td><td>91.60</td></tr><tr><td>SST2</td><td>84.14</td><td>81.36</td><td>83.54</td><td>82.28</td><td>82.01</td></tr><tr><td>Iris</td><td>98.89</td><td>96.67</td><td>97.78</td><td>98.89</td><td>97.78</td></tr><tr><td>B.Cancer</td><td>99.41</td><td>98.83</td><td>99.41</td><td>98.83</td><td>97.36</td></tr><tr><td>Reduced CIFAR-10</td><td>79.36</td><td>79.40</td><td>78.88</td><td>79.33</td><td>74.68</td></tr><tr><td>Reduced SVHN</td><td>81.23</td><td>80.65</td><td>79.25</td><td>78.12</td><td>74.01</td></tr><tr><td>HAR</td><td>91.87</td><td>89.01</td><td>91.72</td><td>90.81</td><td>90.96</td></tr><tr><td>Malware (s)</td><td>84.07</td><td>83.27</td><td>82.76</td><td>83.94</td><td>82.46</td></tr><tr><td>Average</td><td>89.12</td><td>87.69</td><td>88.37</td><td>88.18</td><td>86.36</td></tr><tr><td>Change</td><td></td><td>-1.63%</td><td>-0.85%</td><td>-1.07%</td><td>-3.20%</td></tr><tr><td>(cont&#x27;)</td><td></td><td>- Aug.</td><td>- Aug.</td><td>- Aug.</td><td></td></tr><tr><td>TREC6</td><td>94.00</td><td>-Ltri-Ladu 82.67</td><td>-Ladu 92.60</td><td>-Ltri</td><td></td></tr><tr><td>SST2</td><td>84.14</td><td>81.91</td><td>82.15</td><td>92.33 79.52</td><td></td></tr><tr><td>Iris</td><td>98.89</td><td>96.67</td><td>96.67</td><td>96.67</td><td></td></tr><tr><td>B.Cancer</td><td>99.41</td><td>96.78</td><td>97.95</td><td>97.67</td><td></td></tr><tr><td>Reduced CIFAR-10</td><td>79.36</td><td>75.62</td><td>78.06</td><td>79.02</td><td></td></tr><tr><td>Reduced SVHN</td><td>81.23</td><td>76.17</td><td>77.72</td><td>78.07</td><td></td></tr><tr><td>HAR</td><td>91.87</td><td></td><td></td><td></td><td></td></tr><tr><td>Malware (s)</td><td>84.07</td><td>88.64 79.24</td><td>89.36 79.39</td><td>88.59 81.21</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Average</td><td>89.12</td><td>84.71</td><td>86.74</td><td>86.64</td><td></td></tr><tr><td>Change</td><td>1</td><td>-5.20%</td><td>-2.75%</td><td>-2.87%</td><td></td></tr></table>
+
+# A.2.1 LOSS
+
+Here, we study the effect of using additional loss metrics for data augmentation in the latent space.   
+We repeat our previous experiments by removing one or both of the triplet and adversarial losses.
+
+Table 8 shows that adding the proposed loss metrics improves the classification performance across all datasets of different modalities.
+
+We further analyze the effect of the triplet loss in the augmentation context. Using the triplet loss forces the distribution of data points in the same class to be more compact. Consequently, the local class region becomes more convex and isotropic and hence facilitates smoother label-preserving transformation. We validate our conjecture by constraining the latent space to two dimensions to facilitate visualizing the data points (see Figure 3). Without the triplet loss, some class regions overlap and appear in less regular shapes. When the triplet loss is used, the class regions become more compact and appear in more circular shapes as observed from the coordinate axes and the visualization plots. This favors the convex and isotropic assumption in Section 2 of the paper when we propose to apply linear transformation on the feature vectors in local class regions. As the classes are better separated, the transformation can better preserve the original class labels.
+
+![](images/a0729706d17cf7ff148323d2f690b4d7d79885c890905a332b14397e218d35c5.jpg)  
+Figure 3: Visualization of data points in the latent space for the TREC6 dataset
+
+In addition to visualizing the data points qualitatively, we also provide quantitative measurements in Table 9 to show the separation between and within the class regions for higher dimensionality. Specifically, we measure the average within-class distance and between-class distance of the latent representations when training with and without the triplet loss. Our study shows that the average within-class distance with the triplet loss is smaller, resulting in a more compact class region. The ratio of between-class and within-class distances suggests a better separation between class regions rather than solely the scaling effect. Similar observations are also noticed in other datasets.
+
+Table 9: Quantitative results for within-class and between-class distances under the effect of triplet loss on the TREC6 dataset. $d$ : dimensionality; $c _ { w }$ : within-class distance; $c _ { b }$ : between-class distance)   
+
+<table><tr><td></td><td colspan="3">w/o triplet loss</td><td colspan="3">w/ triplet loss</td></tr><tr><td>d</td><td>Cw</td><td>Cb</td><td>Cb/Cw</td><td>cw</td><td>Cb</td><td>Cb/Cw</td></tr><tr><td>2</td><td>9.32</td><td>25.86</td><td>2.77</td><td>1.55</td><td>7.68</td><td>4.92</td></tr><tr><td>4</td><td>6.40</td><td>20.26</td><td>3.16</td><td>1.79</td><td>7.11</td><td>3.96</td></tr><tr><td>8</td><td>7.40</td><td>21.09</td><td>2.84</td><td>2.02</td><td>7.14</td><td>3.53</td></tr><tr><td>16</td><td>8.10</td><td>19.51</td><td>2.40</td><td>2.04</td><td>6.56</td><td>3.20</td></tr><tr><td>32</td><td>9.19</td><td>22.17</td><td>2.41</td><td>2.37</td><td>7.07</td><td>2.97</td></tr><tr><td>64</td><td>9.34</td><td>22.07</td><td>2.36</td><td>2.56</td><td>7.01</td><td>2.73</td></tr><tr><td>128</td><td>9.67</td><td>21.26</td><td>2.19</td><td>3.04</td><td>7.53</td><td>2.46</td></tr></table>
+
+# A.2.2 HARD EXAMPLE AUGMENTATION
+
+Next, we study the effectiveness of our proposed transformation in creating hard examples. In our experiment, we measure the uncertainty of an example by the difference in predicted probability between the most likely and second most likely labels (Scheffer et al., 2001). We call this metric as margin. A smaller margin implies a more uncertain prediction.
+
+$$
+M a r g i n ( z ) = p ( y _ { 1 } | z ) - p ( y _ { 2 } | z )
+$$
+
+We train the models on eight datasets and compute the margin for the original features and the augmented features. Our results show that hard interpolation is more effective in creating uncertain examples than hard extrapolation in most datasets (see Table 10). Admittedly, this finding is a bit counter-intuitive. We suspect that it may be due to the different shapes and complexity of the class boundaries, but more investigation is needed to understand the reasons behind.
+
+Table 10: Comparison of the margin between models trained without augmentation and with hard interpolation or extrapolation   
+
+<table><tr><td>Dataset</td><td>w/o Aug.</td><td>+hard interpolation</td><td>+hard extrapolation</td></tr><tr><td>SST2</td><td>0.4498</td><td>0.4168 (-7.33%)</td><td>0.4492 (-0.13%)</td></tr><tr><td>TREC</td><td>0.9681</td><td>0.9468 (-2.20%)</td><td>0.9273 (-4.22%)</td></tr><tr><td>Iris</td><td>0.5220</td><td>0.4884 (-6.44%)</td><td>0.4946(-5.25%)</td></tr><tr><td>B.Cancer</td><td>0.8822</td><td>0.8130 (-7.85%)</td><td>0.8634 (-2.14%)</td></tr><tr><td>Reduced SVHN</td><td>0.7770</td><td>0.7066 (-9.07%)</td><td>0.7655 (-1.48%)</td></tr><tr><td>Reduced CIFAR-10</td><td>0.8129</td><td>0.7719 (-5.04%)</td><td>0.7867 (-3.22%)</td></tr><tr><td>HAR</td><td>0.5069</td><td>0.4514 (-10.95%)</td><td>0.5044 (-0.49%)</td></tr><tr><td>Malware (s)</td><td>0.7561</td><td>0.6697 (-11.43 %)</td><td>0.7510 (-0.67%)</td></tr></table>
+
+# A.2.3 HARD EXAMPLE TRAINING
+
+We also study whether the hard examples created using the proposed transformation benefit model training. In the ablation test, we sample the top $5 \%$ hardest examples based on the classification loss from each class and compare the changes in the margin and accuracy of the hard examples after training with different augmentation settings (see Table 11). We use a fixed augmentation instead of a fine-tuned policy schedule. In the experiment, the models trained with hard example interpolation and extrapolation achieve a higher accuracy on the sampled hard examples. The larger increases in margin show that the models can learn to predict the hard examples with higher certainty.
+
+Table 11: Comparison of the change in margin and classification accuracy on the hard examples between models trained with different augmentation schemes   
+
+<table><tr><td rowspan="2">Dataset</td><td colspan="2">w/o Aug.</td><td colspan="2">+hard interpolation</td><td colspan="2">+hard extrapolation</td></tr><tr><td>margin</td><td> accuracy</td><td>margin</td><td> accuracy</td><td>margin</td><td> accuracy</td></tr><tr><td>SST2</td><td>0.0092</td><td>0.4167</td><td>0.0719</td><td>0.4667</td><td>0.0588</td><td>0.4667</td></tr><tr><td>TREC6</td><td>0.0981</td><td>0.0580</td><td>0.0777</td><td>0.0592</td><td>0.0887</td><td>0.0580</td></tr><tr><td>Reduced CIFAR-10</td><td>0.3572</td><td>0.1900</td><td>0.3847</td><td>0.2533</td><td>0.3729</td><td>0.2133</td></tr><tr><td>Reduced SVHN</td><td>0.2731</td><td>0.7926</td><td>0.3514</td><td>0.8222</td><td>0.3441</td><td>0.8667</td></tr><tr><td>Iris</td><td>-0.0833</td><td>0.0370</td><td>0.1122</td><td>0.2592</td><td>0.0231</td><td>0.0740</td></tr><tr><td>B.Cancer</td><td>0.0542</td><td>0.3589</td><td>0.1077</td><td>0.3895</td><td>0.0666</td><td>0.4102</td></tr><tr><td>HAR</td><td>0.3808</td><td>0.0895</td><td>0.4037</td><td>0.1461</td><td>0.3530</td><td>0.1525</td></tr><tr><td>Malware (s)</td><td>-0.0162</td><td>0.0044</td><td>0.0074</td><td>0.0126</td><td>-0.1121</td><td>0.0259</td></tr></table>
+
+Finally, we compare the end-to-end training with simple interpolation and extrapolation to our proposed hard augmentation methods. Table 12 presents the accuracy of the model trained with hard augmentation and simple interpolation and extrapolation.
+
+Table 12: Comparison of models trained with simple interpolation and extrapolation and with hard interpolation and extrapolation   
+
+<table><tr><td>Dataset</td><td>Non-hard</td><td>Hard</td></tr><tr><td>Reduced CIFAR-10</td><td>78.11</td><td>79.36</td></tr><tr><td>Reduced SVHN</td><td>80.11</td><td>81.23</td></tr><tr><td>TREC6</td><td>91.40</td><td>94.00</td></tr><tr><td>SST2</td><td>82.28</td><td>84.14</td></tr><tr><td>Iris</td><td>98.89</td><td>98.89</td></tr><tr><td>B.Cancer</td><td>96.49</td><td>99.41</td></tr><tr><td>HAR</td><td>88.72</td><td>91.87</td></tr><tr><td>Malware (s)</td><td>81.29</td><td>84.07</td></tr></table>
+
+# A.3 EXPERIMENT DETAILS
+
+In this section, we present the detailed configuration and augmentation schedule for each of the data modalities. In all the experiments, the augmentation policy is searched using $50 \%$ of the data as the validation set. We use 16 child models in PBA implemented using the Ray Tune framework (https://docs.ray.io/en/latest/tune/index.html). The child models are evaluated and perturbed every three epochs. For the discriminator, we employ a 2-layer MLP model with 256 hidden units and ReLU activations. The discriminator is trained using the Adam optimizer with learning rate 0.01.
+
+# A.3.1 TEXT DATA
+
+We employ a single-layer bidirectional LSTM to encode the 300-dimensional GloVe text embedding input as a 128-dimensional latent representation. The model is trained for 100 epochs using the Adam optimizer with learning rate 0.01 and batch size 100. Figure 4(a,b) and Figure 4(c,d) illustrate the augmentation policies for the SST2 and TREC6 datasets, respectively.
+
+# A.3.2 TABULAR DATA
+
+For all tabular datasets, we split $20 \%$ of the dataset as the test set unless the test set is explicitly provided in the repository. The tabular data are first standardized and trained with a 2-layer MLP model with 128 hidden units in each hidden layer. We use the Adam optimizer with learning rate 0.01 and batch size 32 to train the model for 30 epochs. In some cases when the dataset size is too small, we use a batch size of 16 instead. Figure 4(e,f) and Figure $^ { 4 ( \mathrm { g , h } ) }$ show the augmentation policies for the IRIS and Breast Cancer datasets, respectively.
+
+# A.3.3 TIME-SERIES DATA
+
+For the HAR and Malware datasets, the time series are split into subsequences using a sliding window of size 256 with $50 \%$ overlap. In the Malware dataset, we remove consecutive duplicated API calls. We use a single-layer LSTM model to encode the time-series input as a 128-dimensional latent representation. For the Malware dataset, we exploit an additional embedding layer to map the discrete API call events into a 32-dimensional input embedding. The LSTM models are trained using the Adam optimizer with learning rate 0.01 and batch size 128 for 50 epochs. The augmentation policies for the HAR and Malware datasets are presented in Figure $4 ( \mathrm { i , j } )$ and Figure 4(k,l), respectively.
+
+# A.3.4 IMAGE DATA
+
+We use Wide-ResNet-40-2 as the feature extractor for the CIFAR-10 and SVHN datasets. The models are trained using the SGD optimizer with batch size 100 for 200 epochs. We use a weight decay of $1 0 ^ { - 4 }$ , learning rate of 0.01, and a cosine learning decay with one annealing cycle. Figure ${ 4 } ( \mathrm { m } , \mathrm { n } )$ and Figure 4(o,p) show the augmentation policies for the CIFAR-10 and SVHN datasets, respectively.
+
+![](images/4cb32d3cb2d8b5c9e81747866ae709a987fcb1e87c9093edd9aea1ba9c14502c.jpg)
+
+![](images/8c7340326cb62d020ee23ddb6e4599cfe4dc50b04bb32cde817fe136ad5d40e1.jpg)  
+Figure 4: Visualization of the scaling factor and probability of the searched augmentation policies on the SST2 (a,b), TREC6 (c,d), Iris (e,f), B. Cancer (g,h), HAR (i,j), Malware (k,l), CIFAR-10 $\scriptstyle { \mathrm { ( m , n ) } }$ , and SVHN (o,p) datasets

parse/train/Z7IViZ6Ir1k/Z7IViZ6Ir1k.md

@@ -0,0 +1,355 @@
+# Post-processing for Individual Fairness
+
+Felix Petersen ∗ University of Konstanz felix.petersen@uni.kn
+
+Debarghya Mukherjee ∗ University of Michigan mdeb@umich.edu
+
+Yuekai Sun University of Michigan yuekai@umich.edu
+
+Mikhail Yurochkin IBM Research, MIT-IBM Watson AI Lab mikhail.yurochkin@ibm.com
+
+# Abstract
+
+Post-processing in algorithmic fairness is a versatile approach for correcting bias in ML systems that are already used in production. The main appeal of postprocessing is that it avoids expensive retraining. In this work, we propose general post-processing algorithms for individual fairness (IF). We consider a setting where the learner only has access to the predictions of the original model and a similarity graph between individuals guiding the desired fairness constraints. We cast the IF post-processing problem as a graph smoothing problem corresponding to graph Laplacian regularization that preserves the desired “treat similar individuals similarly” interpretation. Our theoretical results demonstrate the connection of the new objective function to a local relaxation of the original individual fairness. Empirically, our post-processing algorithms correct individual biases in large-scale NLP models such as BERT, while preserving accuracy.
+
+# 1 Introduction
+
+There are many instances of algorithmic bias in machine learning (ML) models [1]–[4], which has led to the development of methods for quantifying and correcting algorithmic bias. To quantify algorithmic bias, researchers have proposed numerous mathematical definitions of algorithmic fairness. Broadly speaking, these definitions fall into two categories: group fairness [5] and individual fairness [6]. The former formalizes the idea that ML system should treat certain groups of individuals similarly, e.g., requiring the average loan approval rate for applicants of different ethnicities be similar [7]. The latter asks for similar treatment of similar individuals, e.g., same outcome for applicants with resumes that differ only in names [8]. Researchers have also developed many ways of correcting algorithmic bias. These fairness interventions broadly fall into three categories: pre-processing the data, enforcing fairness during model training (also known as in-processing), and post-processing the outputs of a model.
+
+While both group and individual fairness (IF) definitions have their benefits and drawbacks [5], [6], [9], the existing suite of algorithmic fairness solutions mostly enforces group fairness. The few prior works on individual fairness are all in-processing methods [10]–[13]. Although in-processing is arguably the most-effective type of intervention, it has many practical limitations. For example, it requires training models from scratch. Nowadays, it is more common to fine-tune publicly available models (e.g., language models such as BERT [14] and GPT-3 [15]) than to train models afresh, as many practitioners do not have the necessary computational resources. Even with enough computational resources, training large deep learning models has a significant environmental impact [4], [16].
+
+Post-processing offers an easier path towards incorporating algorithmic fairness into deployed ML models, and has potential to reduce environmental harm from re-training with in-processing fairness techniques.
+
+In this paper, we propose a computationally efficient method for post-processing off-the-shelf models to be individually fair. We consider a setting where we are given the outputs of a (possibly unfair) ML model on a set of $n$ individuals, and side information about their similarity for the ML task at hand, which can either be obtained using a fair metric on the input space or from external (e.g., human) annotations. Our starting point is a post-processing version of the algorithm by Dwork et al. [6] (see (2.3)). Unfortunately, this method has two drawbacks: poor scalability and an unfavorable trade-off with accuracy. As we shall see, the sharp trade-off is due to the restrictions imposed on dissimilar individuals by Dwork et al. [6]’s global Lipschitz continuity condition. By relaxing these restrictions on dissimilar individuals, we obtain a better trade-off between accuracy and fairness, while preserving the intuition of treating similar individuals similarly. This leads us to consider a graph signal-processing approach to IF post-processing that only enforces similar outputs between similar individuals. The nodes in the underlying graph correspond to individuals, edges (possibly weighted) indicate similarity, and the signal on the graph is the output of the model on the corresponding node-individuals. To enforce IF, we use Laplacian regularization [17], which encourages the signal to
+
+be smooth on the graph. We illustrate this idea in Figure 1: a biased model decides whom to show a job ad for a Python programming job based on their CVs and chooses Charlie and Dave but excludes Alice. However, from the qualifications, we can see that Alice, Charlie and Dave are similar because they all have experience in Python, which is the job requirement, and thus should be treated similarly. We represent all five candidates as nodes in a graph, where the node signal (checkmark or cross) is the model’s decision for the corresponding candidate, and the edge weights are indicated by the thickness of the connecting line. Alice and Charlie have the same qualifications and are therefore connected with a large edge-weight. For the predictions to satisfy IF, the graph needs to be smooth, i.e., the similar / connected candidates should have similar node
+
+![](images/f23f92c1b7b23609fd732c54d7541ee19aa81b25fe90a8adab304cc5cb266631.jpg)  
+Figure 1: IF on a graph.
+
+signals, which can be accomplished by also offering the job to Alice. In contrast, directly enforcing IF constraints [6] requires a certain degree of output similarity on all pairs of candidates, and not just on those which are connected and thus similar. Our main contributions are summarized below.
+
+1. We cast post-processing for individual fairness as a graph smoothing problem and propose a coordinate descent algorithm to scale the approach to large data sets.   
+2. We demonstrate theoretically and verify empirically that graph smoothing enforces individual fairness constraints locally, i.e., it guarantees similar treatment of similar individuals.   
+3. We empirically compare the Laplacian smoothing method to the post-processing adaptation of the algorithm by Dwork et al. [6] enforcing global Lipschitz continuity. The Laplacian smoothing method is not only computationally more efficient but is also more effective in reducing algorithmic bias while preserving accuracy of the original model.   
+4. We demonstrate the efficacy of Laplacian smoothing on two large-scale text data sets by reducing biases in fine-tuned BERT models.
+
+# 2 Post-processing Problem Formulation
+
+Let $\mathcal { X }$ be the feature space, $\mathcal { V }$ be the set of possible labels/targets, and $h : \mathcal { X }  \mathcal { Y }$ be a (possibly unfair) ML model trained for the task. Our goal is to post-process the outputs of $h$ so that they are individually fair. Formally, the post-processor is provided with a set of inputs $\{ x _ { i } \} _ { i = 1 } ^ { n }$ and the outputs of $h$ on the inputs $\{ \widehat { y } _ { i } \triangleq h ( x _ { i } ) \} _ { i = 1 } ^ { n }$ , and its goal is to produce $\{ \widehat { f } _ { i } \} _ { i = 1 } ^ { n }$ that is both individually fair and similar to the $\widehat { y } _ { i }$ b ’s. Recall that individual fairness of $h$ is the Lipschitz continuity of $h$ with respect
+
+to a fair metric $d _ { \mathcal { X } }$ on the input space:
+
+$$
+d y ( h ( x ) , h ( x ^ { \prime } ) ) \leq L d _ { \mathcal { X } } ( x , x ^ { \prime } ) \mathrm { ~ f o r ~ a l l ~ } x , x ^ { \prime } \in \mathcal { X } ,
+$$
+
+where $L > 0$ is a Lipschitz constant. The fair metric encodes problem-specific intuition of which samples should be treated similarly by the ML model. It is analogous to the knowledge of protected attributes in group fairness needed to define corresponding fairness constraints. Recent literature proposes several practical methods for learning fair metric from data [18], [19]. We assume the postprocessor is either given access to the fair metric (it can evaluate the fair distance on any pair of points in $\mathcal { X }$ ), or receives feedback on which inputs should be treated similarly. We encode this information in an adjacency matrix $W \in \mathbb { R } ^ { n \times n }$ of a graph with individuals as nodes. If the post-processor is given the fair metric, then the entries of $W$ are
+
+$$
+W _ { i j } = { \left\{ \begin{array} { l l } { \exp ( - \theta d _ { \mathcal { X } } ( x _ { i } , x _ { j } ) ^ { 2 } ) } & { d _ { \mathcal { X } } ( x _ { i } , x _ { j } ) \leq \tau } \\ { 0 } & { { \mathrm { o t h e r w i s e } } , } \end{array} \right. }
+$$
+
+where $\theta > 0$ is a scale parameter and $\tau > 0$ is a threshold parameter. If the post-processor is given an annotator’s feedback, then $W$ is a binary matrix with $W _ { i j } = 1$ if $i$ and $j$ are considered to be treated similarly by the annotator and 0 otherwise. Extensions to multiple annotators are straightforward.
+
+We start with a simple post-processing adaptation of the algorithm by Dwork et al. [6] for enforcing individual fairness, that projects the (possibly unfair) outputs of $h$ onto a constraint set to enforce (2.1). In other words, the post-processor seeks the closest set of outputs to the $\widehat { y } _ { i }$ ’s that satisfies individual fairness:
+
+$$
+\begin{array} { r } { \{ \widehat { f } _ { i } \} _ { i = 1 } ^ { n } \in \left\{ \begin{array} { l l } { \arg \operatorname* { m i n } _ { f _ { 1 } , \ldots , f _ { n } } } & { \sum _ { i = 1 } ^ { n } \frac { 1 } { 2 } d y ( f _ { i } , \widehat { y } _ { i } ) ^ { 2 } } \\ { \mathrm { s u b j e c t ~ t o } } & { d y ( f _ { i } , f _ { j } ) \leq L d _ { \mathcal { X } } ( x _ { i } , x _ { j } ) } \end{array} \right\} . } \end{array}
+$$
+
+This objective function, though convex, scales poorly due to the order of $n ^ { 2 }$ constraints. Empirically, we observe that (2.3) leads to post-processed outputs that are dissimilar to the $\widehat { y } _ { i }$ ’s, leading to poor performance in practice. The goal of our method is to improve performance and scalability, while preserving the IF desiderata of treating similar individual similarly. Before presenting our method, we discuss other post-processing perspectives that differ in their applicability and input requirements.
+
+# 2.1 Alternative Post-processing Formulations
+
+We review three post-processing problem setups and the corresponding methods in the literature. First, one can fine-tune a model via an in-processing algorithm to reduce algorithmic biases. Yurochkin et al. [12] proposed an in-processing algorithm for IF and used it to train fair models for text classification using sentence BERT embeddings. This setting is the most demanding in terms of input and computational requirements: a user needs access to the original model parameters, fair metric function, and train a predictor, e.g., a moderately deep fully connected neural network, with a non-trivial fairness-promoting objective function.
+
+Second, it is possible to post-process by training additional models to correct the initial model’s behavior. For example, Kim et al. [20] propose a boosting-based method for group fairness postprocessing. This perspective can be adapted to individual fairness; however, it implicitly assumes that we can train weak-learners to boost. Lohia et al. [21], [22] propose to train a bias detector to post-process for group fairness and a special, group based, notion of individual fairness. Such methods are challenging to apply to text data or other non-tabular data types.
+
+The third perspective is the most generic: a user has access to original model outputs only, and a minimal additional feedback guiding fairness constraints. Wei et al. [23] consider such setting and propose a method to satisfy group fairness constraints; however, it is not applicable to individual fairness. Our problem formulation belongs to this post-processing setup. The main benefit of this approach is its broad applicability and ease of deployment.
+
+# 3 Graph Laplacian Individual Fairness
+
+To formulate our method, we cast IF post-processing as a graph smoothing problem. Using the fair metric or human annotations as discussed in Section 2, we obtain an $n \times n$ matrix $W$ that we treat as an adjacency matrix. As elaborated earlier, the goal of post-processing is to obtain a model $f$ that is individually fair and accurate. The accuracy is achieved by minimizing the distance between the outputs of $f$ and $h$ , a pre-trained model assumed to be accurate but possibly biased. Recall that we do not have access to the parameters of $h$ , but can evaluate its predictions. Our method enforces fairness using a graph Laplacian quadratic form [24] regularizer:
+
+$$
+\widehat { \mathbf { f } } = \arg \operatorname* { m i n } _ { \mathbf { f } } { g _ { \lambda } ( \mathbf { f } ) } = \arg \operatorname* { m i n } _ { \mathbf { f } } \ \| \mathbf { f } - \hat { \mathbf { y } } \| _ { 2 } ^ { 2 } + \lambda \mathbf { f } ^ { \top } \mathbb { L } _ { n } \mathbf { f } ,
+$$
+
+where $\hat { \mathbf { y } }$ is the output of the model $h$ , and $\widehat { \mathbf { f } }$ is the vector of the post-processed outputs, i.e., ${ \widehat { f } } _ { i } = f ( x _ { i } )$ for $i = 1 , \ldots , n$ . The matrix $\mathbb { L } _ { n } \in \mathbb { R } ^ { n \times n }$ is called graph Laplacian matrix and is a function of $W$ . There are multiple versions of $\mathbb { L } _ { n }$ popularized in the graph literature (see, e.g., [25] or [26]). To elucidwhere t, ual f for s, consider the unnormalized Laplaciais the degree matrix corresponding to $\mathbb { L } _ { u n , n } = D - W$ , $\begin{array} { r } { D _ { i i } = \sum _ { j = 1 } ^ { n } W _ { i j } } \end{array}$ $D _ { i j } = 0$ $i \neq j$ $W$ identity is:
+
+$$
+\begin{array} { r } { \mathbf { f } ^ { \top } \mathbb { L } _ { u n , n } \mathbf { f } = \frac { 1 } { 2 } \sum _ { i \neq j } W _ { i j } \left( f _ { i } - f _ { j } \right) ^ { 2 } . } \end{array}
+$$
+
+Hence, the Laplacian regularizer is small if the post-processed model outputs $\widehat { f } _ { i }$ and ${ \widehat { f } } _ { j }$ (i.e., treatment) are similar for large $W _ { i j }$ (i.e., for similar individuals $i$ and $j$ ). This promotes the philosophy of individual fairness: “treat similar individuals similarly”. This observation intuitively explains the motivation for minimizing the graph Laplacian quadratic form to achieve IF. In Section 4, we present a more formal discussion on the connections between the graph Laplacian regularization and IF.
+
+Our post-processing problem (3.1) is easy to solve: setting the gradient of $g _ { \lambda }$ to 0 implies that the optimal solution $\widehat { \mathbf { f } }$ is:
+
+$$
+\widehat { \mathbf { f } } = \left( I + \lambda \left( \frac { \mathbb { L } _ { n } + \mathbb { L } _ { n } ^ { \top } } { 2 } \right) \right) ^ { - 1 } \widehat { \mathbf { y } } .
+$$
+
+The Laplacian $\mathbb { L } _ { n }$ is a positive semi-definite matrix ensuring that (3.1) is strongly convex and that (3.3) is a global minimum. In comparison to the computationally expensive constraint optimization problem (2.3), this approach has a simple closed-form expression.
+
+Note that the symmetry of the unnormalized Laplacian $\mathbb { L } _ { u n , n }$ simplifies (3.3); however, there are also non-symmetric Laplacian variations. In this work, we also consider the normalized random walk Laplacian $\mathbb { L } _ { n r w , n } = ( I - \widetilde { D } ^ { - 1 } \widetilde { W } )$ , where $\widetilde { W } = D ^ { - 1 / 2 } W D ^ { - 1 / 2 }$ is the normalized adjacency matrix and De is its degree matrix. We discuss its properties in the context of IF in Section 4. Henceforth, we refer to our method as Graph Laplacian Individual Fairness (GLIF) when using the unnormalized Laplacian, and GLIF-NRW when using Normalized Random Walk Laplacian.
+
+# 3.1 Prior Work on Graph Laplacians
+
+Graph-based learning via a similarity matrix is prevalent in statistics and ML literature, specifically, in semi-supervised learning. The core idea is to gather information from similar unlabeled inputs to improve prediction accuracy (e.g., see [27], [28], [29] and references therein). Laplacian regularization is widely used in science engineering. We refer to Chapelle [17] for a survey.
+
+We note that [30], [31] also use graph Laplacian regularizers to enforce individual fairness. Our work builds on their work by elucidating the key role played by the graph Laplacian in enforcing individual fairness. In particular, we clarify the connection between the choice of the graph Laplacian and the exact notion of individual fairness the corresponding graph Laplacian regularizer enforces.
+
+# 3.2 Extensions of the Basic Method
+
+In this subsection, we present four extensions of our method: multi-dimensional outputs, coordinate descent for large-scale data, an inductive setting, and alternative output space discrepancy measures.
+
+# 3.2.1 Multi-dimensional Output
+
+We presented our objective function (3.1) and post-processing procedure (3.3) for the case of univariate outputs. This covers regression and binary classification. Our method readily extends to multi-dimensional output space, for example, in classification, $f _ { i } , \widehat { y } _ { i } \in \mathbb { R } ^ { K }$ can represent logits, i.e.,
+
+softmax inputs, of the $K$ classes. In this case, f and $\hat { \mathbf { y } }$ are $n \times K$ matrices, and the term f $\mathbf { : } ^ { \top } \mathbb { L } _ { n } \mathbf { f }$ is a $K \times K$ matrix. We use the trace of it as a regularizer. The optimization problem (3.1) then becomes:
+
+$$
+\widehat { \mathbf { f } } = \arg \operatorname* { m i n } _ { f } g _ { \lambda } ( \mathbf { f } ) = \arg \operatorname* { m i n } _ { f } \| \mathbf { f } - \widehat { \mathbf { y } } \| _ { F } ^ { 2 } + \lambda \operatorname { t r } \left( \mathbf { f } ^ { \top } \mathbb { L } _ { n } \mathbf { f } \right) ,
+$$
+
+where $\| \cdot \| _ { F }$ is the Frobenius norm. Similar to the univariate output case, this yields:
+
+$$
+\widehat { \mathbf { f } } = \left( I + \lambda \left( \frac { \mathbb { L } _ { n } + \mathbb { L } _ { n } ^ { \top } } { 2 } \right) \right) ^ { - 1 } \widehat { \mathbf { y } } .
+$$
+
+The solution is the same as (3.3); however, now it accounts for multi-dimensional outputs.
+
+# 3.2.2 Coordinate Descent for Large-Scale Data
+
+Although our method has a closed form solution, it is not immediately scalable, as we have to invert a $n \times n$ matrix to obtain the optimal solution. We propose a coordinate descent variant of our method that readily scales to any data size. The idea stems primarily from the gradient of equation (3.4), where we solve:
+
+$$
+\mathbf { f } - \widehat { \mathbf { y } } + \lambda \frac { \mathbb { L } _ { n } + \mathbb { L } _ { n } ^ { \top } } { 2 } \mathbf { f } = 0 .
+$$
+
+Fixing $\{ f _ { j } \} _ { j \neq i }$ , we can solve (3.6) for $f _ { i }$
+
+$$
+f _ { i } \gets \frac { \hat { y } _ { i } - \frac { \lambda } { 2 } \sum _ { j \neq i } ( \mathbb { L } _ { n , i j } + \mathbb { L } _ { n , j i } ) f _ { j } } { 1 + \lambda \mathbb { L } _ { n , i i } } .
+$$
+
+This gives rise to the coordinate descent algorithm. We perform asynchronous updates over randomly selected coordinate batches until convergence. We refer the reader to Wright [32] and the references therein for the convergence properties of (asynchronous) coordinate descent.
+
+# 3.2.3 Extension to the Inductive Setting
+
+This coordinate descent update is key to extending our approach to the inductive setting. To handle new unseen points, we assume we have a set of test points on which we have already post-processed the outputs of the ML model. To post-process new unseen points, we simply fix the outputs of the other test points and perform a single coordinate descent step with respect to the output of the new point. Similar strategies are often employed to extend transductive graph-based algorithms to the inductive setting [17].
+
+# 3.2.4 Alternative Discrepancy Measures on the Output Space
+
+So far, we have considered the squared Euclidean distance as a measure of discrepancy between outputs. This is a natural choice for post-processing models with continuous-valued outputs. For models that output a probability distribution over the possible classes, we consider alternative discrepancy measures on the output space. It is possible to replace the squared Euclidean distance with a Bregman divergence with very little change to the algorithm in the case of the unnormalized Laplacian. Below, we work through the details for the KL divergence as a demonstration of the idea. A result for the general Bregman divergence can be found in Appendix B.3 (see Theorem B.4).
+
+Suppose the output of the pre-trained model $h$ is $\hat { y } _ { i } \in \Delta ^ { K }$ , where $\begin{array} { r } { \hat { y } _ { i } = \{ e ^ { o _ { i , j } } / \sum _ { k = 1 } ^ { K } e ^ { o _ { i , k } } \} _ { j = 1 } ^ { K } } \end{array}$ a $K$ - dimensional probability vector corresponding to a $K$ class classification problem $\left. { o _ { i , j } } \right\}$ is the output of tand del and is the p $\hat { y } _ { i }$ is obtained by passbability simplex in it thr. Let h softmax) denote the $\Delta ^ { K } = \{ x \in \mathbb { R } ^ { K } : x _ { i } \geq 0 , \sum _ { i = 1 } ^ { K } x _ { i } = 1 \}$ $\mathbb { R } ^ { K }$ $P _ { v }$ multinomial distribution with success probabilities $v$ for any $v \in \Delta ^ { k }$ . Define $\hat { \eta } _ { i } \in \mathbb { R } ^ { K - 1 }$ (resp. $\eta _ { i }$ ) as the natural parameter corresponding to $\hat { y } _ { i }$ (resp. $f _ { i }$ ), i.e., $\hat { \eta } _ { i , j } = \log \left( \hat { y } _ { i , j } / \hat { y } _ { i , K } \right) = o _ { i , j } - o _ { i , K }$ for $1 \leq j \leq K - 1$ . The (unnormalized) Laplacian smoothing problem with the KL divergence is
+
+$$
+\left( \widetilde { y } _ { 1 } , \dots , \widetilde { y } _ { n } \right) = \arg \operatorname* { m i n } _ { y _ { 1 } , \dots , y _ { n } \in \Delta ^ { K } } \left[ \sum _ { i } \left\{ \mathsf { K L } \left( P _ { y _ { i } } | | P _ { \widetilde { y } _ { i } } \right) + \frac { \lambda } { 2 } \sum _ { j = 1 , j \neq i } ^ { n } W _ { i j } \mathsf { K L } \left( P _ { y _ { i } } | | P _ { y _ { j } } \right) \right\} \right] .
+$$
+
+A coordinate descent approach for solving the above equation is:
+
+$$
+\begin{array} { r } { \tilde { y } _ { i } = \arg \operatorname* { m i n } _ { y \in \Delta ^ { k } } \left\{ \mathsf { K L } \left( P _ { y } | | P _ { \hat { y } _ { i } } \right) + \frac { \lambda } { 2 } \sum _ { j = 1 , j \neq i } ^ { n } W _ { i j } \mathsf { K L } \left( P _ { y } | | P _ { \tilde { y } _ { j } } \right) \right\} . } \end{array}
+$$
+
+The following theorem establishes that (3.5) solves the above problem in the logit space, or equivalently in the space of the corresponding natural parameters (see Appendix $\mathbf { B }$ for the proof):
+
+Theorem 3.1. Consider the following optimization problem on the space of natural parameters:
+
+$$
+\begin{array} { r } { \widetilde { \eta } _ { i } = \arg \operatorname* { m i n } _ { \eta } \left[ \| \eta - \widehat { \eta } _ { i } \| ^ { 2 } + \frac { \lambda } { 2 } \sum _ { j = 1 , j \neq i } ^ { n } W _ { i j } \| \eta - \widetilde { \eta } _ { j } \| ^ { 2 } \right] . } \end{array}
+$$
+
+Then, the minimizer $\tilde { \eta } _ { i }$ of equation (3.10) is the natural parameter corresponding to the minimizer $\tilde { y } _ { i }$ of (3.8).
+
+# 4 Local IF and Graph Laplacian Regularization
+
+In this section, we provide theoretical insights into why the graph Laplacian regularizer enforces individual fairness. As pointed out in Section 2, enforcing IF globally is expensive and often reduces a significant amount of accuracy of the final classifier. Here, we establish that solving (3.1) is tantamount to enforcing a localized version of individual fairness, namely Local Individual Fairness, which is defined below:
+
+Definition 4.1 (Local Individual Fairness). An ML model $h$ is said to be locally individually fair if it
+
+$$
+\mathbb { E } _ { x \sim P } \left[ \operatorname* { l i m } _ { x ^ { \prime } : d _ { \mathcal { X } } ( x , x ^ { \prime } ) \downarrow 0 } \frac { d _ { \mathcal { Y } } ( h ( x ) , h ( x ^ { \prime } ) ) } { d _ { \mathcal { X } } ( x , x ^ { \prime } ) } \right] \leq L < \infty .
+$$
+
+For practical purposes, this means that $h$ is locally individually fair with constants $\epsilon$ and $L$ if it satisfies
+
+$$
+d y ( h ( x ) , h ( x ^ { \prime } ) ) \leq L d _ { \mathcal { X } } ( x , x ^ { \prime } ) \mathrm { ~ f o r ~ a l l ~ } x , x ^ { \prime } \in \mathcal { X } \mathrm { ~ w h e r e ~ } d _ { \mathcal { X } } ( x , x ^ { \prime } ) \leq \epsilon
+$$
+
+in analogy to equation (2.1). Equation (4.2) is a relaxation of traditional IF, where we only care about the Lipschitz-constraint for all pairs of points with small fair distances, i.e., where it is less than some user-defined threshold $\epsilon$ .
+
+Example 4.2. For our theoretical analysis, we need to specify a functional form of the fair metric. A popular choice is a Mahalanobis fair metric proposed by $I I 9 J$ , which is defined as:
+
+$$
+d _ { \mathcal { X } } ^ { 2 } ( \boldsymbol { x } , \boldsymbol { x } ^ { \prime } ) = ( \boldsymbol { x } - \boldsymbol { x } ^ { \prime } ) ^ { \top } \Sigma ( \boldsymbol { x } - \boldsymbol { x } ^ { \prime } ) ,
+$$
+
+where $\Sigma$ is a dispersion matrix that puts lower weight in the directions of sensitive attributes and higher weight in the directions of relevant attributes. [19] also proposed several algorithms to learn such a fair metric from the data. If we further assume $d y ( y _ { 1 } , y _ { 2 } ) = | y _ { 1 } - y _ { 2 } |$ , then a simple application of Lagrange’s mean value theorem yields:
+
+$$
+\operatorname* { l i m } _ { x ^ { \prime } : d _ { \mathcal { X } } ( x , x ^ { \prime } ) \downarrow 0 } \frac { | h ( x ) - h ( x ^ { \prime } ) | } { d _ { \mathcal { X } } ( x , x ^ { \prime } ) } \leq \| \Sigma ^ { - 1 / 2 } \nabla h ( x ) \| .
+$$
+
+This immediately implies:
+
+$$
+\mathbb { E } _ { x \sim P } \left[ \operatorname* { l i m } _ { { x ^ { \prime } : d _ { \mathcal { X } } ( x , x ^ { \prime } ) } \downarrow 0 } \frac { d _ { \mathcal { Y } } ( h ( x ) , h ( x ^ { \prime } ) ) } { d _ { \mathcal { X } } ( x , x ^ { \prime } ) } \right] \leq \mathbb { E } [ \| { \Sigma } ^ { - 1 / 2 } \nabla h ( x ) \| ] ,
+$$
+
+i.e., h satisfies local individual fairness constraint as long as $\mathbb { E } [ | | \Sigma ^ { - 1 / 2 } \nabla h ( x ) | | ] < \infty$ . On the other hand, the global $I F$ constraint necessitates $\begin{array} { r } { \operatorname* { s u p } _ { x \in \mathcal { X } } \| \Sigma ^ { - 1 / 2 } \nabla h ( x ) \| < \infty , } \end{array}$ , i.e., h is Lipschitz continuous with respect to the Mahalanobis distance.
+
+The main advantage of this local notion of IF over its global counterpart is that the local definition concentrates on the input pairs with smaller fair distance and ignores those with larger distance. For example, in Figure 1, the edge-weights among Alice, Charlie, and Dave are much larger than among any other pairs (which have a weight of 0); therefore, our local notion enforces fairness constraint on the corresponding similar pairs, while ignoring (or being less stringent on) others. This prevents over-smoothing and consequently preserves accuracy while enforcing fairness as is evident from our real data experiments in Section 5.
+
+We now present our main theorem, which establishes that, under certain assumptions on the underlying hypothesis class and the distribution of inputs, the graph Laplacian regularizers (both unnormalized and normalized random walk) enforce the local IF constraint (as defined in Definition 4.1) in the limit. For our theory, we work with $d _ { \mathcal { X } }$ as the Mahalanobis distance introduced in Example 4.2 in equation (2.2) along with $\theta = 1 / ( 2 \sigma ^ { 2 } )$ $\sigma$ is a bandwidth parameter which goes to 0 at an appropriate rate as $n \to \infty$ ) and $\tau = \infty$ . All our results will be thorough for any finite $\tau$ but with more tedious technical analysis. Therefore, our weight matrix $W$ becomes:
+
+$$
+W _ { i j } = \frac { | \Sigma | ^ { 1 / 2 } } { ( 2 \pi ) ^ { d / 2 } \sigma ^ { d } } \mathrm { e x p } \left( - \frac { 1 } { 2 \sigma ^ { 2 } } ( x _ { i } - x _ { j } ) ^ { \top } \Sigma \left( x _ { i } - x _ { j } \right) \right) .
+$$
+
+The constant $| \Sigma | ^ { 1 / 2 } / ( ( 2 \pi ) ^ { d / 2 } \sigma ^ { d } )$ is for the normalization purpose and can be absorbed into the penalty parameter $\lambda$ . We start by listing our assumptions:
+
+Assumption 4.3 (Assumption on the domain). The domain of the inputs $\mathcal { X }$ is a compact subset of $\mathbb { R } ^ { d }$ where $d$ is the underlying dimension.
+
+Assumption 4.4 (Assumption on the hypothesis). All functions $f \in { \mathcal { F } }$ of the hypothesis class satisfy the following:
+
+1. The $i ^ { t h }$ derivative $f ^ { ( i ) }$ is uniformly bounded over the domain $\mathcal { X }$ of inputs for $i \in \{ 0 , 1 , 2 \}$ .
+
+2. $f ^ { ( 1 ) } ( x ) = 0$ for all $x \in \partial X$ , where $\partial X$ denotes the boundary of $\mathcal { X }$ .
+
+Assumption 4.5 (Assumption on the density of inputs). The density $p$ of the input random variable x on the domain $\mathcal { X }$ satisfies the following:
+
+1. There exists $p _ { \operatorname* { m a x } } < \infty$ and $p _ { \operatorname* { m i n } } > 0$ such that, for all $x \in \mathcal { X }$ , we have $p _ { \operatorname* { m i n } } \le p ( x ) \le p _ { \operatorname* { m a x } }$ .   
+2. The derivatives $\{ p ^ { ( i ) } \} _ { i = 0 , 1 , 2 }$ of the density $p$ are uniformly bounded on the domain $\mathcal { X }$ .
+
+Discussion on the assumptions Most of our assumptions (e.g., compactness of the domain, bounded derivatives of $f$ or $p$ ) are for technical simplicity and are fairly common for the asymptotic analysis of graph regularization (see, e.g., Hein et al. [25], [33] and references therein). It is possible to relax some of the assumptions: for example, if the domain $\mathcal { X }$ of inputs is unbounded, then the target function $f$ and the density $p$ should decay at certain rate so that observations far away will not be able to affect the convergence (e.g., sub-exponential tails). Part (2.) of Assumption 4.4 can be relaxed if we assume $p ( x )$ is 0 at boundary. However, we do not pursue these extensions further in this manuscript, as they are purely technical and do not add anything of significance to the main intuition of the result.
+
+Theorem 4.6. Under Assumptions 4.3 - 4.5, we have:
+
+1. If the sequence of bandwidths $\sigma \equiv \sigma _ { n } \downarrow 0$ such that $n \sigma _ { n } ^ { 2 } \to \infty$ and $\mathbb { L } _ { u n , n }$ is unnormalized Laplacian matrix, then
+
+$$
+\frac { 2 } { n ^ { 2 } \sigma ^ { 2 } } \mathbf { f } ^ { \top } \mathbb { L } _ { u n , n } \mathbf { f } \xrightarrow { P } \mathbb { E } _ { x \sim p } \left[ \nabla f ( x ) ^ { \top } \Sigma ^ { - 1 } \nabla f ( x ) p ( x ) \right] .
+$$
+
+2. If the sequence of bandwidths $\sigma \equiv \sigma _ { n } \downarrow 0$ such that $( n \sigma ^ { d + 4 } ) / ( \log { ( 1 / \sigma ) } ) \to \infty$ and $\mathbb { L } _ { n r w , n }$ is the normalized random walk Laplacian matrix, then:
+
+$$
+\frac { 1 } { n \sigma ^ { 2 } } \mathbf { f } ^ { \top } \mathbb { L } _ { n r w , n } \mathbf { f } \stackrel { P } { \longrightarrow } \mathbb { E } _ { x \sim p } \left[ \nabla f ( x ) ^ { \top } { \Sigma } ^ { - 1 } \nabla f ( x ) \right] .
+$$
+
+where $\mathbf { f } = \{ f ( x _ { i } ) \} _ { i = 1 } ^ { n }$ . Consequently, both Laplacian regularizers asymptotically enforce local IF.
+
+The proof of the above theorem can be found in Appendix B. When we use a normalized random walk graph Laplacian matrix $\mathbb { L } _ { n r w , n }$ as regularizer, the regularizer does (asymptotically) penalize $\mathbb { E } \left[ \nabla f ( x ) ^ { \top } \Sigma ^ { - 1 } \nabla f ( x ) \right] = \mathbb { E } \left[ \| \Sigma ^ { - 1 / 2 } \nabla f ( x ) \| ^ { 2 } \right]$ , which, by Example 4.2, is equivalent to enforcing the local IF constraint. Similarly, the un-normalized Laplacian matrix $\mathbb { L } _ { u n , n }$ , also enforces the same under Assumption 4.5 as:
+
+$$
+\mathbb { E } \left[ \Vert \Sigma ^ { - 1 / 2 } \nabla f ( x ) \Vert ^ { 2 } \right] \leq \frac { 1 } { p _ { \operatorname* { m i n } } } \mathbb { E } \left[ \nabla f ( x ) ^ { \top } \Sigma ^ { - 1 } \nabla f ( x ) p ( x ) \right] , \mathrm { ~ w h e r e ~ } p _ { \operatorname* { m i n } } = \operatorname* { i n f } _ { x \in \mathcal { X } } p ( x ) .
+$$
+
+Although both the Laplacian matrices enforce local IF, the primary difference between them is that the limit of the unnormalized Laplacian involves the density $p ( x )$ , i.e., it upweights the high-density region (consequently stringent imposition of fairness constraint), whereas it down-weights the underrepresented/low-density region. On the other hand, the limit corresponding to the normalized random walk Laplacian matrix does not depend on $p ( x )$ and enforces fairness constraint with equal intensity on the entire input space. We used both regularizers in our experiments, comparing and contrasting their performance on several practical ML problems.
+
+# 5 Experiments
+
+The goals of our experiments are threefold:
+
+1. Exploring the trade-offs between post-processing for local IF with GLIF and post-processing with (global) IF constraints using our adaptation of the algorithm by Dwork et al. [6] described in (2.3).   
+2. Studying practical implications of theoretical differences between GLIF and GLIF-NRW, i.e., different graph Laplacians, presented in Section 4.   
+3. Evaluating the effectiveness of GLIF in its main application, i.e., computationally light debiasing of large deep learning models such as BERT.
+
+The implementation of this work is available at github.com/Felix-Petersen/fairness-post-processing.
+
+# 5.1 Comparing GLIF and Global IF-constraints
+
+For our first experiment, we consider the sentiment prediction task [34], where our goal is to classify words as having a positive or negative sentiment. The baseline model is a neural network trained with GloVe word embeddings [35]. Following Yurochkin et al. [11], we evaluate the model on a set of names and observe that it assigns varying sentiments to names. An individually fair model should assign similar sentiment scores to all names. Further, we observe that there is a gap between average sentiments of names typical for Caucasian and African-American ethnic groups [36], which is violating group fairness. Yurochkin et al. [11] propose a fair metric learning procedure for this task using a side data set of names, and an in-processing technique for achieving individual fairness. We use their method to obtain the fair metric and compare post-processing of the baseline model with GLIF, GLIF-NRW and the global IF-constraints method. The test set comprises 663 words from the original task and 94 names. For post-processing, no problem specific knowledge is used. The resulting post-processed predictions for the original test set are used to evaluate accuracy, and the predictions on the names are used for evaluating fairness metrics. Even for this small problem, the global IF-constraints method, i.e., a CVXPY [37] implementation of (2.3), takes 7 minutes to run. Due to the poor scalability of the global IF-constraints method, we can use it only for the study of this smaller data set and can not consider it for the large language model experiments in Section 5.2. For GLIF(-NRW), we implement the closed-form solution (3.3) that takes less than a tenth of a second to run. See Appendix A for additional experimental details and a runtime analysis.
+
+We evaluate the fairness-accuracy trade-offs for a range of threshold parameters $\tau$ (for GLIF and GLIF-NRW) and for a range of Lipschitz-constants $L$ (for IF-constraints) in Figure 2. Figure 2 (left) shows the standard deviation of the post-processed outputs on all names as a function of test accuracy on the original sentiment task. Lower standard deviations imply that all names received similar predictions, which is the goal of individual fairness. Figure 2 (center) visualizes group fairness and accuracy, i.e., difference in average name sentiment scores for the two ethnic groups. In this problem, individual fairness is a stronger notion of fairness: achieving similar predictions for all names implies similar group averages, but not vice a versa. Therefore, for this task, post-processing for individual fairness also corrects group disparities.
+
+![](images/918fbdc2656ad0da27cbad9688ad1474168f32e745c722f2bcebde4c7b9eda00.jpg)  
+Figure 2: Sentiment experiment. Left: Trade-off between standard deviations of logits of names (measuring individual fairness) and accuracy. Center: Trade-off between race gap (measuring group fairness) and accuracy. Right: Frequencies of violations of the global IF constraints after applying GLIF, constraints corresponding to names, and GLIF’s global IF constraint violations for names.
+
+In both settings, GLIF and GLIF-NRW achieve substantially better fairness metrics for the same levels of test accuracy in comparison to the IF-constraints method. To understand the reason for this, we study which global IF constraints are violated after applying the GLIF method in Figure 2 (right). Corresponding to the unique pairs of words in our test set, there are $n ( n - 1 ) / 2$ unique constraints in (2.3), and the global IF-constraints method satisfies all of them by design. Each constraint (i.e., each pair of words) corresponds to a fair distance, which is small for (under the fair metric) similar words and large for dissimilar words. We bin the constraints by fair distance and present the proportion of global IF constraints violated after applying the GLIF method for each bin in the histogram in Figure 2 (right). Here, we set the Lipschitz-constant $L$ in (2.3) to $L = 2 . 2 5$ corresponding to a $8 9 . 4 \%$ accuracy of the IF-constraints method and show global IF constraint violations of GLIF corresponding to $9 5 \%$ accuracy in blue. This means that we use strong global IF constraints and use a setting of the GLIF method which maintains most of the accuracy, which would not be possible using the IF-constraints method. GLIF does not violate any constraints corresponding to small fair distances, i.e., it satisfies IF on similar individuals, while violating many large fair distance constraints. This can be seen as basically all constraint violations (blue) are at large fair distances of greater or equal 6. This demonstrates the effect of enforcing local individual fairness from our theoretical analysis in Section 4. At the same time, we display frequency of constraints that correspond to pairs of names in orange, where we can see that almost all constraints corresponding to names occur at small fair distances of smaller or equal to 6. This is expected in this task because we consider all names similar, so fair distances between them should be small. We can see that the distributions of constraint violations after applying GLIF (blue, right) and names (orange, left) are almost disjoint. We mark all global IF constraint violations after applying GLIF that correspond to names in green, and observe that there are none. Summarizing, GLIF ignores unnecessary (in the context of this problem) constraints allowing it to achieve higher accuracy, while satisfying the more relevant local IF constraints leading to improved fairness.
+
+Regarding the practical differences between GLIF and GLIF-NRW, in Figure 2 (left) GLIF has smaller standard deviations on the name outputs, but in in Figure 2 (center) GLIF-NRW achieves lower race gap. In Theorem 4.6, we showed that GLIF penalizes fairness violations in high density data regions stronger. As a result, GLIF may favor enforcing similar outputs in the high density region causing lower standard deviation, while leaving outputs nearly unchanged in the lower density region, resulting in larger race gaps. GLIF-NRW weights all data density regions equally, i.e., it is less likely to miss a small subset of names, but is less stringent in the high density regions.
+
+# 5.2 Post-processing for Debiasing Large Language Models
+
+Large language models have achieved impressive results on many tasks; however, there is also significant evidence demonstrating that they are prone to biases [4], [38], [39]. Debiasing these models remains largely an open problem: most in-processing algorithms are not applicable or computationally prohibitive due to large and highly complex model architectures, and challenges in handling text inputs. Even if an appropriate in-processing algorithm arises, significant environmental impact due to re-training is unavoidable [4], [16]. In our experiments, we evaluate effectiveness of GLIF as a simple post-processing technique to debias BERT-based models for text classification. Another possible solution is to fine-tune BERT with an in-processing technique as was done by Yurochkin et al. [12]. The two approaches are not directly comparable: fine-tuning with SenSeI [12] requires knowledge of the model parameters, alleviates only part of the computational burden, and has more stringent requirements on the fair metric, while post-processing with GLIF is transductive, i.e., it requires access to unlabeled test data (see extended discussion in Section 2.1).
+
+![](images/d8797f1f8a189470f5f4dac9da7fcb31f67a3d412338cd47d6ced12d932c6f3f.jpg)  
+Figure 3: Accuracy-Consistency trade-offs for Bios (left) and Toxicity (right).
+
+Table 1: Results for the Bios task.   
+
+<table><tr><td>Method</td><td>Test Acc.</td><td>Pred. Consist.</td></tr><tr><td>Baseline</td><td>0.846 ± 0.003</td><td>0.942 ± 0.002</td></tr><tr><td>GLIF</td><td>0.830± 0.004</td><td>0.986 ± 0.002</td></tr><tr><td>GLIF-NRW</td><td>0.834 ± 0.003</td><td>0.988 ± 0.002</td></tr><tr><td>SenSEI</td><td>0.843 ± 0.003</td><td>0.977 ± 0.001</td></tr></table>
+
+Table 2: Results for the Toxicity task.   
+
+<table><tr><td>Method</td><td>Test Acc.</td><td>Pred. Consist.</td></tr><tr><td>Baseline</td><td>0.809 ± 0.004</td><td>0.614 ± 0.013</td></tr><tr><td>GLIF</td><td>0.803 ±0.003</td><td>0.835 ± 0.012</td></tr><tr><td>GLIF-NRW</td><td>0.803 ± 0.003</td><td>0.844 ± 0.013</td></tr><tr><td>SenSEI</td><td>0.791 ± 0.005</td><td>0.773 ± 0.043</td></tr></table>
+
+We replicate the experiments of Yurochkin et al. [12] on Bios [40] and Toxicity1 data sets. They use the approach of Mukherjee et al. [19] for fair metric learning which we reproduce. We refer to the Appendix B.1 of [12] for details. In both tasks, following [12], we quantify performance with balanced accuracy due to class imbalance, and measure individual fairness via prediction consistency, i.e., the fraction of test points where the prediction remains unchanged when performing task-specific input modifications. For implementation details, see Appendix A. In Appendix A.4, we analyze the runtime and distinguish between the closed-form and coordinate descent variants of GLIF.
+
+In Bios, the goal is to predict the occupation of a person based on their textual biography. Such models can be useful for recruiting purposes. However, due to historical gender bias in some occupations, the baseline BERT model learns to associate gender pronouns and names with the corresponding occupations. Individual fairness is measured with prediction consistency with respect to gender pronouns and names alterations. A prediction is considered consistent if it is the same after swapping the gender pronouns and names. We present the fairness-accuracy trade-off in Figure 3 (left) for a range of threshold parameters $\tau$ , and compare performance based on hyperparameter values selected with a validation data in Table 1. Both GLIF and GLIF-NRW noticeably improve individual fairness measured with prediction consistency, while retaining most of the accuracy.
+
+In Toxicity, the task is to identify toxic comments—an important tool for facilitating inclusive discussions online. The baseline BERT model learns to associate certain identity words with toxicity (e.g., “gay”) because they are often abused in online conversations. The prediction consistency is measured with respect to changes to identity words in the inputs. There are 50 identity words, e.g., “gay”, “muslim”, “asian”, etc. and a prediction is considered consistent if it is the same for all 50 identities. We present the trade-off plots in Figure 3 (right) and compare performance in Table 2 (right). Our methods reduce individual biases in BERT predictions. We note that in both Toxicity and Bios experiments, we observe no practical differences between GLIF and GLIF-NRW.
+
+# 6 Summary and Discussion
+
+We studied post-processing methods for enforcing individual fairness. The methods provably enforce a local form of IF and scale readily to large data sets. We hope this broadens the appeal of IF by (i) alleviating the computational costs of operationalizing IF and (ii) allowing practitioners to use off-the-shelf models for standard ML tasks. We also note that it is possible to use our objective for in-processing.
+
+We conclude with two warnings: First, enforcing any algorithmic fairness definition does not guarantee complete fairness from the perspective of the user. The problem-specific meaning of fairness is often hard to encode exactly with a mathematical fairness definition. Second, while local individual fairness is a reasonable choice in many applications, this choice should be understood and verified by the practitioner depending on the situation.
+
+# Acknowledgments and Disclosure of Funding
+
+This note is based upon work supported by the National Science Foundation (NSF) under grants no. 1916271, 2027737, and 2113373 and supported by the German Research Foundation (DFG) under Germany’s Excellence Strategy EXC–2117–390829875. Any opinions, findings, and conclusions or recommendations expressed in this note are those of the authors and do not necessarily reflect the views of the NSF nor the DFG.
+
+# References
+
+[1] S. Barocas and A. D. Selbst, “Big data’s disparate impact,” Calif. L. Rev., vol. 104, p. 671, 2016.   
+[2] J. Larson, J. Angwin, L. Kirchner, and S. Mattu, “How we examined racial discrimination in auto insurance prices,” ProPublica, 2017.   
+[3] J. Buolamwini and T. Gebru, “Gender shades: Intersectional accuracy disparities in commercial gender classification,” in Conference on fairness, accountability and transparency, PMLR, 2018, pp. 77–91.   
+[4] E. M. Bender, T. Gebru, A. McMillan-Major, and S. Shmitchell, “On the dangers of stochastic parrots: Can language models be too big?” In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, 2021, pp. 610–623.   
+[5] A. Chouldechova and A. Roth, “A snapshot of the frontiers of fairness in machine learning,” Communications of the ACM, vol. 63, no. 5, pp. 82–89, 2020.   
+[6] C. Dwork, M. Hardt, T. Pitassi, O. Reingold, and R. Zemel, “Fairness through awareness,” in Proceedings of the 3rd innovations in theoretical computer science conference, 2012, pp. 214–226.   
+[7] D. C. Hsia, “Credit scoring and the equal credit opportunity act,” Hastings LJ, vol. 30, p. 371, 1978.   
+[8] M. Bertrand and S. Mullainathan, “Are emily and greg more employable than lakisha and jamal? a field experiment on labor market discrimination,” American Economic Review, vol. 94, no. 4, pp. 991–1013, 2004.   
+[9] W. Fleisher, “What’s fair about individual fairness?” Available at SSRN 3819799, 2021.   
+[10] C. Jung, M. Kearns, S. Neel, A. Roth, L. Stapleton, and Z. S. Wu, “An algorithmic framework for fairness elicitation,” arXiv preprint arXiv:1905.10660, 2019.   
+[11] M. Yurochkin, A. Bower, and Y. Sun, “Training individually fair ML models with sensitive subspace robustness,” in International Conference on Learning Representations (ICLR), 2020.   
+[12] M. Yurochkin and Y. Sun, “Sensei: Sensitive set invariance for enforcing individual fairness,” in International Conference on Learning Representations (ICLR), 2021.   
+[13] A. Vargo, F. Zhang, M. Yurochkin, and Y. Sun, “Individually fair gradient boosting,” in International Conference on Learning Representations (ICLR), 2021.   
+[14] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova, “BERT: Pre-training of deep bidirectional transformers for language understanding. arxiv,” in Proc. Conference of the North American Chapter of the Association for Computational Linguistics (ACL), 2018.   
+[15] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al., “Language models are few-shot learners,” arXiv preprint arXiv:2005.14165, 2020.   
+[16] E. Strubell, A. Ganesh, and A. McCallum, “Energy and policy considerations for deep learning in nlp,” in 57th Annual Meeting of the Association for Computational Linguistics, 2019.   
+[17] O. Chapelle, B. Schölkopf, and A. Zien, Eds., Semi-Supervised Learning. Cambridge, Mass: MIT Press, 2006.   
+[18] C. Ilvento, “Metric Learning for Individual Fairness,” in 1st Symposium on Foundations of Responsible Computing (FORC 2020), Leibniz International Proceedings in Informatics (LIPIcs), vol. 156, Dagstuhl, Germany: Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2020.   
+[19] D. Mukherjee, M. Yurochkin, M. Banerjee, and Y. Sun, “Two simple ways to learn individual fairness metrics from data,” in International Conference on Machine Learning (ICML), 2020.   
+[20] M. P. Kim, A. Ghorbani, and J. Zou, “Multiaccuracy: Black-box post-processing for fairness in classification,” in Proceedings of the 2019 AAAI/ACM Conference on AI, Ethics, and Society, 2019.   
+[21] P. K. Lohia, K. N. Ramamurthy, M. Bhide, D. Saha, K. R. Varshney, and R. Puri, “Bias mitigation post-processing for individual and group fairness,” in IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), 2019, pp. 2847–2851.   
+[22] P. Lohia, “Priority-based post-processing bias mitigation for individual and group fairness,” arXiv preprint arXiv:2102.00417, 2021.   
+[23] D. Wei, K. N. Ramamurthy, and F. d. P. Calmon, “Optimized score transformation for fair classification,” in International Conference on Artificial Intelligence and Statistics (AISTATS), 2020.   
+[24] D. Spielman, “Spectral graph theory,” Combinatorial scientific computing, no. 18, 2012.   
+[25] M. Hein, J.-Y. Audibert, and U. v. Luxburg, “Graph laplacians and their convergence on random neighborhood graphs.,” Journal of Machine Learning Research, vol. 8, no. 6, 2007.   
+[26] R. R. Coifman and S. Lafon, “Diffusion maps,” Applied and computational harmonic analysis, vol. 21, no. 1, 2006.   
+[27] D. Zhou and B. Schölkopf, “A regularization framework for learning from graph data,” in ICML 2004 Workshop on Statistical Relational Learning and Its Connections to Other Fields (SRL 2004), 2004, pp. 132–137.   
+[28] M. Belkin, I. Matveeva, and P. Niyogi, “Regularization and semi-supervised learning on large graphs,” in International Conference on Computational Learning Theory, Springer, 2004, pp. 624–638.   
+[29] A. J. Smola and R. Kondor, “Kernels and regularization on graphs,” in Learning theory and kernel machines, Springer, 2003.   
+[30] P. Lahoti, K. P. Gummadi, and G. Weikum, “Ifair: Learning individually fair data representations for algorithmic decision making,” in 2019 ieee 35th international conference on data engineering (icde), IEEE, 2019, pp. 1334–1345.   
+[31] J. Kang, J. He, R. Maciejewski, and H. Tong, “Inform: Individual fairness on graph mining,” in Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, 2020, pp. 379–389.   
+[32] S. J. Wright, “Coordinate descent algorithms,” Mathematical Programming, 2015.   
+[33] M. Hein, J.-Y. Audibert, and U. Von Luxburg, “From graphs to manifolds–weak and strong pointwise consistency of graph laplacians,” in International Conference on Computational Learning Theory, Springer, 2005.   
+[34] M. Hu and B. Liu, “Mining and summarizing customer reviews,” in Proceedings of the tenth ACM SIGKDD international conference on Knowledge discovery and data mining, 2004.   
+[35] J. Pennington, R. Socher, and C. D. Manning, “Glove: Global vectors for word representation,” in Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), 2014, pp. 1532–1543.   
+[36] A. Caliskan, J. J. Bryson, and A. Narayanan, “Semantics derived automatically from language corpora contain human-like biases,” Science, 2017.   
+[37] S. Diamond and S. Boyd, “Cvxpy: A python-embedded modeling language for convex optimization,” The Journal of Machine Learning Research, vol. 17, no. 1, pp. 2909–2913, 2016.   
+[38] K. Kurita, N. Vyas, A. Pareek, A. W. Black, and Y. Tsvetkov, “Measuring bias in contextualized word representations,” in First Workshop on Gender Bias in Natural Language Processing, 2019.   
+[39] M. Nadeem, A. Bethke, and S. Reddy, “Stereoset: Measuring stereotypical bias in pretrained language models,” arXiv preprint arXiv:2004.09456, 2020.   
+[40] M. De-Arteaga, A. Romanov, H. Wallach, J. Chayes, C. Borgs, A. Chouldechova, S. Geyik, K. Kenthapadi, and A. T. Kalai, “Bias in bios: A case study of semantic representation bias in a high-stakes setting,” in Proceedings of the Conference on Fairness, Accountability, and Transparency (ACM FAccT), 2019.   
+[41] L. Dixon, J. Li, J. Sorensen, N. Thain, and L. Vasserman, “Measuring and mitigating unintended bias in text classification,” in Proceedings of the 2018 AAAI/ACM Conference on AI, Ethics, and Society, 2018.   
+[42] B. Sen, A gentle introduction to empirical process theory and applications, 2018.

parse/train/Z7IViZ6Ir1k/Z7IViZ6Ir1k_content_list.json

@@ -0,0 +1,1550 @@
+[
+    {
+        "type": "text",
+        "text": "Post-processing for Individual Fairness ",
+        "text_level": 1,
+        "bbox": [
+            261,
+            122,
+            736,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Felix Petersen ∗ University of Konstanz felix.petersen@uni.kn ",
+        "bbox": [
+            266,
+            200,
+            447,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Debarghya Mukherjee ∗ University of Michigan mdeb@umich.edu ",
+        "bbox": [
+            562,
+            200,
+            727,
+            242
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yuekai Sun University of Michigan yuekai@umich.edu ",
+        "bbox": [
+            274,
+            263,
+            429,
+            305
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mikhail Yurochkin IBM Research, MIT-IBM Watson AI Lab mikhail.yurochkin@ibm.com ",
+        "bbox": [
+            504,
+            263,
+            779,
+            305
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            342,
+            535,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Post-processing in algorithmic fairness is a versatile approach for correcting bias in ML systems that are already used in production. The main appeal of postprocessing is that it avoids expensive retraining. In this work, we propose general post-processing algorithms for individual fairness (IF). We consider a setting where the learner only has access to the predictions of the original model and a similarity graph between individuals guiding the desired fairness constraints. We cast the IF post-processing problem as a graph smoothing problem corresponding to graph Laplacian regularization that preserves the desired “treat similar individuals similarly” interpretation. Our theoretical results demonstrate the connection of the new objective function to a local relaxation of the original individual fairness. Empirically, our post-processing algorithms correct individual biases in large-scale NLP models such as BERT, while preserving accuracy. ",
+        "bbox": [
+            233,
+            375,
+            766,
+            540
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            573,
+            310,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are many instances of algorithmic bias in machine learning (ML) models [1]–[4], which has led to the development of methods for quantifying and correcting algorithmic bias. To quantify algorithmic bias, researchers have proposed numerous mathematical definitions of algorithmic fairness. Broadly speaking, these definitions fall into two categories: group fairness [5] and individual fairness [6]. The former formalizes the idea that ML system should treat certain groups of individuals similarly, e.g., requiring the average loan approval rate for applicants of different ethnicities be similar [7]. The latter asks for similar treatment of similar individuals, e.g., same outcome for applicants with resumes that differ only in names [8]. Researchers have also developed many ways of correcting algorithmic bias. These fairness interventions broadly fall into three categories: pre-processing the data, enforcing fairness during model training (also known as in-processing), and post-processing the outputs of a model. ",
+        "bbox": [
+            173,
+            604,
+            825,
+            757
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While both group and individual fairness (IF) definitions have their benefits and drawbacks [5], [6], [9], the existing suite of algorithmic fairness solutions mostly enforces group fairness. The few prior works on individual fairness are all in-processing methods [10]–[13]. Although in-processing is arguably the most-effective type of intervention, it has many practical limitations. For example, it requires training models from scratch. Nowadays, it is more common to fine-tune publicly available models (e.g., language models such as BERT [14] and GPT-3 [15]) than to train models afresh, as many practitioners do not have the necessary computational resources. Even with enough computational resources, training large deep learning models has a significant environmental impact [4], [16]. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Post-processing offers an easier path towards incorporating algorithmic fairness into deployed ML models, and has potential to reduce environmental harm from re-training with in-processing fairness techniques. ",
+        "bbox": [
+            174,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a computationally efficient method for post-processing off-the-shelf models to be individually fair. We consider a setting where we are given the outputs of a (possibly unfair) ML model on a set of $n$ individuals, and side information about their similarity for the ML task at hand, which can either be obtained using a fair metric on the input space or from external (e.g., human) annotations. Our starting point is a post-processing version of the algorithm by Dwork et al. [6] (see (2.3)). Unfortunately, this method has two drawbacks: poor scalability and an unfavorable trade-off with accuracy. As we shall see, the sharp trade-off is due to the restrictions imposed on dissimilar individuals by Dwork et al. [6]’s global Lipschitz continuity condition. By relaxing these restrictions on dissimilar individuals, we obtain a better trade-off between accuracy and fairness, while preserving the intuition of treating similar individuals similarly. This leads us to consider a graph signal-processing approach to IF post-processing that only enforces similar outputs between similar individuals. The nodes in the underlying graph correspond to individuals, edges (possibly weighted) indicate similarity, and the signal on the graph is the output of the model on the corresponding node-individuals. To enforce IF, we use Laplacian regularization [17], which encourages the signal to ",
+        "bbox": [
+            173,
+            140,
+            826,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "be smooth on the graph. We illustrate this idea in Figure 1: a biased model decides whom to show a job ad for a Python programming job based on their CVs and chooses Charlie and Dave but excludes Alice. However, from the qualifications, we can see that Alice, Charlie and Dave are similar because they all have experience in Python, which is the job requirement, and thus should be treated similarly. We represent all five candidates as nodes in a graph, where the node signal (checkmark or cross) is the model’s decision for the corresponding candidate, and the edge weights are indicated by the thickness of the connecting line. Alice and Charlie have the same qualifications and are therefore connected with a large edge-weight. For the predictions to satisfy IF, the graph needs to be smooth, i.e., the similar / connected candidates should have similar node ",
+        "bbox": [
+            174,
+            333,
+            491,
+            579
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/f23f92c1b7b23609fd732c54d7541ee19aa81b25fe90a8adab304cc5cb266631.jpg",
+        "image_caption": [
+            "Figure 1: IF on a graph. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            529,
+            348,
+            820,
+            540
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "signals, which can be accomplished by also offering the job to Alice. In contrast, directly enforcing IF constraints [6] requires a certain degree of output similarity on all pairs of candidates, and not just on those which are connected and thus similar. Our main contributions are summarized below. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            622
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We cast post-processing for individual fairness as a graph smoothing problem and propose a coordinate descent algorithm to scale the approach to large data sets.   \n2. We demonstrate theoretically and verify empirically that graph smoothing enforces individual fairness constraints locally, i.e., it guarantees similar treatment of similar individuals.   \n3. We empirically compare the Laplacian smoothing method to the post-processing adaptation of the algorithm by Dwork et al. [6] enforcing global Lipschitz continuity. The Laplacian smoothing method is not only computationally more efficient but is also more effective in reducing algorithmic bias while preserving accuracy of the original model.   \n4. We demonstrate the efficacy of Laplacian smoothing on two large-scale text data sets by reducing biases in fine-tuned BERT models. ",
+        "bbox": [
+            173,
+            638,
+            826,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Post-processing Problem Formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            803,
+            521,
+            820
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { X }$ be the feature space, $\\mathcal { V }$ be the set of possible labels/targets, and $h : \\mathcal { X }  \\mathcal { Y }$ be a (possibly unfair) ML model trained for the task. Our goal is to post-process the outputs of $h$ so that they are individually fair. Formally, the post-processor is provided with a set of inputs $\\{ x _ { i } \\} _ { i = 1 } ^ { n }$ and the outputs of $h$ on the inputs $\\{ \\widehat { y } _ { i } \\triangleq h ( x _ { i } ) \\} _ { i = 1 } ^ { n }$ , and its goal is to produce $\\{ \\widehat { f } _ { i } \\} _ { i = 1 } ^ { n }$ that is both individually fair and similar to the $\\widehat { y } _ { i }$ b ’s. Recall that individual fairness of $h$ is the Lipschitz continuity of $h$ with respect ",
+        "bbox": [
+            173,
+            838,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "to a fair metric $d _ { \\mathcal { X } }$ on the input space: ",
+        "bbox": [
+            174,
+            92,
+            423,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4811805f8214c0932bc029d8f17d5db72f39e62820dbc31d74e2fc330e5fab3.jpg",
+        "text": "$$\nd y ( h ( x ) , h ( x ^ { \\prime } ) ) \\leq L d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) \\mathrm { ~ f o r ~ a l l ~ } x , x ^ { \\prime } \\in \\mathcal { X } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            333,
+            111,
+            663,
+            128
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $L > 0$ is a Lipschitz constant. The fair metric encodes problem-specific intuition of which samples should be treated similarly by the ML model. It is analogous to the knowledge of protected attributes in group fairness needed to define corresponding fairness constraints. Recent literature proposes several practical methods for learning fair metric from data [18], [19]. We assume the postprocessor is either given access to the fair metric (it can evaluate the fair distance on any pair of points in $\\mathcal { X }$ ), or receives feedback on which inputs should be treated similarly. We encode this information in an adjacency matrix $W \\in \\mathbb { R } ^ { n \\times n }$ of a graph with individuals as nodes. If the post-processor is given the fair metric, then the entries of $W$ are ",
+        "bbox": [
+            173,
+            133,
+            825,
+            246
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c9eb76df7d7fb0ce1db8cc3b55eb155865a61794ab44781ad87248725c0e4c83.jpg",
+        "text": "$$\nW _ { i j } = { \\left\\{ \\begin{array} { l l } { \\exp ( - \\theta d _ { \\mathcal { X } } ( x _ { i } , x _ { j } ) ^ { 2 } ) } & { d _ { \\mathcal { X } } ( x _ { i } , x _ { j } ) \\leq \\tau } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e } } , } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            251,
+            656,
+            286
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\theta > 0$ is a scale parameter and $\\tau > 0$ is a threshold parameter. If the post-processor is given an annotator’s feedback, then $W$ is a binary matrix with $W _ { i j } = 1$ if $i$ and $j$ are considered to be treated similarly by the annotator and 0 otherwise. Extensions to multiple annotators are straightforward. ",
+        "bbox": [
+            174,
+            292,
+            825,
+            335
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We start with a simple post-processing adaptation of the algorithm by Dwork et al. [6] for enforcing individual fairness, that projects the (possibly unfair) outputs of $h$ onto a constraint set to enforce (2.1). In other words, the post-processor seeks the closest set of outputs to the $\\widehat { y } _ { i }$ ’s that satisfies individual fairness: ",
+        "bbox": [
+            174,
+            340,
+            825,
+            396
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/37cb1b16f13da1f475472566017c32fa51357ba261c45329114db958659e71c0.jpg",
+        "text": "$$\n\\begin{array} { r } { \\{ \\widehat { f } _ { i } \\} _ { i = 1 } ^ { n } \\in \\left\\{ \\begin{array} { l l } { \\arg \\operatorname* { m i n } _ { f _ { 1 } , \\ldots , f _ { n } } } & { \\sum _ { i = 1 } ^ { n } \\frac { 1 } { 2 } d y ( f _ { i } , \\widehat { y } _ { i } ) ^ { 2 } } \\\\ { \\mathrm { s u b j e c t ~ t o } } & { d y ( f _ { i } , f _ { j } ) \\leq L d _ { \\mathcal { X } } ( x _ { i } , x _ { j } ) } \\end{array} \\right\\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            396,
+            697,
+            439
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This objective function, though convex, scales poorly due to the order of $n ^ { 2 }$ constraints. Empirically, we observe that (2.3) leads to post-processed outputs that are dissimilar to the $\\widehat { y } _ { i }$ ’s, leading to poor performance in practice. The goal of our method is to improve performance and scalability, while preserving the IF desiderata of treating similar individual similarly. Before presenting our method, we discuss other post-processing perspectives that differ in their applicability and input requirements. ",
+        "bbox": [
+            174,
+            445,
+            826,
+            516
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Alternative Post-processing Formulations ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            531,
+            501,
+            546
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We review three post-processing problem setups and the corresponding methods in the literature. First, one can fine-tune a model via an in-processing algorithm to reduce algorithmic biases. Yurochkin et al. [12] proposed an in-processing algorithm for IF and used it to train fair models for text classification using sentence BERT embeddings. This setting is the most demanding in terms of input and computational requirements: a user needs access to the original model parameters, fair metric function, and train a predictor, e.g., a moderately deep fully connected neural network, with a non-trivial fairness-promoting objective function. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            654
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Second, it is possible to post-process by training additional models to correct the initial model’s behavior. For example, Kim et al. [20] propose a boosting-based method for group fairness postprocessing. This perspective can be adapted to individual fairness; however, it implicitly assumes that we can train weak-learners to boost. Lohia et al. [21], [22] propose to train a bias detector to post-process for group fairness and a special, group based, notion of individual fairness. Such methods are challenging to apply to text data or other non-tabular data types. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            743
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The third perspective is the most generic: a user has access to original model outputs only, and a minimal additional feedback guiding fairness constraints. Wei et al. [23] consider such setting and propose a method to satisfy group fairness constraints; however, it is not applicable to individual fairness. Our problem formulation belongs to this post-processing setup. The main benefit of this approach is its broad applicability and ease of deployment. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Graph Laplacian Individual Fairness ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            838,
+            516,
+            856
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To formulate our method, we cast IF post-processing as a graph smoothing problem. Using the fair metric or human annotations as discussed in Section 2, we obtain an $n \\times n$ matrix $W$ that we treat as an adjacency matrix. As elaborated earlier, the goal of post-processing is to obtain a model $f$ that is individually fair and accurate. The accuracy is achieved by minimizing the distance between the outputs of $f$ and $h$ , a pre-trained model assumed to be accurate but possibly biased. Recall that we do not have access to the parameters of $h$ , but can evaluate its predictions. Our method enforces fairness using a graph Laplacian quadratic form [24] regularizer: ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/45ba0bd0856ffe15c83f6456d6053f2e94cd7915945e175ec3e19e4b71e1a379.jpg",
+        "text": "$$\n\\widehat { \\mathbf { f } } = \\arg \\operatorname* { m i n } _ { \\mathbf { f } } { g _ { \\lambda } ( \\mathbf { f } ) } = \\arg \\operatorname* { m i n } _ { \\mathbf { f } } \\ \\| \\mathbf { f } - \\hat { \\mathbf { y } } \\| _ { 2 } ^ { 2 } + \\lambda \\mathbf { f } ^ { \\top } \\mathbb { L } _ { n } \\mathbf { f } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            155,
+            676,
+            181
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { \\mathbf { y } }$ is the output of the model $h$ , and $\\widehat { \\mathbf { f } }$ is the vector of the post-processed outputs, i.e., ${ \\widehat { f } } _ { i } = f ( x _ { i } )$ for $i = 1 , \\ldots , n$ . The matrix $\\mathbb { L } _ { n } \\in \\mathbb { R } ^ { n \\times n }$ is called graph Laplacian matrix and is a function of $W$ . There are multiple versions of $\\mathbb { L } _ { n }$ popularized in the graph literature (see, e.g., [25] or [26]). To elucidwhere t, ual f for s, consider the unnormalized Laplaciais the degree matrix corresponding to $\\mathbb { L } _ { u n , n } = D - W$ , $\\begin{array} { r } { D _ { i i } = \\sum _ { j = 1 } ^ { n } W _ { i j } } \\end{array}$ $D _ { i j } = 0$ $i \\neq j$ $W$ identity is: ",
+        "bbox": [
+            173,
+            190,
+            826,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8cfffaa922892d5295494c0391dbbc1ad6e519175c2569ffd61bcd3f82b58bed.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { f } ^ { \\top } \\mathbb { L } _ { u n , n } \\mathbf { f } = \\frac { 1 } { 2 } \\sum _ { i \\neq j } W _ { i j } \\left( f _ { i } - f _ { j } \\right) ^ { 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            280,
+            624,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hence, the Laplacian regularizer is small if the post-processed model outputs $\\widehat { f } _ { i }$ and ${ \\widehat { f } } _ { j }$ (i.e., treatment) are similar for large $W _ { i j }$ (i.e., for similar individuals $i$ and $j$ ). This promotes the philosophy of individual fairness: “treat similar individuals similarly”. This observation intuitively explains the motivation for minimizing the graph Laplacian quadratic form to achieve IF. In Section 4, we present a more formal discussion on the connections between the graph Laplacian regularization and IF. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our post-processing problem (3.1) is easy to solve: setting the gradient of $g _ { \\lambda }$ to 0 implies that the optimal solution $\\widehat { \\mathbf { f } }$ is: ",
+        "bbox": [
+            174,
+            385,
+            820,
+            415
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf1f3c26af9044b24d9bef75a67a86584b276607bddb9a41ea94f8267d796373.jpg",
+        "text": "$$\n\\widehat { \\mathbf { f } } = \\left( I + \\lambda \\left( \\frac { \\mathbb { L } _ { n } + \\mathbb { L } _ { n } ^ { \\top } } { 2 } \\right) \\right) ^ { - 1 } \\widehat { \\mathbf { y } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            411,
+            611,
+            449
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Laplacian $\\mathbb { L } _ { n }$ is a positive semi-definite matrix ensuring that (3.1) is strongly convex and that (3.3) is a global minimum. In comparison to the computationally expensive constraint optimization problem (2.3), this approach has a simple closed-form expression. ",
+        "bbox": [
+            174,
+            454,
+            823,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the symmetry of the unnormalized Laplacian $\\mathbb { L } _ { u n , n }$ simplifies (3.3); however, there are also non-symmetric Laplacian variations. In this work, we also consider the normalized random walk Laplacian $\\mathbb { L } _ { n r w , n } = ( I - \\widetilde { D } ^ { - 1 } \\widetilde { W } )$ , where $\\widetilde { W } = D ^ { - 1 / 2 } W D ^ { - 1 / 2 }$ is the normalized adjacency matrix and De is its degree matrix. We discuss its properties in the context of IF in Section 4. Henceforth, we refer to our method as Graph Laplacian Individual Fairness (GLIF) when using the unnormalized Laplacian, and GLIF-NRW when using Normalized Random Walk Laplacian. ",
+        "bbox": [
+            173,
+            502,
+            825,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Prior Work on Graph Laplacians ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            611,
+            444,
+            626
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Graph-based learning via a similarity matrix is prevalent in statistics and ML literature, specifically, in semi-supervised learning. The core idea is to gather information from similar unlabeled inputs to improve prediction accuracy (e.g., see [27], [28], [29] and references therein). Laplacian regularization is widely used in science engineering. We refer to Chapelle [17] for a survey. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We note that [30], [31] also use graph Laplacian regularizers to enforce individual fairness. Our work builds on their work by elucidating the key role played by the graph Laplacian in enforcing individual fairness. In particular, we clarify the connection between the choice of the graph Laplacian and the exact notion of individual fairness the corresponding graph Laplacian regularizer enforces. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Extensions of the Basic Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            431,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we present four extensions of our method: multi-dimensional outputs, coordinate descent for large-scale data, an inductive setting, and alternative output space discrepancy measures. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 Multi-dimensional Output ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            844,
+            408,
+            859
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We presented our objective function (3.1) and post-processing procedure (3.3) for the case of univariate outputs. This covers regression and binary classification. Our method readily extends to multi-dimensional output space, for example, in classification, $f _ { i } , \\widehat { y } _ { i } \\in \\mathbb { R } ^ { K }$ can represent logits, i.e., ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "softmax inputs, of the $K$ classes. In this case, f and $\\hat { \\mathbf { y } }$ are $n \\times K$ matrices, and the term f $\\mathbf { : } ^ { \\top } \\mathbb { L } _ { n } \\mathbf { f }$ is a $K \\times K$ matrix. We use the trace of it as a regularizer. The optimization problem (3.1) then becomes: ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d2c3e75b1fc3ac083b1de4bcc4e16cd1836e2dbde0518597f1f42cf4be2b6f9.jpg",
+        "text": "$$\n\\widehat { \\mathbf { f } } = \\arg \\operatorname* { m i n } _ { f } g _ { \\lambda } ( \\mathbf { f } ) = \\arg \\operatorname* { m i n } _ { f } \\| \\mathbf { f } - \\widehat { \\mathbf { y } } \\| _ { F } ^ { 2 } + \\lambda \\operatorname { t r } \\left( \\mathbf { f } ^ { \\top } \\mathbb { L } _ { n } \\mathbf { f } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            123,
+            692,
+            150
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\| \\cdot \\| _ { F }$ is the Frobenius norm. Similar to the univariate output case, this yields: ",
+        "bbox": [
+            174,
+            155,
+            728,
+            170
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/676116820a88f7eec0d6242c6ce4fc54e491844342c82fdd770cf7612a29ea8a.jpg",
+        "text": "$$\n\\widehat { \\mathbf { f } } = \\left( I + \\lambda \\left( \\frac { \\mathbb { L } _ { n } + \\mathbb { L } _ { n } ^ { \\top } } { 2 } \\right) \\right) ^ { - 1 } \\widehat { \\mathbf { y } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            172,
+            611,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The solution is the same as (3.3); however, now it accounts for multi-dimensional outputs. ",
+        "bbox": [
+            173,
+            214,
+            761,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 Coordinate Descent for Large-Scale Data ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            242,
+            513,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Although our method has a closed form solution, it is not immediately scalable, as we have to invert a $n \\times n$ matrix to obtain the optimal solution. We propose a coordinate descent variant of our method that readily scales to any data size. The idea stems primarily from the gradient of equation (3.4), where we solve: ",
+        "bbox": [
+            173,
+            266,
+            825,
+            320
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/83ff825ff15b7fd79b2390905d08830423451ccf025d16ec8f9023eed1c64aeb.jpg",
+        "text": "$$\n\\mathbf { f } - \\widehat { \\mathbf { y } } + \\lambda \\frac { \\mathbb { L } _ { n } + \\mathbb { L } _ { n } ^ { \\top } } { 2 } \\mathbf { f } = 0 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            318,
+            589,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fixing $\\{ f _ { j } \\} _ { j \\neq i }$ , we can solve (3.6) for $f _ { i }$ ",
+        "bbox": [
+            176,
+            351,
+            447,
+            366
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5955c091ff740a9916da61ad64bdbb54c5e09bedc4ce986449eef6aadac0fd19.jpg",
+        "text": "$$\nf _ { i } \\gets \\frac { \\hat { y } _ { i } - \\frac { \\lambda } { 2 } \\sum _ { j \\neq i } ( \\mathbb { L } _ { n , i j } + \\mathbb { L } _ { n , j i } ) f _ { j } } { 1 + \\lambda \\mathbb { L } _ { n , i i } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            369,
+            625,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This gives rise to the coordinate descent algorithm. We perform asynchronous updates over randomly selected coordinate batches until convergence. We refer the reader to Wright [32] and the references therein for the convergence properties of (asynchronous) coordinate descent. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            453
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 Extension to the Inductive Setting ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            467,
+            460,
+            481
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This coordinate descent update is key to extending our approach to the inductive setting. To handle new unseen points, we assume we have a set of test points on which we have already post-processed the outputs of the ML model. To post-process new unseen points, we simply fix the outputs of the other test points and perform a single coordinate descent step with respect to the output of the new point. Similar strategies are often employed to extend transductive graph-based algorithms to the inductive setting [17]. ",
+        "bbox": [
+            173,
+            489,
+            826,
+            575
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.4 Alternative Discrepancy Measures on the Output Space ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            588,
+            611,
+            603
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "So far, we have considered the squared Euclidean distance as a measure of discrepancy between outputs. This is a natural choice for post-processing models with continuous-valued outputs. For models that output a probability distribution over the possible classes, we consider alternative discrepancy measures on the output space. It is possible to replace the squared Euclidean distance with a Bregman divergence with very little change to the algorithm in the case of the unnormalized Laplacian. Below, we work through the details for the KL divergence as a demonstration of the idea. A result for the general Bregman divergence can be found in Appendix B.3 (see Theorem B.4). ",
+        "bbox": [
+            173,
+            611,
+            826,
+            709
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Suppose the output of the pre-trained model $h$ is $\\hat { y } _ { i } \\in \\Delta ^ { K }$ , where $\\begin{array} { r } { \\hat { y } _ { i } = \\{ e ^ { o _ { i , j } } / \\sum _ { k = 1 } ^ { K } e ^ { o _ { i , k } } \\} _ { j = 1 } ^ { K } } \\end{array}$ a $K$ - dimensional probability vector corresponding to a $K$ class classification problem $\\left. { o _ { i , j } } \\right\\}$ is the output of tand del and is the p $\\hat { y } _ { i }$ is obtained by passbability simplex in it thr. Let h softmax) denote the $\\Delta ^ { K } = \\{ x \\in \\mathbb { R } ^ { K } : x _ { i } \\geq 0 , \\sum _ { i = 1 } ^ { K } x _ { i } = 1 \\}$ $\\mathbb { R } ^ { K }$ $P _ { v }$ multinomial distribution with success probabilities $v$ for any $v \\in \\Delta ^ { k }$ . Define $\\hat { \\eta } _ { i } \\in \\mathbb { R } ^ { K - 1 }$ (resp. $\\eta _ { i }$ ) as the natural parameter corresponding to $\\hat { y } _ { i }$ (resp. $f _ { i }$ ), i.e., $\\hat { \\eta } _ { i , j } = \\log \\left( \\hat { y } _ { i , j } / \\hat { y } _ { i , K } \\right) = o _ { i , j } - o _ { i , K }$ for $1 \\leq j \\leq K - 1$ . The (unnormalized) Laplacian smoothing problem with the KL divergence is ",
+        "bbox": [
+            173,
+            715,
+            826,
+            821
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9dd0506a9937275452912317c54ac78019bd3935d9985875cde83d895333bedc.jpg",
+        "text": "$$\n\\left( \\widetilde { y } _ { 1 } , \\dots , \\widetilde { y } _ { n } \\right) = \\arg \\operatorname* { m i n } _ { y _ { 1 } , \\dots , y _ { n } \\in \\Delta ^ { K } } \\left[ \\sum _ { i } \\left\\{ \\mathsf { K L } \\left( P _ { y _ { i } } | | P _ { \\widetilde { y } _ { i } } \\right) + \\frac { \\lambda } { 2 } \\sum _ { j = 1 , j \\neq i } ^ { n } W _ { i j } \\mathsf { K L } \\left( P _ { y _ { i } } | | P _ { y _ { j } } \\right) \\right\\} \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            179,
+            824,
+            785,
+            868
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A coordinate descent approach for solving the above equation is: ",
+        "bbox": [
+            174,
+            871,
+            599,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f18aa002a91c448315e3a6e6dcf6582a3e3d0be7968e1e7e69415ec500fc988d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\tilde { y } _ { i } = \\arg \\operatorname* { m i n } _ { y \\in \\Delta ^ { k } } \\left\\{ \\mathsf { K L } \\left( P _ { y } | | P _ { \\hat { y } _ { i } } \\right) + \\frac { \\lambda } { 2 } \\sum _ { j = 1 , j \\neq i } ^ { n } W _ { i j } \\mathsf { K L } \\left( P _ { y } | | P _ { \\tilde { y } _ { j } } \\right) \\right\\} . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            888,
+            730,
+            916
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The following theorem establishes that (3.5) solves the above problem in the logit space, or equivalently in the space of the corresponding natural parameters (see Appendix $\\mathbf { B }$ for the proof): ",
+        "bbox": [
+            173,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3.1. Consider the following optimization problem on the space of natural parameters: ",
+        "bbox": [
+            171,
+            123,
+            803,
+            138
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ec3fd3b5e15cbbf2a02400539ce77d86a3b1eb29be2aebb244a78e27332fc30b.jpg",
+        "text": "$$\n\\begin{array} { r } { \\widetilde { \\eta } _ { i } = \\arg \\operatorname* { m i n } _ { \\eta } \\left[ \\| \\eta - \\widehat { \\eta } _ { i } \\| ^ { 2 } + \\frac { \\lambda } { 2 } \\sum _ { j = 1 , j \\neq i } ^ { n } W _ { i j } \\| \\eta - \\widetilde { \\eta } _ { j } \\| ^ { 2 } \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            143,
+            692,
+            171
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Then, the minimizer $\\tilde { \\eta } _ { i }$ of equation (3.10) is the natural parameter corresponding to the minimizer $\\tilde { y } _ { i }$ of (3.8). ",
+        "bbox": [
+            171,
+            176,
+            823,
+            205
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Local IF and Graph Laplacian Regularization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            223,
+            591,
+            242
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide theoretical insights into why the graph Laplacian regularizer enforces individual fairness. As pointed out in Section 2, enforcing IF globally is expensive and often reduces a significant amount of accuracy of the final classifier. Here, we establish that solving (3.1) is tantamount to enforcing a localized version of individual fairness, namely Local Individual Fairness, which is defined below: ",
+        "bbox": [
+            173,
+            253,
+            825,
+            324
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Definition 4.1 (Local Individual Fairness). An ML model $h$ is said to be locally individually fair if it ",
+        "bbox": [
+            169,
+            328,
+            826,
+            348
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/41742888f38d5111cad39e02d426cf79090d47d4475a5d7f98c808b5a5b54c19.jpg",
+        "text": "$$\n\\mathbb { E } _ { x \\sim P } \\left[ \\operatorname* { l i m } _ { x ^ { \\prime } : d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) \\downarrow 0 } \\frac { d _ { \\mathcal { Y } } ( h ( x ) , h ( x ^ { \\prime } ) ) } { d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) } \\right] \\leq L < \\infty .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            348,
+            666,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For practical purposes, this means that $h$ is locally individually fair with constants $\\epsilon$ and $L$ if it satisfies ",
+        "bbox": [
+            169,
+            398,
+            825,
+            425
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dd63b0be464b4931f26357ade74c6c476be9d179a457b30a464228c65a3df717.jpg",
+        "text": "$$\nd y ( h ( x ) , h ( x ^ { \\prime } ) ) \\leq L d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) \\mathrm { ~ f o r ~ a l l ~ } x , x ^ { \\prime } \\in \\mathcal { X } \\mathrm { ~ w h e r e ~ } d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) \\leq \\epsilon\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            424,
+            730,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "in analogy to equation (2.1). Equation (4.2) is a relaxation of traditional IF, where we only care about the Lipschitz-constraint for all pairs of points with small fair distances, i.e., where it is less than some user-defined threshold $\\epsilon$ . ",
+        "bbox": [
+            174,
+            445,
+            825,
+            487
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Example 4.2. For our theoretical analysis, we need to specify a functional form of the fair metric. A popular choice is a Mahalanobis fair metric proposed by $I I 9 J$ , which is defined as: ",
+        "bbox": [
+            173,
+            491,
+            823,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0861429dcc4b63fc5165914d35c3d59d296c32b06ccdb232e46b3d7b81ebe133.jpg",
+        "text": "$$\nd _ { \\mathcal { X } } ^ { 2 } ( \\boldsymbol { x } , \\boldsymbol { x } ^ { \\prime } ) = ( \\boldsymbol { x } - \\boldsymbol { x } ^ { \\prime } ) ^ { \\top } \\Sigma ( \\boldsymbol { x } - \\boldsymbol { x } ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            525,
+            612,
+            545
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\Sigma$ is a dispersion matrix that puts lower weight in the directions of sensitive attributes and higher weight in the directions of relevant attributes. [19] also proposed several algorithms to learn such a fair metric from the data. If we further assume $d y ( y _ { 1 } , y _ { 2 } ) = | y _ { 1 } - y _ { 2 } |$ , then a simple application of Lagrange’s mean value theorem yields: ",
+        "bbox": [
+            173,
+            550,
+            825,
+            607
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b0c5559893ff3d76f6eafe4f4b6c6bc3fe268870e454e6dacaeae9980ed1f22.jpg",
+        "text": "$$\n\\operatorname* { l i m } _ { x ^ { \\prime } : d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) \\downarrow 0 } \\frac { | h ( x ) - h ( x ^ { \\prime } ) | } { d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) } \\leq \\| \\Sigma ^ { - 1 / 2 } \\nabla h ( x ) \\| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            612,
+            656,
+            647
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This immediately implies: ",
+        "bbox": [
+            173,
+            655,
+            343,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5ce2efb5402acfdd60734388c8ecc732d47faa036222a91e9d36a65191a967bf.jpg",
+        "text": "$$\n\\mathbb { E } _ { x \\sim P } \\left[ \\operatorname* { l i m } _ { { x ^ { \\prime } : d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) } \\downarrow 0 } \\frac { d _ { \\mathcal { Y } } ( h ( x ) , h ( x ^ { \\prime } ) ) } { d _ { \\mathcal { X } } ( x , x ^ { \\prime } ) } \\right] \\leq \\mathbb { E } [ \\| { \\Sigma } ^ { - 1 / 2 } \\nabla h ( x ) \\| ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            674,
+            702,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "i.e., h satisfies local individual fairness constraint as long as $\\mathbb { E } [ | | \\Sigma ^ { - 1 / 2 } \\nabla h ( x ) | | ] < \\infty$ . On the other hand, the global $I F$ constraint necessitates $\\begin{array} { r } { \\operatorname* { s u p } _ { x \\in \\mathcal { X } } \\| \\Sigma ^ { - 1 / 2 } \\nabla h ( x ) \\| < \\infty , } \\end{array}$ , i.e., h is Lipschitz continuous with respect to the Mahalanobis distance. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            768
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The main advantage of this local notion of IF over its global counterpart is that the local definition concentrates on the input pairs with smaller fair distance and ignores those with larger distance. For example, in Figure 1, the edge-weights among Alice, Charlie, and Dave are much larger than among any other pairs (which have a weight of 0); therefore, our local notion enforces fairness constraint on the corresponding similar pairs, while ignoring (or being less stringent on) others. This prevents over-smoothing and consequently preserves accuracy while enforcing fairness as is evident from our real data experiments in Section 5. ",
+        "bbox": [
+            173,
+            779,
+            825,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We now present our main theorem, which establishes that, under certain assumptions on the underlying hypothesis class and the distribution of inputs, the graph Laplacian regularizers (both unnormalized and normalized random walk) enforce the local IF constraint (as defined in Definition 4.1) in the limit. For our theory, we work with $d _ { \\mathcal { X } }$ as the Mahalanobis distance introduced in Example 4.2 in equation (2.2) along with $\\theta = 1 / ( 2 \\sigma ^ { 2 } )$ $\\sigma$ is a bandwidth parameter which goes to 0 at an appropriate rate as $n \\to \\infty$ ) and $\\tau = \\infty$ . All our results will be thorough for any finite $\\tau$ but with more tedious technical analysis. Therefore, our weight matrix $W$ becomes: ",
+        "bbox": [
+            173,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3af875483e730a88c2510ee0184d31983dba7063014ac0c4bd8ee4ee0a67514.jpg",
+        "text": "$$\nW _ { i j } = \\frac { | \\Sigma | ^ { 1 / 2 } } { ( 2 \\pi ) ^ { d / 2 } \\sigma ^ { d } } \\mathrm { e x p } \\left( - \\frac { 1 } { 2 \\sigma ^ { 2 } } ( x _ { i } - x _ { j } ) ^ { \\top } \\Sigma \\left( x _ { i } - x _ { j } \\right) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            162,
+            687,
+            199
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The constant $| \\Sigma | ^ { 1 / 2 } / ( ( 2 \\pi ) ^ { d / 2 } \\sigma ^ { d } )$ is for the normalization purpose and can be absorbed into the penalty parameter $\\lambda$ . We start by listing our assumptions: ",
+        "bbox": [
+            173,
+            202,
+            823,
+            232
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Assumption 4.3 (Assumption on the domain). The domain of the inputs $\\mathcal { X }$ is a compact subset of $\\mathbb { R } ^ { d }$ where $d$ is the underlying dimension. ",
+        "bbox": [
+            173,
+            233,
+            823,
+            262
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Assumption 4.4 (Assumption on the hypothesis). All functions $f \\in { \\mathcal { F } }$ of the hypothesis class satisfy the following: ",
+        "bbox": [
+            173,
+            263,
+            825,
+            294
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. The $i ^ { t h }$ derivative $f ^ { ( i ) }$ is uniformly bounded over the domain $\\mathcal { X }$ of inputs for $i \\in \\{ 0 , 1 , 2 \\}$ . ",
+        "bbox": [
+            173,
+            295,
+            787,
+            310
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. $f ^ { ( 1 ) } ( x ) = 0$ for all $x \\in \\partial X$ , where $\\partial X$ denotes the boundary of $\\mathcal { X }$ . ",
+        "bbox": [
+            174,
+            311,
+            642,
+            325
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Assumption 4.5 (Assumption on the density of inputs). The density $p$ of the input random variable x on the domain $\\mathcal { X }$ satisfies the following: ",
+        "bbox": [
+            174,
+            328,
+            823,
+            357
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. There exists $p _ { \\operatorname* { m a x } } < \\infty$ and $p _ { \\operatorname* { m i n } } > 0$ such that, for all $x \\in \\mathcal { X }$ , we have $p _ { \\operatorname* { m i n } } \\le p ( x ) \\le p _ { \\operatorname* { m a x } }$ .   \n2. The derivatives $\\{ p ^ { ( i ) } \\} _ { i = 0 , 1 , 2 }$ of the density $p$ are uniformly bounded on the domain $\\mathcal { X }$ . ",
+        "bbox": [
+            173,
+            359,
+            810,
+            391
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Discussion on the assumptions Most of our assumptions (e.g., compactness of the domain, bounded derivatives of $f$ or $p$ ) are for technical simplicity and are fairly common for the asymptotic analysis of graph regularization (see, e.g., Hein et al. [25], [33] and references therein). It is possible to relax some of the assumptions: for example, if the domain $\\mathcal { X }$ of inputs is unbounded, then the target function $f$ and the density $p$ should decay at certain rate so that observations far away will not be able to affect the convergence (e.g., sub-exponential tails). Part (2.) of Assumption 4.4 can be relaxed if we assume $p ( x )$ is 0 at boundary. However, we do not pursue these extensions further in this manuscript, as they are purely technical and do not add anything of significance to the main intuition of the result. ",
+        "bbox": [
+            173,
+            400,
+            826,
+            526
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4.6. Under Assumptions 4.3 - 4.5, we have: ",
+        "bbox": [
+            174,
+            527,
+            529,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. If the sequence of bandwidths $\\sigma \\equiv \\sigma _ { n } \\downarrow 0$ such that $n \\sigma _ { n } ^ { 2 } \\to \\infty$ and $\\mathbb { L } _ { u n , n }$ is unnormalized Laplacian matrix, then ",
+        "bbox": [
+            173,
+            550,
+            823,
+            579
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/35452ebefc4c3e5c55e3350d27c72744a583cfce03568ad5fb9ef985006b895b.jpg",
+        "text": "$$\n\\frac { 2 } { n ^ { 2 } \\sigma ^ { 2 } } \\mathbf { f } ^ { \\top } \\mathbb { L } _ { u n , n } \\mathbf { f } \\xrightarrow { P } \\mathbb { E } _ { x \\sim p } \\left[ \\nabla f ( x ) ^ { \\top } \\Sigma ^ { - 1 } \\nabla f ( x ) p ( x ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            582,
+            694,
+            612
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. If the sequence of bandwidths $\\sigma \\equiv \\sigma _ { n } \\downarrow 0$ such that $( n \\sigma ^ { d + 4 } ) / ( \\log { ( 1 / \\sigma ) } ) \\to \\infty$ and $\\mathbb { L } _ { n r w , n }$ is the normalized random walk Laplacian matrix, then: ",
+        "bbox": [
+            179,
+            614,
+            823,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c1c42276b6b29eaba683336661ba5adfe275a6223b5df15a8b5f117976fd34d6.jpg",
+        "text": "$$\n\\frac { 1 } { n \\sigma ^ { 2 } } \\mathbf { f } ^ { \\top } \\mathbb { L } _ { n r w , n } \\mathbf { f } \\stackrel { P } { \\longrightarrow } \\mathbb { E } _ { x \\sim p } \\left[ \\nabla f ( x ) ^ { \\top } { \\Sigma } ^ { - 1 } \\nabla f ( x ) \\right] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            645,
+            678,
+            675
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { f } = \\{ f ( x _ { i } ) \\} _ { i = 1 } ^ { n }$ . Consequently, both Laplacian regularizers asymptotically enforce local IF. ",
+        "bbox": [
+            174,
+            683,
+            818,
+            698
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The proof of the above theorem can be found in Appendix B. When we use a normalized random walk graph Laplacian matrix $\\mathbb { L } _ { n r w , n }$ as regularizer, the regularizer does (asymptotically) penalize $\\mathbb { E } \\left[ \\nabla f ( x ) ^ { \\top } \\Sigma ^ { - 1 } \\nabla f ( x ) \\right] = \\mathbb { E } \\left[ \\| \\Sigma ^ { - 1 / 2 } \\nabla f ( x ) \\| ^ { 2 } \\right]$ , which, by Example 4.2, is equivalent to enforcing the local IF constraint. Similarly, the un-normalized Laplacian matrix $\\mathbb { L } _ { u n , n }$ , also enforces the same under Assumption 4.5 as: ",
+        "bbox": [
+            173,
+            705,
+            825,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e0f800bb3be1d0d6984b0eac9d91672cc99824b2dce72e2f3542aa7dfa4e4da9.jpg",
+        "text": "$$\n\\mathbb { E } \\left[ \\Vert \\Sigma ^ { - 1 / 2 } \\nabla f ( x ) \\Vert ^ { 2 } \\right] \\leq \\frac { 1 } { p _ { \\operatorname* { m i n } } } \\mathbb { E } \\left[ \\nabla f ( x ) ^ { \\top } \\Sigma ^ { - 1 } \\nabla f ( x ) p ( x ) \\right] , \\mathrm { ~ w h e r e ~ } p _ { \\operatorname* { m i n } } = \\operatorname* { i n f } _ { x \\in \\mathcal { X } } p ( x ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            197,
+            780,
+            767,
+            813
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although both the Laplacian matrices enforce local IF, the primary difference between them is that the limit of the unnormalized Laplacian involves the density $p ( x )$ , i.e., it upweights the high-density region (consequently stringent imposition of fairness constraint), whereas it down-weights the underrepresented/low-density region. On the other hand, the limit corresponding to the normalized random walk Laplacian matrix does not depend on $p ( x )$ and enforces fairness constraint with equal intensity on the entire input space. We used both regularizers in our experiments, comparing and contrasting their performance on several practical ML problems. ",
+        "bbox": [
+            173,
+            814,
+            825,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            89,
+            312,
+            107
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The goals of our experiments are threefold: ",
+        "bbox": [
+            176,
+            125,
+            455,
+            138
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1. Exploring the trade-offs between post-processing for local IF with GLIF and post-processing with (global) IF constraints using our adaptation of the algorithm by Dwork et al. [6] described in (2.3).   \n2. Studying practical implications of theoretical differences between GLIF and GLIF-NRW, i.e., different graph Laplacians, presented in Section 4.   \n3. Evaluating the effectiveness of GLIF in its main application, i.e., computationally light debiasing of large deep learning models such as BERT. ",
+        "bbox": [
+            174,
+            152,
+            826,
+            236
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The implementation of this work is available at github.com/Felix-Petersen/fairness-post-processing. ",
+        "bbox": [
+            174,
+            250,
+            821,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 Comparing GLIF and Global IF-constraints ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            286,
+            521,
+            303
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For our first experiment, we consider the sentiment prediction task [34], where our goal is to classify words as having a positive or negative sentiment. The baseline model is a neural network trained with GloVe word embeddings [35]. Following Yurochkin et al. [11], we evaluate the model on a set of names and observe that it assigns varying sentiments to names. An individually fair model should assign similar sentiment scores to all names. Further, we observe that there is a gap between average sentiments of names typical for Caucasian and African-American ethnic groups [36], which is violating group fairness. Yurochkin et al. [11] propose a fair metric learning procedure for this task using a side data set of names, and an in-processing technique for achieving individual fairness. We use their method to obtain the fair metric and compare post-processing of the baseline model with GLIF, GLIF-NRW and the global IF-constraints method. The test set comprises 663 words from the original task and 94 names. For post-processing, no problem specific knowledge is used. The resulting post-processed predictions for the original test set are used to evaluate accuracy, and the predictions on the names are used for evaluating fairness metrics. Even for this small problem, the global IF-constraints method, i.e., a CVXPY [37] implementation of (2.3), takes 7 minutes to run. Due to the poor scalability of the global IF-constraints method, we can use it only for the study of this smaller data set and can not consider it for the large language model experiments in Section 5.2. For GLIF(-NRW), we implement the closed-form solution (3.3) that takes less than a tenth of a second to run. See Appendix A for additional experimental details and a runtime analysis. ",
+        "bbox": [
+            173,
+            314,
+            826,
+            564
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the fairness-accuracy trade-offs for a range of threshold parameters $\\tau$ (for GLIF and GLIF-NRW) and for a range of Lipschitz-constants $L$ (for IF-constraints) in Figure 2. Figure 2 (left) shows the standard deviation of the post-processed outputs on all names as a function of test accuracy on the original sentiment task. Lower standard deviations imply that all names received similar predictions, which is the goal of individual fairness. Figure 2 (center) visualizes group fairness and accuracy, i.e., difference in average name sentiment scores for the two ethnic groups. In this problem, individual fairness is a stronger notion of fairness: achieving similar predictions for all names implies similar group averages, but not vice a versa. Therefore, for this task, post-processing for individual fairness also corrects group disparities. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            694
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/918fbdc2656ad0da27cbad9688ad1474168f32e745c722f2bcebde4c7b9eda00.jpg",
+        "image_caption": [
+            "Figure 2: Sentiment experiment. Left: Trade-off between standard deviations of logits of names (measuring individual fairness) and accuracy. Center: Trade-off between race gap (measuring group fairness) and accuracy. Right: Frequencies of violations of the global IF constraints after applying GLIF, constraints corresponding to names, and GLIF’s global IF constraint violations for names. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            726,
+            823,
+            842
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In both settings, GLIF and GLIF-NRW achieve substantially better fairness metrics for the same levels of test accuracy in comparison to the IF-constraints method. To understand the reason for this, we study which global IF constraints are violated after applying the GLIF method in Figure 2 (right). Corresponding to the unique pairs of words in our test set, there are $n ( n - 1 ) / 2$ unique constraints in (2.3), and the global IF-constraints method satisfies all of them by design. Each constraint (i.e., each pair of words) corresponds to a fair distance, which is small for (under the fair metric) similar words and large for dissimilar words. We bin the constraints by fair distance and present the proportion of global IF constraints violated after applying the GLIF method for each bin in the histogram in Figure 2 (right). Here, we set the Lipschitz-constant $L$ in (2.3) to $L = 2 . 2 5$ corresponding to a $8 9 . 4 \\%$ accuracy of the IF-constraints method and show global IF constraint violations of GLIF corresponding to $9 5 \\%$ accuracy in blue. This means that we use strong global IF constraints and use a setting of the GLIF method which maintains most of the accuracy, which would not be possible using the IF-constraints method. GLIF does not violate any constraints corresponding to small fair distances, i.e., it satisfies IF on similar individuals, while violating many large fair distance constraints. This can be seen as basically all constraint violations (blue) are at large fair distances of greater or equal 6. This demonstrates the effect of enforcing local individual fairness from our theoretical analysis in Section 4. At the same time, we display frequency of constraints that correspond to pairs of names in orange, where we can see that almost all constraints corresponding to names occur at small fair distances of smaller or equal to 6. This is expected in this task because we consider all names similar, so fair distances between them should be small. We can see that the distributions of constraint violations after applying GLIF (blue, right) and names (orange, left) are almost disjoint. We mark all global IF constraint violations after applying GLIF that correspond to names in green, and observe that there are none. Summarizing, GLIF ignores unnecessary (in the context of this problem) constraints allowing it to achieve higher accuracy, while satisfying the more relevant local IF constraints leading to improved fairness. ",
+        "bbox": [
+            173,
+            92,
+            825,
+            435
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Regarding the practical differences between GLIF and GLIF-NRW, in Figure 2 (left) GLIF has smaller standard deviations on the name outputs, but in in Figure 2 (center) GLIF-NRW achieves lower race gap. In Theorem 4.6, we showed that GLIF penalizes fairness violations in high density data regions stronger. As a result, GLIF may favor enforcing similar outputs in the high density region causing lower standard deviation, while leaving outputs nearly unchanged in the lower density region, resulting in larger race gaps. GLIF-NRW weights all data density regions equally, i.e., it is less likely to miss a small subset of names, but is less stringent in the high density regions. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 Post-processing for Debiasing Large Language Models ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            565,
+            591,
+            580
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Large language models have achieved impressive results on many tasks; however, there is also significant evidence demonstrating that they are prone to biases [4], [38], [39]. Debiasing these models remains largely an open problem: most in-processing algorithms are not applicable or computationally prohibitive due to large and highly complex model architectures, and challenges in handling text inputs. Even if an appropriate in-processing algorithm arises, significant environmental impact due to re-training is unavoidable [4], [16]. In our experiments, we evaluate effectiveness of GLIF as a simple post-processing technique to debias BERT-based models for text classification. Another possible solution is to fine-tune BERT with an in-processing technique as was done by Yurochkin et al. [12]. The two approaches are not directly comparable: fine-tuning with SenSeI [12] requires knowledge of the model parameters, alleviates only part of the computational burden, and has more stringent requirements on the fair metric, while post-processing with GLIF is transductive, i.e., it requires access to unlabeled test data (see extended discussion in Section 2.1). ",
+        "bbox": [
+            173,
+            594,
+            825,
+            734
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d8797f1f8a189470f5f4dac9da7fcb31f67a3d412338cd47d6ced12d932c6f3f.jpg",
+        "image_caption": [
+            "Figure 3: Accuracy-Consistency trade-offs for Bios (left) and Toxicity (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            767,
+            823,
+            883
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/40f87c50a69d2e40dec3b8bde390079b4cc58d977aabe44159a9769dfbd20e13.jpg",
+        "table_caption": [
+            "Table 1: Results for the Bios task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Test Acc.</td><td>Pred. Consist.</td></tr><tr><td>Baseline</td><td>0.846 ± 0.003</td><td>0.942 ± 0.002</td></tr><tr><td>GLIF</td><td>0.830± 0.004</td><td>0.986 ± 0.002</td></tr><tr><td>GLIF-NRW</td><td>0.834 ± 0.003</td><td>0.988 ± 0.002</td></tr><tr><td>SenSEI</td><td>0.843 ± 0.003</td><td>0.977 ± 0.001</td></tr></table>",
+        "bbox": [
+            176,
+            114,
+            490,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/a7268725e52b9592635f5f79da555517a8410db555847cff5b646f443120b360.jpg",
+        "table_caption": [
+            "Table 2: Results for the Toxicity task. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Test Acc.</td><td>Pred. Consist.</td></tr><tr><td>Baseline</td><td>0.809 ± 0.004</td><td>0.614 ± 0.013</td></tr><tr><td>GLIF</td><td>0.803 ±0.003</td><td>0.835 ± 0.012</td></tr><tr><td>GLIF-NRW</td><td>0.803 ± 0.003</td><td>0.844 ± 0.013</td></tr><tr><td>SenSEI</td><td>0.791 ± 0.005</td><td>0.773 ± 0.043</td></tr></table>",
+        "bbox": [
+            508,
+            114,
+            821,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            220,
+            825,
+            248
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We replicate the experiments of Yurochkin et al. [12] on Bios [40] and Toxicity1 data sets. They use the approach of Mukherjee et al. [19] for fair metric learning which we reproduce. We refer to the Appendix B.1 of [12] for details. In both tasks, following [12], we quantify performance with balanced accuracy due to class imbalance, and measure individual fairness via prediction consistency, i.e., the fraction of test points where the prediction remains unchanged when performing task-specific input modifications. For implementation details, see Appendix A. In Appendix A.4, we analyze the runtime and distinguish between the closed-form and coordinate descent variants of GLIF. ",
+        "bbox": [
+            173,
+            255,
+            825,
+            352
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Bios, the goal is to predict the occupation of a person based on their textual biography. Such models can be useful for recruiting purposes. However, due to historical gender bias in some occupations, the baseline BERT model learns to associate gender pronouns and names with the corresponding occupations. Individual fairness is measured with prediction consistency with respect to gender pronouns and names alterations. A prediction is considered consistent if it is the same after swapping the gender pronouns and names. We present the fairness-accuracy trade-off in Figure 3 (left) for a range of threshold parameters $\\tau$ , and compare performance based on hyperparameter values selected with a validation data in Table 1. Both GLIF and GLIF-NRW noticeably improve individual fairness measured with prediction consistency, while retaining most of the accuracy. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            484
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Toxicity, the task is to identify toxic comments—an important tool for facilitating inclusive discussions online. The baseline BERT model learns to associate certain identity words with toxicity (e.g., “gay”) because they are often abused in online conversations. The prediction consistency is measured with respect to changes to identity words in the inputs. There are 50 identity words, e.g., “gay”, “muslim”, “asian”, etc. and a prediction is considered consistent if it is the same for all 50 identities. We present the trade-off plots in Figure 3 (right) and compare performance in Table 2 (right). Our methods reduce individual biases in BERT predictions. We note that in both Toxicity and Bios experiments, we observe no practical differences between GLIF and GLIF-NRW. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            601
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Summary and Discussion ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            619,
+            416,
+            637
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We studied post-processing methods for enforcing individual fairness. The methods provably enforce a local form of IF and scale readily to large data sets. We hope this broadens the appeal of IF by (i) alleviating the computational costs of operationalizing IF and (ii) allowing practitioners to use off-the-shelf models for standard ML tasks. We also note that it is possible to use our objective for in-processing. ",
+        "bbox": [
+            173,
+            650,
+            825,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We conclude with two warnings: First, enforcing any algorithmic fairness definition does not guarantee complete fairness from the perspective of the user. The problem-specific meaning of fairness is often hard to encode exactly with a mathematical fairness definition. Second, while local individual fairness is a reasonable choice in many applications, this choice should be understood and verified by the practitioner depending on the situation. ",
+        "bbox": [
+            174,
+            727,
+            825,
+            796
+        ],
+        "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 note is based upon work supported by the National Science Foundation (NSF) under grants no. 1916271, 2027737, and 2113373 and supported by the German Research Foundation (DFG) under Germany’s Excellence Strategy EXC–2117–390829875. Any opinions, findings, and conclusions or recommendations expressed in this note are those of the authors and do not necessarily reflect the views of the NSF nor the DFG. ",
+        "bbox": [
+            174,
+            119,
+            826,
+            189
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            266,
+            226
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] S. Barocas and A. D. Selbst, “Big data’s disparate impact,” Calif. L. Rev., vol. 104, p. 671, 2016.   \n[2] J. Larson, J. Angwin, L. Kirchner, and S. Mattu, “How we examined racial discrimination in auto insurance prices,” ProPublica, 2017.   \n[3] J. Buolamwini and T. Gebru, “Gender shades: Intersectional accuracy disparities in commercial gender classification,” in Conference on fairness, accountability and transparency, PMLR, 2018, pp. 77–91.   \n[4] E. M. Bender, T. Gebru, A. McMillan-Major, and S. Shmitchell, “On the dangers of stochastic parrots: Can language models be too big?” In Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, 2021, pp. 610–623.   \n[5] A. Chouldechova and A. Roth, “A snapshot of the frontiers of fairness in machine learning,” Communications of the ACM, vol. 63, no. 5, pp. 82–89, 2020.   \n[6] C. Dwork, M. Hardt, T. Pitassi, O. Reingold, and R. Zemel, “Fairness through awareness,” in Proceedings of the 3rd innovations in theoretical computer science conference, 2012, pp. 214–226.   \n[7] D. C. Hsia, “Credit scoring and the equal credit opportunity act,” Hastings LJ, vol. 30, p. 371, 1978.   \n[8] M. Bertrand and S. Mullainathan, “Are emily and greg more employable than lakisha and jamal? a field experiment on labor market discrimination,” American Economic Review, vol. 94, no. 4, pp. 991–1013, 2004.   \n[9] W. Fleisher, “What’s fair about individual fairness?” Available at SSRN 3819799, 2021.   \n[10] C. Jung, M. Kearns, S. Neel, A. Roth, L. Stapleton, and Z. S. Wu, “An algorithmic framework for fairness elicitation,” arXiv preprint arXiv:1905.10660, 2019.   \n[11] M. Yurochkin, A. Bower, and Y. Sun, “Training individually fair ML models with sensitive subspace robustness,” in International Conference on Learning Representations (ICLR), 2020.   \n[12] M. Yurochkin and Y. Sun, “Sensei: Sensitive set invariance for enforcing individual fairness,” in International Conference on Learning Representations (ICLR), 2021.   \n[13] A. Vargo, F. Zhang, M. Yurochkin, and Y. Sun, “Individually fair gradient boosting,” in International Conference on Learning Representations (ICLR), 2021.   \n[14] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova, “BERT: Pre-training of deep bidirectional transformers for language understanding. arxiv,” in Proc. Conference of the North American Chapter of the Association for Computational Linguistics (ACL), 2018.   \n[15] T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, et al., “Language models are few-shot learners,” arXiv preprint arXiv:2005.14165, 2020.   \n[16] E. Strubell, A. Ganesh, and A. McCallum, “Energy and policy considerations for deep learning in nlp,” in 57th Annual Meeting of the Association for Computational Linguistics, 2019.   \n[17] O. Chapelle, B. Schölkopf, and A. Zien, Eds., Semi-Supervised Learning. Cambridge, Mass: MIT Press, 2006.   \n[18] C. Ilvento, “Metric Learning for Individual Fairness,” in 1st Symposium on Foundations of Responsible Computing (FORC 2020), Leibniz International Proceedings in Informatics (LIPIcs), vol. 156, Dagstuhl, Germany: Schloss Dagstuhl–Leibniz-Zentrum für Informatik, 2020.   \n[19] D. Mukherjee, M. Yurochkin, M. Banerjee, and Y. Sun, “Two simple ways to learn individual fairness metrics from data,” in International Conference on Machine Learning (ICML), 2020.   \n[20] M. P. Kim, A. Ghorbani, and J. Zou, “Multiaccuracy: Black-box post-processing for fairness in classification,” in Proceedings of the 2019 AAAI/ACM Conference on AI, Ethics, and Society, 2019.   \n[21] P. K. Lohia, K. N. Ramamurthy, M. Bhide, D. Saha, K. R. Varshney, and R. Puri, “Bias mitigation post-processing for individual and group fairness,” in IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), 2019, pp. 2847–2851.   \n[22] P. Lohia, “Priority-based post-processing bias mitigation for individual and group fairness,” arXiv preprint arXiv:2102.00417, 2021.   \n[23] D. Wei, K. N. Ramamurthy, and F. d. P. Calmon, “Optimized score transformation for fair classification,” in International Conference on Artificial Intelligence and Statistics (AISTATS), 2020.   \n[24] D. Spielman, “Spectral graph theory,” Combinatorial scientific computing, no. 18, 2012.   \n[25] M. Hein, J.-Y. Audibert, and U. v. Luxburg, “Graph laplacians and their convergence on random neighborhood graphs.,” Journal of Machine Learning Research, vol. 8, no. 6, 2007.   \n[26] R. R. Coifman and S. Lafon, “Diffusion maps,” Applied and computational harmonic analysis, vol. 21, no. 1, 2006.   \n[27] D. Zhou and B. Schölkopf, “A regularization framework for learning from graph data,” in ICML 2004 Workshop on Statistical Relational Learning and Its Connections to Other Fields (SRL 2004), 2004, pp. 132–137.   \n[28] M. Belkin, I. Matveeva, and P. Niyogi, “Regularization and semi-supervised learning on large graphs,” in International Conference on Computational Learning Theory, Springer, 2004, pp. 624–638.   \n[29] A. J. Smola and R. Kondor, “Kernels and regularization on graphs,” in Learning theory and kernel machines, Springer, 2003.   \n[30] P. Lahoti, K. P. Gummadi, and G. Weikum, “Ifair: Learning individually fair data representations for algorithmic decision making,” in 2019 ieee 35th international conference on data engineering (icde), IEEE, 2019, pp. 1334–1345.   \n[31] J. Kang, J. He, R. Maciejewski, and H. Tong, “Inform: Individual fairness on graph mining,” in Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, 2020, pp. 379–389.   \n[32] S. J. Wright, “Coordinate descent algorithms,” Mathematical Programming, 2015.   \n[33] M. Hein, J.-Y. Audibert, and U. Von Luxburg, “From graphs to manifolds–weak and strong pointwise consistency of graph laplacians,” in International Conference on Computational Learning Theory, Springer, 2005.   \n[34] M. Hu and B. Liu, “Mining and summarizing customer reviews,” in Proceedings of the tenth ACM SIGKDD international conference on Knowledge discovery and data mining, 2004.   \n[35] J. Pennington, R. Socher, and C. D. Manning, “Glove: Global vectors for word representation,” in Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), 2014, pp. 1532–1543.   \n[36] A. Caliskan, J. J. Bryson, and A. Narayanan, “Semantics derived automatically from language corpora contain human-like biases,” Science, 2017.   \n[37] S. Diamond and S. Boyd, “Cvxpy: A python-embedded modeling language for convex optimization,” The Journal of Machine Learning Research, vol. 17, no. 1, pp. 2909–2913, 2016.   \n[38] K. Kurita, N. Vyas, A. Pareek, A. W. Black, and Y. Tsvetkov, “Measuring bias in contextualized word representations,” in First Workshop on Gender Bias in Natural Language Processing, 2019.   \n[39] M. Nadeem, A. Bethke, and S. Reddy, “Stereoset: Measuring stereotypical bias in pretrained language models,” arXiv preprint arXiv:2004.09456, 2020.   \n[40] M. De-Arteaga, A. Romanov, H. Wallach, J. Chayes, C. Borgs, A. Chouldechova, S. Geyik, K. Kenthapadi, and A. T. Kalai, “Bias in bios: A case study of semantic representation bias in a high-stakes setting,” in Proceedings of the Conference on Fairness, Accountability, and Transparency (ACM FAccT), 2019.   \n[41] L. Dixon, J. Li, J. Sorensen, N. Thain, and L. Vasserman, “Measuring and mitigating unintended bias in text classification,” in Proceedings of the 2018 AAAI/ACM Conference on AI, Ethics, and Society, 2018.   \n[42] B. Sen, A gentle introduction to empirical process theory and applications, 2018. ",
+        "bbox": [
+            173,
+            229,
+            826,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            89,
+            826,
+            664
+        ],
+        "page_idx": 11
+    }
+]

parse/train/huAdB-Tj4yG/huAdB-Tj4yG.md

@@ -0,0 +1,269 @@
+# Rethinking Graph Transformers with Spectral Attention
+
+Devin Kreuzer ∗ McGill University, Mila Montreal, Canada devin.kreuzer@mail.mcgill.ca
+
+Dominique Beaini \* Valence Discovery Montreal, Canada dominique@valencediscovery.com
+
+William L. Hamilton   
+McGill University, Mila   
+Montreal, Canada   
+wlh@cs.mcgill.ca
+
+Vincent Létourneau University of Ottawa Ottawa, Canada vletour2@uottawa.ca
+
+Prudencio Tossou Valence Discovery Montreal, Canada prudencio@valencediscovery.com
+
+# Abstract
+
+In recent years, the Transformer architecture has proven to be very successful in sequence processing, but its application to other data structures, such as graphs, has remained limited due to the difficulty of properly defining positions. Here, we present the Spectral Attention Network (SAN), which uses a learned positional encoding (LPE) that can take advantage of the full Laplacian spectrum to learn the position of each node in a given graph. This LPE is then added to the node features of the graph and passed to a fully-connected Transformer. By leveraging the full spectrum of the Laplacian, our model is theoretically powerful in distinguishing graphs, and can better detect similar sub-structures from their resonance. Further, by fully connecting the graph, the Transformer does not suffer from over-squashing, an information bottleneck of most GNNs, and enables better modeling of physical phenomenons such as heat transfer and electric interaction. When tested empirically on a set of 4 standard datasets, our model performs on par or better than state-of-theart GNNs, and outperforms any attention-based model by a wide margin, becoming the first fully-connected architecture to perform well on graph benchmarks.
+
+# 1 Introduction
+
+The prevailing strategy for graph neural networks (GNNs) has been to directly encode graph structure structure through a sparse message-passing process [17, 19]. In this approach, vector messages are iteratively passed between nodes that are connected in the graph. Multiple instantiations of this message-passing paradigm have been proposed, differing in the architectural details of the message-passing apparatus (see [19] for a review).
+
+However, there is a growing recognition that the message-passing paradigm has inherent limitations. The expressive power of message passing appears inexorably bounded by the Weisfeiler-Lehman isomorphism hierarchy [29, 30, 39]. Message-passing GNNs are known to suffer from pathologies, such as oversmoothing, due to their repeated aggregation of local information [19], and over-squashing, due to the exponential blow-up in computation paths as the model depth increases [1].
+
+As a result, there is a growing interest in deep learning techniques that encode graph structure as a soft inductive bias, rather than as a hard-coded aspect of message passing [14, 24]. A central issue with message-passing paradigm is that input graph structure is encoded by restricting the structure of the model’s computation graph, inherently limiting its flexibility. This reminds us of how early recurrent neural networks (RNNs) encoded sequential structure via their computation graph—a strategy that leads to well-known pathologies such as the inability to model long-range dependencies [20].
+
+There is a growing trend across deep learning towards more flexible architectures, which avoid strict and structural inductive biases. Most notably, the exceptionally successful Transformer architecture removes any structural inductive bias by encoding the structure via soft inductive biases, such as positional encodings [36]. In the context of GNNs, the self-attention mechanism of a Transformer can be viewed as passing messages between all nodes, regardless of the input graph connectivity.
+
+Prior work has proposed to use attention in GNNs in different ways. First, the GAT model [37] proposed local attention on pairs of nodes that allows a learnable convolutional kernel. The GTN work [42] has improved on the GAT for node and link predictions while keeping a similar architecture, while other message-passing approaches have used enhancing spectral features [8, 13] . More recently, the GT model [14] was proposed as a generalization of Transformers to graphs, where they experimented with sparse and full graph attention while providing low-frequency eigenvectors of the Laplacian as positional encodings.
+
+In this work, we offer a principled investigation of how Transformer architectures can be applied in graph representation learning. Our primary contribution is the development of novel and powerful learnable positional encoding methods, which are rooted in spectral graph theory. Our positional encoding technique — and the resulting spectral attention network (SAN) architecture — addresses key theoretical limitations in prior graph Transformer work [14] and provably exceeds the expressive power of standard message-passing GNNs. We show that full Transformer-style attention provides consistent empirical gains compared to an equivalent sparse message-passing model, and we demonstrate that our SAN architecture is competitive with or exceeding the state-of-the-art on several well-known graph benchmarks. An overview of the entire method is presented in Figure 1, with a link to the code here: https://github.com/DevinKreuzer/SAN.
+
+# 2 Theoretical Motivations
+
+There can be a significant loss in structural information if naively generalizing Transformers to graphs. To preserve this information as well as local connectivity, previous studies [37, 14] have proposed to use the eigenfunctions of their Laplacian as positional encodings. Taking this idea further by using the full expressivity of eigenfunctions as positional encodings, we can propose a principled way of understanding graph structures using their spectra. The advantages of our methods compared to previous studies [37, 14] are shown in Table 1.
+
+Table 1: Comparison of the properties of different graph Transformer models.   
+
+<table><tr><td>MODELS</td><td>GAT</td><td>GT sparse</td><td>GT full</td><td>SAN</td></tr><tr><td>Preserves local structure in attention</td><td>&gt;xxx</td><td>√&lt;x√</td><td>xxv√</td><td>?</td></tr><tr><td>Uses edge features</td><td></td><td></td><td></td><td></td></tr><tr><td>Connects non-neighbouring nodes</td><td></td><td></td><td></td><td></td></tr><tr><td>Uses eigenvector-based PE for attention</td><td></td><td></td><td></td><td></td></tr><tr><td>Use a PE with structural information</td><td>x</td><td>←</td><td>+</td><td></td></tr><tr><td>Considers the ordering of the eigenvalues</td><td>X</td><td>√</td><td>vv</td><td></td></tr><tr><td>Invariant to the norm of the eigenvector</td><td></td><td>√</td><td></td><td></td></tr><tr><td>Considers the spectrum of eigenvalues</td><td>X</td><td></td><td></td><td></td></tr><tr><td>Considers variable # of eigenvectors</td><td></td><td></td><td></td><td></td></tr><tr><td>Aware of eigenvalue multiplicities</td><td></td><td>xxx</td><td></td><td>√</td></tr><tr><td>Invariant to the sign of the eigenvectors</td><td></td><td>×</td><td>xxxx</td><td>X</td></tr></table>
+
+![](images/6fdefa909906706bb5dccb238d25f45b161e68c2331a8e8d01f82d197ead59e6.jpg)  
+Figure 1: The proposed SAN model with the node LPE, a generalization of Transformers to graphs.
+
+# 2.1 Absolute and relative positional encoding with eigenfunctions
+
+The notion of positional encodings (PEs) in graphs is not a trivial concept, as there exists no canonical way of ordering nodes or defining axes. In this section, we investigate how eigenfunctions of the Laplacian can be used to define absolute and relative PEs in graphs, to measure physical interactions between nodes, and to enable ”hearing” of specific sub-structures - similar to how the sound of a drum can reveal its structure.
+
+# 2.1.1 Eigenvectors equate to sine functions over graphs
+
+In the Transformer architecture, a fundamental aspect is the use of sine and cosine functions as PEs for sequences [36]. However, sinusoids cannot be clearly defined for arbitrary graphs, since there is no clear notion of position along an axis. Instead, their equivalent is given by the eigenvectors $\phi$ of the graph Laplacian $\pmb { L }$ . Indeed, in a Euclidean space, the Laplacian (or Laplace) operator corresponds to the divergence of the gradient and its eigenfunctions are sine/cosine functions, with the squared frequencies corresponding to the eigenvalues (we sometimes interchange the two notions from here on). Hence, in the graph domain, the eigenvectors of the graph Laplacian are the natural equivalent of sine functions, and this intuition was employed in multiple recent works which use the eigenvectors as PEs for GNNs [15], for directional flows [4] and for Transformers [14].
+
+Being equivalent to sine functions, we naturally find that the Fourier Transform of a function $\mathcal { F } [ f ]$ applied to a graph gives $\mathcal { F } [ f ] ( \lambda _ { i } ) = \langle f , \phi _ { i } \rangle$ , where the eigenvalue is considered as a position in the Fourier domain of that graph [6]. Thus, the eigenvectors are best viewed as vectors positioned on the axis of eigenvalues rather than components of a matrix as illustrated in Figure 2.
+
+# 2.1.2 What do eigenfunctions tell us about relative positions?
+
+In addition to being the analog of sine functions, the eigenvectors of the Laplacian also hold important information about the physics of a system and can reveal distance metrics. This is not surprising as the Laplacian is a fundamental operator in physics and is notably used in Maxwell’s equations [16] and the heat diffusion [6].
+
+![](images/62eb856f3aba9054a14539ddc42e07cb54b4c6c12479b8ea05b4e55506ff52b1.jpg)  
+Figure 2: a) Standard view of the eigenvectors as a matrix. b) Eigenvectors $\phi _ { i }$ viewed as vectors positionned on the axis of frequencies (eigenvalues).
+
+In electromagnetic theory, the (pseudo)inverse of the Laplacian, known in mathematics as the Green’s function of the Laplacian [9], represents the electrostatic potential of a given charge. In a graph, the same concept uses the pseudo-inverse of the Laplacian $G$ and can be computed by its eigenfunctions. See equation 1 , where $G ( j _ { 1 } , j _ { 2 } )$ is the electric potential between nodes $j _ { 1 }$ and $j _ { 2 }$ , $\hat { \phi } _ { i }$ and $\hat { \lambda _ { i } }$ are the $i$ -th eigenvectors and eigenvalues of the symmetric Laplacian $D ^ { \frac { - 1 } { 2 } } L D ^ { \frac { - 1 } { 2 } }$ , and $_ D$ is the degree matrix, and $\hat { \phi } _ { i , j }$ the $j$ -th row of the vector.
+
+$$
+G ( j _ { 1 } , j _ { 2 } ) = d _ { j _ { 1 } } ^ { \frac { 1 } { 2 } } d _ { j _ { 2 } } ^ { \frac { - 1 } { 2 } } \sum _ { i > 0 } ^ { } \frac { ( \hat { \phi } _ { i , j _ { 1 } } \hat { \phi } _ { i , j _ { 2 } } ) ^ { 2 } } { \hat { \lambda } _ { i } }
+$$
+
+Further, the original solution of the heat equation given by Fourier relied on a sum of sines/cosines known as a Fourier series [7]. As eigenvectors of the Laplacian are the analogue of these functions in graphs, we find similar solutions. Knowing that heat kernels are correlated to random walks [6, 4], we use the interaction between two heat kernels to define in equation 2 the diffusion distance $d _ { D }$ between nodes $j _ { 1 } , j _ { 2 }$ [6, 10]. Similarly, the biharmonic distance $d _ { B }$ was proposed as a better measure of distances [28]. Here we use the eigenfunctions of the regular Laplacian $\pmb { L }$ .
+
+$$
+d _ { D } ^ { 2 } ( j _ { 1 } , j _ { 2 } ) = \sum _ { k > 0 } e ^ { - 2 t \lambda _ { i } } ( \phi _ { i , j _ { 1 } } - \phi _ { i , j _ { 2 } } ) ^ { 2 } \quad , \quad d _ { B } ^ { 2 } ( j _ { 1 } , j _ { 2 } ) = \sum _ { i > 0 } \frac { ( \phi _ { i , j _ { 1 } } - \phi _ { i , j _ { 2 } } ) ^ { 2 } } { \lambda _ { i } ^ { 2 } }
+$$
+
+There are a few things to note from these equations. Firstly, they highlight the importance of pairing eigenvectors and their corresponding eigenvalues when supplying information about relative positions in a graph. Secondly, we notice that the product of eigenvectors is proportional to the electrostatic interaction, while the subtraction is proportional to the diffusion and biharmonic distances. Lastly, there is a consistent pattern across all 3 equations: smaller frequencies/eigenvalues are more heavily weighted when determining distances between nodes.
+
+# 2.1.3 Hearing the shape of a graph and its sub-structures
+
+Another well-known property of eigenvalues is how they can be used to discriminate between different graph structures and sub-structures, as they can be interpreted as the frequencies of resonance of the graph. This led to the famous question about whether we can hear the shape of a drum from its eigenvalues [23], with the same questions also applying to geometric objects [12] and 3D molecules [33]. Various success was found with the eigenfunctions being used for partial functional correspondence [32], algorithmic understanding geometries [26], and style correspondence [12]. Examples of eigenvectors for molecular graphs are presented in Figure 3.
+
+![](images/b0da6292320ff0dc820d5dede7d45fd8e901266195d4c5355023fa0868362024.jpg)  
+Figure 3: Examples of eigenvalues $\lambda _ { i }$ and eigenvectors $\phi _ { i }$ for molecular graphs. The low-frequency eigenvectors $\phi _ { 1 } , \phi _ { 2 }$ are spread accross the graph, while higher frequencies, such as $\phi _ { 1 4 } , \phi _ { 1 5 }$ for the left molecule or $\phi _ { 1 0 } , \phi _ { 1 1 }$ for the right molecule, often resonate in local structures.
+
+# 2.2 Laplace Eigenfunctions etiquette
+
+In Euclidean space and sequences, using sinusoids as PEs is trivial: we can simply select a set of frequencies, compute the sinusoids, and add or concatenate them to the input embeddings, as is done in the original Transformer [36]. However, in arbitrary graphs, reproducing these steps is not as simple since each graph has a unique set of eigenfunctions. In the following section, we present key principles from spectral graph theory to consider when constructing PEs for graphs, most of which have been overlooked by prior methods. They include normalization, the importance of the eigenvalues and their multiplicities, the number of eigenvectors being variable, and sign ambiguities. Our LPE architectures, presented in section 3, aim to address them.
+
+Normalization. Given an eigenvalue of the Laplacian, there is an associated eigenspace of dimension greater than 1. To make use of this information in our model, a single eigenvector has to be chosen. In our work, we use the $L _ { 2 }$ normalization since it is compatible with the definition of the Green’s function (1). Thus, we will always chose eigenvectors $\phi$ such that $\langle \phi , \phi \rangle = 1$ .
+
+Eigenvalues. Another fundamental aspect is that the eigenvalue associated with each eigenvector supplies valuable information. An ordering of the eigenvectors based on their eigenvalue works in sequences since the frequencies are pre-determined. However, this assumption does not work in graphs since the eigenvalues in their spectrum can vary. For example, in Figure 3, we observe how an ordering would miss the fact that both molecules resonate at $\lambda = 1$ in different ways.
+
+Multiplicities. Another important problem with choosing eigenfunctions is the possibility of a high multiplicity of the eigenvalues, i.e. when an eigenvalue appears as a root of the characteristic polynomial more than once. In this case, the associated eigenspace may have dimension 2 or more as we can generate a valid eigenvector from any linear combination of eigenvectors with the same eigenvalue. This further complicates the problem of choosing eigenvectors for algorithmic computations and highlights the importance of having a model that can handle this ambiguity.
+
+Variable number of eigenvectors. A graph $G _ { i }$ can have at most $N _ { i }$ linearly independent eigenvectors with $N _ { i }$ being its number of nodes. Most importantly, $N _ { i }$ can vary across all $G _ { i }$ in the dataset. Prior work [14] elected to select a fixed number $k$ eigenvectors for each graph, where $k \leq N _ { i } , \forall i$ . This produces a major bottleneck when the smallest graphs have significantly fewer nodes than the largest graphs in the dataset since a very small proportion of eigenvectors will be used for large graphs. This inevitably causes loss of information and motivates the need for a model which constructs fixed PEs of dimension $k$ , where $k$ does not depend on the number of eigenvectors in the graph.
+
+Sign invariance. As noted earlier, there is a sign ambiguity with the eigenvectors. With the sign of $\phi$ being independent of its normalization, we are left with a total of $2 ^ { k }$ possible combination of signs when choosing $k$ eigenvectors of a graph. Previous work has proposed to do data augmentation by randomly flipping the sign of the eigenvectors [4, 15, 14], and although it can work when $k$ is small, it becomes intractable for large $k$ .
+
+# 2.3 Learning with Eigenfunctions
+
+Learning generalizable information from eigenfunctions is fundamental to their succesful usage. Here we detail important points that support it is possible to do so if done correctly.
+
+Similar graphs have similar spectra. Thus, we can expect the network to transfer patterns across graphs through the similarity of their spectra. In fact, spectral graph theory tells us that the lowest and largest non-zero eigenvalues are both linked to the geometry of the graph (algebraic connectivity and spectral radius).
+
+Eigenspaces contain geometric information. Spectral graph theory has studied the geometric and physical properties of graphs from their Laplacian eigenfunctions in depth. Developing a method that can use the full spectrum of a graph makes it theoretically possible capture this information. It us thus important to capture differences between the full eigenspaces instead of minor differences between specific eigenvalues or eigenvectors from graph to graph.
+
+Learned positions are relative within graphs. Eigenspaces are used to understand the relationship between nodes within graphs, not across them. Proposed models should therefore only compare the eigenfunctions of nodes within graphs.
+
+# 3 Model Architecture
+
+In this section, we propose an elegant architecture that can use the eigenfunctions as PEs while addressing the concerns raised in section 2.2. Our Spectral Attention Network (SAN) model inputs eigenfunctions of a graph and projects them into a learned positional encoding (LPE) of fixed size. The LPE allows the network to use up to the entire Laplace spectrum of each graph, learn how the frequencies interact, and decide which are most important for the given task.
+
+We propose a two-step learning process summarized earlier in Figure 1. The first step, depicted by blocks (c-d-e) in the figure, applies a Transformer over the eigenfunctions of each node to generate an LPE matrix for each graph. The LPE is then concatenated to the node embeddings (blocks g-h), before being passed to the Graph Transformer (block i). If the task involves graph classification or regression, the final node embeddings are subsequently passed to a final pooling layer.
+
+# 3.1 LPE Transformer Over Nodes
+
+Using Laplace encodings as node features is ubiquitous in the literature concerning the topic. Here, we propose a method for learning node PEs motivated by the principles from section 2.2. The idea of our LPE is inspired by Figure 2, where the eigenvectors $\phi$ are represented as a non-uniform sequence with the eigenvalue $\lambda$ being the position on the frequency axis. With this representation, Transformers are a natural choice for processing them and generating a fixed-size PE.
+
+The proposed LPE architecture is presented in Figure 4. First, we create an embedding matrix of size $2 \times m$ for each node $j$ by concatenating the $m$ -lowest eigenvalues with their associated eigenvectors. Here, $m$ is a hyper-parameter for the maximum number of eigenvectors to compute and is analog to the variable-length sequence for a standard Transformer. For graphs where $m > N$ , a masked-padding is simply added. Note that to capture the entire spectrum of all graphs, one can simply select $m$ such that it is equal to the maximum number of nodes a graph has in the dataset. A linear layer is then applied on the dimension of size 2 to generate new embeddings of size $k$ . A Transformer Encoder then computes self-attention on the sequence of length $m$ and hidden dimension $k$ . Finally, a sum pooling reduces the sequence into a fixed $k$ -dimensional node embedding.
+
+The LPE model addresses key limitations of previous graph Transformers and is aligned with the first four etiquettes presented in section 2.2. By concatenating the eigenvalues with the normalized eigenvector, this model directly addresses the first three etiquettes. Namely, it normalizes the eigenvectors, pairs eigenvectors with their eigenvalues and treats the number of eigenvectors as a variable. Furthermore, the model is aware of multiplicities and has the potential to linearly combine or ignore some of the repeated eigenvalues.
+
+However, this method still does not address the limitation that the sign of the pre-computed eigenvectors is arbitrary. To combat this issue, we randomly flip the sign of the pre-computed eigenvectors during training as employed by previous work [15, 14], to promote invariance to the sign ambiguity.
+
+![](images/db1815f2d04f6f59e1b99c9323e1f509fa40804dac0fe563e0f4530eb752450e.jpg)  
+Figure 4: Learned positional encoding (LPE) architectures, with the model being aware of the graph’s Laplace spectrum by considering $m$ eigenvalues and eigenvectors, where we permit $m \leq N$ , with $N$ denoting the number of nodes. Since the Transformer loops over the nodes, each node can be viewed as an element of a batch to parallelize the computation. Here $\phi _ { i , j }$ is the $j$ -th element of the eigenvector paired to the $i$ -th lowest eigenvalue $\lambda _ { i }$ .
+
+# 3.2 LPE Transformer Over Edges
+
+Here we present an alternative formulation for Laplace encodings. This method addresses the same issues as the LPE over nodes, but also resolves the eigenvector sign ambiguity. Instead of encoding absolute positions as node features, the idea is to consider relative positions encoded as edge features.
+
+Inspired by the physical interactions introduced in 1 and 2, we can take a pair of nodes $( j _ { 1 } , j _ { 2 } )$ and obtain sign-invariant operators using the absolute subtraction $\lvert \phi _ { i , j _ { 1 } } - \bar { \phi } _ { i , j _ { 2 } } \rvert$ and the product $\phi _ { i , j _ { 1 } } \phi _ { i , j _ { 2 } }$ . These operators acknowledge that the sign of $\phi _ { i , j _ { 1 } }$ at a given node $j _ { 1 }$ is not important, but that the relative sign between nodes $j _ { 1 }$ and $j _ { 2 }$ is important. One might argue that we could directly compute the deterministic values from equations $( 1 , 2 )$ as edge features instead. However, our goal is to construct models that can learn which frequencies to emphasize and are not biased towards the lower frequencies — despite lower frequencies being useful in many tasks.
+
+This approach is only presented thoroughly in appendix A, since it suffers from a major computational bottleneck compared to the LPE over nodes. In fact, for a fully-connected graph, there are $N$ times more edges than nodes, thus the computation complexity is $\dot { O } ( m ^ { 2 } N ^ { 2 } )$ , or $\bar { O ( N ^ { 4 } ) }$ considering all eigenfunctions. The same limitation also affects memory and prevents the use of large batch sizes.
+
+# 3.3 Main Graph Transformer
+
+Our attention mechanism in the main Transformer is based on previous work [14], which attempts to repurpose the original Transformer to graphs by considering the graph structure and improving attention estimates with edge feature embeddings.
+
+In the following, note that $h _ { i } ^ { l }$ is the $i$ -th node’s features at the $l$ -th layer, and $e _ { i j }$ is the edge feature embedding between nodes $i$ and $j$ . Our model employs multi-head attention over all nodes:
+
+$$
+\hat { \pmb { h } } _ { i } ^ { l + 1 } = \pmb { O } _ { h } ^ { l } \prod _ { k = 1 } ^ { H } ( \sum _ { j \in V } w _ { i j } ^ { k , l } V ^ { k , l } { \pmb { h } } _ { j } ^ { l } )
+$$
+
+where $O _ { h } ^ { l } \in \mathbb { R } ^ { d \times d }$ , $V ^ { k , l } \in \mathbb { R } ^ { d _ { k } \times d }$ , $H$ denotes the number of heads, $L$ the number of layers, and $| |$ concatenation. Note that $d$ is the hidden dimension, while $d _ { k }$ is the dimension of a head $\begin{array} { r } { \frac { d } { H } = d _ { k } \rangle } \end{array}$ ).
+
+A key addition from our work is the design of an architecture that performs full-graph attention while preserving local connectivity with edge features via two sets of attention mechanisms: one for nodes connected by real edges in the sparse graph and one for nodes connected by added edges in the fully-connected graph. The attention weights $w _ { i j } ^ { k , l }$ in equation 3 at layer $l$ and head $k$ are given by:
+
+$$
+\begin{array} { r } { \hat { w } _ { i j } ^ { k , l } = \left\{ \begin{array} { l l } { \frac { Q ^ { 1 , k , l } h _ { i } ^ { l } \circ K ^ { 1 , k , l } h _ { j } ^ { l } \circ E ^ { 1 , k , l } e _ { i j } } { \sqrt { d _ { k } } } } & { \mathrm { i f ~ } i \mathrm { a n d ~ } j \mathrm { ~ a r e ~ c o n n e c t e d ~ i n ~ s p a r s e ~ g r a p h } } \\ { \frac { Q ^ { 2 , k , l } h _ { i } ^ { l } \circ K ^ { 2 , k , l } h _ { j } ^ { l } \circ E ^ { 2 , k , l } e _ { i j } } { \sqrt { d _ { k } } } } & { \mathrm { o t h e r w i s e } } \end{array} \right\} } \\ { w _ { i j } ^ { k , l } = \left\{ \begin{array} { l l } { \frac { 1 } { 1 + \gamma } \cdot \mathrm { s o f t m a x } ( \sum _ { d _ { k } } \hat { w } _ { i j } ^ { k , l } ) } & { \mathrm { i f ~ } i \mathrm { a n d ~ } j \mathrm { ~ a r e ~ c o n n e c t e d ~ i n ~ s p a r s e ~ g r a p h } } \\ { \frac { \gamma } { 1 + \gamma } \cdot \mathrm { s o f t m a x } ( \sum _ { d _ { k } } \hat { w } _ { i j } ^ { k , l } ) } & { \mathrm { o t h e r w i s e } } \end{array} \right\} } \end{array}
+$$
+
+where $\circ$ denotes element-wise multiplication and $Q ^ { 1 , k , l }$ , $Q ^ { 2 , k , l }$ , ${ \pmb K } ^ { 1 , k , l }$ , $\pmb { K } ^ { 2 , k , l }$ , $\mathbf { \delta } _ { E ^ { 1 , k , l } }$ , $E ^ { 2 , k , l } \in$ $\mathbb { R } ^ { d _ { k } \times d }$ . $\gamma \in \mathbb { R } ^ { + }$ is a hyperparameter which tunes the amount of bias towards full-graph attention, allowing flexibility of the model to different datasets and tasks where the necessity to capture longrange dependencies may vary. Note that softmax outputs are clamped between $- 5$ and 5 for numerical stability and that the keys, queries and edge projections are different for pairs of connected nodes $( Q ^ { 1 } , \dot { K ^ { 1 } } , E ^ { 1 } )$ and disconnected nodes $( Q ^ { \tilde { 2 } } , \dot { K } ^ { 2 } , E ^ { 2 } )$ .
+
+A multi-layer perceptron (MLP) with residual connections and normalization layers are then applied to update representations, in the same fashion as the GT method [14].
+
+$$
+\begin{array} { r } { \hat { \hat { h } } ^ { l + 1 } = \operatorname { N o r m } ( h _ { i } ^ { l } + \hat { h } _ { i } ^ { l + 1 } ) , \quad \hat { \hat { h } } _ { i } ^ { l + 1 } = W _ { 2 } ^ { l } \operatorname { R e L U } ( W _ { 1 } ^ { l } \hat { \hat { h } } _ { i } ^ { l + 1 } ) , \quad h _ { i } ^ { l + 1 } = \operatorname { N o r m } ( \hat { \hat { h } } ^ { l + 1 } + \hat { \hat { h } } _ { i } ^ { l + 1 } ) } \end{array}
+$$
+
+with the weight matrices $W _ { 1 } ^ { l } \in \mathbb { R } ^ { 2 d \times d }$ , $W _ { 2 } ^ { l } \in \mathbb { R } ^ { d \times 2 d }$ . Edge representations are not updated as it adds complexity with little to no performance gain. Bias terms are omitted for presentation.
+
+# 3.4 Limitations
+
+The first limitation of the node-wise LPE, and noted in Table 1 is the lack of sign invariance of the model. A random sign-flip of an eigenvector can produce different outputs for the LPE, meaning that the model needs to learn a representation invariant to these flips. We resolve this issue with the edge-wise LPE proposed in 3.2, but it comes at a computational cost.
+
+Another limitation of the approach is the computational complexity of the LPE being $O ( m ^ { 2 } N )$ , or $O ( N ^ { 3 } )$ if considering all eigenfunctions. Further, as nodes are batched in the LPE, the total memory on the GPU will be num_params \* num_nodes_in_batch instead of num_params $^ *$ batch_size. Although this is limiting, the LPE is not parameter hungry, with $k$ usually kept around 16. Most of the model’s parameters are in the Main Graph Transformer of complexity $O ( \bar { N } ^ { 2 } )$ .
+
+Despite Transformers having increased complexity, they managed to revolutionalize the NLP community. We argue that to shift away from the message-passing paradigm and generalize Transformers to graphs, it is natural to expect higher computational complexities. This is exacerbated by sequences being much simpler to understand than graphs due to their linear structure. Future work could overcome this by using variations of Transformers that scale linearly or logarithmically [34].
+
+# 3.5 Theoretical properties of the architecture
+
+Due to the full connectivity, it is trivial that our model does not suffer from the same limitations in expressivity as its convolutional/message-passing counterpart.
+
+WL test and universality. The DGN paper [4] showed that using the eigenvector $\phi _ { 1 }$ is enough to distinguish some non-isomorphic graphs indistinguishable by the 1-WL test.
+
+Given that our model uses the full set of eigenfunctions, and given enough parameters, our model can distinguish any pair of non-isomorphic graphs and is more powerful than any WL test in that regard. However, this does not solve the graph isomorphism problem in polynomial time; it only approximates a solution, and the number of parameters required is unknown and possibly non-polynomial. In appendix C, we present a proof of our statement, and discuss why the WL test is not well suited to study the expressivity of graph Transformers due to their universality.
+
+Reduced over-squashing. Over-squashing represents the difficulty of a graph neural network to pass information to distant neighbours due to the exponential blow-up in computational paths [1].
+
+For the fully-connected network, it is trivial to see that over-squashing is non-existent since there are direct paths between distant nodes.
+
+Physical interactions. Another point to consider is the ability of the network to learn physical interactions between nodes. This is especially important when the graph models physical, chemical, or biological structures, but can also help understanding pixel interaction in images [2, 3]. Here, we argue that our SAN model, which uses the Laplace spectrum more effectively, can learn to mimic the physical interactions presented in section 2.1.2. This contrasts with the convolutional approach that requires deep layers for the receptive field to capture long-distance interactions. It also contrasts with the GT model [14], which does not use eigenvalues or enough eigenfunctions to properly model physical interactions in early layers. However, due to the lack of sign-invariance in the proposed node-wise LPE, it is difficult to learn these interactions accurately. The edge-wise LPE (section 3.2) could be better suited for the problem, but it suffers from higher computational complexity.
+
+# 4 Experimental Results
+
+The model is implemented in PyTorch [31] and DGL [38] and tested on established benchmarks from [15] and [21] provided under MIT license. Specifically, we applied our method on ZINC, PATTERN, CLUSTER, MolHIV and MolPCBA, while following their respective training protocols with minor changes, as detailed in the appendix B.1. The computation time and hardware is provided in appendix B.4.
+
+We first conducted an ablation study to fairly compare the benefits of using full attention and/or the node LPE. We then took the best-performing model, tuned some of its hyperparameters, and matched it up against the current state-of-the-art methods. Since we use a similar attention mechanism, our code was developed on top of the code from the GT paper [14], provided under the MIT license.
+
+![](images/d5bbaf77fda3e2b0ff6f576a445dfc5384bfb1722dab6d7b4851bc2e2612da69.jpg)  
+Figure 5: Effect of the $\gamma$ parameter on the performance across datasets from [15, 21], using the Node LPE. Dotted black lines indicate sparse attention, which is equivalent to setting $\gamma = 0$ . Each box plot consists of 4 runs, with different seeds (except MolHIV).
+
+<table><tr><td rowspan=1 colspan=2>Model details</td><td rowspan=1 colspan=1>ZINC</td><td rowspan=1 colspan=1>PATTERN</td><td rowspan=1 colspan=1>CLUSTER</td><td rowspan=1 colspan=1>MOLHIV</td><td rowspan=6 colspan=2>BestWorst</td></tr><tr><td rowspan=1 colspan=1>AttentionLPE</td><td rowspan=1 colspan=1>LPE</td><td rowspan=1 colspan=1>MAE</td><td rowspan=1 colspan=1>% ACC</td><td rowspan=1 colspan=1>%ACC</td><td rowspan=1 colspan=1>% ROC-AUC</td><td rowspan=5 colspan=1></td><td rowspan=5 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Sparse</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0.267±0.032</td><td rowspan=1 colspan=1>83.613 ±0.663</td><td rowspan=1 colspan=1>75.683±0.098</td><td rowspan=1 colspan=1>73.46±0.71</td></tr><tr><td rowspan=1 colspan=1>Sparse</td><td rowspan=1 colspan=1>Node</td><td rowspan=1 colspan=1>0.198±0.004</td><td rowspan=1 colspan=1>81.329±2.150</td><td rowspan=1 colspan=1>75.738 ±0.106</td><td rowspan=1 colspan=1>76.61±0.62</td></tr><tr><td rowspan=1 colspan=1>Full</td><td rowspan=1 colspan=1>：</td><td rowspan=1 colspan=1>0.392 ±0.055</td><td rowspan=1 colspan=1>86.322±0.049</td><td rowspan=1 colspan=1>76.447±0.177</td><td rowspan=1 colspan=1>73.84± 1.80</td></tr><tr><td rowspan=1 colspan=1>Full</td><td rowspan=1 colspan=1>Node</td><td rowspan=1 colspan=1>0.157±0.006</td><td rowspan=1 colspan=1>86.441±0.040</td><td rowspan=1 colspan=1>76.691±0.247</td><td rowspan=1 colspan=1>77.57 ±0.61</td></tr></table>
+
+Figure 6: Ablation study on datasets from [15, 21] for the node LPE and full graph attention, with no hyperparameter tuning other than $\gamma$ taken from Figure 5. For a given dataset, all models use the same hyperparameters, but the hidden dimensions are adjusted to have $\sim 5 0 0 k$ learnable parameters. Means and uncertainties are derived from four runs, with different seeds (except MolHIV).
+
+# 4.1 Sparse vs. Full Attention
+
+To study the effect of incorporating full attention, we present an ablation study of the $\gamma$ parameter in Figure 5. We remind readers that $\gamma$ is used in equation 5 to balance between sparse and full attention. Setting $\gamma = 0$ strictly enables sparse attention, while $\gamma = 1$ does not bias the model in any direction.
+
+It is apparent that molecular datasets, namely ZINC and MOLHIV, benefit less from full attention, with the best parameter being $\log { \gamma } \in ( - 7 , - 5 )$ . On the other hand, the larger SBM datasets (PATTERN and CLUSTER) benefit from a higher $\gamma$ value. This can be explained by the fact that molecular graphs rely more on understanding local structures such as the presence of rings and specific bonds, especially in the artificial task from ZINC which relies on counting these specific patterns [15]. Furthermore, molecules are generally smaller than SBMs. As a result, we would expect less need for full attention, as information between distant nodes can be propagated with few iterations of even sparse attention. We also expect molecules to have fewer multiplicities, thus reducing the space of eigenvectors. Lastly, the performance gains in using full attention on the CLUSTER dataset can be attributed to it being a semi-supervised task, where some nodes within each graph are assigned their true labels. With full attention, every node receives information from the labeled nodes at each iteration, reinforcing confidence about the community they belong to.
+
+In Figure 6, we present another ablation study to measure the impact of the node LPE in both the sparse and full architectures. We observe that the proposed node-wise LPE contributes significantly to the performance for molecular tasks (ZINC and MOLHIV), and believe that it can be attributed to the detection of substructures (see Figure 3). For PATTERN and CLUSTER, the improvement is modest as the tasks are simple clustering [15]. Previous work even found that the optimal number of eigenvectors to construct PE for PATTERN is only 2 [14].
+
+# 4.2 Comparison to the state-of-the-art
+
+When comparing to the state-of-the-art (SOTA) models in the literature in Figure 7, we observe that our SAN model consistently performs better on all synthetic datasets from [15], highlighting the strong expressive power of the model. On the MolHIV dataset, the performance on the test set is slightly lower than the SOTA. However, the model performs better on the validation set $( 8 5 . 3 0 \% )$ in comparison to PNA $( 8 4 . 2 5 \% )$ and DGN $( 8 4 . 7 0 \% )$ . This can be attributed to a well-known issue with this dataset: the validation and test metrics have low correlation. In our experiments, we found higher test results with lower validation scores when restricting the number of epochs. Here, we also included results on the MolPCBA dataset, where we witnessed competitive results as well.
+
+Other top-performing models, namely PNA [11] and DGN [4], use a message-passing approach [17] with multiple aggregators. When compared to attention-based models, SAN consistently outperforms the SOTA by a wide margin. To the best of our knowledge, SAN is the first fully-connected model to perform well on graph tasks, as is evident by the poor performance of the GT (full) model.
+
+![](images/93b1105e11e1e554e1b6c09555f02af64ce0f2dd31b0d13d2087ec29687349b9.jpg)
+
+![](images/6044e1c2c1c58edc9537adb666ceec63206f09bcdef5ed386de81fa68b83196d.jpg)  
+Figure 7: Comparing our tuned model on datasets from [15, 21], against GCN [25], GraphSage [18], GIN [39], GAT [37], GatedGCN [5], PNA [11], and DGN [4]. Means and uncertainties are derived from four runs with different seeds, except MolHIV which uses 10 runs with identical seed. The number of parameters is fixed to $\sim 5 0 0 k$ for ZINC, PATTERN and CLUSTER.
+
+# 5 Conclusion
+
+In summary, we presented the SAN model for graph neural networks, a new Transformer-based architecture that is aware of the Laplace spectrum of a given graph from the learned positional encodings. The model was shown to perform on par or better than the SOTA on multiple benchmarks and outperforms other Attention-based models by a large margin. As is often the case with Transformers, the current model suffers from a computational bottleneck, and we leave it for future work to implement variations of Transformers that scale linearly or logarithmically. This will enable the edge-wise LPE presented in appendix A, a theoretically more powerful version of the SAN model.
+
+Societal Impact. The presented work is focused on theoretical and methodological improvements to graph neural networks, so there are limited direct societal impacts. However, indirect negative impacts could be caused by malicious applications developed using the algorithm. One such example is the tracking of people on social media by representing their interaction as graphs, thus predicting and influencing their behavior towards an external goal. It also has an environmental impact due to the greater energy use that arises from the computational cost $O ( m ^ { 2 } N + N ^ { 2 } )$ being larger than standard message passing or convolutional approaches of $O ( E )$ .
+
+# Funding Disclosure.
+
+Devin Kreuzer is supported by an NSERC grant.
+
+# References
+
+[1] Uri Alon and Eran Yahav. On the bottleneck of graph neural networks and its practical implications. arXiv:2006.05205 [cs, stat], 2020.   
+[2] Dominique Beaini, Sofiane Achiche, Alexandre Duperré, and Maxime Raison. Deep green function convolution for improving saliency in convolutional neural networks. The Visual Computer, 37(2):227–244, 2020.   
+[3] Dominique Beaini, Sofiane Achiche, and Maxime Raison. Improving convolutional neural networks via conservative field regularisation and integration.   
+[4] Dominique Beaini, Saro Passaro, Vincent Létourneau, William L. Hamilton, Gabriele Corso, and Pietro Liò. Directional graph networks. ICML2021, 2021.   
+[5] Xavier Bresson and Thomas Laurent. Residual gated graph convnets. arXiv preprint arXiv:1711.07553, 2017.   
+[6] Michael M. Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.   
+[7] F. Cajori. A History of Mathematics. AMS Chelsea Publishing Series. AMS Chelsea, 1999.   
+[8] Heng Chang, Yu Rong, Tingyang Xu, Wenbing Huang, Somayeh Sojoudi, Junzhou Huang, and Wenwu Zhu. Spectral graph attention network. CoRR, abs/2003.07450, 2020.   
+[9] Fan Chung and S. T. Yau. Discrete green’s functions. Journal of Combinatorial Theory, Series A, 91(1):191–214, 2000.   
+[10] Ronald R. Coifman and Stéphane Lafon. Diffusion maps. Applied and Computational Harmonic Analysis, 21(1):5–30, 2006. Special Issue: Diffusion Maps and Wavelets.   
+[11] Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Liò, and Petar Velickovi ˇ c. Principal ´ neighbourhood aggregation for graph nets. arXiv preprint arXiv:2004.05718, 2020.   
+[12] Luca Cosmo, Mikhail Panine, Arianna Rampini, Maks Ovsjanikov, Michael M. Bronstein, and Emanuele Rodola. Isospectralization, or how to hear shape, style, and correspondence. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   
+[13] Yushun Dong, Kaize Ding, Brian Jalaian, Shuiwang Ji, and Jundong Li. Graph neural networks with adaptive frequency response filter. CoRR, abs/2104.12840, 2021.   
+[14] Vijay Prakash Dwivedi and Xavier Bresson. A generalization of transformer networks to graphs, 2020.   
+[15] Vijay Prakash Dwivedi, Chaitanya K Joshi, Thomas Laurent, Yoshua Bengio, and Xavier Bresson. Benchmarking graph neural networks. arXiv preprint arXiv:2003.00982, 2020.   
+[16] Richard Phillips Feynman, Robert Benjamin Leighton, and Matthew Sands. The Feynman lectures on physics; New millennium ed. Basic Books, New York, NY, 2010. Originally published 1963-1965.   
+[17] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1263–1272. JMLR. org, 2017.   
+[18] Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in neural information processing systems, pages 1024–1034, 2017.   
+[19] William L. Hamilton. Graph Representation Learning. Morgan and Claypool, 2020.   
+[20] Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   
+[21] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.   
+[22] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. arXiv:1802.04364 [cs, stat], 2018.   
+[23] Mark Kac. Can one hear the shape of a drum? The American Mathematical Monthly, 73(4):1, 1966.   
+[24] Anees Kazi, Luca Cosmo, Nassir Navab, and Michael Bronstein. Differentiable graph module (dgm) graph convolutional networks. arXiv preprint arXiv:2002.04999, 2020.   
+[25] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.   
+[26] B. Levy. Laplace-beltrami eigenfunctions towards an algorithm that "understands" geometry. In IEEE International Conference on Shape Modeling and Applications 2006 (SMI’06), pages 13–13, 2006.   
+[27] Pan Li, Yanbang Wang, Hongwei Wang, and Jure Leskovec. Distance encoding: Design provably more powerful neural networks for graph representation learning, 2020.   
+[28] Yaron Lipman, Raif M. Rustamov, and Thomas A. Funkhouser. Biharmonic distance. ACM Trans. Graph., 29(3), July 2010.   
+[29] Haggai Maron, Heli Ben-Hamu, Hadar Serviansky, and Yaron Lipman. Provably powerful graph networks. arXiv preprint arXiv:1905.11136, 2019.   
+[30] Christopher Morris, Martin Ritzert, Matthias Fey, William L Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 4602–4609, 2019.   
+[31] Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.   
+[32] Emanuele Rodolà, Luca Cosmo, Michael M. Bronstein, Andrea Torsello, and Daniel Cremers. Partial functional correspondence, 2015.   
+[33] Joshua Schrier. Can one hear the shape of a molecule (from its coulomb matrix eigenvalues)? Journal of Chemical Information and Modeling, 60(8):3804–3811, 2020. Publisher: American Chemical Society.   
+[34] Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey, 2020.   
+[35] Edwin R. van Dam and Willem H. Haemers. Which graphs are determined by their spectrum? Linear Algebra and its Applications, 373:241–272, 2003.   
+[36] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, abs/1706.03762, 2017.   
+[37] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   
+[38] Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, Tianjun Xiao, Tong He, George Karypis, Jinyang Li, and Zheng Zhang. Deep graph library: A graph-centric, highly-performant package for graph neural networks. arXiv preprint arXiv:1909.01315, 2019.   
+[39] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.   
+[40] Chulhee Yun, Srinadh Bhojanapalli, Ankit Singh Rawat, Sashank J. Reddi, and Sanjiv Kumar. Are transformers universal approximators of sequence-to-sequence functions?, 2020.   
+[41] Chulhee Yun, Yin-Wen Chang, Srinadh Bhojanapalli, Ankit Singh Rawat, Sashank J. Reddi, and Sanjiv Kumar. $\$ 0( n )5$ connections are expressive enough: Universal approximability of sparse transformers. CoRR, abs/2006.04862, 2020.   
+[42] Seongjun Yun, Minbyul Jeong, Raehyun Kim, Jaewoo Kang, and Hyunwoo J. Kim. Graph transformer networks, 2020.

parse/train/huAdB-Tj4yG/huAdB-Tj4yG_content_list.json

@@ -0,0 +1,1267 @@
+[
+    {
+        "type": "text",
+        "text": "Rethinking Graph Transformers with Spectral Attention ",
+        "text_level": 1,
+        "bbox": [
+            218,
+            122,
+            781,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Devin Kreuzer ∗ McGill University, Mila Montreal, Canada devin.kreuzer@mail.mcgill.ca ",
+        "bbox": [
+            377,
+            222,
+            620,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Dominique Beaini \\* Valence Discovery Montreal, Canada dominique@valencediscovery.com ",
+        "bbox": [
+            186,
+            297,
+            446,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "William L. Hamilton   \nMcGill University, Mila   \nMontreal, Canada   \nwlh@cs.mcgill.ca ",
+        "bbox": [
+            465,
+            297,
+            625,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vincent Létourneau University of Ottawa Ottawa, Canada vletour2@uottawa.ca ",
+        "bbox": [
+            645,
+            299,
+            812,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Prudencio Tossou Valence Discovery Montreal, Canada prudencio@valencediscovery.com ",
+        "bbox": [
+            369,
+            376,
+            627,
+            431
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            467,
+            535,
+            483
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, the Transformer architecture has proven to be very successful in sequence processing, but its application to other data structures, such as graphs, has remained limited due to the difficulty of properly defining positions. Here, we present the Spectral Attention Network (SAN), which uses a learned positional encoding (LPE) that can take advantage of the full Laplacian spectrum to learn the position of each node in a given graph. This LPE is then added to the node features of the graph and passed to a fully-connected Transformer. By leveraging the full spectrum of the Laplacian, our model is theoretically powerful in distinguishing graphs, and can better detect similar sub-structures from their resonance. Further, by fully connecting the graph, the Transformer does not suffer from over-squashing, an information bottleneck of most GNNs, and enables better modeling of physical phenomenons such as heat transfer and electric interaction. When tested empirically on a set of 4 standard datasets, our model performs on par or better than state-of-theart GNNs, and outperforms any attention-based model by a wide margin, becoming the first fully-connected architecture to perform well on graph benchmarks. ",
+        "bbox": [
+            233,
+            498,
+            766,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            729,
+            310,
+            747
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The prevailing strategy for graph neural networks (GNNs) has been to directly encode graph structure structure through a sparse message-passing process [17, 19]. In this approach, vector messages are iteratively passed between nodes that are connected in the graph. Multiple instantiations of this message-passing paradigm have been proposed, differing in the architectural details of the message-passing apparatus (see [19] for a review). ",
+        "bbox": [
+            174,
+            761,
+            825,
+            830
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, there is a growing recognition that the message-passing paradigm has inherent limitations. The expressive power of message passing appears inexorably bounded by the Weisfeiler-Lehman isomorphism hierarchy [29, 30, 39]. Message-passing GNNs are known to suffer from pathologies, such as oversmoothing, due to their repeated aggregation of local information [19], and over-squashing, due to the exponential blow-up in computation paths as the model depth increases [1]. ",
+        "bbox": [
+            176,
+            837,
+            825,
+            878
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As a result, there is a growing interest in deep learning techniques that encode graph structure as a soft inductive bias, rather than as a hard-coded aspect of message passing [14, 24]. A central issue with message-passing paradigm is that input graph structure is encoded by restricting the structure of the model’s computation graph, inherently limiting its flexibility. This reminds us of how early recurrent neural networks (RNNs) encoded sequential structure via their computation graph—a strategy that leads to well-known pathologies such as the inability to model long-range dependencies [20]. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            209
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There is a growing trend across deep learning towards more flexible architectures, which avoid strict and structural inductive biases. Most notably, the exceptionally successful Transformer architecture removes any structural inductive bias by encoding the structure via soft inductive biases, such as positional encodings [36]. In the context of GNNs, the self-attention mechanism of a Transformer can be viewed as passing messages between all nodes, regardless of the input graph connectivity. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            285
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Prior work has proposed to use attention in GNNs in different ways. First, the GAT model [37] proposed local attention on pairs of nodes that allows a learnable convolutional kernel. The GTN work [42] has improved on the GAT for node and link predictions while keeping a similar architecture, while other message-passing approaches have used enhancing spectral features [8, 13] . More recently, the GT model [14] was proposed as a generalization of Transformers to graphs, where they experimented with sparse and full graph attention while providing low-frequency eigenvectors of the Laplacian as positional encodings. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we offer a principled investigation of how Transformer architectures can be applied in graph representation learning. Our primary contribution is the development of novel and powerful learnable positional encoding methods, which are rooted in spectral graph theory. Our positional encoding technique — and the resulting spectral attention network (SAN) architecture — addresses key theoretical limitations in prior graph Transformer work [14] and provably exceeds the expressive power of standard message-passing GNNs. We show that full Transformer-style attention provides consistent empirical gains compared to an equivalent sparse message-passing model, and we demonstrate that our SAN architecture is competitive with or exceeding the state-of-the-art on several well-known graph benchmarks. An overview of the entire method is presented in Figure 1, with a link to the code here: https://github.com/DevinKreuzer/SAN. ",
+        "bbox": [
+            174,
+            393,
+            826,
+            532
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Theoretical Motivations ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            551,
+            405,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There can be a significant loss in structural information if naively generalizing Transformers to graphs. To preserve this information as well as local connectivity, previous studies [37, 14] have proposed to use the eigenfunctions of their Laplacian as positional encodings. Taking this idea further by using the full expressivity of eigenfunctions as positional encodings, we can propose a principled way of understanding graph structures using their spectra. The advantages of our methods compared to previous studies [37, 14] are shown in Table 1. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/2a3fa9f7cf5a7f2db232ad3eb7037538e4495943b1612d6e1b64db4ca4022e85.jpg",
+        "table_caption": [
+            "Table 1: Comparison of the properties of different graph Transformer models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>MODELS</td><td>GAT</td><td>GT sparse</td><td>GT full</td><td>SAN</td></tr><tr><td>Preserves local structure in attention</td><td>&gt;xxx</td><td>√&lt;x√</td><td>xxv√</td><td>?</td></tr><tr><td>Uses edge features</td><td></td><td></td><td></td><td></td></tr><tr><td>Connects non-neighbouring nodes</td><td></td><td></td><td></td><td></td></tr><tr><td>Uses eigenvector-based PE for attention</td><td></td><td></td><td></td><td></td></tr><tr><td>Use a PE with structural information</td><td>x</td><td>←</td><td>+</td><td></td></tr><tr><td>Considers the ordering of the eigenvalues</td><td>X</td><td>√</td><td>vv</td><td></td></tr><tr><td>Invariant to the norm of the eigenvector</td><td></td><td>√</td><td></td><td></td></tr><tr><td>Considers the spectrum of eigenvalues</td><td>X</td><td></td><td></td><td></td></tr><tr><td>Considers variable # of eigenvectors</td><td></td><td></td><td></td><td></td></tr><tr><td>Aware of eigenvalue multiplicities</td><td></td><td>xxx</td><td></td><td>√</td></tr><tr><td>Invariant to the sign of the eigenvectors</td><td></td><td>×</td><td>xxxx</td><td>X</td></tr></table>",
+        "bbox": [
+            222,
+            700,
+            777,
+            873
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/6fdefa909906706bb5dccb238d25f45b161e68c2331a8e8d01f82d197ead59e6.jpg",
+        "image_caption": [
+            "Figure 1: The proposed SAN model with the node LPE, a generalization of Transformers to graphs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            80,
+            826,
+            464
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Absolute and relative positional encoding with eigenfunctions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            638,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The notion of positional encodings (PEs) in graphs is not a trivial concept, as there exists no canonical way of ordering nodes or defining axes. In this section, we investigate how eigenfunctions of the Laplacian can be used to define absolute and relative PEs in graphs, to measure physical interactions between nodes, and to enable ”hearing” of specific sub-structures - similar to how the sound of a drum can reveal its structure. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            609
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1.1 Eigenvectors equate to sine functions over graphs ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            628,
+            568,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the Transformer architecture, a fundamental aspect is the use of sine and cosine functions as PEs for sequences [36]. However, sinusoids cannot be clearly defined for arbitrary graphs, since there is no clear notion of position along an axis. Instead, their equivalent is given by the eigenvectors $\\phi$ of the graph Laplacian $\\pmb { L }$ . Indeed, in a Euclidean space, the Laplacian (or Laplace) operator corresponds to the divergence of the gradient and its eigenfunctions are sine/cosine functions, with the squared frequencies corresponding to the eigenvalues (we sometimes interchange the two notions from here on). Hence, in the graph domain, the eigenvectors of the graph Laplacian are the natural equivalent of sine functions, and this intuition was employed in multiple recent works which use the eigenvectors as PEs for GNNs [15], for directional flows [4] and for Transformers [14]. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            779
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Being equivalent to sine functions, we naturally find that the Fourier Transform of a function $\\mathcal { F } [ f ]$ applied to a graph gives $\\mathcal { F } [ f ] ( \\lambda _ { i } ) = \\langle f , \\phi _ { i } \\rangle$ , where the eigenvalue is considered as a position in the Fourier domain of that graph [6]. Thus, the eigenvectors are best viewed as vectors positioned on the axis of eigenvalues rather than components of a matrix as illustrated in Figure 2. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            840
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1.2 What do eigenfunctions tell us about relative positions? ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            858,
+            607,
+            873
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In addition to being the analog of sine functions, the eigenvectors of the Laplacian also hold important information about the physics of a system and can reveal distance metrics. This is not surprising as the Laplacian is a fundamental operator in physics and is notably used in Maxwell’s equations [16] and the heat diffusion [6]. ",
+        "bbox": [
+            173,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/62eb856f3aba9054a14539ddc42e07cb54b4c6c12479b8ea05b4e55506ff52b1.jpg",
+        "image_caption": [
+            "Figure 2: a) Standard view of the eigenvectors as a matrix. b) Eigenvectors $\\phi _ { i }$ viewed as vectors positionned on the axis of frequencies (eigenvalues). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            87,
+            764,
+            156
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            207,
+            821,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In electromagnetic theory, the (pseudo)inverse of the Laplacian, known in mathematics as the Green’s function of the Laplacian [9], represents the electrostatic potential of a given charge. In a graph, the same concept uses the pseudo-inverse of the Laplacian $G$ and can be computed by its eigenfunctions. See equation 1 , where $G ( j _ { 1 } , j _ { 2 } )$ is the electric potential between nodes $j _ { 1 }$ and $j _ { 2 }$ , $\\hat { \\phi } _ { i }$ and $\\hat { \\lambda _ { i } }$ are the $i$ -th eigenvectors and eigenvalues of the symmetric Laplacian $D ^ { \\frac { - 1 } { 2 } } L D ^ { \\frac { - 1 } { 2 } }$ , and $_ D$ is the degree matrix, and $\\hat { \\phi } _ { i , j }$ the $j$ -th row of the vector. ",
+        "bbox": [
+            173,
+            242,
+            826,
+            334
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0082920e6813a8acaede3a6e6dd1c66bcd9a72eba4b09e6db026fe9635520b6.jpg",
+        "text": "$$\nG ( j _ { 1 } , j _ { 2 } ) = d _ { j _ { 1 } } ^ { \\frac { 1 } { 2 } } d _ { j _ { 2 } } ^ { \\frac { - 1 } { 2 } } \\sum _ { i > 0 } ^ { } \\frac { ( \\hat { \\phi } _ { i , j _ { 1 } } \\hat { \\phi } _ { i , j _ { 2 } } ) ^ { 2 } } { \\hat { \\lambda } _ { i } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            342,
+            627,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Further, the original solution of the heat equation given by Fourier relied on a sum of sines/cosines known as a Fourier series [7]. As eigenvectors of the Laplacian are the analogue of these functions in graphs, we find similar solutions. Knowing that heat kernels are correlated to random walks [6, 4], we use the interaction between two heat kernels to define in equation 2 the diffusion distance $d _ { D }$ between nodes $j _ { 1 } , j _ { 2 }$ [6, 10]. Similarly, the biharmonic distance $d _ { B }$ was proposed as a better measure of distances [28]. Here we use the eigenfunctions of the regular Laplacian $\\pmb { L }$ . ",
+        "bbox": [
+            173,
+            395,
+            826,
+            479
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/43a203c974d8ee197dba4f7fb4950c68ca9da3790a9aabee1e1b1aa64928c3c2.jpg",
+        "text": "$$\nd _ { D } ^ { 2 } ( j _ { 1 } , j _ { 2 } ) = \\sum _ { k > 0 } e ^ { - 2 t \\lambda _ { i } } ( \\phi _ { i , j _ { 1 } } - \\phi _ { i , j _ { 2 } } ) ^ { 2 } \\quad , \\quad d _ { B } ^ { 2 } ( j _ { 1 } , j _ { 2 } ) = \\sum _ { i > 0 } \\frac { ( \\phi _ { i , j _ { 1 } } - \\phi _ { i , j _ { 2 } } ) ^ { 2 } } { \\lambda _ { i } ^ { 2 } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            487,
+            764,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There are a few things to note from these equations. Firstly, they highlight the importance of pairing eigenvectors and their corresponding eigenvalues when supplying information about relative positions in a graph. Secondly, we notice that the product of eigenvectors is proportional to the electrostatic interaction, while the subtraction is proportional to the diffusion and biharmonic distances. Lastly, there is a consistent pattern across all 3 equations: smaller frequencies/eigenvalues are more heavily weighted when determining distances between nodes. ",
+        "bbox": [
+            173,
+            539,
+            826,
+            625
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1.3 Hearing the shape of a graph and its sub-structures ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            638,
+            583,
+            654
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another well-known property of eigenvalues is how they can be used to discriminate between different graph structures and sub-structures, as they can be interpreted as the frequencies of resonance of the graph. This led to the famous question about whether we can hear the shape of a drum from its eigenvalues [23], with the same questions also applying to geometric objects [12] and 3D molecules [33]. Various success was found with the eigenfunctions being used for partial functional correspondence [32], algorithmic understanding geometries [26], and style correspondence [12]. Examples of eigenvectors for molecular graphs are presented in Figure 3. ",
+        "bbox": [
+            173,
+            661,
+            826,
+            760
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0da6292320ff0dc820d5dede7d45fd8e901266195d4c5355023fa0868362024.jpg",
+        "image_caption": [
+            "Figure 3: Examples of eigenvalues $\\lambda _ { i }$ and eigenvectors $\\phi _ { i }$ for molecular graphs. The low-frequency eigenvectors $\\phi _ { 1 } , \\phi _ { 2 }$ are spread accross the graph, while higher frequencies, such as $\\phi _ { 1 4 } , \\phi _ { 1 5 }$ for the left molecule or $\\phi _ { 1 0 } , \\phi _ { 1 1 }$ for the right molecule, often resonate in local structures. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            250,
+            770,
+            750,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 Laplace Eigenfunctions etiquette ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            436,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Euclidean space and sequences, using sinusoids as PEs is trivial: we can simply select a set of frequencies, compute the sinusoids, and add or concatenate them to the input embeddings, as is done in the original Transformer [36]. However, in arbitrary graphs, reproducing these steps is not as simple since each graph has a unique set of eigenfunctions. In the following section, we present key principles from spectral graph theory to consider when constructing PEs for graphs, most of which have been overlooked by prior methods. They include normalization, the importance of the eigenvalues and their multiplicities, the number of eigenvectors being variable, and sign ambiguities. Our LPE architectures, presented in section 3, aim to address them. ",
+        "bbox": [
+            174,
+            121,
+            825,
+            232
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Normalization. Given an eigenvalue of the Laplacian, there is an associated eigenspace of dimension greater than 1. To make use of this information in our model, a single eigenvector has to be chosen. In our work, we use the $L _ { 2 }$ normalization since it is compatible with the definition of the Green’s function (1). Thus, we will always chose eigenvectors $\\phi$ such that $\\langle \\phi , \\phi \\rangle = 1$ . ",
+        "bbox": [
+            174,
+            238,
+            825,
+            294
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Eigenvalues. Another fundamental aspect is that the eigenvalue associated with each eigenvector supplies valuable information. An ordering of the eigenvectors based on their eigenvalue works in sequences since the frequencies are pre-determined. However, this assumption does not work in graphs since the eigenvalues in their spectrum can vary. For example, in Figure 3, we observe how an ordering would miss the fact that both molecules resonate at $\\lambda = 1$ in different ways. ",
+        "bbox": [
+            174,
+            300,
+            825,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Multiplicities. Another important problem with choosing eigenfunctions is the possibility of a high multiplicity of the eigenvalues, i.e. when an eigenvalue appears as a root of the characteristic polynomial more than once. In this case, the associated eigenspace may have dimension 2 or more as we can generate a valid eigenvector from any linear combination of eigenvectors with the same eigenvalue. This further complicates the problem of choosing eigenvectors for algorithmic computations and highlights the importance of having a model that can handle this ambiguity. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            459
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Variable number of eigenvectors. A graph $G _ { i }$ can have at most $N _ { i }$ linearly independent eigenvectors with $N _ { i }$ being its number of nodes. Most importantly, $N _ { i }$ can vary across all $G _ { i }$ in the dataset. Prior work [14] elected to select a fixed number $k$ eigenvectors for each graph, where $k \\leq N _ { i } , \\forall i$ . This produces a major bottleneck when the smallest graphs have significantly fewer nodes than the largest graphs in the dataset since a very small proportion of eigenvectors will be used for large graphs. This inevitably causes loss of information and motivates the need for a model which constructs fixed PEs of dimension $k$ , where $k$ does not depend on the number of eigenvectors in the graph. ",
+        "bbox": [
+            173,
+            465,
+            825,
+            563
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Sign invariance. As noted earlier, there is a sign ambiguity with the eigenvectors. With the sign of $\\phi$ being independent of its normalization, we are left with a total of $2 ^ { k }$ possible combination of signs when choosing $k$ eigenvectors of a graph. Previous work has proposed to do data augmentation by randomly flipping the sign of the eigenvectors [4, 15, 14], and although it can work when $k$ is small, it becomes intractable for large $k$ . ",
+        "bbox": [
+            174,
+            569,
+            825,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 Learning with Eigenfunctions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            666,
+            419,
+            681
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning generalizable information from eigenfunctions is fundamental to their succesful usage. Here we detail important points that support it is possible to do so if done correctly. ",
+        "bbox": [
+            176,
+            696,
+            823,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar graphs have similar spectra. Thus, we can expect the network to transfer patterns across graphs through the similarity of their spectra. In fact, spectral graph theory tells us that the lowest and largest non-zero eigenvalues are both linked to the geometry of the graph (algebraic connectivity and spectral radius). ",
+        "bbox": [
+            174,
+            731,
+            825,
+            786
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Eigenspaces contain geometric information. Spectral graph theory has studied the geometric and physical properties of graphs from their Laplacian eigenfunctions in depth. Developing a method that can use the full spectrum of a graph makes it theoretically possible capture this information. It us thus important to capture differences between the full eigenspaces instead of minor differences between specific eigenvalues or eigenvectors from graph to graph. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            863
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learned positions are relative within graphs. Eigenspaces are used to understand the relationship between nodes within graphs, not across them. Proposed models should therefore only compare the eigenfunctions of nodes within graphs. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 Model Architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            369,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose an elegant architecture that can use the eigenfunctions as PEs while addressing the concerns raised in section 2.2. Our Spectral Attention Network (SAN) model inputs eigenfunctions of a graph and projects them into a learned positional encoding (LPE) of fixed size. The LPE allows the network to use up to the entire Laplace spectrum of each graph, learn how the frequencies interact, and decide which are most important for the given task. ",
+        "bbox": [
+            174,
+            122,
+            825,
+            191
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We propose a two-step learning process summarized earlier in Figure 1. The first step, depicted by blocks (c-d-e) in the figure, applies a Transformer over the eigenfunctions of each node to generate an LPE matrix for each graph. The LPE is then concatenated to the node embeddings (blocks g-h), before being passed to the Graph Transformer (block i). If the task involves graph classification or regression, the final node embeddings are subsequently passed to a final pooling layer. ",
+        "bbox": [
+            174,
+            198,
+            825,
+            268
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 LPE Transformer Over Nodes ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            287,
+            421,
+            303
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Using Laplace encodings as node features is ubiquitous in the literature concerning the topic. Here, we propose a method for learning node PEs motivated by the principles from section 2.2. The idea of our LPE is inspired by Figure 2, where the eigenvectors $\\phi$ are represented as a non-uniform sequence with the eigenvalue $\\lambda$ being the position on the frequency axis. With this representation, Transformers are a natural choice for processing them and generating a fixed-size PE. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            383
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proposed LPE architecture is presented in Figure 4. First, we create an embedding matrix of size $2 \\times m$ for each node $j$ by concatenating the $m$ -lowest eigenvalues with their associated eigenvectors. Here, $m$ is a hyper-parameter for the maximum number of eigenvectors to compute and is analog to the variable-length sequence for a standard Transformer. For graphs where $m > N$ , a masked-padding is simply added. Note that to capture the entire spectrum of all graphs, one can simply select $m$ such that it is equal to the maximum number of nodes a graph has in the dataset. A linear layer is then applied on the dimension of size 2 to generate new embeddings of size $k$ . A Transformer Encoder then computes self-attention on the sequence of length $m$ and hidden dimension $k$ . Finally, a sum pooling reduces the sequence into a fixed $k$ -dimensional node embedding. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            515
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The LPE model addresses key limitations of previous graph Transformers and is aligned with the first four etiquettes presented in section 2.2. By concatenating the eigenvalues with the normalized eigenvector, this model directly addresses the first three etiquettes. Namely, it normalizes the eigenvectors, pairs eigenvectors with their eigenvalues and treats the number of eigenvectors as a variable. Furthermore, the model is aware of multiplicities and has the potential to linearly combine or ignore some of the repeated eigenvalues. ",
+        "bbox": [
+            173,
+            521,
+            825,
+            604
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, this method still does not address the limitation that the sign of the pre-computed eigenvectors is arbitrary. To combat this issue, we randomly flip the sign of the pre-computed eigenvectors during training as employed by previous work [15, 14], to promote invariance to the sign ambiguity. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/db1815f2d04f6f59e1b99c9323e1f509fa40804dac0fe563e0f4530eb752450e.jpg",
+        "image_caption": [
+            "Figure 4: Learned positional encoding (LPE) architectures, with the model being aware of the graph’s Laplace spectrum by considering $m$ eigenvalues and eigenvectors, where we permit $m \\leq N$ , with $N$ denoting the number of nodes. Since the Transformer loops over the nodes, each node can be viewed as an element of a batch to parallelize the computation. Here $\\phi _ { i , j }$ is the $j$ -th element of the eigenvector paired to the $i$ -th lowest eigenvalue $\\lambda _ { i }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            667,
+            823,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 LPE Transformer Over Edges ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            421,
+            858
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we present an alternative formulation for Laplace encodings. This method addresses the same issues as the LPE over nodes, but also resolves the eigenvector sign ambiguity. Instead of encoding absolute positions as node features, the idea is to consider relative positions encoded as edge features. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the physical interactions introduced in 1 and 2, we can take a pair of nodes $( j _ { 1 } , j _ { 2 } )$ and obtain sign-invariant operators using the absolute subtraction $\\lvert \\phi _ { i , j _ { 1 } } - \\bar { \\phi } _ { i , j _ { 2 } } \\rvert$ and the product $\\phi _ { i , j _ { 1 } } \\phi _ { i , j _ { 2 } }$ . These operators acknowledge that the sign of $\\phi _ { i , j _ { 1 } }$ at a given node $j _ { 1 }$ is not important, but that the relative sign between nodes $j _ { 1 }$ and $j _ { 2 }$ is important. One might argue that we could directly compute the deterministic values from equations $( 1 , 2 )$ as edge features instead. However, our goal is to construct models that can learn which frequencies to emphasize and are not biased towards the lower frequencies — despite lower frequencies being useful in many tasks. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            189
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This approach is only presented thoroughly in appendix A, since it suffers from a major computational bottleneck compared to the LPE over nodes. In fact, for a fully-connected graph, there are $N$ times more edges than nodes, thus the computation complexity is $\\dot { O } ( m ^ { 2 } N ^ { 2 } )$ , or $\\bar { O ( N ^ { 4 } ) }$ considering all eigenfunctions. The same limitation also affects memory and prevents the use of large batch sizes. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            251
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 Main Graph Transformer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            265,
+            393,
+            281
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our attention mechanism in the main Transformer is based on previous work [14], which attempts to repurpose the original Transformer to graphs by considering the graph structure and improving attention estimates with edge feature embeddings. ",
+        "bbox": [
+            176,
+            291,
+            825,
+            334
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the following, note that $h _ { i } ^ { l }$ is the $i$ -th node’s features at the $l$ -th layer, and $e _ { i j }$ is the edge feature embedding between nodes $i$ and $j$ . Our model employs multi-head attention over all nodes: ",
+        "bbox": [
+            173,
+            339,
+            821,
+            368
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9364f62ffa3844d60241d68113e262bf8075f405b8e4cb878fea96e0efe807d.jpg",
+        "text": "$$\n\\hat { \\pmb { h } } _ { i } ^ { l + 1 } = \\pmb { O } _ { h } ^ { l } \\prod _ { k = 1 } ^ { H } ( \\sum _ { j \\in V } w _ { i j } ^ { k , l } V ^ { k , l } { \\pmb { h } } _ { j } ^ { l } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            385,
+            371,
+            611,
+            416
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $O _ { h } ^ { l } \\in \\mathbb { R } ^ { d \\times d }$ , $V ^ { k , l } \\in \\mathbb { R } ^ { d _ { k } \\times d }$ , $H$ denotes the number of heads, $L$ the number of layers, and $| |$ concatenation. Note that $d$ is the hidden dimension, while $d _ { k }$ is the dimension of a head $\\begin{array} { r } { \\frac { d } { H } = d _ { k } \\rangle } \\end{array}$ ). ",
+        "bbox": [
+            169,
+            426,
+            825,
+            459
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A key addition from our work is the design of an architecture that performs full-graph attention while preserving local connectivity with edge features via two sets of attention mechanisms: one for nodes connected by real edges in the sparse graph and one for nodes connected by added edges in the fully-connected graph. The attention weights $w _ { i j } ^ { k , l }$ in equation 3 at layer $l$ and head $k$ are given by: ",
+        "bbox": [
+            174,
+            463,
+            825,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f2fe6f521525fad25b61150be82c97261abcb811159bb6e71247147b4fdddc60.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { w } _ { i j } ^ { k , l } = \\left\\{ \\begin{array} { l l } { \\frac { Q ^ { 1 , k , l } h _ { i } ^ { l } \\circ K ^ { 1 , k , l } h _ { j } ^ { l } \\circ E ^ { 1 , k , l } e _ { i j } } { \\sqrt { d _ { k } } } } & { \\mathrm { i f ~ } i \\mathrm { a n d ~ } j \\mathrm { ~ a r e ~ c o n n e c t e d ~ i n ~ s p a r s e ~ g r a p h } } \\\\ { \\frac { Q ^ { 2 , k , l } h _ { i } ^ { l } \\circ K ^ { 2 , k , l } h _ { j } ^ { l } \\circ E ^ { 2 , k , l } e _ { i j } } { \\sqrt { d _ { k } } } } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right\\} } \\\\ { w _ { i j } ^ { k , l } = \\left\\{ \\begin{array} { l l } { \\frac { 1 } { 1 + \\gamma } \\cdot \\mathrm { s o f t m a x } ( \\sum _ { d _ { k } } \\hat { w } _ { i j } ^ { k , l } ) } & { \\mathrm { i f ~ } i \\mathrm { a n d ~ } j \\mathrm { ~ a r e ~ c o n n e c t e d ~ i n ~ s p a r s e ~ g r a p h } } \\\\ { \\frac { \\gamma } { 1 + \\gamma } \\cdot \\mathrm { s o f t m a x } ( \\sum _ { d _ { k } } \\hat { w } _ { i j } ^ { k , l } ) } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right\\} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            225,
+            529,
+            771,
+            650
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\circ$ denotes element-wise multiplication and $Q ^ { 1 , k , l }$ , $Q ^ { 2 , k , l }$ , ${ \\pmb K } ^ { 1 , k , l }$ , $\\pmb { K } ^ { 2 , k , l }$ , $\\mathbf { \\delta } _ { E ^ { 1 , k , l } }$ , $E ^ { 2 , k , l } \\in$ $\\mathbb { R } ^ { d _ { k } \\times d }$ . $\\gamma \\in \\mathbb { R } ^ { + }$ is a hyperparameter which tunes the amount of bias towards full-graph attention, allowing flexibility of the model to different datasets and tasks where the necessity to capture longrange dependencies may vary. Note that softmax outputs are clamped between $- 5$ and 5 for numerical stability and that the keys, queries and edge projections are different for pairs of connected nodes $( Q ^ { 1 } , \\dot { K ^ { 1 } } , E ^ { 1 } )$ and disconnected nodes $( Q ^ { \\tilde { 2 } } , \\dot { K } ^ { 2 } , E ^ { 2 } )$ . ",
+        "bbox": [
+            173,
+            659,
+            826,
+            744
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A multi-layer perceptron (MLP) with residual connections and normalization layers are then applied to update representations, in the same fashion as the GT method [14]. ",
+        "bbox": [
+            173,
+            750,
+            821,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5a0e7db9212a629d2cb3573b11c3f152e9633257acc1cf14f57d83c349e3bbb5.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { \\hat { h } } ^ { l + 1 } = \\operatorname { N o r m } ( h _ { i } ^ { l } + \\hat { h } _ { i } ^ { l + 1 } ) , \\quad \\hat { \\hat { h } } _ { i } ^ { l + 1 } = W _ { 2 } ^ { l } \\operatorname { R e L U } ( W _ { 1 } ^ { l } \\hat { \\hat { h } } _ { i } ^ { l + 1 } ) , \\quad h _ { i } ^ { l + 1 } = \\operatorname { N o r m } ( \\hat { \\hat { h } } ^ { l + 1 } + \\hat { \\hat { h } } _ { i } ^ { l + 1 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            776,
+            790,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "with the weight matrices $W _ { 1 } ^ { l } \\in \\mathbb { R } ^ { 2 d \\times d }$ , $W _ { 2 } ^ { l } \\in \\mathbb { R } ^ { d \\times 2 d }$ . Edge representations are not updated as it adds complexity with little to no performance gain. Bias terms are omitted for presentation. ",
+        "bbox": [
+            174,
+            811,
+            826,
+            843
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Limitations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            294,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The first limitation of the node-wise LPE, and noted in Table 1 is the lack of sign invariance of the model. A random sign-flip of an eigenvector can produce different outputs for the LPE, meaning that the model needs to learn a representation invariant to these flips. We resolve this issue with the edge-wise LPE proposed in 3.2, but it comes at a computational cost. ",
+        "bbox": [
+            173,
+            882,
+            823,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another limitation of the approach is the computational complexity of the LPE being $O ( m ^ { 2 } N )$ , or $O ( N ^ { 3 } )$ if considering all eigenfunctions. Further, as nodes are batched in the LPE, the total memory on the GPU will be num_params \\* num_nodes_in_batch instead of num_params $^ *$ batch_size. Although this is limiting, the LPE is not parameter hungry, with $k$ usually kept around 16. Most of the model’s parameters are in the Main Graph Transformer of complexity $O ( \\bar { N } ^ { 2 } )$ . ",
+        "bbox": [
+            174,
+            126,
+            825,
+            195
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Despite Transformers having increased complexity, they managed to revolutionalize the NLP community. We argue that to shift away from the message-passing paradigm and generalize Transformers to graphs, it is natural to expect higher computational complexities. This is exacerbated by sequences being much simpler to understand than graphs due to their linear structure. Future work could overcome this by using variations of Transformers that scale linearly or logarithmically [34]. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            271
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.5 Theoretical properties of the architecture ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            304,
+            498,
+            319
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Due to the full connectivity, it is trivial that our model does not suffer from the same limitations in expressivity as its convolutional/message-passing counterpart. ",
+        "bbox": [
+            176,
+            337,
+            821,
+            364
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "WL test and universality. The DGN paper [4] showed that using the eigenvector $\\phi _ { 1 }$ is enough to distinguish some non-isomorphic graphs indistinguishable by the 1-WL test. ",
+        "bbox": [
+            176,
+            371,
+            820,
+            398
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Given that our model uses the full set of eigenfunctions, and given enough parameters, our model can distinguish any pair of non-isomorphic graphs and is more powerful than any WL test in that regard. However, this does not solve the graph isomorphism problem in polynomial time; it only approximates a solution, and the number of parameters required is unknown and possibly non-polynomial. In appendix C, we present a proof of our statement, and discuss why the WL test is not well suited to study the expressivity of graph Transformers due to their universality. ",
+        "bbox": [
+            174,
+            405,
+            825,
+            488
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Reduced over-squashing. Over-squashing represents the difficulty of a graph neural network to pass information to distant neighbours due to the exponential blow-up in computational paths [1]. ",
+        "bbox": [
+            176,
+            494,
+            820,
+            523
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the fully-connected network, it is trivial to see that over-squashing is non-existent since there are direct paths between distant nodes. ",
+        "bbox": [
+            174,
+            529,
+            821,
+            558
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Physical interactions. Another point to consider is the ability of the network to learn physical interactions between nodes. This is especially important when the graph models physical, chemical, or biological structures, but can also help understanding pixel interaction in images [2, 3]. Here, we argue that our SAN model, which uses the Laplace spectrum more effectively, can learn to mimic the physical interactions presented in section 2.1.2. This contrasts with the convolutional approach that requires deep layers for the receptive field to capture long-distance interactions. It also contrasts with the GT model [14], which does not use eigenvalues or enough eigenfunctions to properly model physical interactions in early layers. However, due to the lack of sign-invariance in the proposed node-wise LPE, it is difficult to learn these interactions accurately. The edge-wise LPE (section 3.2) could be better suited for the problem, but it suffers from higher computational complexity. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            702
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Experimental Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            738,
+            385,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The model is implemented in PyTorch [31] and DGL [38] and tested on established benchmarks from [15] and [21] provided under MIT license. Specifically, we applied our method on ZINC, PATTERN, CLUSTER, MolHIV and MolPCBA, while following their respective training protocols with minor changes, as detailed in the appendix B.1. The computation time and hardware is provided in appendix B.4. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            848
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first conducted an ablation study to fairly compare the benefits of using full attention and/or the node LPE. We then took the best-performing model, tuned some of its hyperparameters, and matched it up against the current state-of-the-art methods. Since we use a similar attention mechanism, our code was developed on top of the code from the GT paper [14], provided under the MIT license. ",
+        "bbox": [
+            174,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d5bbaf77fda3e2b0ff6f576a445dfc5384bfb1722dab6d7b4851bc2e2612da69.jpg",
+        "image_caption": [
+            "Figure 5: Effect of the $\\gamma$ parameter on the performance across datasets from [15, 21], using the Node LPE. Dotted black lines indicate sparse attention, which is equivalent to setting $\\gamma = 0$ . Each box plot consists of 4 runs, with different seeds (except MolHIV). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            79,
+            767,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/fde69eca3ab0ab9a3b0a89a16d6b2f51ea24e8fec0901fc2b4a21c32fd06d366.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=2>Model details</td><td rowspan=1 colspan=1>ZINC</td><td rowspan=1 colspan=1>PATTERN</td><td rowspan=1 colspan=1>CLUSTER</td><td rowspan=1 colspan=1>MOLHIV</td><td rowspan=6 colspan=2>BestWorst</td></tr><tr><td rowspan=1 colspan=1>AttentionLPE</td><td rowspan=1 colspan=1>LPE</td><td rowspan=1 colspan=1>MAE</td><td rowspan=1 colspan=1>% ACC</td><td rowspan=1 colspan=1>%ACC</td><td rowspan=1 colspan=1>% ROC-AUC</td><td rowspan=5 colspan=1></td><td rowspan=5 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Sparse</td><td rowspan=1 colspan=1>-</td><td rowspan=1 colspan=1>0.267±0.032</td><td rowspan=1 colspan=1>83.613 ±0.663</td><td rowspan=1 colspan=1>75.683±0.098</td><td rowspan=1 colspan=1>73.46±0.71</td></tr><tr><td rowspan=1 colspan=1>Sparse</td><td rowspan=1 colspan=1>Node</td><td rowspan=1 colspan=1>0.198±0.004</td><td rowspan=1 colspan=1>81.329±2.150</td><td rowspan=1 colspan=1>75.738 ±0.106</td><td rowspan=1 colspan=1>76.61±0.62</td></tr><tr><td rowspan=1 colspan=1>Full</td><td rowspan=1 colspan=1>：</td><td rowspan=1 colspan=1>0.392 ±0.055</td><td rowspan=1 colspan=1>86.322±0.049</td><td rowspan=1 colspan=1>76.447±0.177</td><td rowspan=1 colspan=1>73.84± 1.80</td></tr><tr><td rowspan=1 colspan=1>Full</td><td rowspan=1 colspan=1>Node</td><td rowspan=1 colspan=1>0.157±0.006</td><td rowspan=1 colspan=1>86.441±0.040</td><td rowspan=1 colspan=1>76.691±0.247</td><td rowspan=1 colspan=1>77.57 ±0.61</td></tr></table>",
+        "bbox": [
+            236,
+            263,
+            748,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 6: Ablation study on datasets from [15, 21] for the node LPE and full graph attention, with no hyperparameter tuning other than $\\gamma$ taken from Figure 5. For a given dataset, all models use the same hyperparameters, but the hidden dimensions are adjusted to have $\\sim 5 0 0 k$ learnable parameters. Means and uncertainties are derived from four runs, with different seeds (except MolHIV). ",
+        "bbox": [
+            173,
+            339,
+            826,
+            395
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.1 Sparse vs. Full Attention ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            420,
+            385,
+            435
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To study the effect of incorporating full attention, we present an ablation study of the $\\gamma$ parameter in Figure 5. We remind readers that $\\gamma$ is used in equation 5 to balance between sparse and full attention. Setting $\\gamma = 0$ strictly enables sparse attention, while $\\gamma = 1$ does not bias the model in any direction. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            489
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "It is apparent that molecular datasets, namely ZINC and MOLHIV, benefit less from full attention, with the best parameter being $\\log { \\gamma } \\in ( - 7 , - 5 )$ . On the other hand, the larger SBM datasets (PATTERN and CLUSTER) benefit from a higher $\\gamma$ value. This can be explained by the fact that molecular graphs rely more on understanding local structures such as the presence of rings and specific bonds, especially in the artificial task from ZINC which relies on counting these specific patterns [15]. Furthermore, molecules are generally smaller than SBMs. As a result, we would expect less need for full attention, as information between distant nodes can be propagated with few iterations of even sparse attention. We also expect molecules to have fewer multiplicities, thus reducing the space of eigenvectors. Lastly, the performance gains in using full attention on the CLUSTER dataset can be attributed to it being a semi-supervised task, where some nodes within each graph are assigned their true labels. With full attention, every node receives information from the labeled nodes at each iteration, reinforcing confidence about the community they belong to. ",
+        "bbox": [
+            174,
+            496,
+            825,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In Figure 6, we present another ablation study to measure the impact of the node LPE in both the sparse and full architectures. We observe that the proposed node-wise LPE contributes significantly to the performance for molecular tasks (ZINC and MOLHIV), and believe that it can be attributed to the detection of substructures (see Figure 3). For PATTERN and CLUSTER, the improvement is modest as the tasks are simple clustering [15]. Previous work even found that the optimal number of eigenvectors to construct PE for PATTERN is only 2 [14]. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            752
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Comparison to the state-of-the-art ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            773,
+            450,
+            787
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "When comparing to the state-of-the-art (SOTA) models in the literature in Figure 7, we observe that our SAN model consistently performs better on all synthetic datasets from [15], highlighting the strong expressive power of the model. On the MolHIV dataset, the performance on the test set is slightly lower than the SOTA. However, the model performs better on the validation set $( 8 5 . 3 0 \\% )$ in comparison to PNA $( 8 4 . 2 5 \\% )$ and DGN $( 8 4 . 7 0 \\% )$ . This can be attributed to a well-known issue with this dataset: the validation and test metrics have low correlation. In our experiments, we found higher test results with lower validation scores when restricting the number of epochs. Here, we also included results on the MolPCBA dataset, where we witnessed competitive results as well. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Other top-performing models, namely PNA [11] and DGN [4], use a message-passing approach [17] with multiple aggregators. When compared to attention-based models, SAN consistently outperforms the SOTA by a wide margin. To the best of our knowledge, SAN is the first fully-connected model to perform well on graph tasks, as is evident by the poor performance of the GT (full) model. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/93b1105e11e1e554e1b6c09555f02af64ce0f2dd31b0d13d2087ec29687349b9.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            738,
+            213,
+            810,
+            327
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/6044e1c2c1c58edc9537adb666ceec63206f09bcdef5ed386de81fa68b83196d.jpg",
+        "image_caption": [
+            "Figure 7: Comparing our tuned model on datasets from [15, 21], against GCN [25], GraphSage [18], GIN [39], GAT [37], GatedGCN [5], PNA [11], and DGN [4]. Means and uncertainties are derived from four runs with different seeds, except MolHIV which uses 10 runs with identical seed. The number of parameters is fixed to $\\sim 5 0 0 k$ for ZINC, PATTERN and CLUSTER. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            161,
+            763,
+            378
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            469,
+            299,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In summary, we presented the SAN model for graph neural networks, a new Transformer-based architecture that is aware of the Laplace spectrum of a given graph from the learned positional encodings. The model was shown to perform on par or better than the SOTA on multiple benchmarks and outperforms other Attention-based models by a large margin. As is often the case with Transformers, the current model suffers from a computational bottleneck, and we leave it for future work to implement variations of Transformers that scale linearly or logarithmically. This will enable the edge-wise LPE presented in appendix A, a theoretically more powerful version of the SAN model. ",
+        "bbox": [
+            174,
+            502,
+            825,
+            599
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Societal Impact. The presented work is focused on theoretical and methodological improvements to graph neural networks, so there are limited direct societal impacts. However, indirect negative impacts could be caused by malicious applications developed using the algorithm. One such example is the tracking of people on social media by representing their interaction as graphs, thus predicting and influencing their behavior towards an external goal. It also has an environmental impact due to the greater energy use that arises from the computational cost $O ( m ^ { 2 } N + N ^ { 2 } )$ being larger than standard message passing or convolutional approaches of $O ( E )$ . ",
+        "bbox": [
+            174,
+            606,
+            825,
+            703
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Funding Disclosure. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            709,
+            313,
+            724
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Devin Kreuzer is supported by an NSERC grant. ",
+        "bbox": [
+            176,
+            729,
+            490,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            766,
+            266,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Uri Alon and Eran Yahav. On the bottleneck of graph neural networks and its practical implications. arXiv:2006.05205 [cs, stat], 2020.   \n[2] Dominique Beaini, Sofiane Achiche, Alexandre Duperré, and Maxime Raison. Deep green function convolution for improving saliency in convolutional neural networks. The Visual Computer, 37(2):227–244, 2020.   \n[3] Dominique Beaini, Sofiane Achiche, and Maxime Raison. Improving convolutional neural networks via conservative field regularisation and integration.   \n[4] Dominique Beaini, Saro Passaro, Vincent Létourneau, William L. Hamilton, Gabriele Corso, and Pietro Liò. Directional graph networks. ICML2021, 2021.   \n[5] Xavier Bresson and Thomas Laurent. Residual gated graph convnets. arXiv preprint arXiv:1711.07553, 2017.   \n[6] Michael M. Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. IEEE Signal Processing Magazine, 34(4):18–42, 2017.   \n[7] F. Cajori. A History of Mathematics. AMS Chelsea Publishing Series. AMS Chelsea, 1999.   \n[8] Heng Chang, Yu Rong, Tingyang Xu, Wenbing Huang, Somayeh Sojoudi, Junzhou Huang, and Wenwu Zhu. Spectral graph attention network. CoRR, abs/2003.07450, 2020.   \n[9] Fan Chung and S. T. Yau. Discrete green’s functions. Journal of Combinatorial Theory, Series A, 91(1):191–214, 2000.   \n[10] Ronald R. Coifman and Stéphane Lafon. Diffusion maps. Applied and Computational Harmonic Analysis, 21(1):5–30, 2006. Special Issue: Diffusion Maps and Wavelets.   \n[11] Gabriele Corso, Luca Cavalleri, Dominique Beaini, Pietro Liò, and Petar Velickovi ˇ c. Principal ´ neighbourhood aggregation for graph nets. arXiv preprint arXiv:2004.05718, 2020.   \n[12] Luca Cosmo, Mikhail Panine, Arianna Rampini, Maks Ovsjanikov, Michael M. Bronstein, and Emanuele Rodola. Isospectralization, or how to hear shape, style, and correspondence. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   \n[13] Yushun Dong, Kaize Ding, Brian Jalaian, Shuiwang Ji, and Jundong Li. Graph neural networks with adaptive frequency response filter. CoRR, abs/2104.12840, 2021.   \n[14] Vijay Prakash Dwivedi and Xavier Bresson. A generalization of transformer networks to graphs, 2020.   \n[15] Vijay Prakash Dwivedi, Chaitanya K Joshi, Thomas Laurent, Yoshua Bengio, and Xavier Bresson. Benchmarking graph neural networks. arXiv preprint arXiv:2003.00982, 2020.   \n[16] Richard Phillips Feynman, Robert Benjamin Leighton, and Matthew Sands. The Feynman lectures on physics; New millennium ed. Basic Books, New York, NY, 2010. Originally published 1963-1965.   \n[17] Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1263–1272. JMLR. org, 2017.   \n[18] Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in neural information processing systems, pages 1024–1034, 2017.   \n[19] William L. Hamilton. Graph Representation Learning. Morgan and Claypool, 2020.   \n[20] Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8):1735–1780, 1997.   \n[21] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.   \n[22] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. arXiv:1802.04364 [cs, stat], 2018.   \n[23] Mark Kac. Can one hear the shape of a drum? The American Mathematical Monthly, 73(4):1, 1966.   \n[24] Anees Kazi, Luca Cosmo, Nassir Navab, and Michael Bronstein. Differentiable graph module (dgm) graph convolutional networks. arXiv preprint arXiv:2002.04999, 2020.   \n[25] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.   \n[26] B. Levy. Laplace-beltrami eigenfunctions towards an algorithm that \"understands\" geometry. In IEEE International Conference on Shape Modeling and Applications 2006 (SMI’06), pages 13–13, 2006.   \n[27] Pan Li, Yanbang Wang, Hongwei Wang, and Jure Leskovec. Distance encoding: Design provably more powerful neural networks for graph representation learning, 2020.   \n[28] Yaron Lipman, Raif M. Rustamov, and Thomas A. Funkhouser. Biharmonic distance. ACM Trans. Graph., 29(3), July 2010.   \n[29] Haggai Maron, Heli Ben-Hamu, Hadar Serviansky, and Yaron Lipman. Provably powerful graph networks. arXiv preprint arXiv:1905.11136, 2019.   \n[30] Christopher Morris, Martin Ritzert, Matthias Fey, William L Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pages 4602–4609, 2019.   \n[31] Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. 2017.   \n[32] Emanuele Rodolà, Luca Cosmo, Michael M. Bronstein, Andrea Torsello, and Daniel Cremers. Partial functional correspondence, 2015.   \n[33] Joshua Schrier. Can one hear the shape of a molecule (from its coulomb matrix eigenvalues)? Journal of Chemical Information and Modeling, 60(8):3804–3811, 2020. Publisher: American Chemical Society.   \n[34] Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey, 2020.   \n[35] Edwin R. van Dam and Willem H. Haemers. Which graphs are determined by their spectrum? Linear Algebra and its Applications, 373:241–272, 2003.   \n[36] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, abs/1706.03762, 2017.   \n[37] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   \n[38] Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, Tianjun Xiao, Tong He, George Karypis, Jinyang Li, and Zheng Zhang. Deep graph library: A graph-centric, highly-performant package for graph neural networks. arXiv preprint arXiv:1909.01315, 2019.   \n[39] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.   \n[40] Chulhee Yun, Srinadh Bhojanapalli, Ankit Singh Rawat, Sashank J. Reddi, and Sanjiv Kumar. Are transformers universal approximators of sequence-to-sequence functions?, 2020.   \n[41] Chulhee Yun, Yin-Wen Chang, Srinadh Bhojanapalli, Ankit Singh Rawat, Sashank J. Reddi, and Sanjiv Kumar. $\\$ 0( n )5$ connections are expressive enough: Universal approximability of sparse transformers. CoRR, abs/2006.04862, 2020.   \n[42] Seongjun Yun, Minbyul Jeong, Raehyun Kim, Jaewoo Kang, and Hyunwoo J. Kim. Graph transformer networks, 2020. ",
+        "bbox": [
+            181,
+            790,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            34,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            80,
+            828,
+            920
+        ],
+        "page_idx": 11
+    }
+]