Add files using upload-large-folder tool

parse/train/B16dGcqlx/B16dGcqlx.md

@@ -0,0 +1,356 @@
+# THIRD-PERSON IMITATION LEARNING
+
+Bradly C. Stadie1,2, Pieter Abbeel1,3, Ilya Sutskever1
+
+1 OpenAI 2 UC Berkeley, Department of Statistics 3 UC Berkeley, Departments of EECS and ICSI {bstadie, pieter, ilyasu,}@openai.com
+
+# ABSTRACT
+
+Reinforcement learning (RL) makes it possible to train agents capable of achieving sophisticated goals in complex and uncertain environments. A key difficulty in reinforcement learning is specifying a reward function for the agent to optimize. Traditionally, imitation learning in RL has been used to overcome this problem. Unfortunately, hitherto imitation learning methods tend to require that demonstrations are supplied in the first-person: the agent is provided with a sequence of states and a specification of the actions that it should have taken. While powerful, this kind of imitation learning is limited by the relatively hard problem of collecting first-person demonstrations. Humans address this problem by learning from third-person demonstrations: they observe other humans perform tasks, infer the task, and accomplish the same task themselves.
+
+In this paper, we present a method for unsupervised third-person imitation learning. Here third-person refers to training an agent to correctly achieve a simple goal in a simple environment when it is provided a demonstration of a teacher achieving the same goal but from a different viewpoint; and unsupervised refers to the fact that the agent receives only these third-person demonstrations, and is not provided a correspondence between teacher states and student states. Our methods primary insight is that recent advances from domain confusion can be utilized to yield domain agnostic features which are crucial during the training process. To validate our approach, we report successful experiments on learning from third-person demonstrations in a pointmass domain, a reacher domain, and inverted pendulum.
+
+# 1 INTRODUCTION
+
+Reinforcement learning (RL) is a framework for training agents to maximize rewards in large, unknown, stochastic environments. In recent years, combining techniques from deep learning with reinforcement learning has yielded a string of successful applications in game playing and robotics Mnih et al. (2015; 2016); Schulman et al. (2015a); Levine et al. (2016). These successful applications, and the speed at which the abilities of RL algorithms have been increasing, makes it an exciting area of research with significant potential for future applications.
+
+One of the major weaknesses of RL is the need to manually specify a reward function. For each task we wish our agent to accomplish, we must provide it with a reward function whose maximizer will precisely recover the desired behavior. This weakness is addressed by the field of Inverse Reinforcement Learning (IRL). Given a set of expert trajectories, IRL algorithms produce a reward function under which these the expert trajectories enjoy the property of optimality. Recently, there has been a significant amount of work on IRL, and current algorithms can infer a reward function from a very modest number of demonstrations (e.g,. Abbeel & $\mathrm { N g }$ (2004); Ratliff et al. (2006); Ziebart et al. (2008); Levine et al. (2011); Ho & Ermon (2016); Finn et al. (2016)).
+
+While IRL algorithms are appealing, they impose the somewhat unrealistic requirement that the demonstrations should be provided from the first-person point of view with respect to the agent. Human beings learn to imitate entirely from third-person demonstrations – i.e., by observing other humans achieve goals. Indeed, in many situations, first-person demonstrations are outright impossible to obtain. Meanwhile, third-person demonstrations are often relatively easy to obtain.
+
+The goal of this paper is to develop an algorithm for third-person imitation learning. Future advancements in this class of algorithms would significantly improve the state of robotics, because it will enable people to easily teach robots news skills and abilities. Importantly, we want our algorithm to be unsupervised: it should be able to observe another agent perform a task, infer that there is an underlying correspondence to itself, and find a way to accomplish the same task.
+
+We offer an approach to this problem by borrowing ideas from domain confusion Tzeng et al. (2014) and generative adversarial networks (GANs) Goodfellow et al. (2014). The high-level idea is to introduce an optimizer under which we can recover both a domain-agnostic representation of the agent’s observations, and a cost function which utilizes this domain-agnostic representation to capture the essence of expert trajectories. We formulate this as a third-person RL-GAN problem, and our solution builds on the first-person RL-GAN formulation by Ho & Ermon (2016).
+
+Surprisingly, we find that this simple approach has been able to solve the problems that are presented in this paper (illustrated in Figure 1), even though the student’s observations are related in a complicated way to the teacher’s demonstrations (given that the observations and the demonstrations are pixel-level). As techniques for training GANs become more stable and capable, we expect our algorithm to be able to infer solve harder third-person imitation tasks without any direct supervision.
+
+![](images/4f116f6ef62dbbe520d3cfcd3efa9281e7a38397e6e00f6ac5c062e2df069dc2.jpg)  
+Figure 1: From left to right, the three domains we consider in this paper: pointmass, reacher, and pendulum. Top-row is the third-person view of a teacher demonstration. Bottom row is the agent’s view in their version of the environment. For the point and reacher environments, the camera angles differ by approximately 40 degrees. For the pendulum environment, the color of the pole differs.
+
+# 2 RELATED WORK
+
+Imitation learning (also learning from demonstrations or programming by demonstration) considers the problem of acquiring skills from observing demonstrations. Imitation learning has a long history, with several good survey articles, including (Schaal, 1999; Calinon, 2009; Argall et al., 2009). Two main lines of work within imitation learning are: 1) behavioral cloning, where the demonstrations are used to directly learn a mapping from observations to actions using supervised learning, potentially with interleaving learning and data collection (e.g., Pomerleau (1989); Ross et al. (2011)). 2) Inverse reinforcement learning $\mathrm { N g }$ et al., 2000), where a reward function is estimated that explains the demonstrations as (near) optimal behavior. This reward function could be represented as nearness to a trajectory (Calinon et al., 2007; Abbeel et al., 2010), as a weighted combination of features (Abbeel & $\mathrm { N g }$ , 2004; Ratliff et al., 2006; Ramachandran & Amir, 2007; Ziebart et al., 2008; Boularias et al., 2011; Kalakrishnan et al., 2013; Doerr et al., 2015), or could also involve feature learning (Ratliff et al., 2007; Levine et al., 2011; Wulfmeier et al., 2015; Finn et al., 2016; Ho & Ermon, 2016).
+
+This past work, however, is not directly applicable to the third person imitation learning setting. In third-person imitation learning, the observations and actions obtained from the demonstrations are not the same as what the imitator agent will be faced with. A typical scenario would be: the imitator agent watches a human perform a demonstration, and then has to execute that same task. As discussed in Nehaniv & Dautenhahn (2001) the ”what and how to imitate” questions become significantly more challenging in this setting. To directly apply existing behavioral cloning or inverse reinforcement learning techniques would require knowledge of a mapping between observations and actions in the demonstrator space to observations and actions in the imitator space. Such a mapping is often difficult to obtain, and it typically relies on providing feature representations that captures the invariance between both environments Carpenter et al. (2002); Shon et al. (2005); Calinon et al. (2007); Nehaniv (2007); Gioioso et al. (2013); Gupta et al. (2016). Contrary to prior work, we consider third-person imitation learning from raw sensory data, where no such features are made available.
+
+The most closely related work to ours is by Finn et al. (2016); Ho & Ermon (2016); Wulfmeier et al. (2015), who also consider inverse reinforcement learning directly from raw sensory data. However, the applicability of their approaches is limited to the first-person setting. Indeed, matching raw sensory observations is impossible in the 3rd person setting.
+
+Our work also closely builds on advances in generative adversarial networks Goodfellow et al. (2014), which are very closely related to imitation learning as explained in Finn et al. (2016); Ho & Ermon (2016). In our optimization formulation, we apply the gradient flipping technique from Ganin & Lempitsky (2014).
+
+The problem of adapting what is learned in one domain to another domain has been studied extensively in computer vision in the supervised learning setting Yang et al. (2007); Mansour et al. (2009); Kulis et al. (2011); Aytar & Zisserman (2011); Duan et al. (2012); Hoffman et al. (2013); Long & Wang (2015). It has also been shown that features trained in one domain can often be relevant to other domains Donahue et al. (2014). The work most closely related to ours is Tzeng et al. (2014; 2015), who also consider an explicit domain confusion loss, forcing trained classifiers to rely on features that don’t allow to distinguish between two domains. This work in turn relates to earlier work by Bromley et al. (1993); Chopra et al. (2005), which also considers supervised training of deep feature embeddings.
+
+Our approach to third-person imitation learning relies on reinforcement learning from raw sensory data in the imitator domain. Several recent advances in deep reinforcement learning have made this practical, including Deep Q-Networks (Mnih et al., 2015), Trust Region Policy Optimization (Schulman et al., 2015a), A3C Mnih et al. (2016), and Generalized Advantage Estimation (Schulman et al., 2015b). Our approach uses Trust Region Policy Optimization.
+
+# 3 BACKGROUND AND PRELIMINARIES
+
+A discrete-time finite-horizon discounted Markov decision process (MDP) is represented by a tuple $M = ( S , A , \mathcal { P } , r , \rho _ { 0 } , \gamma , T )$ , in which $s$ is a state set, $\mathcal { A }$ an action set, $\mathcal { P } : \bar { S \times A } \times \bar { S } \stackrel { \cdot } { \to } \mathbb { R } _ { + }$ a transition probability distribution, $r : S \times \mathcal { A }  \mathbb { R }$ a reward function, $\rho _ { 0 } : { \mathcal { S } } \to \mathbb { R } _ { + }$ an initial state distribution, $\gamma \in [ 0 , 1 ]$ a discount factor, and $T$ the horizon.
+
+In the reinforcement learning setting, the goal is to find a policy $\pi _ { \theta } : \mathcal { S } \times \mathcal { A } \to \mathbb { R } _ { + }$ parametrized by $\theta$ that maximizes the expected discounted sum of rewards incurred, $\begin{array} { r } { \eta ( \pi _ { \theta } ) = \mathbb { E } _ { \pi _ { \theta } } [ \sum _ { t = 0 } ^ { T } \gamma ^ { t } c ( s _ { t } ) ] } \end{array}$ , where $s _ { 0 } \sim \rho _ { 0 } ( s _ { 0 } )$ , $a _ { t } \sim \pi _ { \theta } ( a _ { t } | s _ { t } )$ , and $s _ { t + 1 } \sim \mathcal { P } ( s _ { t + 1 } | s _ { t } , a _ { t } )$ .
+
+In the (first-person) imitation learning setting, we are not given the reward function. Instead we are given traces (i.e., sequences of states traversed) by an expert who acts according to an unknown policy $\pi _ { E }$ . The goal is to find a policy $\pi _ { \theta }$ that performs as well as the expert against the unknown reward function. It was shown in Abbeel & $\mathrm { N g }$ (2004) that this can be achieved through inverse reinforcement learning by finding a policy $\pi _ { \theta }$ that matches the expert’s empirical expectation over discounted sum of all features that might contribute to the reward function. The work by Ho & Ermon (2016) generalizes this to the setting when no features are provided as follows: Find a policy $\pi _ { \theta }$ that makes it impossible for a discriminator (in their work a deep neural net) to distinguish states visited by the expert from states visited by the imitator agent. This can be formalized as follows:
+
+$$
+\begin{array} { r l } { \underset { \pi _ { \theta } } { \mathop { \operatorname* { m a x } } } \underset { \mathcal { D } _ { R } } { \mathop { \operatorname* { m i n } } } } & { { } - \mathbb { E } _ { \pi _ { \theta } } [ \log \mathcal { D } _ { R } ( s ) ] - \mathbb { E } _ { \pi _ { E } } [ \log ( 1 - \mathcal { D } _ { R } ( s ) ) ] } \end{array}
+$$
+
+Here, the expectations are over the states experienced by the policy of the imitator agent, $\pi _ { \theta }$ , and by the policy of the expert, $\pi _ { E }$ , respectively. $\mathcal { D } _ { R }$ is the discriminator, which outputs the probability of a state having originated from a trace from the imitator policy $\pi _ { \theta }$ . If the discriminator is perfectly able to distinguish which policy originated state-action pairs, then $\mathcal { D } _ { R }$ will consistently output a probability of 1 in the first term, and a probability of 0 in the second term, making the objective its lowest possible value of zero. It is the role of the imitator agent $\pi _ { \theta }$ to find a policy that makes it difficult for the discriminator to make that distinction. The desired equilibrium has the imitator agent making it impractical for the discriminator to distinguish, hence forcing the discriminator to assign probability 0.5 in all cases. Ho & Ermon (2016) present a practical approach for solving this type of game when representing both $\pi _ { \theta }$ and $\mathcal { D } _ { R }$ as deep neural networks. Their approach repeatedly performs gradient updates on each of them. Concretely, for a current policy $\pi _ { \theta }$ traces can be collected, which together with the expert traces form a data-set on which $\mathcal { D } _ { R }$ can be trained with supervised learning minimizing the negative log-likelihood (in practice only performing a modest number of updates). For a fixed $\mathcal { D } _ { R }$ , this is a policy optimization problem where $- \log \mathcal { D } _ { R } ( s , a )$ is the reward, and policy gradients can be computed from those same traces. Their approach uses trust region policy optimization (Schulman et al., 2015a) to update the imitator policy $\pi _ { \theta }$ from those gradients.
+
+In our work we will have more terms in the objective, so for compactness of notation, we will realize the discriminative minimization from Eqn. (1) as follows:
+
+$$
+\operatorname* { m a x } _ { \pi _ { \boldsymbol { \theta } } } \operatorname* { m i n } _ { \mathcal { D } _ { R } } \mathcal { L } _ { R } = \sum _ { i } C E ( \mathcal { D } _ { R } ( \boldsymbol { s } _ { i } ) , \boldsymbol { c } _ { \boldsymbol { \ell } _ { i } } )
+$$
+
+Where $s _ { i }$ is state $i$ , $c _ { \ell _ { i } }$ is the correct class label (was the state $s _ { i }$ obtained from an expert vs. from a non-expert), and $C E$ is the standard cross entropy loss.
+
+# 4 A FORMAL DEFINITION OF THE THIRD-PERSON IMITATION LEARNINGPROBLEM
+
+Formally, the third-person imitation learning problem can be stated as follows. Suppose we are given two Markov Decision Processes $M _ { \pi _ { E } }$ and $M _ { \pi _ { \theta } }$ . Suppose further there exists a set of traces $\rho =$ $\{ ( s _ { 1 } , \ldots , s _ { n } ) \} _ { i = 0 } ^ { n }$ which were generated under a policy $\pi _ { E }$ acting optimally under some unknown reward $R _ { \pi _ { E } }$ . In third-person imitation learning, one attempts to recover by proxy through $\rho$ a policy $\pi _ { \theta } = f ( \rho )$ which acts optimally with respect to $R _ { \pi _ { \theta } }$ .
+
+# 5 A THIRD-PERSON IMITATION LEARNING ALGORITHM
+
+# 5.1 GAME FORMULATION
+
+In this section, we discuss a simple algorithm for third-person imitation learning. This algorithm is able to successfully discriminate between expert and novice policies, even when the policies are executed under different environments. Subsequently, this discrimination signal can be used to train expert policies in new domains via RL by training the novice policy to fool the discriminator, thus forcing it to match the expert policy.
+
+In third-person learning, observations are more typically available rather than direct state access, so going forward we will work with observations $o _ { t }$ instead of states $s _ { t }$ as representing the expert traces. The top row of Figure 8 illustrates what these observations are like in our experiments.
+
+We begin by recalling that in the algorithm proposed by Ho & Ermon (2016) the loss in Equation 2 is utilized to train a discriminator $\mathcal { D } _ { R }$ capable of distinguishing expert vs non-expert policies. Unfortunately, (2) will likely fail in cases when the expert and non-expert act in different environments, since $\mathcal { D } _ { R }$ will quickly learn these differences and use them as a strong classification signal.
+
+To handle the third-person setting, where expert and novice are in different environments, we consider that $\mathcal { D } _ { R }$ works by first extracting features from $o _ { t }$ , and then using these features to make a classification. Suppose then that we partition $\mathcal { D } _ { R }$ into a feature extractor $\mathcal { D } _ { F }$ and the actual classifier which assigns probabilities to the outputs of $D _ { F }$ . Overloading notation, we will refer to the classifier as $\mathcal { D } _ { R }$ going forward. For example, in case of a deep neural net representation, $\mathcal { D } _ { F }$ would correspond to the earlier layers, and $\mathcal { D } _ { R }$ to the later layers. The problem is then to ensure that $D _ { F }$ contains no information regarding the rollout’s domain label $d _ { \ell }$ (i.e., expert vs. novice domain). This can be realized as
+
+$$
+\begin{array} { r l r } & { } & { \underset { \pi _ { \theta } } { \operatorname* { m a x } } \operatorname* { m i n } \mathcal L _ { { R } } = \displaystyle \sum _ { i } C E ( \mathcal D _ { { R } } ( \mathcal D _ { { F } } ( o _ { i } ) ) , c _ { \ell _ { i } } ) } \\ & { } & { \mathrm { s . t . } ~ \mathrm { M I } ( D _ { { F } } ( o _ { i } ) ; d _ { l } ) = 0 } \end{array}
+$$
+
+Where MI is mutual information and hence we have abused notation by using $\mathcal { D } _ { R } , D _ { F }$ , and $d _ { \ell }$ to mean the classifier, feature extractor, and the domain label respectively as well as distributions over these objects.
+
+The mutual information term can be instantiated by introducing another classifier $\mathcal { D } _ { D }$ , which takes features produced by $D _ { F }$ and outputs the probability that those features were produced by in the expert vs. non-expert environment. (See Bridle et al. (1992); Barber & Agakov (2005); Krause et al. (2010); Chen et al. (2016) for further discussion on instantiating the information term by introducing another classifier.) If $\sigma _ { i } = D _ { F } { ( o _ { i } ) }$ , then the problem can be written as
+
+$$
+\operatorname* { m a x } _ { \pi _ { \theta } } \operatorname* { m i n } _ { \mathcal { D } _ { R } } \operatorname* { m a x } _ { \mathcal { D } _ { D } } \mathcal { L } _ { R } + \mathcal { L } _ { D } = \sum _ { i } C E ( \mathcal { D } _ { R } ( \sigma _ { i } ) , c _ { \ell _ { i } } ) + C E ( \mathcal { D } _ { D } ( \sigma _ { i } ) , d _ { \ell _ { i } } )
+$$
+
+In words, we wish to minimize class loss while maximizing domain confusion.
+
+Often, it can be difficult for even humans to judge a static image as expert vs. non-expert because it does not convey any information about the environmental change affected by the agent’s actions. For example, if a pointmass is attempting to move to a target location and starts far away from its goal state, it can be difficult to judge if the policy itself is bad or the initialization was simply unlucky. In response to this difficulty, we give $\mathcal { D } _ { R }$ access to not only the image at time $t$ , but also at some future time $t + n$ . Define $\sigma _ { t } = D _ { F } ( o _ { t } )$ and $\sigma _ { t + n } = D _ { F } ( o _ { t + n } )$ . The classifier then makes a prediction $\mathcal { D } _ { R } ( \sigma _ { t } , \sigma _ { t + n } ) = \hat { c } _ { \ell }$ .
+
+This renders the following formulation:
+
+$$
+\operatorname* { m a x } _ { \pi _ { \theta } } \operatorname* { m i n } _ { \mathcal { D } _ { R } } \operatorname* { m a x } _ { \mathcal { D } _ { D } } \mathcal { L } _ { R } + \mathcal { L } _ { D } = \sum _ { i } C E ( \mathcal { D } _ { R } ( \sigma _ { i } , \sigma _ { i + n } ) , c _ { \ell _ { i } } ) + C E ( \mathcal { D } _ { D } ( \sigma _ { i } ) , d _ { \ell _ { i } } )
+$$
+
+Note we also want to optimize over $\mathcal { D } _ { F }$ , the feature extractor, but it feeds both into $\mathcal { D } _ { R }$ and into $\mathcal { D } _ { D }$ , which are competing (hidden under $\sigma$ ), which we will address now.
+
+To deal with the competition over $\mathcal { D } _ { F }$ , we introduce a function $\mathcal { G }$ that acts as the identity when moving forward through a directed acyclic graph and flips the sign when backpropagating through the graph. This technique has enjoyed recent success in computer vision. See, for example, (Ganin & Lempitsky, 2014). With this trick, the problem reduces to its final form
+
+$$
+\operatorname* { m a x } _ { \pi _ { \theta } } \operatorname* { m i n } _ { \mathcal { D } _ { R } , \mathcal { D } _ { D } , \mathcal { D } _ { F } } \mathcal { L } _ { R } + \mathcal { L } _ { D } = \sum _ { i } C E ( \mathcal { D } _ { R } ( \sigma _ { i } , \sigma _ { i + n } ) , c _ { \ell _ { i } } ) + \lambda C E ( \mathcal { D } _ { D } ( \mathcal { G } ( \sigma _ { i } ) , d _ { \ell _ { i } } ) - c _ { \ell _ { i } } )
+$$
+
+In Equation (5), we flip the gradient’s sign during backpropagation of $D _ { F }$ with respect to the domain classification loss. This corresponds to stochastic gradient ascent away from features that are useful for domain classification, thus ensuring that $D _ { F }$ produces domain agnostic features. Equation 5 can be solved efficiently with stochastic gradient descent. Here $\lambda$ is a hyperparameter that determines the trade-off made between the objectives that are competing over $\mathcal { D } _ { F }$ .
+
+To ensure sufficient signal for discrimination between expert and non-expert, we collect third-person demonstrations in the expert domain from both an expert and from a non-expert.
+
+Our complete formulation is graphically summarized in Figure 2.
+
+![](images/0f6e6112f36cfebf12955fa02ddf614350be92d58e85c57da82c1566c4d52336.jpg)  
+Figure 2: Architecture diagram for third-person imitation learning. Images at time $t$ and $t + 4$ are sent through a feature extractor to obtain $F ( o _ { t } )$ and $F ( o _ { t + 4 } )$ . Subsequently, these feature vectors are reused in two places. First, they are concatenated and used to predict whether the samples are drawn from expert or non-expert trajectories. Second, $F ( o _ { t } )$ is utilized to predict a domain label (expert vs. novice domain). During backpropogation, the sign on the domain loss $L _ { D }$ is flipped to destroy information that was useful for distinguishing the two domains. This ensures that the feature extractor $F$ is domain agnostic. Finally, the classes probabilities that were computed using this domain-agnostic feature vector are utilized as a cost signal in TRPO; which is subsequently utilized to train the novice policy to take expert-like actions and collect further rollouts.
+
+# 5.2 ALGORITHM
+
+To solve the game formulation in Equation (5), we perform alternating (partial) optimization over the policy $\pi _ { \theta }$ and the reward function and domain confusion encoded through $\mathcal { D } _ { R } , \mathcal { D } _ { D } , \mathcal { D } _ { F }$ .
+
+The optimization over $\mathcal { D } _ { R } , \mathcal { D } _ { D } , \mathcal { D } _ { F }$ is done through stochastic gradient descent with ADAM Kingma & Ba (2014).
+
+Our generator $\left( \pi _ { \boldsymbol { \theta } } \right)$ step is similar to the generator step in the algorithm by (Ho & Ermon, 2016). We simply use $- \log \mathcal { D } _ { R }$ as the reward. Using policy gradient methods (TRPO), we train the generator to minimize this cost and thus push the policy further towards replicating expert behavior. Once the generator step is done, we start again with the discriminator step. The entire process is summarized in algorithm 1.
+
+# 6 EXPERIMENTS
+
+We seek to answer the following questions through experiments:
+
+1. Is it possible to solve the third-person imitation learning problem in simple settings? I.e., given a collection of expert image-based rollouts in one domain, is it possible to train a policy in a different domain that replicates the essence of the original behavior? 2. Does the algorithm we propose benefit from both domain confusion and velocity? 3. How sensitive is our proposed algorithm to the selection of hyper-parameters used in deployment? 4. How sensitive is our proposed algorithm to changes in camera angle? 5. How does our method compare against some reasonable baselines?
+
+# Algorithm 1 A third-person imitation learning algorithm.
+
+1: Let CE be the standard cross entropy loss.   
+2: Let $\mathcal { G }$ be a function that flips the gradient sign during backpropogation and acts as the identity   
+map otherwise.   
+3: Initialize two domains, $E$ and $N$ for the expert and novice.   
+4: Initialize a memory bank $\Omega$ of expert success and of failure in domain $E$ . Each trajectory $\omega \in \Omega$   
+comprises a rollout of images $o = o _ { 1 } , \ldots , o _ { t } , \ldots o _ { n }$ , a class label $c _ { \ell }$ , and a domain label $d _ { \ell }$ .   
+5: Initialize $\mathcal { D } = \mathcal { D } _ { F } , \mathcal { D } _ { R } , \mathcal { D } _ { D }$ , a domain invariant discriminator.   
+6: Initialize a novice policy $\pi _ { \theta }$ .   
+7: Initialize numiters, the number of inner policy optimization iterations we wish to run.   
+8: for iter in numiters do   
+9: Sample a set of successes and failures $\omega _ { E }$ from $\Omega$ .   
+10: Collect on policy samples $\omega _ { N }$   
+11: Set $\omega = \omega _ { E } \cup \omega _ { N }$ .   
+12: Shuffle $\omega$   
+13: for $o , c _ { \ell } , d _ { \ell }$ in $\omega$ do   
+14: for $o _ { t }$ in $o$ do   
+15: $\sigma _ { t } = \mathcal { D } _ { F } \big ( o _ { t } \big )$   
+16: $\sigma _ { t + 4 } = \mathscr { D } _ { F } ( o _ { t + 4 } )$   
+17: $\mathcal { L } _ { R } = C E ( \mathcal { D } _ { R } ( \sigma _ { t } , \sigma _ { t + 4 } ) , c _ { \ell } )$   
+18: $\mathcal { L } _ { d } = C E ( \mathcal { D } _ { D } ( \mathcal { G } ( \sigma _ { t } ) ) , d _ { \ell } )$   
+19: L = λ · Ld + LR   
+20: minimize $\mathcal { L }$ with ADAM.   
+21: end for   
+22: end for   
+23: Collect on policy samples $\omega _ { N }$ from $\pi _ { \theta }$ .   
+24: for $\omega$ in $\omega _ { N }$ do   
+25: for $\omega _ { t }$ in $\omega$ do   
+26: $\begin{array} { l } { \sigma _ { t } = \mathcal { D } _ { F } \big ( o _ { t } \big ) } \\ { \sigma _ { t + 4 } = \mathcal { D } _ { F } \big ( o _ { t + 4 } \big ) } \\ { \hat { c } _ { \ell } = \mathcal { D } _ { R } \big ( \sigma _ { t } , \sigma _ { t + 4 } \big ) } \end{array}$   
+27:   
+28:   
+29: $r = \hat { c } _ { \ell } [ 0 ]$ , the probability that $o _ { t } , o _ { t + 4 }$ were generated via expert rollouts.   
+30: Use $r$ to train $\pi _ { \theta }$ with via policy gradients (TRPO).   
+31: end for   
+32: end for   
+33: end for   
+34: return optimized policy $\pi _ { \theta }$
+
+# 6.1 ENVIRONMENTS
+
+To evaluate our algorithm, we consider three environments in the MuJoCo physics simulator. There are two different versions of each environment, an expert variant and a novice variant. Our goal is to train a cost function that is domain agnostic, and hence can be trained with images on the expert domain but nevertheless produce a reasonable cost on the novice domain. See Figure 1 for a visualization of the differences between expert and novice environments for the three tasks.
+
+Point: A pointmass attempts to reach a point in a plane. The color of the target and the camera angle change between domains.
+
+Reacher: A two DOF arm attempts to reach a designated point in the plane. The camera angle, the length of the arms, and the color of the target point are changed between domains. Note that changing the camera angle significantly alters the image background color from largely gray to roughly 30 percent black. This presents a significant challenge for our method.
+
+Inverted Pendulum: A classic RL task wherein a pendulum must be made to balance via control. For this domain, We only change the color of the pendulum and not the camera angle. Since there is no target point, we found that changing the camera angle left the domain invariant representations with too little information and resulted in a failure case. In contrast to some traditional renderings of this problem, we do not terminate an episode when the agent falls but rather allow data collection to continue for a fixed horizon.
+
+# 6.2 EVALUATIONS
+
+Is it possible to solve the third-person imitation learning problem in simple settings? In Figure 3, we see that our proposed algorithm is indeed able to recover reasonable policies for all three tasks we examined. Initially, the training is quite unstable due to the domain confusion wreaking havoc on the learned cost. However, after several iterations the policies eventually head towards reasonable local minima and the standard deviation over the reward distribution shrinks substantially. Finally, we note that the extracted feature representations used to complete this task are in fact domain-agnostic, as seen in Figure 9. Hence, the learning is properly taking place from a third-person perspective.
+
+![](images/e5de99af5cf3a1c7aa7654c1a187c2ca412166671d36a48182ca68fd643f5215.jpg)  
+Figure 3: Reward vs training iteration for reacher, inverted pendulum, and point environments. The learning curves are averaged over 5 trials with error bars represent one standard deviation in the reward distribution at the given point.
+
+![](images/f7b7c6bcd21543c32d56d84f9174ade28e4f6a584b6d9c3ad7db142b231a7a52.jpg)  
+Figure 4: Domain accuracy vs. training iteration for reacher, inverted pendulum, and point environments.
+
+Does the algorithm we propose benefit from both domain confusion and the multi-time step input? We answer this question with the experiments summarized in Figure 5. This experiment compares our approach with: (i) our approach without the domain confusion loss; (ii) our approach without the multi-time step input; (iii) our approach without the domain confusion loss and without the multitime step input (which is very similar to the approach in Ho & Ermon (2016)). We see that adding domain confusion is essential for getting strong performance in all three experiments. Meanwhile, adding multi-time step input marginally improves the results. See also Figure 7 for an analysis of the effects of multi-time step input on the final results.
+
+![](images/e3119af18c1c7e62ae4ef64c2ed955904fbe120c4d62bd13f90f984b9217f8c5.jpg)  
+Figure 5: Reward vs iteration for reacher, inverted pendulum, and point environments with no domain confusion and no velocity (red), domain confusion (orange), velocity (brown), and both domain confusion and velocity (blue).
+
+How sensitive is our proposed algorithm to the selection of hyper-parameters used in deployment? Figure 6 shows the effect of the domain confusion coefficient $\lambda$ , which trades off how much we should weight the domain confusion objective vs. the standard cost-recovery objective, on the final performance of the algorithm. Setting $\lambda$ too low results in slower learning and features that are not domain-invariant. Setting $\lambda$ too high results in an objective that is too quick to destroy information, which makes it impossible to recover an accurate cost.
+
+For multi-time step input, one must choose the number of look-ahead frames that are utilized. If too small a window is chosen, the agent’s actions have not affected a large amount of change in the environment and it is difficult to discern any additional class signal over static images. If too large a time-frame passes, causality becomes difficult to interpolate and the agent does worse than simply being trained on static frames. Figure 7 illustrates that no number of look-ahead frames is consistently optimal across tasks. However, a value of 4 showed good performance over all tasks, and so this value was utilized in all other experiments.
+
+![](images/45ed8ae8770c3fc15032a995eb4946b54fae1133b7d3d76076733073924dca65.jpg)  
+Figure 6: Reward of final trained policy vs domain confusion weight $\lambda$ for reacher, inverted pendulum, and point environments.
+
+![](images/0f0f2a991076420a5f9323afd72fe3d58d1351a3000f704f8ceb0602171cdb82.jpg)  
+Figure 7: Reward of final trained policy vs number of look-ahead frames for reacher, inverted pendulum, and point environments.
+
+How sensitive is our algorithm to changes in camera angle? We present graphs for the reacher and point experiments wherein we exam the final reward obtained by a policy trained with thirdperson imitation learning vs the camera angle difference between the first-person and third-person perspective. We omit the inverted double pendulum experiment, as the color and not the camera angle changes in that setting and we found the case of slowly transitioning the color to be the definition of uninteresting science.
+
+![](images/878be86e4c28e17ce3098944393f81394f948537ce33b7bc32f67d1492e063e5.jpg)  
+Figure 8: Point and reacher final reward after 20 epochs of third-person imitation learning vs the camera angle difference between the first and third-person perspective. We see that the point follows a fairly linear slope in regards to camera angle differences, whereas the reacher environment is more stochastic against these changes.
+
+![](images/63dd757b05b53e432ebdfa3f1f6ac421e8f43a1c47d1053932e4f96e81238dfd.jpg)  
+Figure 9: Learning curves for third-person imitation vs. three baselines: 1)RL with true reward, 2) first-person imitation, 3) attempting to use first-person features on the third-person agent.
+
+How does our method compare against reasonable baselines? We consider the following baselines for comparisons against third-person imitation learning. 1) Standard reinforcement learning with using full state information and the true reward signal. This agent is trained via TRPO. 2)
+
+Standard GAIL (first-person imitation learning). Here, the agent receives first-person demonstration and attempts to imitate the correct behavior. This is an upper bound on how well we can expect to do, since we have the correct perspective. 3) Training a policy using first-person data and applying it to the third-person environment.
+
+We compare all three of these baselines to third-person imitation learning. As we see in figure 9: 1) Standard RL, which (unlike the imitation learning approaches) has access to full state and true reward, helps calibrate performance of the other approaches. 2) First-person imitation learning is faced with a simpler imitation problem and accordingly outperforms third-person imitation, yet third-person imitation learning is nevertheless competitive. 3) Applying the first-person policy to the third-person agent fails miserably, illustrating that explicitly considering third-person imitation is important in these settings.
+
+Somewhat unfortunately, the different reward function scales make it difficult to capture information on the variance of each learning curve. Consequently, in Appendix A we have included the full learning curves for these experiments with variance bars, each plotted with an appropriate scale to examine the variance of the individual curves.
+
+# 7 DISCUSSION AND FUTURE WORK
+
+In this paper, we presented the problem of third-person imitation learning. We argue that this problem will be important going forward, as techniques in reinforcement learning and generative adversarial learning improve and the cost of collecting first-person samples remains high. We presented an algorithm which builds on Generative Adversarial Imitation Learning and is capable of solving simple third-person imitation tasks.
+
+One promising direction of future work in this area is to jointly train policy features and cost features at the pixel level, allowing the reuse of image features. Code to train a third person imitation learning agent on the domains from this paper is presented here: https://github.com/bstadie/ third_person_im
+
+# ACKNOWLEDGEMENTS
+
+This work was done partially at OpenAI and partially at Berkeley. Work done at Berkeley was supported in part by Darpa under the Simplex program and the FunLoL program.
+
+# REFERENCES
+
+P. Abbeel and A. Ng. Apprenticeship learning via inverse reinforcement learning. In International Conference on Machine Learning (ICML), 2004.
+
+Pieter Abbeel, Adam Coates, and Andrew Y Ng. Autonomous helicopter aerobatics through apprenticeship learning. The International Journal of Robotics Research, 2010.
+
+Brenna D Argall, Sonia Chernova, Manuela Veloso, and Brett Browning. A survey of robot learning from demonstration. Robotics and autonomous systems, 57(5):469–483, 2009.
+
+Yusuf Aytar and Andrew Zisserman. Tabula rasa: Model transfer for object category detection. In 2011 International Conference on Computer Vision, pp. 2252–2259. IEEE, 2011.
+
+D. Barber and F. V. Agakov. Kernelized infomax clustering. NIPS, 2005.
+
+A. Boularias, J. Kober, and J. Peters. Relative entropy inverse reinforcement learning. In International Conference on Artificial Intelligence and Statistics (AISTATS), 2011.
+
+J. S. Bridle, A. J. Heading, and D. J. MacKay. Unsupervised classifiers, mutual information and phantom targets. NIPS, 1992.
+
+Jane Bromley, James W Bentz, Leon Bottou, Isabelle Guyon, Yann LeCun, Cliff Moore, Eduard ´ Sackinger, and Roopak Shah. Signature verification using a siamese time delay neural network.¨ International Journal of Pattern Recognition and Artificial Intelligence, 7(04):669–688, 1993.
+
+Sylvain Calinon. Robot programming by demonstration. EPFL Press, 2009.
+
+Sylvain Calinon, Florent Guenter, and Aude Billard. On learning, representing, and generalizing a task in a humanoid robot. IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), 37(2):286–298, 2007.
+
+Malinda Carpenter, Josep Call, and Michael Tomasello. Understanding prior intentions enables two–year–olds to imitatively learn a complex task. Child development, 73(5):1431–1441, 2002.
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. NIPS, 2016.
+
+Sumit Chopra, Raia Hadsell, and Yann LeCun. Learning a similarity metric discriminatively, with application to face verification. In 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’05), volume 1, pp. 539–546. IEEE, 2005.
+
+A. Doerr, N. Ratliff, J. Bohg, M. Toussaint, and S. Schaal. Direct loss minimization inverse optimal control. In Proceedings of Robotics: Science and Systems (R:SS), Rome, Italy, July 2015.
+
+Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. Decaf: A deep convolutional activation feature for generic visual recognition. In ICML, pp. 647–655, 2014.
+
+Lixin Duan, Dong Xu, and Ivor Tsang. Learning with augmented features for heterogeneous domain adaptation. arXiv preprint arXiv:1206.4660, 2012.
+
+C. Finn, S. Levine, and P. Abbeel. Guided cost learning: Deep inverse optimal control via policy optimization. ICML, 2016.
+
+Y. Ganin and V. Lempitsky. Unsupervised domain adaptation by backpropagation. Arxiv preprint 1409.7495, 2014.
+
+G Gioioso, G Salvietti, M Malvezzi, and D Prattichizzo. An object-based approach to map human hand synergies onto robotic hands with dissimilar kinematics. Robotics: Science and Systems VIII, pp. 97, 2013.
+
+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.
+
+Abhishek Gupta, Clemens Eppner, Sergey Levine, and Pieter Abbeel. Learning dexterous manipulation for a soft robotic hand from human demonstration. arXiv preprint arXiv:1603.06348, 2016.
+
+J. Ho and S. Ermon. Generative adversarial imitation learning. arXiv pre-print: 1606.03476, pp. 1061–1068, 2016.
+
+Judy Hoffman, Erik Rodner, Jeff Donahue, Trevor Darrell, and Kate Saenko. Efficient learning of domain-invariant image representations. arXiv preprint arXiv:1301.3224, 2013.
+
+M. Kalakrishnan, P. Pastor, L. Righetti, and S. Schaal. Learning objective functions for manipulation. In International Conference on Robotics and Automation (ICRA), 2013.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the 3rd International Conference on Learning Representations (ICLR), 2014.
+
+A. Krause, P. Perona, and R. G. Gomes. Discriminative clustering by regularized information maximization. NIPS, 2010.
+
+Brian Kulis, Kate Saenko, and Trevor Darrell. What you saw is not what you get: Domain adaptation using asymmetric kernel transforms. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 1785–1792. IEEE, 2011.
+
+S. Levine, Z. Popovic, and V. Koltun. Nonlinear inverse reinforcement learning with gaussian processes. In Advances in Neural Information Processing Systems (NIPS), 2011.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016.
+
+Mingsheng Long and Jianmin Wang. Learning transferable features with deep adaptation networks. CoRR, abs/1502.02791, 1:2, 2015.
+
+Yishay Mansour, Mehryar Mohri, and Afshin Rostamizadeh. Domain adaptation: Learning bounds and algorithms. arXiv preprint arXiv:0902.3430, 2009.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.
+
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. arXiv preprint arXiv:1602.01783, 2016.
+
+Chrystopher L Nehaniv. Nine billion correspondence problems. Imitation and Social Learning in Robots, Humans and Animals: Behavioural, Social and Communicative Dimensions, Cambridge University Press, 8:10, 2007.
+
+Chrystopher L Nehaniv and Kerstin Dautenhahn. Like me?-measures of correspondence and imitation. Cybernetics & Systems, 32(1-2):11–51, 2001.
+
+A. Ng, S. Russell, et al. Algorithms for inverse reinforcement learning. In International Conference on Machine Learning (ICML), 2000.
+
+Dean A Pomerleau. Alvinn: An autonomous land vehicle in a neural network. In Advances in Neural Information Processing Systems, pp. 305–313, 1989.
+
+D. Ramachandran and E. Amir. Bayesian inverse reinforcement learning. In AAAI Conference on Artificial Intelligence, volume 51, 2007.
+
+N. Ratliff, J. A. Bagnell, and M. A. Zinkevich. Maximum margin planning. In International Conference on Machine Learning (ICML), 2006.
+
+N. Ratliff, D. Bradley, J. A. Bagnell, and J. Chestnutt. Boosting structured prediction for imitation learning. 2007.
+
+Stephane Ross, Geoffrey J Gordon, and Drew Bagnell. A reduction of imitation learning and struc-´ tured prediction to no-regret online learning. In AISTATS, volume 1, pp. 6, 2011.
+
+Stefan Schaal. Is imitation learning the route to humanoid robots? Trends in cognitive sciences, 3 (6):233–242, 1999.
+
+John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region policy optimization. Arxiv preprint 1502.05477, 2015a.
+
+John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015b.
+
+Aaron Shon, Keith Grochow, Aaron Hertzmann, and Rajesh P Rao. Learning shared latent structure for image synthesis and robotic imitation. In Advances in Neural Information Processing Systems, pp. 1233–1240, 2005.
+
+Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014.
+
+Eric Tzeng, Coline Devin, Judy Hoffman, Chelsea Finn, Xingchao Peng, Pieter Abbeel, Sergey Levine, Kate Saenko, and Trevor Darrell. Towards adapting deep visuomotor representations from simulated to real environments. arXiv preprint arXiv:1511.07111, 2015.
+
+M. Wulfmeier, P. Ondruska, and I. Posner. Maximum entropy deep inverse reinforcement learning. arXiv preprint arXiv:1507.04888, 2015.
+
+Jun Yang, Rong Yan, and Alexander G Hauptmann. Cross-domain video concept detection using adaptive svms. In Proceedings of the 15th ACM international conference on Multimedia, pp. 188–197. ACM, 2007.
+
+B. Ziebart, A. Maas, J. A. Bagnell, and A. K. Dey. Maximum entropy inverse reinforcement learning. In AAAI Conference on Artificial Intelligence, 2008.
+
+# 8 APPENDIX A: LEARNING CURVES FOR BASELINES
+
+Here, we plot the learning curves for each of the baselines mentioned in the experiments section as a standalone plot. This allows one to better examine the variance of each individual learning curve.
+
+![](images/ea1b67edb2dfdb4fef94fc8a920576a33c7505c4ce55718706bd9be88e6caa3d.jpg)  
+Figure 10: Inverted Pendulum performance under a policy trained on RL, first-person imitation learning, third-person imitation, and a first-person policy applied to a third-person agent.
+
+![](images/b6baae997578e700d576c20450de54e13c29bc04641825948f30b3aa8cd5b4b7.jpg)  
+Figure 11: Reacher performance under a policy trained on RL, first-person imitation learning, thirdperson imitation, and a first-person policy applied to a third-person agent.
+
+![](images/93145b975be3c2886cda5aca0198047a94819a2d2d82acbc535b32d11815a821.jpg)  
+Figure 12: Point performance under a policy trained on RL, first-person imitation learning, thirdperson imitation, and a first-person policy applied to a third-person agent.
+
+# 9 APPENDIX B: ARCHITECTURE PARAMETERS
+
+Joint Feature Extractor: Input is images are size $5 0 \mathrm { ~ x ~ } 5 0$ with 3 channels, RGB. Layers are 2 convolutional layers each followed by a max pooling layer of size 2. Layers use 5 filters of size 3 each.
+
+Domain Discriminator and the Class Discriminator: Input is domain agnostic output of convolutional layers. Layers are two feed forward layers of size 128 followed by a final feed forward layer of size 2 and a soft-max layer to get the log probabilities.
+
+ADAM is used for discriminator training with a learning rate of 0.001. The RL generator uses the off-the-shelf TRPO implementation available in RLLab.

parse/train/B16dGcqlx/B16dGcqlx_content_list.json

@@ -0,0 +1,1741 @@
+[
+    {
+        "type": "text",
+        "text": "THIRD-PERSON IMITATION LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            635,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bradly C. Stadie1,2, Pieter Abbeel1,3, Ilya Sutskever1 ",
+        "bbox": [
+            183,
+            142,
+            552,
+            160
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 OpenAI 2 UC Berkeley, Department of Statistics 3 UC Berkeley, Departments of EECS and ICSI {bstadie, pieter, ilyasu,}@openai.com ",
+        "bbox": [
+            183,
+            161,
+            545,
+            217
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            253,
+            544,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning (RL) makes it possible to train agents capable of achieving sophisticated goals in complex and uncertain environments. A key difficulty in reinforcement learning is specifying a reward function for the agent to optimize. Traditionally, imitation learning in RL has been used to overcome this problem. Unfortunately, hitherto imitation learning methods tend to require that demonstrations are supplied in the first-person: the agent is provided with a sequence of states and a specification of the actions that it should have taken. While powerful, this kind of imitation learning is limited by the relatively hard problem of collecting first-person demonstrations. Humans address this problem by learning from third-person demonstrations: they observe other humans perform tasks, infer the task, and accomplish the same task themselves. ",
+        "bbox": [
+            233,
+            282,
+            764,
+            434
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we present a method for unsupervised third-person imitation learning. Here third-person refers to training an agent to correctly achieve a simple goal in a simple environment when it is provided a demonstration of a teacher achieving the same goal but from a different viewpoint; and unsupervised refers to the fact that the agent receives only these third-person demonstrations, and is not provided a correspondence between teacher states and student states. Our methods primary insight is that recent advances from domain confusion can be utilized to yield domain agnostic features which are crucial during the training process. To validate our approach, we report successful experiments on learning from third-person demonstrations in a pointmass domain, a reacher domain, and inverted pendulum. ",
+        "bbox": [
+            233,
+            438,
+            764,
+            589
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            614,
+            336,
+            630
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning (RL) is a framework for training agents to maximize rewards in large, unknown, stochastic environments. In recent years, combining techniques from deep learning with reinforcement learning has yielded a string of successful applications in game playing and robotics Mnih et al. (2015; 2016); Schulman et al. (2015a); Levine et al. (2016). These successful applications, and the speed at which the abilities of RL algorithms have been increasing, makes it an exciting area of research with significant potential for future applications. ",
+        "bbox": [
+            174,
+            645,
+            823,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the major weaknesses of RL is the need to manually specify a reward function. For each task we wish our agent to accomplish, we must provide it with a reward function whose maximizer will precisely recover the desired behavior. This weakness is addressed by the field of Inverse Reinforcement Learning (IRL). Given a set of expert trajectories, IRL algorithms produce a reward function under which these the expert trajectories enjoy the property of optimality. Recently, there has been a significant amount of work on IRL, and current algorithms can infer a reward function from a very modest number of demonstrations (e.g,. Abbeel & $\\mathrm { N g }$ (2004); Ratliff et al. (2006); Ziebart et al. (2008); Levine et al. (2011); Ho & Ermon (2016); Finn et al. (2016)). ",
+        "bbox": [
+            174,
+            736,
+            825,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While IRL algorithms are appealing, they impose the somewhat unrealistic requirement that the demonstrations should be provided from the first-person point of view with respect to the agent. Human beings learn to imitate entirely from third-person demonstrations – i.e., by observing other humans achieve goals. Indeed, in many situations, first-person demonstrations are outright impossible to obtain. Meanwhile, third-person demonstrations are often relatively easy to obtain. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The goal of this paper is to develop an algorithm for third-person imitation learning. Future advancements in this class of algorithms would significantly improve the state of robotics, because it will enable people to easily teach robots news skills and abilities. Importantly, we want our algorithm to be unsupervised: it should be able to observe another agent perform a task, infer that there is an underlying correspondence to itself, and find a way to accomplish the same task. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We offer an approach to this problem by borrowing ideas from domain confusion Tzeng et al. (2014) and generative adversarial networks (GANs) Goodfellow et al. (2014). The high-level idea is to introduce an optimizer under which we can recover both a domain-agnostic representation of the agent’s observations, and a cost function which utilizes this domain-agnostic representation to capture the essence of expert trajectories. We formulate this as a third-person RL-GAN problem, and our solution builds on the first-person RL-GAN formulation by Ho & Ermon (2016). ",
+        "bbox": [
+            174,
+            180,
+            823,
+            263
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Surprisingly, we find that this simple approach has been able to solve the problems that are presented in this paper (illustrated in Figure 1), even though the student’s observations are related in a complicated way to the teacher’s demonstrations (given that the observations and the demonstrations are pixel-level). As techniques for training GANs become more stable and capable, we expect our algorithm to be able to infer solve harder third-person imitation tasks without any direct supervision. ",
+        "bbox": [
+            174,
+            271,
+            825,
+            340
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f116f6ef62dbbe520d3cfcd3efa9281e7a38397e6e00f6ac5c062e2df069dc2.jpg",
+        "image_caption": [
+            "Figure 1: From left to right, the three domains we consider in this paper: pointmass, reacher, and pendulum. Top-row is the third-person view of a teacher demonstration. Bottom row is the agent’s view in their version of the environment. For the point and reacher environments, the camera angles differ by approximately 40 degrees. For the pendulum environment, the color of the pole differs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            356,
+            789,
+            606
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            710,
+            344,
+            727
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Imitation learning (also learning from demonstrations or programming by demonstration) considers the problem of acquiring skills from observing demonstrations. Imitation learning has a long history, with several good survey articles, including (Schaal, 1999; Calinon, 2009; Argall et al., 2009). Two main lines of work within imitation learning are: 1) behavioral cloning, where the demonstrations are used to directly learn a mapping from observations to actions using supervised learning, potentially with interleaving learning and data collection (e.g., Pomerleau (1989); Ross et al. (2011)). 2) Inverse reinforcement learning $\\mathrm { N g }$ et al., 2000), where a reward function is estimated that explains the demonstrations as (near) optimal behavior. This reward function could be represented as nearness to a trajectory (Calinon et al., 2007; Abbeel et al., 2010), as a weighted combination of features (Abbeel & $\\mathrm { N g }$ , 2004; Ratliff et al., 2006; Ramachandran & Amir, 2007; Ziebart et al., 2008; Boularias et al., 2011; Kalakrishnan et al., 2013; Doerr et al., 2015), or could also involve feature learning (Ratliff et al., 2007; Levine et al., 2011; Wulfmeier et al., 2015; Finn et al., 2016; Ho & Ermon, 2016). ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This past work, however, is not directly applicable to the third person imitation learning setting. In third-person imitation learning, the observations and actions obtained from the demonstrations are not the same as what the imitator agent will be faced with. A typical scenario would be: the imitator agent watches a human perform a demonstration, and then has to execute that same task. As discussed in Nehaniv & Dautenhahn (2001) the ”what and how to imitate” questions become significantly more challenging in this setting. To directly apply existing behavioral cloning or inverse reinforcement learning techniques would require knowledge of a mapping between observations and actions in the demonstrator space to observations and actions in the imitator space. Such a mapping is often difficult to obtain, and it typically relies on providing feature representations that captures the invariance between both environments Carpenter et al. (2002); Shon et al. (2005); Calinon et al. (2007); Nehaniv (2007); Gioioso et al. (2013); Gupta et al. (2016). Contrary to prior work, we consider third-person imitation learning from raw sensory data, where no such features are made available. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The most closely related work to ours is by Finn et al. (2016); Ho & Ermon (2016); Wulfmeier et al. (2015), who also consider inverse reinforcement learning directly from raw sensory data. However, the applicability of their approaches is limited to the first-person setting. Indeed, matching raw sensory observations is impossible in the 3rd person setting. ",
+        "bbox": [
+            174,
+            290,
+            823,
+            347
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our work also closely builds on advances in generative adversarial networks Goodfellow et al. (2014), which are very closely related to imitation learning as explained in Finn et al. (2016); Ho & Ermon (2016). In our optimization formulation, we apply the gradient flipping technique from Ganin & Lempitsky (2014). ",
+        "bbox": [
+            174,
+            354,
+            823,
+            410
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The problem of adapting what is learned in one domain to another domain has been studied extensively in computer vision in the supervised learning setting Yang et al. (2007); Mansour et al. (2009); Kulis et al. (2011); Aytar & Zisserman (2011); Duan et al. (2012); Hoffman et al. (2013); Long & Wang (2015). It has also been shown that features trained in one domain can often be relevant to other domains Donahue et al. (2014). The work most closely related to ours is Tzeng et al. (2014; 2015), who also consider an explicit domain confusion loss, forcing trained classifiers to rely on features that don’t allow to distinguish between two domains. This work in turn relates to earlier work by Bromley et al. (1993); Chopra et al. (2005), which also considers supervised training of deep feature embeddings. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our approach to third-person imitation learning relies on reinforcement learning from raw sensory data in the imitator domain. Several recent advances in deep reinforcement learning have made this practical, including Deep Q-Networks (Mnih et al., 2015), Trust Region Policy Optimization (Schulman et al., 2015a), A3C Mnih et al. (2016), and Generalized Advantage Estimation (Schulman et al., 2015b). Our approach uses Trust Region Policy Optimization. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BACKGROUND AND PRELIMINARIES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            647,
+            506,
+            664
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A discrete-time finite-horizon discounted Markov decision process (MDP) is represented by a tuple $M = ( S , A , \\mathcal { P } , r , \\rho _ { 0 } , \\gamma , T )$ , in which $s$ is a state set, $\\mathcal { A }$ an action set, $\\mathcal { P } : \\bar { S \\times A } \\times \\bar { S } \\stackrel { \\cdot } { \\to } \\mathbb { R } _ { + }$ a transition probability distribution, $r : S \\times \\mathcal { A }  \\mathbb { R }$ a reward function, $\\rho _ { 0 } : { \\mathcal { S } } \\to \\mathbb { R } _ { + }$ an initial state distribution, $\\gamma \\in [ 0 , 1 ]$ a discount factor, and $T$ the horizon. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the reinforcement learning setting, the goal is to find a policy $\\pi _ { \\theta } : \\mathcal { S } \\times \\mathcal { A } \\to \\mathbb { R } _ { + }$ parametrized by $\\theta$ that maximizes the expected discounted sum of rewards incurred, $\\begin{array} { r } { \\eta ( \\pi _ { \\theta } ) = \\mathbb { E } _ { \\pi _ { \\theta } } [ \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } c ( s _ { t } ) ] } \\end{array}$ , where $s _ { 0 } \\sim \\rho _ { 0 } ( s _ { 0 } )$ , $a _ { t } \\sim \\pi _ { \\theta } ( a _ { t } | s _ { t } )$ , and $s _ { t + 1 } \\sim \\mathcal { P } ( s _ { t + 1 } | s _ { t } , a _ { t } )$ . ",
+        "bbox": [
+            174,
+            746,
+            825,
+            792
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In the (first-person) imitation learning setting, we are not given the reward function. Instead we are given traces (i.e., sequences of states traversed) by an expert who acts according to an unknown policy $\\pi _ { E }$ . The goal is to find a policy $\\pi _ { \\theta }$ that performs as well as the expert against the unknown reward function. It was shown in Abbeel & $\\mathrm { N g }$ (2004) that this can be achieved through inverse reinforcement learning by finding a policy $\\pi _ { \\theta }$ that matches the expert’s empirical expectation over discounted sum of all features that might contribute to the reward function. The work by Ho & Ermon (2016) generalizes this to the setting when no features are provided as follows: Find a policy $\\pi _ { \\theta }$ that makes it impossible for a discriminator (in their work a deep neural net) to distinguish states visited by the expert from states visited by the imitator agent. This can be formalized as follows: ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2b5f364431d4a8b2f1b5d96f17baf080496ec4944a44f6a6db5eac570965428.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { \\pi _ { \\theta } } { \\mathop { \\operatorname* { m a x } } } \\underset { \\mathcal { D } _ { R } } { \\mathop { \\operatorname* { m i n } } } } & { { } - \\mathbb { E } _ { \\pi _ { \\theta } } [ \\log \\mathcal { D } _ { R } ( s ) ] - \\mathbb { E } _ { \\pi _ { E } } [ \\log ( 1 - \\mathcal { D } _ { R } ( s ) ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            121,
+            594,
+            146
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, the expectations are over the states experienced by the policy of the imitator agent, $\\pi _ { \\theta }$ , and by the policy of the expert, $\\pi _ { E }$ , respectively. $\\mathcal { D } _ { R }$ is the discriminator, which outputs the probability of a state having originated from a trace from the imitator policy $\\pi _ { \\theta }$ . If the discriminator is perfectly able to distinguish which policy originated state-action pairs, then $\\mathcal { D } _ { R }$ will consistently output a probability of 1 in the first term, and a probability of 0 in the second term, making the objective its lowest possible value of zero. It is the role of the imitator agent $\\pi _ { \\theta }$ to find a policy that makes it difficult for the discriminator to make that distinction. The desired equilibrium has the imitator agent making it impractical for the discriminator to distinguish, hence forcing the discriminator to assign probability 0.5 in all cases. Ho & Ermon (2016) present a practical approach for solving this type of game when representing both $\\pi _ { \\theta }$ and $\\mathcal { D } _ { R }$ as deep neural networks. Their approach repeatedly performs gradient updates on each of them. Concretely, for a current policy $\\pi _ { \\theta }$ traces can be collected, which together with the expert traces form a data-set on which $\\mathcal { D } _ { R }$ can be trained with supervised learning minimizing the negative log-likelihood (in practice only performing a modest number of updates). For a fixed $\\mathcal { D } _ { R }$ , this is a policy optimization problem where $- \\log \\mathcal { D } _ { R } ( s , a )$ is the reward, and policy gradients can be computed from those same traces. Their approach uses trust region policy optimization (Schulman et al., 2015a) to update the imitator policy $\\pi _ { \\theta }$ from those gradients. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In our work we will have more terms in the objective, so for compactness of notation, we will realize the discriminative minimization from Eqn. (1) as follows: ",
+        "bbox": [
+            173,
+            397,
+            823,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c96b2d327a9ada0da185a9fd236c1f54c7a9bb49a09873d840ff412bb36814c0.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi _ { \\boldsymbol { \\theta } } } \\operatorname* { m i n } _ { \\mathcal { D } _ { R } } \\mathcal { L } _ { R } = \\sum _ { i } C E ( \\mathcal { D } _ { R } ( \\boldsymbol { s } _ { i } ) , \\boldsymbol { c } _ { \\boldsymbol { \\ell } _ { i } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            429,
+            482,
+            462
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Where $s _ { i }$ is state $i$ , $c _ { \\ell _ { i } }$ is the correct class label (was the state $s _ { i }$ obtained from an expert vs. from a non-expert), and $C E$ is the standard cross entropy loss. ",
+        "bbox": [
+            171,
+            464,
+            823,
+            493
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 A FORMAL DEFINITION OF THE THIRD-PERSON IMITATION LEARNINGPROBLEM",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            800,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, the third-person imitation learning problem can be stated as follows. Suppose we are given two Markov Decision Processes $M _ { \\pi _ { E } }$ and $M _ { \\pi _ { \\theta } }$ . Suppose further there exists a set of traces $\\rho =$ $\\{ ( s _ { 1 } , \\ldots , s _ { n } ) \\} _ { i = 0 } ^ { n }$ which were generated under a policy $\\pi _ { E }$ acting optimally under some unknown reward $R _ { \\pi _ { E } }$ . In third-person imitation learning, one attempts to recover by proxy through $\\rho$ a policy $\\pi _ { \\theta } = f ( \\rho )$ which acts optimally with respect to $R _ { \\pi _ { \\theta } }$ . ",
+        "bbox": [
+            173,
+            560,
+            825,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5 A THIRD-PERSON IMITATION LEARNING ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            650,
+            656,
+            666
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "5.1 GAME FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            680,
+            367,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we discuss a simple algorithm for third-person imitation learning. This algorithm is able to successfully discriminate between expert and novice policies, even when the policies are executed under different environments. Subsequently, this discrimination signal can be used to train expert policies in new domains via RL by training the novice policy to fool the discriminator, thus forcing it to match the expert policy. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In third-person learning, observations are more typically available rather than direct state access, so going forward we will work with observations $o _ { t }$ instead of states $s _ { t }$ as representing the expert traces. The top row of Figure 8 illustrates what these observations are like in our experiments. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We begin by recalling that in the algorithm proposed by Ho & Ermon (2016) the loss in Equation 2 is utilized to train a discriminator $\\mathcal { D } _ { R }$ capable of distinguishing expert vs non-expert policies. Unfortunately, (2) will likely fail in cases when the expert and non-expert act in different environments, since $\\mathcal { D } _ { R }$ will quickly learn these differences and use them as a strong classification signal. ",
+        "bbox": [
+            176,
+            832,
+            823,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To handle the third-person setting, where expert and novice are in different environments, we consider that $\\mathcal { D } _ { R }$ works by first extracting features from $o _ { t }$ , and then using these features to make a classification. Suppose then that we partition $\\mathcal { D } _ { R }$ into a feature extractor $\\mathcal { D } _ { F }$ and the actual classifier which assigns probabilities to the outputs of $D _ { F }$ . Overloading notation, we will refer to the classifier as $\\mathcal { D } _ { R }$ going forward. For example, in case of a deep neural net representation, $\\mathcal { D } _ { F }$ would correspond to the earlier layers, and $\\mathcal { D } _ { R }$ to the later layers. The problem is then to ensure that $D _ { F }$ contains no information regarding the rollout’s domain label $d _ { \\ell }$ (i.e., expert vs. novice domain). This can be realized as ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            102,
+            825,
+            186
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ebd63f2fbf725e0af448b9d290880690e3dbc8d23cd0bb34cda599bfa86e164.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\underset { \\pi _ { \\theta } } { \\operatorname* { m a x } } \\operatorname* { m i n } \\mathcal L _ { { R } } = \\displaystyle \\sum _ { i } C E ( \\mathcal D _ { { R } } ( \\mathcal D _ { { F } } ( o _ { i } ) ) , c _ { \\ell _ { i } } ) } \\\\ & { } & { \\mathrm { s . t . } ~ \\mathrm { M I } ( D _ { { F } } ( o _ { i } ) ; d _ { l } ) = 0 } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            191,
+            519,
+            246
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Where MI is mutual information and hence we have abused notation by using $\\mathcal { D } _ { R } , D _ { F }$ , and $d _ { \\ell }$ to mean the classifier, feature extractor, and the domain label respectively as well as distributions over these objects. ",
+        "bbox": [
+            173,
+            251,
+            825,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The mutual information term can be instantiated by introducing another classifier $\\mathcal { D } _ { D }$ , which takes features produced by $D _ { F }$ and outputs the probability that those features were produced by in the expert vs. non-expert environment. (See Bridle et al. (1992); Barber & Agakov (2005); Krause et al. (2010); Chen et al. (2016) for further discussion on instantiating the information term by introducing another classifier.) If $\\sigma _ { i } = D _ { F } { ( o _ { i } ) }$ , then the problem can be written as ",
+        "bbox": [
+            173,
+            299,
+            825,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6a8123f3dc19eca9e733d44329bbfd30104f23226bbabb3745bbaf964289d63.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi _ { \\theta } } \\operatorname* { m i n } _ { \\mathcal { D } _ { R } } \\operatorname* { m a x } _ { \\mathcal { D } _ { D } } \\mathcal { L } _ { R } + \\mathcal { L } _ { D } = \\sum _ { i } C E ( \\mathcal { D } _ { R } ( \\sigma _ { i } ) , c _ { \\ell _ { i } } ) + C E ( \\mathcal { D } _ { D } ( \\sigma _ { i } ) , d _ { \\ell _ { i } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            377,
+            697,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In words, we wish to minimize class loss while maximizing domain confusion. ",
+        "bbox": [
+            173,
+            425,
+            691,
+            440
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Often, it can be difficult for even humans to judge a static image as expert vs. non-expert because it does not convey any information about the environmental change affected by the agent’s actions. For example, if a pointmass is attempting to move to a target location and starts far away from its goal state, it can be difficult to judge if the policy itself is bad or the initialization was simply unlucky. In response to this difficulty, we give $\\mathcal { D } _ { R }$ access to not only the image at time $t$ , but also at some future time $t + n$ . Define $\\sigma _ { t } = D _ { F } ( o _ { t } )$ and $\\sigma _ { t + n } = D _ { F } ( o _ { t + n } )$ . The classifier then makes a prediction $\\mathcal { D } _ { R } ( \\sigma _ { t } , \\sigma _ { t + n } ) = \\hat { c } _ { \\ell }$ . ",
+        "bbox": [
+            173,
+            446,
+            825,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This renders the following formulation: ",
+        "bbox": [
+            176,
+            551,
+            433,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d567ab78009db01e84ea31404c46dedb8810ebab385f80fea825c32655b28a3c.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi _ { \\theta } } \\operatorname* { m i n } _ { \\mathcal { D } _ { R } } \\operatorname* { m a x } _ { \\mathcal { D } _ { D } } \\mathcal { L } _ { R } + \\mathcal { L } _ { D } = \\sum _ { i } C E ( \\mathcal { D } _ { R } ( \\sigma _ { i } , \\sigma _ { i + n } ) , c _ { \\ell _ { i } } ) + C E ( \\mathcal { D } _ { D } ( \\sigma _ { i } ) , d _ { \\ell _ { i } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            592,
+            736,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note we also want to optimize over $\\mathcal { D } _ { F }$ , the feature extractor, but it feeds both into $\\mathcal { D } _ { R }$ and into $\\mathcal { D } _ { D }$ , which are competing (hidden under $\\sigma$ ), which we will address now. ",
+        "bbox": [
+            171,
+            640,
+            823,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To deal with the competition over $\\mathcal { D } _ { F }$ , we introduce a function $\\mathcal { G }$ that acts as the identity when moving forward through a directed acyclic graph and flips the sign when backpropagating through the graph. This technique has enjoyed recent success in computer vision. See, for example, (Ganin & Lempitsky, 2014). With this trick, the problem reduces to its final form ",
+        "bbox": [
+            173,
+            674,
+            825,
+            732
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e878630c8a69cba18bd232573af6490d231288140a238744a9aa2e731d5cdffe.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { \\pi _ { \\theta } } \\operatorname* { m i n } _ { \\mathcal { D } _ { R } , \\mathcal { D } _ { D } , \\mathcal { D } _ { F } } \\mathcal { L } _ { R } + \\mathcal { L } _ { D } = \\sum _ { i } C E ( \\mathcal { D } _ { R } ( \\sigma _ { i } , \\sigma _ { i + n } ) , c _ { \\ell _ { i } } ) + \\lambda C E ( \\mathcal { D } _ { D } ( \\mathcal { G } ( \\sigma _ { i } ) , d _ { \\ell _ { i } } ) - c _ { \\ell _ { i } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            756,
+            774,
+            790
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Equation (5), we flip the gradient’s sign during backpropagation of $D _ { F }$ with respect to the domain classification loss. This corresponds to stochastic gradient ascent away from features that are useful for domain classification, thus ensuring that $D _ { F }$ produces domain agnostic features. Equation 5 can be solved efficiently with stochastic gradient descent. Here $\\lambda$ is a hyperparameter that determines the trade-off made between the objectives that are competing over $\\mathcal { D } _ { F }$ . ",
+        "bbox": [
+            173,
+            796,
+            825,
+            867
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To ensure sufficient signal for discrimination between expert and non-expert, we collect third-person demonstrations in the expert domain from both an expert and from a non-expert. ",
+        "bbox": [
+            173,
+            873,
+            823,
+            902
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our complete formulation is graphically summarized in Figure 2. ",
+        "bbox": [
+            173,
+            909,
+            602,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f6e6112f36cfebf12955fa02ddf614350be92d58e85c57da82c1566c4d52336.jpg",
+        "image_caption": [
+            "Figure 2: Architecture diagram for third-person imitation learning. Images at time $t$ and $t + 4$ are sent through a feature extractor to obtain $F ( o _ { t } )$ and $F ( o _ { t + 4 } )$ . Subsequently, these feature vectors are reused in two places. First, they are concatenated and used to predict whether the samples are drawn from expert or non-expert trajectories. Second, $F ( o _ { t } )$ is utilized to predict a domain label (expert vs. novice domain). During backpropogation, the sign on the domain loss $L _ { D }$ is flipped to destroy information that was useful for distinguishing the two domains. This ensures that the feature extractor $F$ is domain agnostic. Finally, the classes probabilities that were computed using this domain-agnostic feature vector are utilized as a cost signal in TRPO; which is subsequently utilized to train the novice policy to take expert-like actions and collect further rollouts. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            101,
+            831,
+            332
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            508,
+            303,
+            522
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To solve the game formulation in Equation (5), we perform alternating (partial) optimization over the policy $\\pi _ { \\theta }$ and the reward function and domain confusion encoded through $\\mathcal { D } _ { R } , \\mathcal { D } _ { D } , \\mathcal { D } _ { F }$ . ",
+        "bbox": [
+            174,
+            537,
+            823,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The optimization over $\\mathcal { D } _ { R } , \\mathcal { D } _ { D } , \\mathcal { D } _ { F }$ is done through stochastic gradient descent with ADAM Kingma & Ba (2014). ",
+        "bbox": [
+            176,
+            571,
+            823,
+            601
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our generator $\\left( \\pi _ { \\boldsymbol { \\theta } } \\right)$ step is similar to the generator step in the algorithm by (Ho & Ermon, 2016). We simply use $- \\log \\mathcal { D } _ { R }$ as the reward. Using policy gradient methods (TRPO), we train the generator to minimize this cost and thus push the policy further towards replicating expert behavior. Once the generator step is done, we start again with the discriminator step. The entire process is summarized in algorithm 1. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            678
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            704,
+            326,
+            720
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We seek to answer the following questions through experiments: ",
+        "bbox": [
+            174,
+            739,
+            596,
+            755
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. Is it possible to solve the third-person imitation learning problem in simple settings? I.e., given a collection of expert image-based rollouts in one domain, is it possible to train a policy in a different domain that replicates the essence of the original behavior? 2. Does the algorithm we propose benefit from both domain confusion and velocity? 3. How sensitive is our proposed algorithm to the selection of hyper-parameters used in deployment? 4. How sensitive is our proposed algorithm to changes in camera angle? 5. How does our method compare against some reasonable baselines? ",
+        "bbox": [
+            209,
+            768,
+            825,
+            925
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 A third-person imitation learning algorithm. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            550,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1: Let CE be the standard cross entropy loss.   \n2: Let $\\mathcal { G }$ be a function that flips the gradient sign during backpropogation and acts as the identity   \nmap otherwise.   \n3: Initialize two domains, $E$ and $N$ for the expert and novice.   \n4: Initialize a memory bank $\\Omega$ of expert success and of failure in domain $E$ . Each trajectory $\\omega \\in \\Omega$   \ncomprises a rollout of images $o = o _ { 1 } , \\ldots , o _ { t } , \\ldots o _ { n }$ , a class label $c _ { \\ell }$ , and a domain label $d _ { \\ell }$ .   \n5: Initialize $\\mathcal { D } = \\mathcal { D } _ { F } , \\mathcal { D } _ { R } , \\mathcal { D } _ { D }$ , a domain invariant discriminator.   \n6: Initialize a novice policy $\\pi _ { \\theta }$ .   \n7: Initialize numiters, the number of inner policy optimization iterations we wish to run.   \n8: for iter in numiters do   \n9: Sample a set of successes and failures $\\omega _ { E }$ from $\\Omega$ .   \n10: Collect on policy samples $\\omega _ { N }$   \n11: Set $\\omega = \\omega _ { E } \\cup \\omega _ { N }$ .   \n12: Shuffle $\\omega$   \n13: for $o , c _ { \\ell } , d _ { \\ell }$ in $\\omega$ do   \n14: for $o _ { t }$ in $o$ do   \n15: $\\sigma _ { t } = \\mathcal { D } _ { F } \\big ( o _ { t } \\big )$   \n16: $\\sigma _ { t + 4 } = \\mathscr { D } _ { F } ( o _ { t + 4 } )$   \n17: $\\mathcal { L } _ { R } = C E ( \\mathcal { D } _ { R } ( \\sigma _ { t } , \\sigma _ { t + 4 } ) , c _ { \\ell } )$   \n18: $\\mathcal { L } _ { d } = C E ( \\mathcal { D } _ { D } ( \\mathcal { G } ( \\sigma _ { t } ) ) , d _ { \\ell } )$   \n19: L = λ · Ld + LR   \n20: minimize $\\mathcal { L }$ with ADAM.   \n21: end for   \n22: end for   \n23: Collect on policy samples $\\omega _ { N }$ from $\\pi _ { \\theta }$ .   \n24: for $\\omega$ in $\\omega _ { N }$ do   \n25: for $\\omega _ { t }$ in $\\omega$ do   \n26: $\\begin{array} { l } { \\sigma _ { t } = \\mathcal { D } _ { F } \\big ( o _ { t } \\big ) } \\\\ { \\sigma _ { t + 4 } = \\mathcal { D } _ { F } \\big ( o _ { t + 4 } \\big ) } \\\\ { \\hat { c } _ { \\ell } = \\mathcal { D } _ { R } \\big ( \\sigma _ { t } , \\sigma _ { t + 4 } \\big ) } \\end{array}$   \n27:   \n28:   \n29: $r = \\hat { c } _ { \\ell } [ 0 ]$ , the probability that $o _ { t } , o _ { t + 4 }$ were generated via expert rollouts.   \n30: Use $r$ to train $\\pi _ { \\theta }$ with via policy gradients (TRPO).   \n31: end for   \n32: end for   \n33: end for   \n34: return optimized policy $\\pi _ { \\theta }$ ",
+        "bbox": [
+            171,
+            122,
+            820,
+            625
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.1 ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            328,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our algorithm, we consider three environments in the MuJoCo physics simulator. There are two different versions of each environment, an expert variant and a novice variant. Our goal is to train a cost function that is domain agnostic, and hence can be trained with images on the expert domain but nevertheless produce a reasonable cost on the novice domain. See Figure 1 for a visualization of the differences between expert and novice environments for the three tasks. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Point: A pointmass attempts to reach a point in a plane. The color of the target and the camera angle change between domains. ",
+        "bbox": [
+            173,
+            770,
+            821,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Reacher: A two DOF arm attempts to reach a designated point in the plane. The camera angle, the length of the arms, and the color of the target point are changed between domains. Note that changing the camera angle significantly alters the image background color from largely gray to roughly 30 percent black. This presents a significant challenge for our method. ",
+        "bbox": [
+            173,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Inverted Pendulum: A classic RL task wherein a pendulum must be made to balance via control. For this domain, We only change the color of the pendulum and not the camera angle. Since there is no target point, we found that changing the camera angle left the domain invariant representations with too little information and resulted in a failure case. In contrast to some traditional renderings of this problem, we do not terminate an episode when the agent falls but rather allow data collection to continue for a fixed horizon. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            922
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 EVALUATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            148,
+            313,
+            162
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Is it possible to solve the third-person imitation learning problem in simple settings? In Figure 3, we see that our proposed algorithm is indeed able to recover reasonable policies for all three tasks we examined. Initially, the training is quite unstable due to the domain confusion wreaking havoc on the learned cost. However, after several iterations the policies eventually head towards reasonable local minima and the standard deviation over the reward distribution shrinks substantially. Finally, we note that the extracted feature representations used to complete this task are in fact domain-agnostic, as seen in Figure 9. Hence, the learning is properly taking place from a third-person perspective. ",
+        "bbox": [
+            173,
+            175,
+            825,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e5de99af5cf3a1c7aa7654c1a187c2ca412166671d36a48182ca68fd643f5215.jpg",
+        "image_caption": [
+            "Figure 3: Reward vs training iteration for reacher, inverted pendulum, and point environments. The learning curves are averaged over 5 trials with error bars represent one standard deviation in the reward distribution at the given point. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            287,
+            807,
+            381
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7b7c6bcd21543c32d56d84f9174ade28e4f6a584b6d9c3ad7db142b231a7a52.jpg",
+        "image_caption": [
+            "Figure 4: Domain accuracy vs. training iteration for reacher, inverted pendulum, and point environments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            473,
+            790,
+            568
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Does the algorithm we propose benefit from both domain confusion and the multi-time step input? We answer this question with the experiments summarized in Figure 5. This experiment compares our approach with: (i) our approach without the domain confusion loss; (ii) our approach without the multi-time step input; (iii) our approach without the domain confusion loss and without the multitime step input (which is very similar to the approach in Ho & Ermon (2016)). We see that adding domain confusion is essential for getting strong performance in all three experiments. Meanwhile, adding multi-time step input marginally improves the results. See also Figure 7 for an analysis of the effects of multi-time step input on the final results. ",
+        "bbox": [
+            173,
+            638,
+            825,
+            750
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e3119af18c1c7e62ae4ef64c2ed955904fbe120c4d62bd13f90f984b9217f8c5.jpg",
+        "image_caption": [
+            "Figure 5: Reward vs iteration for reacher, inverted pendulum, and point environments with no domain confusion and no velocity (red), domain confusion (orange), velocity (brown), and both domain confusion and velocity (blue). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            766,
+            803,
+            859
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "How sensitive is our proposed algorithm to the selection of hyper-parameters used in deployment? Figure 6 shows the effect of the domain confusion coefficient $\\lambda$ , which trades off how much we should weight the domain confusion objective vs. the standard cost-recovery objective, on the final performance of the algorithm. Setting $\\lambda$ too low results in slower learning and features that are not domain-invariant. Setting $\\lambda$ too high results in an objective that is too quick to destroy information, which makes it impossible to recover an accurate cost. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            186
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For multi-time step input, one must choose the number of look-ahead frames that are utilized. If too small a window is chosen, the agent’s actions have not affected a large amount of change in the environment and it is difficult to discern any additional class signal over static images. If too large a time-frame passes, causality becomes difficult to interpolate and the agent does worse than simply being trained on static frames. Figure 7 illustrates that no number of look-ahead frames is consistently optimal across tasks. However, a value of 4 showed good performance over all tasks, and so this value was utilized in all other experiments. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/45ed8ae8770c3fc15032a995eb4946b54fae1133b7d3d76076733073924dca65.jpg",
+        "image_caption": [
+            "Figure 6: Reward of final trained policy vs domain confusion weight $\\lambda$ for reacher, inverted pendulum, and point environments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            353,
+            807,
+            449
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0f0f2a991076420a5f9323afd72fe3d58d1351a3000f704f8ceb0602171cdb82.jpg",
+        "image_caption": [
+            "Figure 7: Reward of final trained policy vs number of look-ahead frames for reacher, inverted pendulum, and point environments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            626,
+            807,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "How sensitive is our algorithm to changes in camera angle? We present graphs for the reacher and point experiments wherein we exam the final reward obtained by a policy trained with thirdperson imitation learning vs the camera angle difference between the first-person and third-person perspective. We omit the inverted double pendulum experiment, as the color and not the camera angle changes in that setting and we found the case of slowly transitioning the color to be the definition of uninteresting science. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/878be86e4c28e17ce3098944393f81394f948537ce33b7bc32f67d1492e063e5.jpg",
+        "image_caption": [
+            "Figure 8: Point and reacher final reward after 20 epochs of third-person imitation learning vs the camera angle difference between the first and third-person perspective. We see that the point follows a fairly linear slope in regards to camera angle differences, whereas the reacher environment is more stochastic against these changes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            104,
+            843,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/63dd757b05b53e432ebdfa3f1f6ac421e8f43a1c47d1053932e4f96e81238dfd.jpg",
+        "image_caption": [
+            "Figure 9: Learning curves for third-person imitation vs. three baselines: 1)RL with true reward, 2) first-person imitation, 3) attempting to use first-person features on the third-person agent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            372,
+            807,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "How does our method compare against reasonable baselines? We consider the following baselines for comparisons against third-person imitation learning. 1) Standard reinforcement learning with using full state information and the true reward signal. This agent is trained via TRPO. 2) ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Standard GAIL (first-person imitation learning). Here, the agent receives first-person demonstration and attempts to imitate the correct behavior. This is an upper bound on how well we can expect to do, since we have the correct perspective. 3) Training a policy using first-person data and applying it to the third-person environment. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We compare all three of these baselines to third-person imitation learning. As we see in figure 9: 1) Standard RL, which (unlike the imitation learning approaches) has access to full state and true reward, helps calibrate performance of the other approaches. 2) First-person imitation learning is faced with a simpler imitation problem and accordingly outperforms third-person imitation, yet third-person imitation learning is nevertheless competitive. 3) Applying the first-person policy to the third-person agent fails miserably, illustrating that explicitly considering third-person imitation is important in these settings. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Somewhat unfortunately, the different reward function scales make it difficult to capture information on the variance of each learning curve. Consequently, in Appendix A we have included the full learning curves for these experiments with variance bars, each plotted with an appropriate scale to examine the variance of the individual curves. ",
+        "bbox": [
+            174,
+            270,
+            825,
+            327
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "7 DISCUSSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            347,
+            485,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented the problem of third-person imitation learning. We argue that this problem will be important going forward, as techniques in reinforcement learning and generative adversarial learning improve and the cost of collecting first-person samples remains high. We presented an algorithm which builds on Generative Adversarial Imitation Learning and is capable of solving simple third-person imitation tasks. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "One promising direction of future work in this area is to jointly train policy features and cost features at the pixel level, allowing the reuse of image features. Code to train a third person imitation learning agent on the domains from this paper is presented here: https://github.com/bstadie/ third_person_im ",
+        "bbox": [
+            176,
+            454,
+            825,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            532,
+            367,
+            546
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was done partially at OpenAI and partially at Berkeley. Work done at Berkeley was supported in part by Darpa under the Simplex program and the FunLoL program. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            612,
+            285,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "P. Abbeel and A. Ng. Apprenticeship learning via inverse reinforcement learning. In International Conference on Machine Learning (ICML), 2004. ",
+        "bbox": [
+            174,
+            635,
+            823,
+            664
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pieter Abbeel, Adam Coates, and Andrew Y Ng. Autonomous helicopter aerobatics through apprenticeship learning. The International Journal of Robotics Research, 2010. ",
+        "bbox": [
+            173,
+            670,
+            820,
+            700
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brenna D Argall, Sonia Chernova, Manuela Veloso, and Brett Browning. A survey of robot learning from demonstration. Robotics and autonomous systems, 57(5):469–483, 2009. ",
+        "bbox": [
+            173,
+            708,
+            820,
+            738
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yusuf Aytar and Andrew Zisserman. Tabula rasa: Model transfer for object category detection. In 2011 International Conference on Computer Vision, pp. 2252–2259. IEEE, 2011. ",
+        "bbox": [
+            176,
+            744,
+            821,
+            775
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "D. Barber and F. V. Agakov. Kernelized infomax clustering. NIPS, 2005. ",
+        "bbox": [
+            174,
+            784,
+            653,
+            799
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A. Boularias, J. Kober, and J. Peters. Relative entropy inverse reinforcement learning. In International Conference on Artificial Intelligence and Statistics (AISTATS), 2011. ",
+        "bbox": [
+            173,
+            806,
+            820,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J. S. Bridle, A. J. Heading, and D. J. MacKay. Unsupervised classifiers, mutual information and phantom targets. NIPS, 1992. ",
+        "bbox": [
+            169,
+            844,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jane Bromley, James W Bentz, Leon Bottou, Isabelle Guyon, Yann LeCun, Cliff Moore, Eduard ´ Sackinger, and Roopak Shah. Signature verification using a siamese time delay neural network.¨ International Journal of Pattern Recognition and Artificial Intelligence, 7(04):669–688, 1993. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sylvain Calinon. Robot programming by demonstration. EPFL Press, 2009. ",
+        "bbox": [
+            173,
+            103,
+            671,
+            119
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sylvain Calinon, Florent Guenter, and Aude Billard. On learning, representing, and generalizing a task in a humanoid robot. IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), 37(2):286–298, 2007. ",
+        "bbox": [
+            174,
+            127,
+            821,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Malinda Carpenter, Josep Call, and Michael Tomasello. Understanding prior intentions enables two–year–olds to imitatively learn a complex task. Child development, 73(5):1431–1441, 2002. ",
+        "bbox": [
+            171,
+            180,
+            821,
+            209
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: Interpretable representation learning by information maximizing generative adversarial nets. NIPS, 2016. ",
+        "bbox": [
+            173,
+            219,
+            823,
+            261
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sumit Chopra, Raia Hadsell, and Yann LeCun. Learning a similarity metric discriminatively, with application to face verification. In 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’05), volume 1, pp. 539–546. IEEE, 2005. ",
+        "bbox": [
+            173,
+            271,
+            826,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A. Doerr, N. Ratliff, J. Bohg, M. Toussaint, and S. Schaal. Direct loss minimization inverse optimal control. In Proceedings of Robotics: Science and Systems (R:SS), Rome, Italy, July 2015. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. Decaf: A deep convolutional activation feature for generic visual recognition. In ICML, pp. 647–655, 2014. ",
+        "bbox": [
+            174,
+            362,
+            825,
+            405
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lixin Duan, Dong Xu, and Ivor Tsang. Learning with augmented features for heterogeneous domain adaptation. arXiv preprint arXiv:1206.4660, 2012. ",
+        "bbox": [
+            171,
+            415,
+            825,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C. Finn, S. Levine, and P. Abbeel. Guided cost learning: Deep inverse optimal control via policy optimization. ICML, 2016. ",
+        "bbox": [
+            174,
+            454,
+            823,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Y. Ganin and V. Lempitsky. Unsupervised domain adaptation by backpropagation. Arxiv preprint 1409.7495, 2014. ",
+        "bbox": [
+            173,
+            492,
+            823,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "G Gioioso, G Salvietti, M Malvezzi, and D Prattichizzo. An object-based approach to map human hand synergies onto robotic hands with dissimilar kinematics. Robotics: Science and Systems VIII, pp. 97, 2013. ",
+        "bbox": [
+            176,
+            531,
+            825,
+            574
+        ],
+        "page_idx": 11
+    },
+    {
+        "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,
+            583,
+            825,
+            626
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Gupta, Clemens Eppner, Sergey Levine, and Pieter Abbeel. Learning dexterous manipulation for a soft robotic hand from human demonstration. arXiv preprint arXiv:1603.06348, 2016. ",
+        "bbox": [
+            173,
+            636,
+            826,
+            678
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. Ho and S. Ermon. Generative adversarial imitation learning. arXiv pre-print: 1606.03476, pp. 1061–1068, 2016. ",
+        "bbox": [
+            173,
+            688,
+            823,
+            717
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Judy Hoffman, Erik Rodner, Jeff Donahue, Trevor Darrell, and Kate Saenko. Efficient learning of domain-invariant image representations. arXiv preprint arXiv:1301.3224, 2013. ",
+        "bbox": [
+            169,
+            727,
+            823,
+            756
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "M. Kalakrishnan, P. Pastor, L. Righetti, and S. Schaal. Learning objective functions for manipulation. In International Conference on Robotics and Automation (ICRA), 2013. ",
+        "bbox": [
+            168,
+            765,
+            823,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Proceedings of the 3rd International Conference on Learning Representations (ICLR), 2014. ",
+        "bbox": [
+            168,
+            804,
+            823,
+            833
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A. Krause, P. Perona, and R. G. Gomes. Discriminative clustering by regularized information maximization. NIPS, 2010. ",
+        "bbox": [
+            168,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brian Kulis, Kate Saenko, and Trevor Darrell. What you saw is not what you get: Domain adaptation using asymmetric kernel transforms. In Computer Vision and Pattern Recognition (CVPR), 2011 IEEE Conference on, pp. 1785–1792. IEEE, 2011. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "S. Levine, Z. Popovic, and V. Koltun. Nonlinear inverse reinforcement learning with gaussian processes. In Advances in Neural Information Processing Systems (NIPS), 2011. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. Journal of Machine Learning Research, 17(39):1–40, 2016. ",
+        "bbox": [
+            173,
+            140,
+            820,
+            170
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mingsheng Long and Jianmin Wang. Learning transferable features with deep adaptation networks. CoRR, abs/1502.02791, 1:2, 2015. ",
+        "bbox": [
+            176,
+            178,
+            821,
+            207
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yishay Mansour, Mehryar Mohri, and Afshin Rostamizadeh. Domain adaptation: Learning bounds and algorithms. arXiv preprint arXiv:0902.3430, 2009. ",
+        "bbox": [
+            171,
+            214,
+            825,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. ",
+        "bbox": [
+            174,
+            252,
+            823,
+            296
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. arXiv preprint arXiv:1602.01783, 2016. ",
+        "bbox": [
+            176,
+            303,
+            823,
+            347
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chrystopher L Nehaniv. Nine billion correspondence problems. Imitation and Social Learning in Robots, Humans and Animals: Behavioural, Social and Communicative Dimensions, Cambridge University Press, 8:10, 2007. ",
+        "bbox": [
+            176,
+            354,
+            823,
+            397
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chrystopher L Nehaniv and Kerstin Dautenhahn. Like me?-measures of correspondence and imitation. Cybernetics & Systems, 32(1-2):11–51, 2001. ",
+        "bbox": [
+            169,
+            405,
+            823,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A. Ng, S. Russell, et al. Algorithms for inverse reinforcement learning. In International Conference on Machine Learning (ICML), 2000. ",
+        "bbox": [
+            169,
+            443,
+            823,
+            473
+        ],
+        "page_idx": 12
+    },
+    {
+        "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": [
+            169,
+            481,
+            823,
+            510
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D. Ramachandran and E. Amir. Bayesian inverse reinforcement learning. In AAAI Conference on Artificial Intelligence, volume 51, 2007. ",
+        "bbox": [
+            174,
+            517,
+            823,
+            546
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "N. Ratliff, J. A. Bagnell, and M. A. Zinkevich. Maximum margin planning. In International Conference on Machine Learning (ICML), 2006. ",
+        "bbox": [
+            173,
+            554,
+            823,
+            584
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "N. Ratliff, D. Bradley, J. A. Bagnell, and J. Chestnutt. Boosting structured prediction for imitation learning. 2007. ",
+        "bbox": [
+            173,
+            592,
+            823,
+            622
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Stephane Ross, Geoffrey J Gordon, and Drew Bagnell. A reduction of imitation learning and struc-´ tured prediction to no-regret online learning. In AISTATS, volume 1, pp. 6, 2011. ",
+        "bbox": [
+            173,
+            628,
+            821,
+            660
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Stefan Schaal. Is imitation learning the route to humanoid robots? Trends in cognitive sciences, 3 (6):233–242, 1999. ",
+        "bbox": [
+            173,
+            666,
+            823,
+            695
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region policy optimization. Arxiv preprint 1502.05477, 2015a. ",
+        "bbox": [
+            171,
+            704,
+            823,
+            734
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Philipp Moritz, Sergey Levine, Michael Jordan, and Pieter Abbeel. Highdimensional continuous control using generalized advantage estimation. arXiv preprint arXiv:1506.02438, 2015b. ",
+        "bbox": [
+            173,
+            741,
+            823,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aaron Shon, Keith Grochow, Aaron Hertzmann, and Rajesh P Rao. Learning shared latent structure for image synthesis and robotic imitation. In Advances in Neural Information Processing Systems, pp. 1233–1240, 2005. ",
+        "bbox": [
+            171,
+            792,
+            823,
+            835
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Judy Hoffman, Ning Zhang, Kate Saenko, and Trevor Darrell. Deep domain confusion: Maximizing for domain invariance. arXiv preprint arXiv:1412.3474, 2014. ",
+        "bbox": [
+            173,
+            843,
+            821,
+            873
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Tzeng, Coline Devin, Judy Hoffman, Chelsea Finn, Xingchao Peng, Pieter Abbeel, Sergey Levine, Kate Saenko, and Trevor Darrell. Towards adapting deep visuomotor representations from simulated to real environments. arXiv preprint arXiv:1511.07111, 2015. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "M. Wulfmeier, P. Ondruska, and I. Posner. Maximum entropy deep inverse reinforcement learning. arXiv preprint arXiv:1507.04888, 2015. ",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Jun Yang, Rong Yan, and Alexander G Hauptmann. Cross-domain video concept detection using adaptive svms. In Proceedings of the 15th ACM international conference on Multimedia, pp. 188–197. ACM, 2007. ",
+        "bbox": [
+            173,
+            204,
+            826,
+            247
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B. Ziebart, A. Maas, J. A. Bagnell, and A. K. Dey. Maximum entropy inverse reinforcement learning. In AAAI Conference on Artificial Intelligence, 2008. ",
+        "bbox": [
+            174,
+            319,
+            823,
+            348
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "8 APPENDIX A: LEARNING CURVES FOR BASELINES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            433,
+            625,
+            449
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Here, we plot the learning curves for each of the baselines mentioned in the experiments section as a standalone plot. This allows one to better examine the variance of each individual learning curve. ",
+        "bbox": [
+            173,
+            486,
+            826,
+            513
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea1b67edb2dfdb4fef94fc8a920576a33c7505c4ce55718706bd9be88e6caa3d.jpg",
+        "image_caption": [
+            "Figure 10: Inverted Pendulum performance under a policy trained on RL, first-person imitation learning, third-person imitation, and a first-person policy applied to a third-person agent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            564,
+            849,
+            872
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/b6baae997578e700d576c20450de54e13c29bc04641825948f30b3aa8cd5b4b7.jpg",
+        "image_caption": [
+            "Figure 11: Reacher performance under a policy trained on RL, first-person imitation learning, thirdperson imitation, and a first-person policy applied to a third-person agent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            103,
+            843,
+            411
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/93145b975be3c2886cda5aca0198047a94819a2d2d82acbc535b32d11815a821.jpg",
+        "image_caption": [
+            "Figure 12: Point performance under a policy trained on RL, first-person imitation learning, thirdperson imitation, and a first-person policy applied to a third-person agent. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            564,
+            841,
+            872
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "9 APPENDIX B: ARCHITECTURE PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            576,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Joint Feature Extractor: Input is images are size $5 0 \\mathrm { ~ x ~ } 5 0$ with 3 channels, RGB. Layers are 2 convolutional layers each followed by a max pooling layer of size 2. Layers use 5 filters of size 3 each. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            175
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Domain Discriminator and the Class Discriminator: Input is domain agnostic output of convolutional layers. Layers are two feed forward layers of size 128 followed by a final feed forward layer of size 2 and a soft-max layer to get the log probabilities. ",
+        "bbox": [
+            176,
+            189,
+            823,
+            231
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "ADAM is used for discriminator training with a learning rate of 0.001. The RL generator uses the off-the-shelf TRPO implementation available in RLLab. ",
+        "bbox": [
+            173,
+            238,
+            823,
+            266
+        ],
+        "page_idx": 15
+    }
+]

parse/train/HkGTwjCctm/HkGTwjCctm.md

@@ -0,0 +1,323 @@
+# PYRAMID RECURRENT NEURAL NETWORKSFOR MULTI-SCALE CHANGE-POINT DETECTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Many real-world time series, such as in activity recognition, finance, or climate science, have changepoints where the system’s structure or parameters change. Detecting changes is important as they may indicate critical events. However, existing methods for changepoint detection face challenges when (1) the patterns of change cannot be modeled using simple and predefined metrics, and (2) changes can occur gradually, at multiple time-scales. To address this, we show how changepoint detection can be treated as a supervised learning problem, and propose a new deep neural network architecture that can efficiently identify both abrupt and gradual changes at multiple scales. Our proposed method, pyramid recurrent neural network (PRNN), is designed to be scale-invariant, by incorporating wavelets and pyramid analysis techniques from multi-scale signal processing. Through experiments on synthetic and real-world datasets, we show that PRNN can detect abrupt and gradual changes with higher accuracy than the state of the art and can extrapolate to detect changepoints at novel timescales that have not been seen in training.
+
+# 1 INTRODUCTION
+
+Changepoints, when the structure or parameters of a system change, are critical to detect in many domains. In medicine, finance, climate science and other fields, these changes can indicate that important events have occurred (e.g. onset of illness or a financial crisis), or changed in important ways (e.g. increasing illness severity). In both cases, these affect decision-making. Changepoint detection (CPD) aims to find these critical times. However, changes may result in complex patterns across multiple observed variables, and can be hard to recognize, especially in multivariate timeseries where interdependencies exist among variables. Further, not all changepoints lead to a sudden transition, many occur over a duration of time (e.g. weightloss, transition between activities) and are harder to identify.
+
+Various methods have been proposed for CPD including parametric methods (Adams & MacKay, 2007; Zhang et al., 2010; Montanez et al., 2015), which make strong assumptions about data distributions, and nonparametric methods (Desobry et al., 2005; Saatc¸i et al., 2010; Li et al., 2015), which are based on engineered divergence metrics or kernel functions. Most parametric methods are highly context specific, and face difficulty when changes result in complex temporal patterns that are hard to model manually. For nonparametic methods, the main drawback is that these methods rely heavily on the choice of parameters or kernels. To handle data from different domains, Chen et al. (2015) proposed a nonparametric CPD method. However, like many other CPD methods, it can only detect abrupt changes. Yet in real-world applications, the effect of a change may be gradual and may happen over different durations. Some methods have been explicitly designed for detecting gradual changepoints (Bardwell & Fearnhead, 2017; Harel et al., 2014), but cannot handle changes occurring at arbitrary timescales. In some applications, like detecting changes in activity, how quickly someone transitions from sitting to standing should not affect accuracy at detecting the transition.
+
+In contrast, Deep Neural Networks (DNN) have been used for time series forecasting (Weigend, 2018) and classification (Yang et al., 2015) as they can learn functions automatically. These can be more easily adapted to new tasks if there is sufficient training data. However, DNNs typically need enough examples of all possible ways a pattern can appear, and thus all possible transition speeds, to reliably detect it in test data. Since this data is costly and may be infeasible to collect in some cases, it is ideal to have a scale-invariant approach that can generalize beyond observed timescales.
+
+We propose a novel DNN architecture for CPD using supervised learning. Our approach makes two key contributions to neural network architecture: a trainable wavelet layer that transforms input into a pyramid of multiscale feature maps; and Pyramid recurrent neural networks (PRNN), which build a multi-scale Recurrent Neural Network (RNN) on top of a multi-channel Convolutional Neural Network (CNN) processing the wavelet layer. Finally, we use a binary classifier on the PRNN output to detect changepoints. On both simulated and real-world data, we show that the proposed model can encode short-term and long-term temporal patterns and detect from abrupt to extremely gradual changepoints. The model is scale invariant, and can detect changes at any timescale, regardless of those seen in training. We focus on the task of CPD, but this architecture may have more general applications in time series analysis.
+
+# 2 RELATED WORK
+
+Changepoint detection CPD is a core problem for times-series analysis. One approach is to use a model and find times when observations deviate from what is predicted by the model. Bayesian Online ChangePoint Detection (BOCPD) (Adams & MacKay, 2007) can find changepoints in an online manner, but makes the limiting assumption that the time series between changes has a stationary exponential-family distribution. More generally, Bayesian techniques require full definition of the likelihood function (Malladi et al., 2013; Montanez et al., 2015), which may be difficult to specify. Nonparametric models increase the flexibility, such as in (Saatc¸i et al., 2010) which is an extension of BOCPD to Gaussian Processes. This however, may significantly increase computational complexity. Xuan & Murphy (2007) introduced Gaussian Graphical Models (GGMs) for CPD, extending (Fearnhead, 2006) to handle mutlivariate time series. GGM is offline and models the correlations between multivariate time series using multivariate Gaussian. This method is closest to ours as a result, but makes strong assumptions about the data distribution. Non-Bayesian techniques exist, such as (Yamanishi & Takeuchi, 2002), which uses an autoregressive model for each time series segment, but this model is limiting.
+
+To eliminate the need to specify a model, model-free approaches have emerged, such as densityratio estimation methods (Yamada et al., 2013; Kawahara & Sugiyama, 2012; Liu et al., 2013; Kuncheva, 2013; Kuncheva & Faithfull, 2014), kernel methods (Harchaoui et al., 2009; Li et al., 2015), and other techniques that define custom divergence functions like difference of covariance matrix (Cabrieto et al., 2017; Barnett & Onnela, 2016) or carefully engineered statistics (Cavalcante et al., 2016; Ide et al., 2016; Qahtan et al., 2015; Li et al., 2015; Gretton et al., 2007). However, ´ covariance matrix based methods cannot deal with the case when the change point does not cause significant variations in covariance matrix. Statistics based methods such as MMD (Gretton et al., 2007), Hotellig T-square (Chen & Gupta, 2000), CUSUM (Page, 1954), or generalized likelihood ratio (GLR) (James et al., 1992) have their own limitations like relying heavily on the choice of kernels (MMD) or parameters (Hotellig T-square), being highly dependent on prior information (CUSUM), or having high complexity for large sample size (GLR). Thus while such models might work in a specific application, they cannot be readily used in a different domain without re-engineering the divergence or kernel functions.
+
+Few methods were explicitly designed to detect gradual changes, though BOCPD has been extended this way by reformulating changes as segments instead of points (Bardwell & Fearnhead, 2017). Alternatively, gradual changes can be formulated as concept drifts (Harel et al., 2014). We do not reformulate the changepoint detection problem, and instead make the model scale-invariant, so it can handle short- and long-term temporal patterns. This results in a model that can generalize to novel time-scales without extra effort.
+
+A similar problem is anomaly detection (Jones et al., 2016; Guha et al., 2016). For instance, Gardner et al. (2006) learns a one-class Support Vector Machine (SVM) on normal data, and distinguishes normal from abnormal in new data. However, a changepoint is not always a transition to an abnormal state and may be between two normal states, such as human activities. Our proposed approach is not limited to binary classification, and can be re-purposed by training with a one-class loss that is used for anomaly detection.
+
+Deep learning Core challenges for CPD are scaling with more variables and recognizing changes resulting in complex patterns involving many variables. Deep neural networks provide a promising solution for CPD, as they can learn to recognize complex patterns without engineering of features and metrics. CNNs for instance, learn to extract increasingly abstract features from raw data through a stack of non-linear convolutions. This leads to recognition of complex patterns such as hundreds of object types in natural images (Szegedy et al., 2015). RNNs on the other hand, learn complex temporal patterns in sequences of arbitrary length, which is used in applications such as human activity recognition with wearable sensors (Hammerla et al., 2016). These are exactly the type of pattern changes that pose challenges for CPD. On the other hand, a key feature of CNNs is shiftinvariance, meaning the prediction will not change even if a pattern shifts in time or space. Gated variants of RNN such as Long Short-Term Memory (LSTM) networks (Hochreiter & Schmidhuber, 1997) and attention-augmented networks (Ba et al., 2015) can also learn shift-invariance, due to their ability to control which part of data to attend or ignore.
+
+Ideally, a CPD method should perform equally well on test data regardless of whether changes happen faster or slower than seen in training data. However, the fixed resolution of CNN and RNN architectures makes them sensitive to scale. CNNs have been extended to model multiple scales simultaneously (Shen et al., 2015), but this is not a scale invariant method, as features are simply concatenated. For RNNs, (Chung et al., 2016) propose a hierarchical architecture to process a sequence through successive RNN layers, at different resolutions. However, layers of RNN there resemble layers of convolution in CNNs (modeling the signal at a different abstraction level) and are not invariant to scale changes at the same abstraction level. Therefore, we propose a new architecture, PRNN, that exploits both CNN and RNN, while augmenting them with scale invariance.
+
+Another limitation of CNNs, and to some extent RNNs for CPD, is the difficulty of modeling longterm dependencies. However, this is necessary to recognize gradual changes. Dilated convolutions have recently allowed long-term dependency modeling in CNNs (Yu & Koltun, 2016; Oord et al., 2016). RNNs are naturally built to model long-term dependencies, but suffer from vanishing gradients. Extensions such as LSTMs and Gated Recurrent Units (GRU) (Cho et al., 2014) solve the problem of vanishing gradients, but still have limited memory space. Intuitively, information from an infinitely long sequence cannot be stored in a fixed-dimensional RNN cell. To reduce the computation complexity for conventional RNN, Campos et al. (2017) proposed Skip RNN to skip state updates while preserving the performance of baseline RNN models. Their skipping-state-updates operation has the advantage of avoiding redundant RNN updates. However, this has the risk of skipping temporal dependencies, especially for long term dependencies, which can hurt the overall performance of RNN. To address this, recent work has augmented RNNs with various types of memory or stack (Sukhbaatar et al., 2015; Joulin & Mikolov, 2015), but these methods are not scale-invariant. Our PRNN, models infinitely long sequences with its multi-scale RNN, which forms a stack of memory cells in an arbitrary number of levels. A higher-level RNN cell in a stack has lower resolution, and thus can store longer dependencies at no additional computational cost, while a lower-level RNN cell has a high resolution and prevents the loss of details in the short term. Frameworks like Feature pyramid networks (Lin et al., 2017) and wavelet CNN (Fujieda et al., 2018) has been proposed to deal with images with different scales or resolutions. However, both of them cannot be applied directly on multivariate time series for change point detection as they cannot model the temporal dependencies in multivariate time series.
+
+# 3 METHOD
+
+We propose a new class of deep learning architectures called Pyramid Recurrent Neural Networks (PRNNs). The model takes a multi-variate time series and transforms it into a pyramid of multi-scale feature maps using a trainable wavelet layer (NWL). All pyramid levels are processed in parallel using multiple streams of CNN with shared weights, yielding a pyramid of more abstract feature maps. Next, we build a multi-scale RNN on top of the pyramid feature map, to encode longer-term, dependencies. The PRNN output is used to detect changes at each time step with a binary classifier.
+
+# 3.1 NEURAL WAVELET LAYER
+
+CNNs can learn to recognize complex patterns in multivariate time series, partly due to parametersharing across time (via the convolution operation), which leads to shift-invariance. However, CNNs are not scale-invariant, so a learned pattern cannot necessarily be recognized when it appears more gradually or more quickly. To augment CNNs with scale invariance, we introduce Deep Wavelet Neural Networks (DWNN), which consist of a proposed Neural Wavelet Layer followed by parallel streams of CNN.
+
+![](images/ec4d2c493e2aec3b5bec00cc0fac99b16d8120f1610d56a496c49fd0b23d9ab6.jpg)  
+Figure 1: An illustration of (a) a convolutional layer; (b) the Neural Wavelet Layer. Only one feature map of each output has been shown.
+
+The Neural Wavelet Layer (NWL) can be seen as a set of multi-scale convolutions with trainable kernels, which are applied in parallel on each variable of the input time series. The input to the NWL is a multivariate time series, $X \in \mathbb { R } ^ { T \times c }$ , where $T$ is the number of timepoints and $c$ is the number of variables. The NWL takes $X$ and produces multiple feature maps, which together form a pyramid of convolution responses. That is:
+
+$$
+f _ { N W L } ( X ) = ( H _ { 1 } , H _ { 2 } , . . . , H _ { k } ) : H _ { i } \in \mathbb { R } ^ { T / 2 ^ { i - 1 } \times c } .
+$$
+
+An example is shown in Figure 1. Specifically, the NWL uses the filter bank technique $\gimel$ for discrete wavelet transform. Given a pair of separating convolutional kernels (typically a low-pass and a highpass kernel), it convolves the signal with both, outputs the high-pass response, and down-samples the low-pass response for the next iteration. It repeats this process and in each iteration outputs an upper level of the output pyramid. Although traditional wavelets such as Haar or Gabor ? can be used, we have experimentally found that initializing the filter banks with random numbers and training them using backpropagation with the rest of the network leads to higher accuracy.
+
+More formally, the NWL is characterized by its trainable kernels $K _ { l } ^ { ( v ) } , K _ { h } ^ { ( v ) } \in \mathbb { R } ^ { \tau \times c }$ for all variables $v \in \{ 1 . . . c \}$ , where $\tau$ is the kernel size. Given each channel of $X$ as input (e.g. ), the NWL iteratively computes lowpass and highpass responses, starting with $L _ { 1 } ^ { ( v ) }$ and $H _ { 1 } ^ { ( v ) }$ , that are:
+
+$$
+\begin{array} { r } { L _ { 1 } ^ { ( v ) } = \omega ( \boldsymbol { X } ^ { ( v ) } * \boldsymbol { K } _ { l } ^ { ( v ) } ) \quad , \quad \boldsymbol { H } _ { 1 } ^ { ( v ) } = \omega ( \boldsymbol { X } ^ { ( v ) } * \boldsymbol { K } _ { h } ^ { ( v ) } ) , } \end{array}
+$$
+
+where is convolution and is a downsampling operation (e.g. implemented by linear interpolation). At the $i$ -th iteration of the wavelet transform, given $L _ { i - 1 } ^ { ( v ) }$ and $H _ { i - 1 } ^ { ( v ) }$ , it computes $L _ { i } ^ { ( v ) }$ and $H _ { i } ^ { ( v ) }$ such that:
+
+$$
+\begin{array} { r } { L _ { i } ^ { ( v ) } = \omega ( L _ { i - 1 } ^ { ( v ) } * K _ { l } ^ { ( v ) } ) \quad , \quad U _ { i } ^ { ( v ) } = \omega ( L _ { i - 1 } ^ { ( v ) } * K _ { h } ^ { ( v ) } ) . } \end{array}
+$$
+
+This operation is repeated for a pre-specified number of times, $k$ , or until the length of $L _ { i } ^ { ( v ) }$ and $H _ { i } ^ { ( v ) }$ becomes smaller than a threshold. The hyperparameter, $k$ , can be selected using cross-validation. A larger $k$ (or smaller threshold) results in a larger receptive field at the highest level of the pyramid, enabling the detection of more gradual patterns. However, a large $k$ also brings more computation and also requires a larger buffer in the case of online processing.
+
+The output of each iteration $i \in \{ 1 . . . k \}$ for variables $v \in \{ 1 . . . c \}$ can be concatenated to form
+
+$$
+L _ { i } = [ L _ { i } ^ { ( 1 ) } | L _ { i } ^ { ( 2 ) } | . . . | L _ { i } ^ { ( c ) } ] \quad , \quad H _ { i } = [ H _ { i } ^ { ( 1 ) } | H _ { i } ^ { ( 2 ) } | . . . | H _ { i } ^ { ( c ) } ] ,
+$$
+
+where $[ . | . ]$ indicates concatenation. The output of the NWL is the stack of all $H _ { i }$ . These are called different levels of a pyramid throughout this paper. In the original filter bank method the last lowpass response, $L _ { k }$ , is also stacked with the output but we did not observe an improvement with $L _ { k }$ .
+
+The key advantage of a NWL over a conventional convolution layer is that a single wavelet can encode the input with multiple granularities at once, whereas a single convolution only encodes a single granularity. Although different layers of a CNN have different granularities, they encode the data at a different level of abstraction, and thus cannot simultaneously extract the same pattern at different scales. On the other hand, a single wavelet layer can encode changes with the same patterns at different paces, simultaneously into the same feature map, at different levels of the pyramid.
+
+![](images/ee33c52e0e5a345e052c9e0a9abbded980f375801c67de99897774cbac9082f2.jpg)  
+Figure 2: An illustration of the proposed Pyramid Recurrent Layer, with downsampling ratio of 2.
+
+We will use the proposed NWL as a part of a larger, deeper architecture, which is described in the rest of this section. Hence, an important aspect of NWL is that it can be used as a layer of a deep network, in composition with other neural layer types such as convolutional and fully connected layers. For example, the input to a wavelet layer can be the output of a convolutional layer. Alternatively, to stack a convolutional layer on the output of a wavelet layer, one should apply the convolution on each level of the wavelet pyramid, resulting in a pyramid-shaped output.
+
+Accordingly, a network composed of one wavelet layer and an arbitrary number of other layers, can take a multi-variate time series as input, and produce a pyramid-shaped response as output. We refer to such a network architecture as a Deep Wavelet Neural Network (DWNN). In this paper we use a specific form of DWNN, which starts with a NWL, directly applied on the input time series $X$ , followed by parallel streams of CNN with shared parameters, each of which takes one level of the NWL pyramid. More specifically, we use an $\ell$ -layer CNN with a down-sampling stride of $p _ { j }$ at the $j$ -th layer, which results in a total down-sampling factor of $\begin{array} { r } { P = \prod _ { j = 1 } ^ { \ell } p _ { j } } \end{array}$ , and with $f _ { j }$ feature maps at the $j$ -th layer. We apply that CNN in parallel on each level of the output pyramid of the NWL, which means for each $i \in \{ 1 . . . k \}$ , it gets $\bar { \boldsymbol { H } } _ { i } \in \mathbb { R } ^ { T / 2 ^ { i - 1 } \times c }$ and outputs $\bar { C _ { i } } \in \bar { \mathbb { R } } ^ { \bar { T } / 2 ^ { i - 1 } / P \times f _ { \ell } }$ .
+
+# 3.2 PYRAMID RECURRENT LAYER
+
+The output of the DWNN is a multi-scale pyramid of sequential feature maps that encode short-term temporal patterns at different times and scales. It is common to process sequential features using an RNN, to encode longer-term temporal patterns. However, conventional RNNs process a single sequence, not a multi-scale pyramid of sequences. Similar to the need for a wavelet layer, RNNs are not scale-invariant, meaning if an RNN can recognize a pattern, it does not necessarily imply it can recognize a temporally shortened or stretched instance of the same pattern without having seen this scale in the training data. Further, RNNs fail to learn very gradual patterns, due to limited memory. While this can be addressed by memory-augmented networks, they remain sensitive to scale.
+
+To address these issues, we introduce a novel hierarchically connected variant of RNNs. Our proposed network, PRNN, scans the multi-scale output of a DWNN, and simultaneously encodes temporal patterns at different scales. An RNN is applied in parallel on different levels of the input pyramid. On each level at each step, it takes as input the corresponding entry from the input pyramid, along with the most recent output of the RNN operating at the upper level. We concatenate those two vectors and feed as input to the RNN. We refer to this technique as Pyramid Recurrent Layer (PRL).
+
+Denoting the value at level $i$ of the input pyramid at time $t$ as $C _ { i } [ t ]$ , and assuming the downsampling ratio in wavelet transform is $d$ , (i.e., each level of the pyramid has $d$ -times the length of its upper level) we can write the recurrent state at level $i$ and time $t$ as:
+
+$$
+h _ { i } [ t ] = \sigma ( W _ { 1 } C _ { i } [ t ] + W _ { 2 } h _ { i } [ t - 1 ] + W _ { 3 } h _ { i + 1 } [ \lfloor t / d \rfloor ] + b ) ,
+$$
+
+where $\sigma$ is a nonlinear activation function such as ReLU, and $W _ { 1 } , W _ { 2 } , W _ { 3 }$ and $b$ are trainable parameters of this layer. These parameters define a linear transformation of the current state, past state, and higher-level state, as illustrated in Figure 2. Note that the proposed hierarchical structure is agnostic of the function of each cell. Although we used a simple RNN cell for illustration, we could use any variant of RNNs such as a Long Short-Term Memory (LSTM) (Hochreiter & Schmidhuber, 1997) or Skip RNN (Campos et al., 2017) as our RNN cell.
+
+The proposed architecture can be compared with an RNN operating on a single data sequence. If the data granularity is high, the RNN likely fails to model long-term dependencies, due to the wellknown problem of vanishing gradients. One can lower the data granularity, so long-term patterns can be summarized in fewer steps, but this results in the loss of details. Accordingly, conventional RNNs were not designed to effectively detect both abrupt and gradual patterns at the same time.
+
+On the other hand, in the proposed PRL, each RNN unit is provided with inputs from the same level of granularity as well as the level above. The RNN that operates at the lowest level, in turn, receives information from all levels of granularity. Figure 2 illustrates the effect of forgetting using decreasing color saturation. While it is impossible to keep track of the past through the lower level alone, the information path from upper levels connect the past to present in only three steps. This lets the PRL model long-term patterns, while it can still model details through the lower levels.
+
+# 3.3 PYRAMID RECURRENT NEURAL NETWORKS
+
+We propose PRNN as a composition of a DWNN and a PRL. An input time series of arbitrary length is transformed through a DWNN into a pyramid-shaped representation, which is then fed into a PRL. For CPD and other classification problems, a logistic regression layer is built on the output of the RNN cells that operate at the lowest level of the pyramid. This layer produces detection scores at each time step with the highest possible granularity. Specifically, the detection score for time $t$ is:
+
+$$
+y _ { t } = \sigma ( W _ { o } h _ { 1 } [ t ] + b _ { o } ) ,
+$$
+
+where $\sigma$ is the sigmoid function and $W _ { o }$ and $b _ { o }$ are trainable parameters. The classification loss at each time is the cross entropy loss written as:
+
+$$
+E _ { t } = y _ { t } ^ { * } \log y _ { t } + ( 1 - y _ { t } ^ { * } ) \log { ( 1 - y _ { t } ) } ,
+$$
+
+where $\boldsymbol { y } _ { t } ^ { * }$ is the ground truth at time $t$ . We optimize this loss using stochastic gradient descent on parameters of the classifier $W _ { o }$ and $b _ { o }$ ), PRL $W _ { 1 }$ , $W _ { 2 }$ , $W _ { 3 }$ and $b$ ), and NWL $K _ { l }$ and $K _ { h }$ ).
+
+# 4 EVALUATION
+
+We compare the proposed PRNN to conventional deep learning baselines. Using both simulated and real-world datasets, we show that PRNNs can detect abrupt and gradual changes more accurately than baseline approaches and can be used for activity recognition by learning labels for different changes.
+
+# 4.1 DATASETS
+
+Synthetic dataset We create a synthetic dataset to evaluate accuracy at simultaneously detecting gradual and abrupt changes. We construct 2000 time series each with 12 variables and 8192 time steps (a power of two chosen to avoid rounding errors in downsampling). Each time series is a combination of a Brownian process and white noise and has 4 changepoints at randomly chosen times. A change is a shift in the mean of 4 randomly chosen dimensions, with randomly chosen speed (duration of change) and amount of shift. A speed of 0 gives an abrupt change, while longer ones provide more challenging cases to recognize. An example of the simulated time series together with ground truth and detection results are shown in Figure 3. We randomly split the data in half, 1000 for training and 1000 for testing. To demonstrate robustness of the proposed method against variability in scale, we also do a split by scale, where all changes in one half are strictly more gradual than all in the other half.
+
+Opportunity dataset For real-world evaluation, we first use the OPPORTUNITY activity recognition dataset (Chavarriaga et al., 2013), which consists of on-body sensor recordings from 4 participants performing activities of daily living, such as cleaning a table. Each participant has 6 records (runs) of around $2 0 \mathrm { { m i n } }$ each. Values of 72 sensors from 10 modalities were recorded at $3 0 \mathrm { H z }$ , and manually labeled with 18 activity types. Following (Hammerla et al., 2016), we ignore variables with missing values, which leads to 79 variables for each record. We use run 2 of subject 1 for validation and runs 4 and 5 of subjects 2 and 3 for test, and the rest for training. To repurpose this activity recognition dataset for CPD, we consider the transition between two activities as a change. This transition can take place at various durations, which makes the task challenging. As ground truth, we use the temporal annotation provided with the OPPORTUNITY dataset to determine moments that the activity type changes. Fig. 6 shows a sample of this dataset with ground truth and detection results.
+
+![](images/eb8c258fb61f883d4120b39334499caebe63e2aeb14df13b433ec0c197a3d12b.jpg)  
+Figure 3: Detected changes in 3 of 12 dimensions of the synthetic dataset.
+
+Bee Waggle Dance dataset We also test our methods on the Bee Waggle Dance data (Oh et al., 2008). Honey bees perform waggle dance to communicate with other bees about the orientation and distance to the food sources. The Bee Waggle Dance data includes six videos of bee waggle dances with 30 frames per second. The data include 3 variables encoding the honey bee’s position and head angle at each frame. Using the position and angle information, each frame is labeled with activity of “turn left”, “turn right”, or “waggle dance.” Similar to the OPPORTUNITY dataset, we consider the transition between two activities of the honey bee as a change point. We test our method and other baselines on “sequence 1” of the bee data. We train on the first 256 frames (a power of 2 chosen to avoid rounding errors) and test on the other 768 frames. We use small size of training data to see how the proposed method behaves and for consistency with other prior works (Saatc¸i et al., 2010).
+
+# 4.2 BASELINES
+
+We compare the proposed architecture to the following unsupervised CPD method and supervised deep-learning baselines:
+
+GGM Xuan & Murphy (2007) is related to BOCPD (Adams & MacKay, 2007), a classic method for CPD, but was selected to provide fairer comparison against our approach as it is offline and incorporates multivariate time series.
+
+CNN We use a CNN that takes a time series as input and predicts a sequence of detection scores for changes. Due to the widely used max-pooling layers, the output has a lower temporal granularity compared to the input. We denote the ratio of output length to the input length as $\gamma$ .
+
+RCN We apply an RNN to the output of the CNN. The output has the same granularity as CNN, while each step of the output has a larger receptive field that encodes all the past data.
+
+DWNN We use the proposed DWNN, which is formed by applying an NWL to the input time series and feeding the output pyramid levels to parallel branches of a CNN. The output of CNN branches are upsampled to have the same size and fused by arithmetic mean.
+
+PRNN We apply the complete proposed method which consists of a DWNN followed by a Pyramid Recurrent Layer to fuse levels of the pyramid.
+
+PRNN-S As a final baseline, we replace the conventional RNN cell in our PRNN method with a Skip RNN (Campos et al., 2017) which was found to have lower time complexity. This enables us to test whether an efficient RNN can preserve the performance of PRNN.
+
+# 4.3 IMPLEMENTATION DETAILS
+
+All of the deep-learning baselines share a core CNN architecture on which the additional modules are built. We fix the architecture of the core CNN to be $[ 9 : 1 2 8 : 4 ] , [ 5 : 1 2 8 : 2 ] , [ 5 : 1 2 8 : 2 ]$ , where we use the notation $x : y : z$ for a convolution layer where $x$ is the kernel size, $y$ is the number of output feature maps, and $z$ is the pooling stride. Each convolution layer is followed by max-pooling and ReLU activation. The output of all baselines are fed to a fully connected perceptron with sigmoid activation which results in binary detection scores at each time step. The granularity ratio $\gamma$ for this architecture is $1 / 1 6$ . For DWNN, PRNN, and PRNN-S, we used a 7-level wavelet with kernel size 3 for both synthetic and OPPORTUNITY dataset. For Bee Waggle Dance data, due to the small size of the data and the more abrupt activities (compared with synthetic and OPPORTUNITY dataset) of honey bee, we used a 5-level wavelet with kernel size 3. For all datasets RCN and PRNN used an LSTM cell with 256 hidden units.
+
+![](images/354fa77d6c3f1cdf3253e65b5ca785277678384229de3b8253095c6d84364a81.jpg)  
+Figure 4: AUC (Area Under the ROC Curve) results for the synthetic dataset with three different test/train scenarios. $\eta$ is the tolerance for how close in time a detected change must be to a true change to be considered a positive. See Appendix A for AUC score tables.
+
+We train all models using Adam (Kingma & Ba, 2014) with early stopping to avoid overfitting. At test time, the models take a time series and predict a sequence of detection scores. To detect changepoints, we apply non-maximum suppression with a sliding window of length $\omega$ and filter the maximum values with a threshold. We evaluate AUC by iterating over this threshold. Hyperparameter $\omega$ controls how nearby two distinct changes can be detected and is tuned for each method separately using cross-validation.
+
+The real world datasets (Bee data and OPPORTUNITY data) are more challenging than the synthetic data, as they include diverse changepoints formed by transitions between many activity types. To address this, we use multitask learning, training the model to both detect changes and classify activity by changing the output dimension of the last fully connected later to have multiple units (19 for OPPORTUNITY data, and 4 for Bee data). For OPPORTUNITY data, the first 18 units predict a log probability for each activity and the last 1 unit outputs the probability of a change point (for bee data, it’s 3 units and 1 unit). We define a softmax cross-entropy loss on those 18 units and add it as a regularization term to the objective function. Multitask learning improved the results equally for all baselines, because the model has auxiliary information, namely the activity type and not just the existence of a change.
+
+For GGM, we use the full covariance model instead of the independent features model to capture the correlations between features. We use a uniform prior as in (Xuan & Murphy, 2007), and set the pruning threshold to $1 0 ^ { - 2 0 }$ . Since there is no training for GGM, we evaluate the algorithm using the same test data as all other methods we compared on both synthetic and real world dataset.
+
+We evaluate precision and recall, and report AUC. As detected changepoints may not exactly match the true changepoints, we use a tolerance parameter $\eta$ that sets how close a detected change must be to a true change to be considered a correct detection. We match detected changepoints to the closest true changepoint within $\eta$ time steps. Precision is the number of matched detections divided by the number of all detections, and recall is the number of matches divided by the number of true changes.
+
+# 4.4 RESULTS
+
+# 4.4.1 SYNTHETIC DATA
+
+For the synthetic dataset, three different train/test splits were used to demonstrate extrapolation from gradual to abrupt changes and vice versa. Fig. 4c shows the results for a random split (mixing scales), while Fig. 4a and 4b use the scale-variant split introduced in section 4.1. In the scale-variant split, the model needs to extrapolate patterns learned from training data to scales that have not been observed. This is extremely challenging for a model that is not scale-invariant. This is apparent in Fig. 4a where both CNN and RCN show worse results in parts compared to their own performance in Fig. 4c. From experiment of Fig. 4c to Fig. 4a, AUC of CNN (RCN) decreased from $41 \%$ $( 3 9 \% )$ to $15 \%$ $( 1 1 \% )$ when the tolerance is 64 steps $( 2 ^ { 6 } )$ . This is because the methods are not designed to be specifically robust against scale variability. In the transition from 4c to 4a, DWNN, PRNN, and PRNN-S like other methods inevitably suffer from a performance drop, which is due to the increase in task difficulty. However, the amount of this drop is substantially lower for DWNN, due to the wavelet layer and shared parameters across scales. At a tolerance of 64 steps, for instance, the performance drop for DWNN is $20 \%$ , which is lower than PRNN-S $( 2 2 \% )$ and CNN $( 2 6 \% )$ . Again DWNN and CNN respectively work better than PRNN and RCN in this setting, which is consistent with the overall results (See Appendix A for AUC details).
+
+![](images/f370684f1ec28911c5b1b81449b8457c46f4a03808a0a60e75e91edb3ae9dfc9.jpg)  
+Figure 5: AUC (Area Under the ROC Curve) results for Opportunity and Bee Waggle Dance data. $\eta$ is the tolerance with a unit of 1/30 seconds for both dataset. See Appendix B for AUC score tables.
+
+While recognizing abrupt changes from gradual training ones (Fig. 4b) is easier than recognizing a mix of scales, CNN and RCN perform worse than our approach due to their inability to generalize in scale. In Fig. 4b, when tolerance is 64 steps, AUC for CNN and RCN are $66 \%$ and $30 \%$ , which are lower than both PRNN $(72 \% )$ and DWNN $(7 9 \% )$ . In contrast, DWNN, PRNN-S, and PRNN have higher AUC than their own performance in the mixed experiment (Fig. 4c). The performance of PRNN at different tolerances is $20 \%$ higher on average in the mixed experiments than the experiment of “train abrupt, test gradual” (Fig. 4a). In the train on gradual and test on abrupt experiment (4b), DWNN performs even better than PRNN and PRNN-S in all tolerances, and similarly, CNN outperforms RCN. This shows recurrent architectures are generally less effective for this kind of extreme generalization. The high performance of DWNN 4b also shows the effectiveness of the added wavelet layer in modeling both gradual and abrupt changes in time series. However, in realworld cases we are more likely to have a mix of scales in both training and test, and it is in this case (fig. 4c) that PRNN is most accurate. As shown in the AUC plots, it is in general more difficult to recognize gradual changes. It is possible to adapt our work to detect segments rather than specific points (e.g. as in (Bardwell & Fearnhead, 2017)), if instead of applying a non-maximum suppression on the output score map of change, we perform binary segmentation to detect intervals with continuously high detection score.
+
+Figure 3 shows example results for our scale invariant PRNN and scale sensitive CNN. Overall CNN has a higher false positive rate, while also missing one of the changes. While detected changes and ground truth are not always precisely aligned, the small gaps are acceptable in the case of gradual changes, where it can be hard to define a single moment when the change occurs.
+
+# 4.4.2 OPPORTUNITY DATA
+
+Figure 6 shows results and AUC plots for the OPPORTUNITY dataset. In the time series, we see that CNN has a missed detection and at least one false positive around time 300, while PRNN detects all changes close to their actual times. In fig 5a, we see that PRNN outperforms other methods at all tolerance levels. In contrast to the synthetic data, PRNN-S has significantly lower AUC than both PRNN and DWNN for every tolerance. It may be that Skip RNN is skipping important information encoded in our wavelet later. Finally, the performance of GGM is lowest for all cases. This is not surprising, as it is an unsupervised method, and does not learn from previously observed patterns. When the tolerance is 64 (around 2 seconds, $\eta = 2 ^ { 6 } = 6 4 ,$ ), a reasonable value for practical activity recognition use, PRNN achieves $81 \%$ AUC while DWNN, RCN, CNN, and PRNN-S respectively achieve $7 5 \%$ , $74 \%$ , $69 \%$ , $47 \%$ . Full results can be seen in Appendix B.1.
+
+![](images/b4d53d49eca2de36109c46114d1ee1cce14dabcdfc5f2a7b1676fed42f914775.jpg)  
+Figure 6: Detected changes on sample (3 of 79 dimensions shown) of Opportunity dataset.
+
+The five deep learning methods, PRNN, PRNN-S, RCN, DWNN, and CNN, respectively took 110, 105, 80, 24, and 6 minutes to train and converge on the OPPORTUNITY dataset. Recurrent methods generally take longer due to backpropagation through time. However, this only happens during training, and does not affect test complexity. One can compare PRNN to RCN, and DWNN to CNN, and observe an increase in time complexity. This is due to repeating computations on multiple levels of a pyramid. This however, only multiplies the time complexity by a constant factor, since the length of pyramid levels exponentially vanish. Note that DWNN has a superior performance to RCN in most cases, while also being faster to train.
+
+# 4.4.3 BEE WAGGLE DANCE DATA
+
+Figure 5b shows AUC plots for all methods we tested on Bee Waggle Dance dataset. Our PRNN method outperforms other methods when the value of $\eta$ is no less than 5 (around 1 second) with AUC of $93 \%$ . Similar to the result on OPPORTUNITY dataset, GGM has the lowest AUC for all tolerances. When the tolerance is 64 (around 2 seconds, $\eta \ : = \ : 2 ^ { 6 } = 6 4 )$ , PRNN achieves $93 \%$ AUC while PRNN-S, RCN, and CNN respectively achieve $64 \%$ , $84 \%$ , $78 \%$ (see Appendix B.2 for AUC details). Similar to OPPORTUNITY dataset, the drop of AUC for PRNN-S is caused by the skipping of states updates. However, compared with the OPPORTUNITY data where PRNN-S has maximum AUC of $51 \%$ , PRNN-S for Bee Waggle Dance data has higher maximum AUC of $64 \%$ . This is because the changes in honey bee activities are more abrupt than human activities, so the skipped updates have lower impact on the detection performance. From the AUC plots, a change in tolerance affects our PRNN much less compared to other methods. For instance, when the tolerance is lowered from 32 $\eta = 2 ^ { 5 } = 3 2$ ) to 16 $( \eta ^ { \star } = 2 ^ { 4 } = 1 6 )$ ), the AUC of RCN drops significantly (from $84 \%$ to $1 8 \%$ ), while AUC of PRNN drops much less (from $93 \%$ to $61 \%$ ). CNN has a dramatic drop in accuracy from $\eta = 4$ to $\eta = 3$ , suggesting it is consistently detecting changes with a delay. Thus, PRNN is less sensitive to this parameter and more reliable for real world cases.
+
+# 5 CONCLUSION
+
+We propose a new class of DNNs that are scale-invariant, and show they can detect from abrupt to gradual changepoints in multimodality time series. The core is 1) augmenting CNNs with trainable Wavelet layers to recognize short-term multi-scale patterns; and 2) building a pyramid-shaped RNN on top of the multi-scale feature maps to simultaneously model long-term patterns and fuse multiscale information. The final model can detect events involving short- and long-term patterns at various scales, which is a difficult task for conventional DNNs. Although this reduces the amount of training data required to learn from changes, the proposed method still requires clean labels. Experiments show our approach detects changes quickly, with lower sensitivity to the tolerance parameter than other approaches. For real-world applications, this leads to much higher reliability. In future work we will real-world challenges (e.g. noisy data, missing/noisy labels) by incorporating robustness, semi-supervised learning methods, and multi-view learning techniques.
+
+# REFERENCES
+
+Ryan Prescott Adams and David JC MacKay. Bayesian Online Changepoint Detection. arXiv preprint arXiv:0710.3742, 2007.
+
+Jimmy Ba, Ruslan R Salakhutdinov, Roger B Grosse, and Brendan J Frey. Learning Wake-Sleep Recurrent Attention Models. In NIPS, pp. 2593–2601, 2015.
+
+Lawrence Bardwell and Paul Fearnhead. Bayesian Detection of Abnormal Segments in Multiple Time Series. Bayesian Analysis, (1):193–218, 2017.
+
+Ian Barnett and Jukka-Pekka Onnela. Change Point Detection in Correlation Networks. Scientific reports, 6:18893, 2016.
+
+Jedelyn Cabrieto, Francis Tuerlinckx, Peter Kuppens, Mariel Grassmann, and Eva Ceulemans. Detecting Correlation Changes in Multivariate Time Series: A Comparison of Four Non-parametric Change Point Detection Methods. Behavior research methods, 49(3):988–1005, 2017.
+
+V´ıctor Campos, Brendan Jou, Xavier Giro-i Nieto, Jordi Torres, and Shih-Fu Chang. Skip RNN: ´ Learning to Skip State Updates in Recurrent Neural Networks. arXiv preprint arXiv:1708.06834, 2017.
+
+Rodolfo C Cavalcante, Leandro L Minku, and Adriano LI Oliveira. FEDD: Feature Extraction for Explicit Concept Drift Detection in Time Series. In IJCNN, pp. 740–747. IEEE, 2016.
+
+Ricardo Chavarriaga, Hesam Sagha, Alberto Calatroni, Sundara Tejaswi Digumarti, Gerhard Troster, Jos ¨ e del R Mill ´ an, and Daniel Roggen. The Opportunity Challenge: A Benchmark ´ Database for On-body Sensor-based Activity Recognition. Pattern Recognition Letters, 34(15): 2033–2042, 2013.
+
+Hao Chen, Nancy Zhang, et al. Graph-based change-point detection. The Annals of Statistics, 43 (1):139–176, 2015.
+
+Jie Chen and AK Gupta. Parametric Statistical Change Point Analysis. Springer, 2000.
+
+Kyunghyun Cho, B van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the Properties of Neural Machine Translation: Encoder-decoder Approaches. In Eighth Workshop on Syntax, Semantics and Structure in Statistical Translation (SSST-8), 2014.
+
+Junyoung Chung, Sungjin Ahn, and Yoshua Bengio. Hierarchical Multiscale Recurrent Neural Networks. arXiv preprint arXiv:1609.01704, 2016.
+
+Fred´ eric Desobry, Manuel Davy, and Christian Doncarli. An Online Kernel Change Detection Al-´ gorithm. IEEE Transactions on Signal Processing, 53(8):2961–2974, 2005.
+
+Paul Fearnhead. Exact and Efficient Bayesian Inference for Multiple Changepoint Problems. Statistics and computing, 16(2), 2006.
+
+Shin Fujieda, Kohei Takayama, and Toshiya Hachisuka. Wavelet Convolutional Neural Networks. arXiv preprint arXiv:1805.08620, 2018.
+
+Andrew B Gardner, Abba M Krieger, George Vachtsevanos, and Brian Litt. One-class Novelty Detection for Seizure Analysis from Intracranial EEG. JMLR, 7(Jun):1025–1044, 2006.
+
+Arthur Gretton, Karsten M Borgwardt, Malte Rasch, Bernhard Scholkopf, and Alex J Smola. A ¨ kernel method for the two-sample-problem. In NIPS, pp. 513–520, 2007.
+
+Sudipto Guha, Nina Mishra, Gourav Roy, and Okke Schrijvers. Robust Random Cut Forest Based Anomaly Detection on Streams. In ICML, pp. 2712–2721, 2016.
+
+Nils Y. Hammerla, Shane Halloran, and Thomas Plotz. Deep, Convolutional, and Recurrent Models ¨ for Human Activity Recognition Using Wearables. In IJCAI, pp. 1533–1540, 2016.
+
+Zaid Harchaoui, Eric Moulines, and Francis R Bach. Kernel change-point analysis. In NIPS, pp. 609–616, 2009.
+
+Maayan Harel, Shie Mannor, Ran El-Yaniv, and Koby Crammer. Concept Drift Detection through Resampling. In ICML, pp. 1009–1017, 2014.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long Short-term Memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Tsuyoshi Ide, Dzung T Phan, and Jayant Kalagnanam. Change Detection Using Directional Statis- ´ tics. In IJCAI, pp. 1613–1619, 2016.
+
+Barry James, Kang Ling James, and David Siegmund. Asymptotic Approximations for Likelihood Ratio Tests and Confidence Regions for a Change-point in the Mean of a Multivariate Normal Distribution. Statistica Sinica, pp. 69–90, 1992.
+
+Michael Jones, Daniel Nikovski, Makoto Imamura, and Takahisa Hirata. Exemplar learning for extremely efficient anomaly detection in real-valued time series. Data Mining and Knowledge Discovery, 30(6):1427–1454, 2016.
+
+Armand Joulin and Tomas Mikolov. Inferring Algorithmic Patterns with Stack-augmented Recurrent Nets. In NIPS, pp. 190–198, 2015.
+
+Yoshinobu Kawahara and Masashi Sugiyama. Sequential Change-point Detection based on Direct Density-ratio Estimation. Statistical Analysis and Data Mining: The ASA Data Science Journal, 5(2):114–127, 2012.
+
+Diederik P Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Ludmila I Kuncheva. Change Detection in Streaming Multivariate Data using Likelihood Detectors. IEEE Transactions on Knowledge and Data Engineering, 25(5):1175–1180, 2013.
+
+Ludmila I Kuncheva and William J Faithfull. PCA Feature Extraction for Change Detection in Multidimensional Unlabeled Data. IEEE transactions on neural networks and learning systems, 25(1):69–80, 2014.
+
+Shuang Li, Yao Xie, Hanjun Dai, and Le Song. M-statistic for Kernel Change-point Detection. In NIPS, pp. 3366–3374, 2015.
+
+Tsung-Yi Lin, Piotr Dollar, Ross B Girshick, Kaiming He, Bharath Hariharan, and Serge J. Belongie. ´ Feature Pyramid Networks for Object Detection. In CVPR, volume 1, 2017.
+
+Song Liu, Makoto Yamada, Nigel Collier, and Masashi Sugiyama. Change-point Detection in Timeseries Data by Relative Density-ratio Estimation. Neural Networks, 43:72–83, 2013.
+
+Rakesh Malladi, Giridhar P Kalamangalam, and Behnaam Aazhang. Online Bayesian Change Point Detection Algorithms for Segmentation of Epileptic Activity. In Signals, Systems and Computers, pp. 1833–1837. IEEE, 2013.
+
+George D Montanez, Saeed Amizadeh, and Nikolay Laptev. Inertial Hidden Markov Models: Modeling Change in Multivariate Time Series. In AAAI, pp. 1819–1825, 2015.
+
+Sang Min Oh, James M Rehg, Tucker Balch, and Frank Dellaert. Learning and Inferring Motion Patterns using Parametric Segmental Switching Linear Dynamic Systems. IJCV, 77(1-3):103– 124, 2008.
+
+Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A Generative Model for Raw Audio. arXiv preprint arXiv:1609.03499, 2016.
+
+Ewan S Page. Continuous inspection schemes. Biometrika, 41(1/2):100–115, 1954.
+
+Abdulhakim A Qahtan, Basma Alharbi, Suojin Wang, and Xiangliang Zhang. A Pca-based Change Detection Framework for Multidimensional Data Streams: Change Detection in Multidimensional Data Streams. In SIGKDD, pp. 935–944. ACM, 2015.
+
+Yunus Saatc¸i, Ryan D Turner, and Carl E Rasmussen. Gaussian Process Change Point Models. In ICML, pp. 927–934. Citeseer, 2010.   
+Wei Shen, Mu Zhou, Feng Yang, Caiyun Yang, and Jie Tian. Multi-scale Convolutional Neural Networks for Lung Nodule Classification. In International Conference on Information Processing in Medical Imaging, pp. 588–599. Springer, 2015.   
+Sainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end Memory Networks. In NIPS, pp. 2440–2448, 2015.   
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, Andrew Rabinovich, et al. Going Deeper with Convolutions. CVPR, 2015.   
+Andreas S Weigend. Time Series Prediction: Forecasting the Future and Understanding the Past. Routledge, 2018.   
+Xiang Xuan and Kevin Murphy. Modeling Changing Dependency Structure in Multivariate Time Series. In ICML, pp. 1055–1062, 2007.   
+Makoto Yamada, Akisato Kimura, Futoshi Naya, and Hiroshi Sawada. Change-Point Detection with Feature Selection in High-Dimensional Time-Series Data. In IJCAI, pp. 1827–1833, 2013.   
+Kenji Yamanishi and Jun-ichi Takeuchi. A Unifying Framework for Detecting Outliers and Change Points from Non-stationary Time Series Data. In SIGKDD, pp. 676–681. ACM, 2002.   
+Jianbo Yang, Minh Nhut Nguyen, Phyo Phyo San, Xiaoli Li, and Shonali Krishnaswamy. Deep Convolutional Neural Networks on Multichannel Time Series for Human Activity Recognition. In IJCAI, pp. 3995–4001, 2015.   
+Fisher Yu and Vladlen Koltun. Multi-scale Context Aggregation by Dilated Convolutions. In ICLR, 2016.   
+Nancy R Zhang, David O Siegmund, Hanlee Ji, and Jun Z Li. Detecting Simultaneous Changepoints in Multiple Sequences. Biometrika, 97(3):631–645, 2010.
+
+# APPENDIX A SYNTHETIC DATA
+
+Table 1-3 show the AUC (Area Under the ROC Curve) results for synthetic data. To detect changepoints, we apply non-maximum suppression with a sliding window of length $\omega$ and filter the maximum values with a threshold. We evaluate AUC by iterating over this threshold. Since changepoints may not exactly match the true changepoints, we use a tolerance parameter $\eta$ that sets how close a detected change must be to a true change to be considered a correct detection. We match detected changepoints to the closest true changepoint within $\eta$ time step.
+
+Table 1 shows the results for the experiment of “train abrupt and test gradual” for synthetic data.   
+Table 2 shows the results for the experiment of “train gradual and test abrupt” for synthetic data.   
+Table 3 shows the results for the experiment of “train all and test all” for synthetic data.
+
+Table 1: AUC results for the experiment of “train abrupt and test gradual” for synthetic data for each tolerance (η)   
+
+<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>8</td><td>0.002</td><td>0.003</td><td>0.007</td><td>0.006</td><td>0.005</td><td>0.003</td></tr><tr><td>16</td><td>0.008</td><td>0.011</td><td>0.010</td><td>0.023</td><td>0.016</td><td>0.011</td></tr><tr><td>32</td><td>0.026</td><td>0.042</td><td>0.012</td><td>0.076</td><td>0.063</td><td>0.043</td></tr><tr><td>64</td><td>0.107</td><td>0.153</td><td>0.012</td><td>0.271</td><td>0.213</td><td>0.155</td></tr><tr><td>128</td><td>0.391</td><td>0.421</td><td>0.013</td><td>0.625</td><td>0.546</td><td>0.503</td></tr><tr><td>256</td><td>0.783</td><td>0.757</td><td>0.016</td><td>0.849</td><td>0.822</td><td>0.863</td></tr><tr><td>512</td><td>0.824</td><td>0.801</td><td>0.023</td><td>0.862</td><td>0.835</td><td>0.876</td></tr></table>
+
+Table 2: AUC results for the experiment of “train gradual and test abrupt” for synthetic data for each tolerance (η)   
+
+<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>8</td><td>0.001</td><td>0.013</td><td>0.007</td><td>0.033</td><td>0.102</td><td>0.027</td></tr><tr><td>16</td><td>0.003</td><td>0.049</td><td>0.011</td><td>0.115</td><td>0.301</td><td>0.100</td></tr><tr><td>32</td><td>0.014</td><td>0.188</td><td>0.013</td><td>0.347</td><td>0.599</td><td>0.376</td></tr><tr><td>64</td><td>0.269</td><td>0.665</td><td>0.013</td><td>0.689</td><td>0.787</td><td>0.724</td></tr><tr><td>128</td><td>0.650</td><td>0.797</td><td>0.014</td><td>0.811</td><td>0.822</td><td>0.816</td></tr><tr><td>256</td><td>0.795</td><td>0.814</td><td>0.018</td><td>0.833</td><td>0.833</td><td>0.830</td></tr><tr><td>512</td><td>0.817</td><td>0.830</td><td>0.026</td><td>0.834</td><td>0.834</td><td>0.830</td></tr></table>
+
+Table 3: AUC results for the experiment of “train all and test all” for synthetic data for each tolerance (η)   
+
+<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>8</td><td>0.039</td><td>0.061</td><td>0.007</td><td>0.027</td><td>0.014</td><td>0.039</td></tr><tr><td>16</td><td>0.093</td><td>0.144</td><td>0.011</td><td>0.100</td><td>0.061</td><td>0.122</td></tr><tr><td>32</td><td>0.204</td><td>0.244</td><td>0.012</td><td>0.249</td><td>0.164</td><td>0.284</td></tr><tr><td>64</td><td>0.390</td><td>0.407</td><td>0.017</td><td>0.496</td><td>0.406</td><td>0.551</td></tr><tr><td>128</td><td>0.582</td><td>0.586</td><td>0.021</td><td>0.737</td><td>0.700</td><td>0.747</td></tr><tr><td>256</td><td>0.788</td><td>0.747</td><td>0.030</td><td>0.863</td><td>0.840</td><td>0.860</td></tr><tr><td>512</td><td>0.852</td><td>0.808</td><td>0.043</td><td>0.874</td><td>0.860</td><td>0.869</td></tr></table>
+
+# APPENDIX B REAL WORLD DATA
+
+# B.1 OPPORTUNITY DATA
+
+Table 4 shows the results for Opportunity data.
+
+Table 4: AUC results of Opportunity data for each tolerance (η)   
+
+<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>2</td><td>0.036</td><td>0.024</td><td>0.007</td><td>0.007</td><td>0.034</td><td>0.040</td></tr><tr><td>4</td><td>0.077</td><td>0.066</td><td>0.016</td><td>0.024</td><td>0.093</td><td>0.104</td></tr><tr><td>8</td><td>0.213</td><td>0.197</td><td>0.022</td><td>0.068</td><td>0.234</td><td>0.297</td></tr><tr><td>16</td><td>0.513</td><td>0.442</td><td>0.027</td><td>0.236</td><td>0.515</td><td>0.601</td></tr><tr><td>32</td><td>0.713</td><td>0.629</td><td>0.032</td><td>0.418</td><td>0.712</td><td>0.773</td></tr><tr><td>64</td><td>0.744</td><td>0.687</td><td>0.046</td><td>0.471</td><td>0.753</td><td>0.815</td></tr><tr><td>128</td><td>0.771</td><td>0.710</td><td>0.065</td><td>0.507</td><td>0.759</td><td>0.833</td></tr></table>
+
+# B.2 BEE WAGGLE DANCE DATA
+
+Table 5 shows the results for Bee Waggle Dance data.
+
+Table 5: AUC results of Bee Waggle Dance data for each tolerance $( \eta )$   
+
+<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>2</td><td>0.007</td><td>0.008</td><td>0.019</td><td>0.009</td><td>0.007</td><td>0.025</td></tr><tr><td>4</td><td>0.007</td><td>0.053</td><td>0.023</td><td>0.009</td><td>0.023</td><td>0.145</td></tr><tr><td>8</td><td>0.054</td><td>0.192</td><td>0.041</td><td>0.119</td><td>0.131</td><td>0.400</td></tr><tr><td>16</td><td>0.178</td><td>0.703</td><td>0.077</td><td>0.393</td><td>0.329</td><td>0.608</td></tr><tr><td>32</td><td>0.841</td><td>0.789</td><td>0.083</td><td>0.643</td><td>0.777</td><td>0.932</td></tr><tr><td>64</td><td>0.841</td><td>0.789</td><td>0.083</td><td>0.643</td><td>0.777</td><td>0.932</td></tr><tr><td>128</td><td>0.841</td><td>0.789</td><td>0.083</td><td>0.643</td><td>0.777</td><td>0.932</td></tr></table>

parse/train/HkGTwjCctm/HkGTwjCctm_content_list.json

@@ -0,0 +1,1715 @@
+[
+    {
+        "type": "text",
+        "text": "PYRAMID RECURRENT NEURAL NETWORKSFOR MULTI-SCALE CHANGE-POINT DETECTION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            754,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many real-world time series, such as in activity recognition, finance, or climate science, have changepoints where the system’s structure or parameters change. Detecting changes is important as they may indicate critical events. However, existing methods for changepoint detection face challenges when (1) the patterns of change cannot be modeled using simple and predefined metrics, and (2) changes can occur gradually, at multiple time-scales. To address this, we show how changepoint detection can be treated as a supervised learning problem, and propose a new deep neural network architecture that can efficiently identify both abrupt and gradual changes at multiple scales. Our proposed method, pyramid recurrent neural network (PRNN), is designed to be scale-invariant, by incorporating wavelets and pyramid analysis techniques from multi-scale signal processing. Through experiments on synthetic and real-world datasets, we show that PRNN can detect abrupt and gradual changes with higher accuracy than the state of the art and can extrapolate to detect changepoints at novel timescales that have not been seen in training. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            336,
+            518
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Changepoints, when the structure or parameters of a system change, are critical to detect in many domains. In medicine, finance, climate science and other fields, these changes can indicate that important events have occurred (e.g. onset of illness or a financial crisis), or changed in important ways (e.g. increasing illness severity). In both cases, these affect decision-making. Changepoint detection (CPD) aims to find these critical times. However, changes may result in complex patterns across multiple observed variables, and can be hard to recognize, especially in multivariate timeseries where interdependencies exist among variables. Further, not all changepoints lead to a sudden transition, many occur over a duration of time (e.g. weightloss, transition between activities) and are harder to identify. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Various methods have been proposed for CPD including parametric methods (Adams & MacKay, 2007; Zhang et al., 2010; Montanez et al., 2015), which make strong assumptions about data distributions, and nonparametric methods (Desobry et al., 2005; Saatc¸i et al., 2010; Li et al., 2015), which are based on engineered divergence metrics or kernel functions. Most parametric methods are highly context specific, and face difficulty when changes result in complex temporal patterns that are hard to model manually. For nonparametic methods, the main drawback is that these methods rely heavily on the choice of parameters or kernels. To handle data from different domains, Chen et al. (2015) proposed a nonparametric CPD method. However, like many other CPD methods, it can only detect abrupt changes. Yet in real-world applications, the effect of a change may be gradual and may happen over different durations. Some methods have been explicitly designed for detecting gradual changepoints (Bardwell & Fearnhead, 2017; Harel et al., 2014), but cannot handle changes occurring at arbitrary timescales. In some applications, like detecting changes in activity, how quickly someone transitions from sitting to standing should not affect accuracy at detecting the transition. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            859
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In contrast, Deep Neural Networks (DNN) have been used for time series forecasting (Weigend, 2018) and classification (Yang et al., 2015) as they can learn functions automatically. These can be more easily adapted to new tasks if there is sufficient training data. However, DNNs typically need enough examples of all possible ways a pattern can appear, and thus all possible transition speeds, to reliably detect it in test data. Since this data is costly and may be infeasible to collect in some cases, it is ideal to have a scale-invariant approach that can generalize beyond observed timescales. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a novel DNN architecture for CPD using supervised learning. Our approach makes two key contributions to neural network architecture: a trainable wavelet layer that transforms input into a pyramid of multiscale feature maps; and Pyramid recurrent neural networks (PRNN), which build a multi-scale Recurrent Neural Network (RNN) on top of a multi-channel Convolutional Neural Network (CNN) processing the wavelet layer. Finally, we use a binary classifier on the PRNN output to detect changepoints. On both simulated and real-world data, we show that the proposed model can encode short-term and long-term temporal patterns and detect from abrupt to extremely gradual changepoints. The model is scale invariant, and can detect changes at any timescale, regardless of those seen in training. We focus on the task of CPD, but this architecture may have more general applications in time series analysis. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            308,
+            343,
+            324
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Changepoint detection CPD is a core problem for times-series analysis. One approach is to use a model and find times when observations deviate from what is predicted by the model. Bayesian Online ChangePoint Detection (BOCPD) (Adams & MacKay, 2007) can find changepoints in an online manner, but makes the limiting assumption that the time series between changes has a stationary exponential-family distribution. More generally, Bayesian techniques require full definition of the likelihood function (Malladi et al., 2013; Montanez et al., 2015), which may be difficult to specify. Nonparametric models increase the flexibility, such as in (Saatc¸i et al., 2010) which is an extension of BOCPD to Gaussian Processes. This however, may significantly increase computational complexity. Xuan & Murphy (2007) introduced Gaussian Graphical Models (GGMs) for CPD, extending (Fearnhead, 2006) to handle mutlivariate time series. GGM is offline and models the correlations between multivariate time series using multivariate Gaussian. This method is closest to ours as a result, but makes strong assumptions about the data distribution. Non-Bayesian techniques exist, such as (Yamanishi & Takeuchi, 2002), which uses an autoregressive model for each time series segment, but this model is limiting. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            541
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To eliminate the need to specify a model, model-free approaches have emerged, such as densityratio estimation methods (Yamada et al., 2013; Kawahara & Sugiyama, 2012; Liu et al., 2013; Kuncheva, 2013; Kuncheva & Faithfull, 2014), kernel methods (Harchaoui et al., 2009; Li et al., 2015), and other techniques that define custom divergence functions like difference of covariance matrix (Cabrieto et al., 2017; Barnett & Onnela, 2016) or carefully engineered statistics (Cavalcante et al., 2016; Ide et al., 2016; Qahtan et al., 2015; Li et al., 2015; Gretton et al., 2007). However, ´ covariance matrix based methods cannot deal with the case when the change point does not cause significant variations in covariance matrix. Statistics based methods such as MMD (Gretton et al., 2007), Hotellig T-square (Chen & Gupta, 2000), CUSUM (Page, 1954), or generalized likelihood ratio (GLR) (James et al., 1992) have their own limitations like relying heavily on the choice of kernels (MMD) or parameters (Hotellig T-square), being highly dependent on prior information (CUSUM), or having high complexity for large sample size (GLR). Thus while such models might work in a specific application, they cannot be readily used in a different domain without re-engineering the divergence or kernel functions. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Few methods were explicitly designed to detect gradual changes, though BOCPD has been extended this way by reformulating changes as segments instead of points (Bardwell & Fearnhead, 2017). Alternatively, gradual changes can be formulated as concept drifts (Harel et al., 2014). We do not reformulate the changepoint detection problem, and instead make the model scale-invariant, so it can handle short- and long-term temporal patterns. This results in a model that can generalize to novel time-scales without extra effort. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A similar problem is anomaly detection (Jones et al., 2016; Guha et al., 2016). For instance, Gardner et al. (2006) learns a one-class Support Vector Machine (SVM) on normal data, and distinguishes normal from abnormal in new data. However, a changepoint is not always a transition to an abnormal state and may be between two normal states, such as human activities. Our proposed approach is not limited to binary classification, and can be re-purposed by training with a one-class loss that is used for anomaly detection. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep learning Core challenges for CPD are scaling with more variables and recognizing changes resulting in complex patterns involving many variables. Deep neural networks provide a promising solution for CPD, as they can learn to recognize complex patterns without engineering of features and metrics. CNNs for instance, learn to extract increasingly abstract features from raw data through a stack of non-linear convolutions. This leads to recognition of complex patterns such as hundreds of object types in natural images (Szegedy et al., 2015). RNNs on the other hand, learn complex temporal patterns in sequences of arbitrary length, which is used in applications such as human activity recognition with wearable sensors (Hammerla et al., 2016). These are exactly the type of pattern changes that pose challenges for CPD. On the other hand, a key feature of CNNs is shiftinvariance, meaning the prediction will not change even if a pattern shifts in time or space. Gated variants of RNN such as Long Short-Term Memory (LSTM) networks (Hochreiter & Schmidhuber, 1997) and attention-augmented networks (Ba et al., 2015) can also learn shift-invariance, due to their ability to control which part of data to attend or ignore. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ideally, a CPD method should perform equally well on test data regardless of whether changes happen faster or slower than seen in training data. However, the fixed resolution of CNN and RNN architectures makes them sensitive to scale. CNNs have been extended to model multiple scales simultaneously (Shen et al., 2015), but this is not a scale invariant method, as features are simply concatenated. For RNNs, (Chung et al., 2016) propose a hierarchical architecture to process a sequence through successive RNN layers, at different resolutions. However, layers of RNN there resemble layers of convolution in CNNs (modeling the signal at a different abstraction level) and are not invariant to scale changes at the same abstraction level. Therefore, we propose a new architecture, PRNN, that exploits both CNN and RNN, while augmenting them with scale invariance. ",
+        "bbox": [
+            174,
+            291,
+            825,
+            416
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another limitation of CNNs, and to some extent RNNs for CPD, is the difficulty of modeling longterm dependencies. However, this is necessary to recognize gradual changes. Dilated convolutions have recently allowed long-term dependency modeling in CNNs (Yu & Koltun, 2016; Oord et al., 2016). RNNs are naturally built to model long-term dependencies, but suffer from vanishing gradients. Extensions such as LSTMs and Gated Recurrent Units (GRU) (Cho et al., 2014) solve the problem of vanishing gradients, but still have limited memory space. Intuitively, information from an infinitely long sequence cannot be stored in a fixed-dimensional RNN cell. To reduce the computation complexity for conventional RNN, Campos et al. (2017) proposed Skip RNN to skip state updates while preserving the performance of baseline RNN models. Their skipping-state-updates operation has the advantage of avoiding redundant RNN updates. However, this has the risk of skipping temporal dependencies, especially for long term dependencies, which can hurt the overall performance of RNN. To address this, recent work has augmented RNNs with various types of memory or stack (Sukhbaatar et al., 2015; Joulin & Mikolov, 2015), but these methods are not scale-invariant. Our PRNN, models infinitely long sequences with its multi-scale RNN, which forms a stack of memory cells in an arbitrary number of levels. A higher-level RNN cell in a stack has lower resolution, and thus can store longer dependencies at no additional computational cost, while a lower-level RNN cell has a high resolution and prevents the loss of details in the short term. Frameworks like Feature pyramid networks (Lin et al., 2017) and wavelet CNN (Fujieda et al., 2018) has been proposed to deal with images with different scales or resolutions. However, both of them cannot be applied directly on multivariate time series for change point detection as they cannot model the temporal dependencies in multivariate time series. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            714
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            281,
+            751
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a new class of deep learning architectures called Pyramid Recurrent Neural Networks (PRNNs). The model takes a multi-variate time series and transforms it into a pyramid of multi-scale feature maps using a trainable wavelet layer (NWL). All pyramid levels are processed in parallel using multiple streams of CNN with shared weights, yielding a pyramid of more abstract feature maps. Next, we build a multi-scale RNN on top of the pyramid feature map, to encode longer-term, dependencies. The PRNN output is used to detect changes at each time step with a binary classifier. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            851
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 NEURAL WAVELET LAYER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            398,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "CNNs can learn to recognize complex patterns in multivariate time series, partly due to parametersharing across time (via the convolution operation), which leads to shift-invariance. However, CNNs are not scale-invariant, so a learned pattern cannot necessarily be recognized when it appears more gradually or more quickly. To augment CNNs with scale invariance, we introduce Deep Wavelet Neural Networks (DWNN), which consist of a proposed Neural Wavelet Layer followed by parallel streams of CNN. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/ec4d2c493e2aec3b5bec00cc0fac99b16d8120f1610d56a496c49fd0b23d9ab6.jpg",
+        "image_caption": [
+            "Figure 1: An illustration of (a) a convolutional layer; (b) the Neural Wavelet Layer. Only one feature map of each output has been shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            104,
+            717,
+            203
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            268,
+            825,
+            325
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Neural Wavelet Layer (NWL) can be seen as a set of multi-scale convolutions with trainable kernels, which are applied in parallel on each variable of the input time series. The input to the NWL is a multivariate time series, $X \\in \\mathbb { R } ^ { T \\times c }$ , where $T$ is the number of timepoints and $c$ is the number of variables. The NWL takes $X$ and produces multiple feature maps, which together form a pyramid of convolution responses. That is: ",
+        "bbox": [
+            173,
+            332,
+            825,
+            402
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb73b282e342d4901fd569246cef5fd7e6da5a143f121f0b5e54a4d4ee3e8563.jpg",
+        "text": "$$\nf _ { N W L } ( X ) = ( H _ { 1 } , H _ { 2 } , . . . , H _ { k } ) : H _ { i } \\in \\mathbb { R } ^ { T / 2 ^ { i - 1 } \\times c } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            409,
+            666,
+            429
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An example is shown in Figure 1. Specifically, the NWL uses the filter bank technique $\\gimel$ for discrete wavelet transform. Given a pair of separating convolutional kernels (typically a low-pass and a highpass kernel), it convolves the signal with both, outputs the high-pass response, and down-samples the low-pass response for the next iteration. It repeats this process and in each iteration outputs an upper level of the output pyramid. Although traditional wavelets such as Haar or Gabor ? can be used, we have experimentally found that initializing the filter banks with random numbers and training them using backpropagation with the rest of the network leads to higher accuracy. ",
+        "bbox": [
+            173,
+            435,
+            825,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "More formally, the NWL is characterized by its trainable kernels $K _ { l } ^ { ( v ) } , K _ { h } ^ { ( v ) } \\in \\mathbb { R } ^ { \\tau \\times c }$ for all variables $v \\in \\{ 1 . . . c \\}$ , where $\\tau$ is the kernel size. Given each channel of $X$ as input (e.g. ), the NWL iteratively computes lowpass and highpass responses, starting with $L _ { 1 } ^ { ( v ) }$ and $H _ { 1 } ^ { ( v ) }$ , that are: ",
+        "bbox": [
+            173,
+            541,
+            825,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d5c39f5fc50029558f3abbe3bd71690d6b0ca516054294adec62e0efb3a87a1e.jpg",
+        "text": "$$\n\\begin{array} { r } { L _ { 1 } ^ { ( v ) } = \\omega ( \\boldsymbol { X } ^ { ( v ) } * \\boldsymbol { K } _ { l } ^ { ( v ) } ) \\quad , \\quad \\boldsymbol { H } _ { 1 } ^ { ( v ) } = \\omega ( \\boldsymbol { X } ^ { ( v ) } * \\boldsymbol { K } _ { h } ^ { ( v ) } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            599,
+            679,
+            621
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where is convolution and is a downsampling operation (e.g. implemented by linear interpolation). At the $i$ -th iteration of the wavelet transform, given $L _ { i - 1 } ^ { ( v ) }$ and $H _ { i - 1 } ^ { ( v ) }$ , it computes $L _ { i } ^ { ( v ) }$ and $H _ { i } ^ { ( v ) }$ such that: ",
+        "bbox": [
+            173,
+            627,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/52f7d9f2ba02dd24651f725650dbd1a6f0b65f804925df0b1f450a79839dc4ef.jpg",
+        "text": "$$\n\\begin{array} { r } { L _ { i } ^ { ( v ) } = \\omega ( L _ { i - 1 } ^ { ( v ) } * K _ { l } ^ { ( v ) } ) \\quad , \\quad U _ { i } ^ { ( v ) } = \\omega ( L _ { i - 1 } ^ { ( v ) } * K _ { h } ^ { ( v ) } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            676,
+            679,
+            699
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This operation is repeated for a pre-specified number of times, $k$ , or until the length of $L _ { i } ^ { ( v ) }$ and $H _ { i } ^ { ( v ) }$ becomes smaller than a threshold. The hyperparameter, $k$ , can be selected using cross-validation. A larger $k$ (or smaller threshold) results in a larger receptive field at the highest level of the pyramid, enabling the detection of more gradual patterns. However, a large $k$ also brings more computation and also requires a larger buffer in the case of online processing. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            777
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The output of each iteration $i \\in \\{ 1 . . . k \\}$ for variables $v \\in \\{ 1 . . . c \\}$ can be concatenated to form ",
+        "bbox": [
+            171,
+            782,
+            784,
+            797
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33316865cac48833a6a3c6e74827ade5ba126ad8486e91c8f3a1e467d02b8710.jpg",
+        "text": "$$\nL _ { i } = [ L _ { i } ^ { ( 1 ) } | L _ { i } ^ { ( 2 ) } | . . . | L _ { i } ^ { ( c ) } ] \\quad , \\quad H _ { i } = [ H _ { i } ^ { ( 1 ) } | H _ { i } ^ { ( 2 ) } | . . . | H _ { i } ^ { ( c ) } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            804,
+            689,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $[ . | . ]$ indicates concatenation. The output of the NWL is the stack of all $H _ { i }$ . These are called different levels of a pyramid throughout this paper. In the original filter bank method the last lowpass response, $L _ { k }$ , is also stacked with the output but we did not observe an improvement with $L _ { k }$ . ",
+        "bbox": [
+            174,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The key advantage of a NWL over a conventional convolution layer is that a single wavelet can encode the input with multiple granularities at once, whereas a single convolution only encodes a single granularity. Although different layers of a CNN have different granularities, they encode the data at a different level of abstraction, and thus cannot simultaneously extract the same pattern at different scales. On the other hand, a single wavelet layer can encode changes with the same patterns at different paces, simultaneously into the same feature map, at different levels of the pyramid. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ee33c52e0e5a345e052c9e0a9abbded980f375801c67de99897774cbac9082f2.jpg",
+        "image_caption": [
+            "Figure 2: An illustration of the proposed Pyramid Recurrent Layer, with downsampling ratio of 2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            302,
+            98,
+            692,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            229,
+            821,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We will use the proposed NWL as a part of a larger, deeper architecture, which is described in the rest of this section. Hence, an important aspect of NWL is that it can be used as a layer of a deep network, in composition with other neural layer types such as convolutional and fully connected layers. For example, the input to a wavelet layer can be the output of a convolutional layer. Alternatively, to stack a convolutional layer on the output of a wavelet layer, one should apply the convolution on each level of the wavelet pyramid, resulting in a pyramid-shaped output. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Accordingly, a network composed of one wavelet layer and an arbitrary number of other layers, can take a multi-variate time series as input, and produce a pyramid-shaped response as output. We refer to such a network architecture as a Deep Wavelet Neural Network (DWNN). In this paper we use a specific form of DWNN, which starts with a NWL, directly applied on the input time series $X$ , followed by parallel streams of CNN with shared parameters, each of which takes one level of the NWL pyramid. More specifically, we use an $\\ell$ -layer CNN with a down-sampling stride of $p _ { j }$ at the $j$ -th layer, which results in a total down-sampling factor of $\\begin{array} { r } { P = \\prod _ { j = 1 } ^ { \\ell } p _ { j } } \\end{array}$ , and with $f _ { j }$ feature maps at the $j$ -th layer. We apply that CNN in parallel on each level of the output pyramid of the NWL, which means for each $i \\in \\{ 1 . . . k \\}$ , it gets $\\bar { \\boldsymbol { H } } _ { i } \\in \\mathbb { R } ^ { T / 2 ^ { i - 1 } \\times c }$ and outputs $\\bar { C _ { i } } \\in \\bar { \\mathbb { R } } ^ { \\bar { T } / 2 ^ { i - 1 } / P \\times f _ { \\ell } }$ . ",
+        "bbox": [
+            173,
+            369,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 PYRAMID RECURRENT LAYER",
+        "text_level": 1,
+        "bbox": [
+            176,
+            518,
+            424,
+            534
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The output of the DWNN is a multi-scale pyramid of sequential feature maps that encode short-term temporal patterns at different times and scales. It is common to process sequential features using an RNN, to encode longer-term temporal patterns. However, conventional RNNs process a single sequence, not a multi-scale pyramid of sequences. Similar to the need for a wavelet layer, RNNs are not scale-invariant, meaning if an RNN can recognize a pattern, it does not necessarily imply it can recognize a temporally shortened or stretched instance of the same pattern without having seen this scale in the training data. Further, RNNs fail to learn very gradual patterns, due to limited memory. While this can be addressed by memory-augmented networks, they remain sensitive to scale. ",
+        "bbox": [
+            174,
+            544,
+            825,
+            657
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To address these issues, we introduce a novel hierarchically connected variant of RNNs. Our proposed network, PRNN, scans the multi-scale output of a DWNN, and simultaneously encodes temporal patterns at different scales. An RNN is applied in parallel on different levels of the input pyramid. On each level at each step, it takes as input the corresponding entry from the input pyramid, along with the most recent output of the RNN operating at the upper level. We concatenate those two vectors and feed as input to the RNN. We refer to this technique as Pyramid Recurrent Layer (PRL). ",
+        "bbox": [
+            174,
+            662,
+            825,
+            761
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Denoting the value at level $i$ of the input pyramid at time $t$ as $C _ { i } [ t ]$ , and assuming the downsampling ratio in wavelet transform is $d$ , (i.e., each level of the pyramid has $d$ -times the length of its upper level) we can write the recurrent state at level $i$ and time $t$ as: ",
+        "bbox": [
+            176,
+            767,
+            823,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/67e83b924c740a2fa308b90dd309c7804387035f149bb107a6c55c7b4246e274.jpg",
+        "text": "$$\nh _ { i } [ t ] = \\sigma ( W _ { 1 } C _ { i } [ t ] + W _ { 2 } h _ { i } [ t - 1 ] + W _ { 3 } h _ { i + 1 } [ \\lfloor t / d \\rfloor ] + b ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            815,
+            691,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ is a nonlinear activation function such as ReLU, and $W _ { 1 } , W _ { 2 } , W _ { 3 }$ and $b$ are trainable parameters of this layer. These parameters define a linear transformation of the current state, past state, and higher-level state, as illustrated in Figure 2. Note that the proposed hierarchical structure is agnostic of the function of each cell. Although we used a simple RNN cell for illustration, we could use any variant of RNNs such as a Long Short-Term Memory (LSTM) (Hochreiter & Schmidhuber, 1997) or Skip RNN (Campos et al., 2017) as our RNN cell. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proposed architecture can be compared with an RNN operating on a single data sequence. If the data granularity is high, the RNN likely fails to model long-term dependencies, due to the wellknown problem of vanishing gradients. One can lower the data granularity, so long-term patterns can be summarized in fewer steps, but this results in the loss of details. Accordingly, conventional RNNs were not designed to effectively detect both abrupt and gradual patterns at the same time. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, in the proposed PRL, each RNN unit is provided with inputs from the same level of granularity as well as the level above. The RNN that operates at the lowest level, in turn, receives information from all levels of granularity. Figure 2 illustrates the effect of forgetting using decreasing color saturation. While it is impossible to keep track of the past through the lower level alone, the information path from upper levels connect the past to present in only three steps. This lets the PRL model long-term patterns, while it can still model details through the lower levels. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            263
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 PYRAMID RECURRENT NEURAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            280,
+            524,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We propose PRNN as a composition of a DWNN and a PRL. An input time series of arbitrary length is transformed through a DWNN into a pyramid-shaped representation, which is then fed into a PRL. For CPD and other classification problems, a logistic regression layer is built on the output of the RNN cells that operate at the lowest level of the pyramid. This layer produces detection scores at each time step with the highest possible granularity. Specifically, the detection score for time $t$ is: ",
+        "bbox": [
+            174,
+            305,
+            825,
+            377
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71e1527b4d9417719ffba2983d0bd28ce62d2f60d8c8ac7cfa09c88a89e260b5.jpg",
+        "text": "$$\ny _ { t } = \\sigma ( W _ { o } h _ { 1 } [ t ] + b _ { o } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            382,
+            575,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ is the sigmoid function and $W _ { o }$ and $b _ { o }$ are trainable parameters. The classification loss at each time is the cross entropy loss written as: ",
+        "bbox": [
+            171,
+            405,
+            825,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3fb8698a91ddac1aa13bac8bb1b83ef86c7cab3b03cecd2989a90ff7e5f7d9e8.jpg",
+        "text": "$$\nE _ { t } = y _ { t } ^ { * } \\log y _ { t } + ( 1 - y _ { t } ^ { * } ) \\log { ( 1 - y _ { t } ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            438,
+            629,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\boldsymbol { y } _ { t } ^ { * }$ is the ground truth at time $t$ . We optimize this loss using stochastic gradient descent on parameters of the classifier $W _ { o }$ and $b _ { o }$ ), PRL $W _ { 1 }$ , $W _ { 2 }$ , $W _ { 3 }$ and $b$ ), and NWL $K _ { l }$ and $K _ { h }$ ). ",
+        "bbox": [
+            173,
+            460,
+            828,
+            489
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            315,
+            525
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare the proposed PRNN to conventional deep learning baselines. Using both simulated and real-world datasets, we show that PRNNs can detect abrupt and gradual changes more accurately than baseline approaches and can be used for activity recognition by learning labels for different changes. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            612,
+            287,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Synthetic dataset We create a synthetic dataset to evaluate accuracy at simultaneously detecting gradual and abrupt changes. We construct 2000 time series each with 12 variables and 8192 time steps (a power of two chosen to avoid rounding errors in downsampling). Each time series is a combination of a Brownian process and white noise and has 4 changepoints at randomly chosen times. A change is a shift in the mean of 4 randomly chosen dimensions, with randomly chosen speed (duration of change) and amount of shift. A speed of 0 gives an abrupt change, while longer ones provide more challenging cases to recognize. An example of the simulated time series together with ground truth and detection results are shown in Figure 3. We randomly split the data in half, 1000 for training and 1000 for testing. To demonstrate robustness of the proposed method against variability in scale, we also do a split by scale, where all changes in one half are strictly more gradual than all in the other half. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            791
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Opportunity dataset For real-world evaluation, we first use the OPPORTUNITY activity recognition dataset (Chavarriaga et al., 2013), which consists of on-body sensor recordings from 4 participants performing activities of daily living, such as cleaning a table. Each participant has 6 records (runs) of around $2 0 \\mathrm { { m i n } }$ each. Values of 72 sensors from 10 modalities were recorded at $3 0 \\mathrm { H z }$ , and manually labeled with 18 activity types. Following (Hammerla et al., 2016), we ignore variables with missing values, which leads to 79 variables for each record. We use run 2 of subject 1 for validation and runs 4 and 5 of subjects 2 and 3 for test, and the rest for training. To repurpose this activity recognition dataset for CPD, we consider the transition between two activities as a change. This transition can take place at various durations, which makes the task challenging. As ground truth, we use the temporal annotation provided with the OPPORTUNITY dataset to determine moments that the activity type changes. Fig. 6 shows a sample of this dataset with ground truth and detection results. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb8c258fb61f883d4120b39334499caebe63e2aeb14df13b433ec0c197a3d12b.jpg",
+        "image_caption": [
+            "Figure 3: Detected changes in 3 of 12 dimensions of the synthetic dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            276,
+            104,
+            722,
+            255
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            310,
+            823,
+            353
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Bee Waggle Dance dataset We also test our methods on the Bee Waggle Dance data (Oh et al., 2008). Honey bees perform waggle dance to communicate with other bees about the orientation and distance to the food sources. The Bee Waggle Dance data includes six videos of bee waggle dances with 30 frames per second. The data include 3 variables encoding the honey bee’s position and head angle at each frame. Using the position and angle information, each frame is labeled with activity of “turn left”, “turn right”, or “waggle dance.” Similar to the OPPORTUNITY dataset, we consider the transition between two activities of the honey bee as a change point. We test our method and other baselines on “sequence 1” of the bee data. We train on the first 256 frames (a power of 2 chosen to avoid rounding errors) and test on the other 768 frames. We use small size of training data to see how the proposed method behaves and for consistency with other prior works (Saatc¸i et al., 2010). ",
+        "bbox": [
+            173,
+            359,
+            825,
+            500
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 BASELINES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            294,
+            530
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare the proposed architecture to the following unsupervised CPD method and supervised deep-learning baselines: ",
+        "bbox": [
+            176,
+            542,
+            823,
+            570
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "GGM Xuan & Murphy (2007) is related to BOCPD (Adams & MacKay, 2007), a classic method for CPD, but was selected to provide fairer comparison against our approach as it is offline and incorporates multivariate time series. ",
+        "bbox": [
+            176,
+            578,
+            823,
+            619
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CNN We use a CNN that takes a time series as input and predicts a sequence of detection scores for changes. Due to the widely used max-pooling layers, the output has a lower temporal granularity compared to the input. We denote the ratio of output length to the input length as $\\gamma$ . ",
+        "bbox": [
+            176,
+            627,
+            821,
+            670
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "RCN We apply an RNN to the output of the CNN. The output has the same granularity as CNN, while each step of the output has a larger receptive field that encodes all the past data. ",
+        "bbox": [
+            171,
+            676,
+            821,
+            704
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DWNN We use the proposed DWNN, which is formed by applying an NWL to the input time series and feeding the output pyramid levels to parallel branches of a CNN. The output of CNN branches are upsampled to have the same size and fused by arithmetic mean. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            753
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "PRNN We apply the complete proposed method which consists of a DWNN followed by a Pyramid Recurrent Layer to fuse levels of the pyramid. ",
+        "bbox": [
+            174,
+            761,
+            821,
+            789
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "PRNN-S As a final baseline, we replace the conventional RNN cell in our PRNN method with a Skip RNN (Campos et al., 2017) which was found to have lower time complexity. This enables us to test whether an efficient RNN can preserve the performance of PRNN. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            838
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            403,
+            869
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All of the deep-learning baselines share a core CNN architecture on which the additional modules are built. We fix the architecture of the core CNN to be $[ 9 : 1 2 8 : 4 ] , [ 5 : 1 2 8 : 2 ] , [ 5 : 1 2 8 : 2 ]$ , where we use the notation $x : y : z$ for a convolution layer where $x$ is the kernel size, $y$ is the number of output feature maps, and $z$ is the pooling stride. Each convolution layer is followed by max-pooling and ReLU activation. The output of all baselines are fed to a fully connected perceptron with sigmoid activation which results in binary detection scores at each time step. The granularity ratio $\\gamma$ for this architecture is $1 / 1 6$ . For DWNN, PRNN, and PRNN-S, we used a 7-level wavelet with kernel size 3 for both synthetic and OPPORTUNITY dataset. For Bee Waggle Dance data, due to the small size of the data and the more abrupt activities (compared with synthetic and OPPORTUNITY dataset) of honey bee, we used a 5-level wavelet with kernel size 3. For all datasets RCN and PRNN used an LSTM cell with 256 hidden units. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/354fa77d6c3f1cdf3253e65b5ca785277678384229de3b8253095c6d84364a81.jpg",
+        "image_caption": [
+            "Figure 4: AUC (Area Under the ROC Curve) results for the synthetic dataset with three different test/train scenarios. $\\eta$ is the tolerance for how close in time a detected change must be to a true change to be considered a positive. See Appendix A for AUC score tables. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            112,
+            802,
+            250
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            333,
+            825,
+            444
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We train all models using Adam (Kingma & Ba, 2014) with early stopping to avoid overfitting. At test time, the models take a time series and predict a sequence of detection scores. To detect changepoints, we apply non-maximum suppression with a sliding window of length $\\omega$ and filter the maximum values with a threshold. We evaluate AUC by iterating over this threshold. Hyperparameter $\\omega$ controls how nearby two distinct changes can be detected and is tuned for each method separately using cross-validation. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            535
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The real world datasets (Bee data and OPPORTUNITY data) are more challenging than the synthetic data, as they include diverse changepoints formed by transitions between many activity types. To address this, we use multitask learning, training the model to both detect changes and classify activity by changing the output dimension of the last fully connected later to have multiple units (19 for OPPORTUNITY data, and 4 for Bee data). For OPPORTUNITY data, the first 18 units predict a log probability for each activity and the last 1 unit outputs the probability of a change point (for bee data, it’s 3 units and 1 unit). We define a softmax cross-entropy loss on those 18 units and add it as a regularization term to the objective function. Multitask learning improved the results equally for all baselines, because the model has auxiliary information, namely the activity type and not just the existence of a change. ",
+        "bbox": [
+            173,
+            541,
+            825,
+            681
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For GGM, we use the full covariance model instead of the independent features model to capture the correlations between features. We use a uniform prior as in (Xuan & Murphy, 2007), and set the pruning threshold to $1 0 ^ { - 2 0 }$ . Since there is no training for GGM, we evaluate the algorithm using the same test data as all other methods we compared on both synthetic and real world dataset. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            743
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We evaluate precision and recall, and report AUC. As detected changepoints may not exactly match the true changepoints, we use a tolerance parameter $\\eta$ that sets how close a detected change must be to a true change to be considered a correct detection. We match detected changepoints to the closest true changepoint within $\\eta$ time steps. Precision is the number of matched detections divided by the number of all detections, and recall is the number of matches divided by the number of true changes. ",
+        "bbox": [
+            174,
+            751,
+            823,
+            820
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            277,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4.1 SYNTHETIC DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            349,
+            883
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the synthetic dataset, three different train/test splits were used to demonstrate extrapolation from gradual to abrupt changes and vice versa. Fig. 4c shows the results for a random split (mixing scales), while Fig. 4a and 4b use the scale-variant split introduced in section 4.1. In the scale-variant split, the model needs to extrapolate patterns learned from training data to scales that have not been observed. This is extremely challenging for a model that is not scale-invariant. This is apparent in Fig. 4a where both CNN and RCN show worse results in parts compared to their own performance in Fig. 4c. From experiment of Fig. 4c to Fig. 4a, AUC of CNN (RCN) decreased from $41 \\%$ $( 3 9 \\% )$ to $15 \\%$ $( 1 1 \\% )$ when the tolerance is 64 steps $( 2 ^ { 6 } )$ . This is because the methods are not designed to be specifically robust against scale variability. In the transition from 4c to 4a, DWNN, PRNN, and PRNN-S like other methods inevitably suffer from a performance drop, which is due to the increase in task difficulty. However, the amount of this drop is substantially lower for DWNN, due to the wavelet layer and shared parameters across scales. At a tolerance of 64 steps, for instance, the performance drop for DWNN is $20 \\%$ , which is lower than PRNN-S $( 2 2 \\% )$ and CNN $( 2 6 \\% )$ . Again DWNN and CNN respectively work better than PRNN and RCN in this setting, which is consistent with the overall results (See Appendix A for AUC details). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f370684f1ec28911c5b1b81449b8457c46f4a03808a0a60e75e91edb3ae9dfc9.jpg",
+        "image_caption": [
+            "Figure 5: AUC (Area Under the ROC Curve) results for Opportunity and Bee Waggle Dance data. $\\eta$ is the tolerance with a unit of 1/30 seconds for both dataset. See Appendix B for AUC score tables. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            300,
+            113,
+            697,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            320,
+            825,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While recognizing abrupt changes from gradual training ones (Fig. 4b) is easier than recognizing a mix of scales, CNN and RCN perform worse than our approach due to their inability to generalize in scale. In Fig. 4b, when tolerance is 64 steps, AUC for CNN and RCN are $66 \\%$ and $30 \\%$ , which are lower than both PRNN $(72 \\% )$ and DWNN $(7 9 \\% )$ . In contrast, DWNN, PRNN-S, and PRNN have higher AUC than their own performance in the mixed experiment (Fig. 4c). The performance of PRNN at different tolerances is $20 \\%$ higher on average in the mixed experiments than the experiment of “train abrupt, test gradual” (Fig. 4a). In the train on gradual and test on abrupt experiment (4b), DWNN performs even better than PRNN and PRNN-S in all tolerances, and similarly, CNN outperforms RCN. This shows recurrent architectures are generally less effective for this kind of extreme generalization. The high performance of DWNN 4b also shows the effectiveness of the added wavelet layer in modeling both gradual and abrupt changes in time series. However, in realworld cases we are more likely to have a mix of scales in both training and test, and it is in this case (fig. 4c) that PRNN is most accurate. As shown in the AUC plots, it is in general more difficult to recognize gradual changes. It is possible to adapt our work to detect segments rather than specific points (e.g. as in (Bardwell & Fearnhead, 2017)), if instead of applying a non-maximum suppression on the output score map of change, we perform binary segmentation to detect intervals with continuously high detection score. ",
+        "bbox": [
+            174,
+            508,
+            825,
+            743
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows example results for our scale invariant PRNN and scale sensitive CNN. Overall CNN has a higher false positive rate, while also missing one of the changes. While detected changes and ground truth are not always precisely aligned, the small gaps are acceptable in the case of gradual changes, where it can be hard to define a single moment when the change occurs. ",
+        "bbox": [
+            174,
+            751,
+            823,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4.2 OPPORTUNITY DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            369,
+            842
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 shows results and AUC plots for the OPPORTUNITY dataset. In the time series, we see that CNN has a missed detection and at least one false positive around time 300, while PRNN detects all changes close to their actual times. In fig 5a, we see that PRNN outperforms other methods at all tolerance levels. In contrast to the synthetic data, PRNN-S has significantly lower AUC than both PRNN and DWNN for every tolerance. It may be that Skip RNN is skipping important information encoded in our wavelet later. Finally, the performance of GGM is lowest for all cases. This is not surprising, as it is an unsupervised method, and does not learn from previously observed patterns. When the tolerance is 64 (around 2 seconds, $\\eta = 2 ^ { 6 } = 6 4 ,$ ), a reasonable value for practical activity recognition use, PRNN achieves $81 \\%$ AUC while DWNN, RCN, CNN, and PRNN-S respectively achieve $7 5 \\%$ , $74 \\%$ , $69 \\%$ , $47 \\%$ . Full results can be seen in Appendix B.1. ",
+        "bbox": [
+            173,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4d53d49eca2de36109c46114d1ee1cce14dabcdfc5f2a7b1676fed42f914775.jpg",
+        "image_caption": [
+            "Figure 6: Detected changes on sample (3 of 79 dimensions shown) of Opportunity dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            331,
+            116,
+            666,
+            232
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            285,
+            823,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The five deep learning methods, PRNN, PRNN-S, RCN, DWNN, and CNN, respectively took 110, 105, 80, 24, and 6 minutes to train and converge on the OPPORTUNITY dataset. Recurrent methods generally take longer due to backpropagation through time. However, this only happens during training, and does not affect test complexity. One can compare PRNN to RCN, and DWNN to CNN, and observe an increase in time complexity. This is due to repeating computations on multiple levels of a pyramid. This however, only multiplies the time complexity by a constant factor, since the length of pyramid levels exponentially vanish. Note that DWNN has a superior performance to RCN in most cases, while also being faster to train. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.4.3 BEE WAGGLE DANCE DATA",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            418,
+            501
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Figure 5b shows AUC plots for all methods we tested on Bee Waggle Dance dataset. Our PRNN method outperforms other methods when the value of $\\eta$ is no less than 5 (around 1 second) with AUC of $93 \\%$ . Similar to the result on OPPORTUNITY dataset, GGM has the lowest AUC for all tolerances. When the tolerance is 64 (around 2 seconds, $\\eta \\ : = \\ : 2 ^ { 6 } = 6 4 )$ , PRNN achieves $93 \\%$ AUC while PRNN-S, RCN, and CNN respectively achieve $64 \\%$ , $84 \\%$ , $78 \\%$ (see Appendix B.2 for AUC details). Similar to OPPORTUNITY dataset, the drop of AUC for PRNN-S is caused by the skipping of states updates. However, compared with the OPPORTUNITY data where PRNN-S has maximum AUC of $51 \\%$ , PRNN-S for Bee Waggle Dance data has higher maximum AUC of $64 \\%$ . This is because the changes in honey bee activities are more abrupt than human activities, so the skipped updates have lower impact on the detection performance. From the AUC plots, a change in tolerance affects our PRNN much less compared to other methods. For instance, when the tolerance is lowered from 32 $\\eta = 2 ^ { 5 } = 3 2$ ) to 16 $( \\eta ^ { \\star } = 2 ^ { 4 } = 1 6 )$ ), the AUC of RCN drops significantly (from $84 \\%$ to $1 8 \\%$ ), while AUC of PRNN drops much less (from $93 \\%$ to $61 \\%$ ). CNN has a dramatic drop in accuracy from $\\eta = 4$ to $\\eta = 3$ , suggesting it is consistently detecting changes with a delay. Thus, PRNN is less sensitive to this parameter and more reliable for real world cases. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            719
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            739,
+            318,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We propose a new class of DNNs that are scale-invariant, and show they can detect from abrupt to gradual changepoints in multimodality time series. The core is 1) augmenting CNNs with trainable Wavelet layers to recognize short-term multi-scale patterns; and 2) building a pyramid-shaped RNN on top of the multi-scale feature maps to simultaneously model long-term patterns and fuse multiscale information. The final model can detect events involving short- and long-term patterns at various scales, which is a difficult task for conventional DNNs. Although this reduces the amount of training data required to learn from changes, the proposed method still requires clean labels. Experiments show our approach detects changes quickly, with lower sensitivity to the tolerance parameter than other approaches. For real-world applications, this leads to much higher reliability. In future work we will real-world challenges (e.g. noisy data, missing/noisy labels) by incorporating robustness, semi-supervised learning methods, and multi-view learning techniques. ",
+        "bbox": [
+            174,
+            770,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Prescott Adams and David JC MacKay. Bayesian Online Changepoint Detection. arXiv preprint arXiv:0710.3742, 2007. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Ba, Ruslan R Salakhutdinov, Roger B Grosse, and Brendan J Frey. Learning Wake-Sleep Recurrent Attention Models. In NIPS, pp. 2593–2601, 2015. ",
+        "bbox": [
+            176,
+            162,
+            823,
+            193
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lawrence Bardwell and Paul Fearnhead. Bayesian Detection of Abnormal Segments in Multiple Time Series. Bayesian Analysis, (1):193–218, 2017. ",
+        "bbox": [
+            174,
+            200,
+            823,
+            229
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian Barnett and Jukka-Pekka Onnela. Change Point Detection in Correlation Networks. Scientific reports, 6:18893, 2016. ",
+        "bbox": [
+            171,
+            238,
+            823,
+            267
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jedelyn Cabrieto, Francis Tuerlinckx, Peter Kuppens, Mariel Grassmann, and Eva Ceulemans. Detecting Correlation Changes in Multivariate Time Series: A Comparison of Four Non-parametric Change Point Detection Methods. Behavior research methods, 49(3):988–1005, 2017. ",
+        "bbox": [
+            173,
+            276,
+            823,
+            319
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "V´ıctor Campos, Brendan Jou, Xavier Giro-i Nieto, Jordi Torres, and Shih-Fu Chang. Skip RNN: ´ Learning to Skip State Updates in Recurrent Neural Networks. arXiv preprint arXiv:1708.06834, 2017. ",
+        "bbox": [
+            176,
+            327,
+            823,
+            369
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rodolfo C Cavalcante, Leandro L Minku, and Adriano LI Oliveira. FEDD: Feature Extraction for Explicit Concept Drift Detection in Time Series. In IJCNN, pp. 740–747. IEEE, 2016. ",
+        "bbox": [
+            169,
+            378,
+            823,
+            409
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ricardo Chavarriaga, Hesam Sagha, Alberto Calatroni, Sundara Tejaswi Digumarti, Gerhard Troster, Jos ¨ e del R Mill ´ an, and Daniel Roggen. The Opportunity Challenge: A Benchmark ´ Database for On-body Sensor-based Activity Recognition. Pattern Recognition Letters, 34(15): 2033–2042, 2013. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hao Chen, Nancy Zhang, et al. Graph-based change-point detection. The Annals of Statistics, 43 (1):139–176, 2015. ",
+        "bbox": [
+            173,
+            481,
+            823,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jie Chen and AK Gupta. Parametric Statistical Change Point Analysis. Springer, 2000. ",
+        "bbox": [
+            171,
+            518,
+            746,
+            535
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, B van Merrienboer, Dzmitry Bahdanau, and Yoshua Bengio. On the Properties of Neural Machine Translation: Encoder-decoder Approaches. In Eighth Workshop on Syntax, Semantics and Structure in Statistical Translation (SSST-8), 2014. ",
+        "bbox": [
+            174,
+            542,
+            823,
+            585
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Junyoung Chung, Sungjin Ahn, and Yoshua Bengio. Hierarchical Multiscale Recurrent Neural Networks. arXiv preprint arXiv:1609.01704, 2016. ",
+        "bbox": [
+            173,
+            593,
+            821,
+            623
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fred´ eric Desobry, Manuel Davy, and Christian Doncarli. An Online Kernel Change Detection Al-´ gorithm. IEEE Transactions on Signal Processing, 53(8):2961–2974, 2005. ",
+        "bbox": [
+            174,
+            631,
+            820,
+            661
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Paul Fearnhead. Exact and Efficient Bayesian Inference for Multiple Changepoint Problems. Statistics and computing, 16(2), 2006. ",
+        "bbox": [
+            173,
+            669,
+            823,
+            699
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shin Fujieda, Kohei Takayama, and Toshiya Hachisuka. Wavelet Convolutional Neural Networks. arXiv preprint arXiv:1805.08620, 2018. ",
+        "bbox": [
+            174,
+            707,
+            821,
+            736
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew B Gardner, Abba M Krieger, George Vachtsevanos, and Brian Litt. One-class Novelty Detection for Seizure Analysis from Intracranial EEG. JMLR, 7(Jun):1025–1044, 2006. ",
+        "bbox": [
+            173,
+            744,
+            821,
+            773
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Arthur Gretton, Karsten M Borgwardt, Malte Rasch, Bernhard Scholkopf, and Alex J Smola. A ¨ kernel method for the two-sample-problem. In NIPS, pp. 513–520, 2007. ",
+        "bbox": [
+            173,
+            782,
+            823,
+            811
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sudipto Guha, Nina Mishra, Gourav Roy, and Okke Schrijvers. Robust Random Cut Forest Based Anomaly Detection on Streams. In ICML, pp. 2712–2721, 2016. ",
+        "bbox": [
+            173,
+            820,
+            823,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nils Y. Hammerla, Shane Halloran, and Thomas Plotz. Deep, Convolutional, and Recurrent Models ¨ for Human Activity Recognition Using Wearables. In IJCAI, pp. 1533–1540, 2016. ",
+        "bbox": [
+            173,
+            857,
+            821,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zaid Harchaoui, Eric Moulines, and Francis R Bach. Kernel change-point analysis. In NIPS, pp. 609–616, 2009. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Maayan Harel, Shie Mannor, Ran El-Yaniv, and Koby Crammer. Concept Drift Detection through Resampling. In ICML, pp. 1009–1017, 2014. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long Short-term Memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsuyoshi Ide, Dzung T Phan, and Jayant Kalagnanam. Change Detection Using Directional Statis- ´ tics. In IJCAI, pp. 1613–1619, 2016. ",
+        "bbox": [
+            173,
+            180,
+            823,
+            209
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barry James, Kang Ling James, and David Siegmund. Asymptotic Approximations for Likelihood Ratio Tests and Confidence Regions for a Change-point in the Mean of a Multivariate Normal Distribution. Statistica Sinica, pp. 69–90, 1992. ",
+        "bbox": [
+            174,
+            218,
+            823,
+            262
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael Jones, Daniel Nikovski, Makoto Imamura, and Takahisa Hirata. Exemplar learning for extremely efficient anomaly detection in real-valued time series. Data Mining and Knowledge Discovery, 30(6):1427–1454, 2016. ",
+        "bbox": [
+            173,
+            271,
+            823,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Armand Joulin and Tomas Mikolov. Inferring Algorithmic Patterns with Stack-augmented Recurrent Nets. In NIPS, pp. 190–198, 2015. ",
+        "bbox": [
+            173,
+            324,
+            823,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yoshinobu Kawahara and Masashi Sugiyama. Sequential Change-point Detection based on Direct Density-ratio Estimation. Statistical Analysis and Data Mining: The ASA Data Science Journal, 5(2):114–127, 2012. ",
+        "bbox": [
+            174,
+            362,
+            823,
+            405
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A Method for Stochastic Optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            171,
+            414,
+            823,
+            444
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ludmila I Kuncheva. Change Detection in Streaming Multivariate Data using Likelihood Detectors. IEEE Transactions on Knowledge and Data Engineering, 25(5):1175–1180, 2013. ",
+        "bbox": [
+            169,
+            453,
+            823,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ludmila I Kuncheva and William J Faithfull. PCA Feature Extraction for Change Detection in Multidimensional Unlabeled Data. IEEE transactions on neural networks and learning systems, 25(1):69–80, 2014. ",
+        "bbox": [
+            173,
+            491,
+            823,
+            535
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shuang Li, Yao Xie, Hanjun Dai, and Le Song. M-statistic for Kernel Change-point Detection. In NIPS, pp. 3366–3374, 2015. ",
+        "bbox": [
+            173,
+            544,
+            823,
+            574
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Piotr Dollar, Ross B Girshick, Kaiming He, Bharath Hariharan, and Serge J. Belongie. ´ Feature Pyramid Networks for Object Detection. In CVPR, volume 1, 2017. ",
+        "bbox": [
+            173,
+            583,
+            820,
+            613
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Song Liu, Makoto Yamada, Nigel Collier, and Masashi Sugiyama. Change-point Detection in Timeseries Data by Relative Density-ratio Estimation. Neural Networks, 43:72–83, 2013. ",
+        "bbox": [
+            173,
+            621,
+            821,
+            651
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Rakesh Malladi, Giridhar P Kalamangalam, and Behnaam Aazhang. Online Bayesian Change Point Detection Algorithms for Segmentation of Epileptic Activity. In Signals, Systems and Computers, pp. 1833–1837. IEEE, 2013. ",
+        "bbox": [
+            173,
+            660,
+            823,
+            703
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "George D Montanez, Saeed Amizadeh, and Nikolay Laptev. Inertial Hidden Markov Models: Modeling Change in Multivariate Time Series. In AAAI, pp. 1819–1825, 2015. ",
+        "bbox": [
+            171,
+            712,
+            825,
+            742
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sang Min Oh, James M Rehg, Tucker Balch, and Frank Dellaert. Learning and Inferring Motion Patterns using Parametric Segmental Switching Linear Dynamic Systems. IJCV, 77(1-3):103– 124, 2008. ",
+        "bbox": [
+            171,
+            751,
+            823,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A Generative Model for Raw Audio. arXiv preprint arXiv:1609.03499, 2016. ",
+        "bbox": [
+            173,
+            804,
+            823,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ewan S Page. Continuous inspection schemes. Biometrika, 41(1/2):100–115, 1954. ",
+        "bbox": [
+            171,
+            856,
+            723,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Abdulhakim A Qahtan, Basma Alharbi, Suojin Wang, and Xiangliang Zhang. A Pca-based Change Detection Framework for Multidimensional Data Streams: Change Detection in Multidimensional Data Streams. In SIGKDD, pp. 935–944. ACM, 2015. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yunus Saatc¸i, Ryan D Turner, and Carl E Rasmussen. Gaussian Process Change Point Models. In ICML, pp. 927–934. Citeseer, 2010.   \nWei Shen, Mu Zhou, Feng Yang, Caiyun Yang, and Jie Tian. Multi-scale Convolutional Neural Networks for Lung Nodule Classification. In International Conference on Information Processing in Medical Imaging, pp. 588–599. Springer, 2015.   \nSainbayar Sukhbaatar, Jason Weston, Rob Fergus, et al. End-to-end Memory Networks. In NIPS, pp. 2440–2448, 2015.   \nChristian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, Andrew Rabinovich, et al. Going Deeper with Convolutions. CVPR, 2015.   \nAndreas S Weigend. Time Series Prediction: Forecasting the Future and Understanding the Past. Routledge, 2018.   \nXiang Xuan and Kevin Murphy. Modeling Changing Dependency Structure in Multivariate Time Series. In ICML, pp. 1055–1062, 2007.   \nMakoto Yamada, Akisato Kimura, Futoshi Naya, and Hiroshi Sawada. Change-Point Detection with Feature Selection in High-Dimensional Time-Series Data. In IJCAI, pp. 1827–1833, 2013.   \nKenji Yamanishi and Jun-ichi Takeuchi. A Unifying Framework for Detecting Outliers and Change Points from Non-stationary Time Series Data. In SIGKDD, pp. 676–681. ACM, 2002.   \nJianbo Yang, Minh Nhut Nguyen, Phyo Phyo San, Xiaoli Li, and Shonali Krishnaswamy. Deep Convolutional Neural Networks on Multichannel Time Series for Human Activity Recognition. In IJCAI, pp. 3995–4001, 2015.   \nFisher Yu and Vladlen Koltun. Multi-scale Context Aggregation by Dilated Convolutions. In ICLR, 2016.   \nNancy R Zhang, David O Siegmund, Hanlee Ji, and Jun Z Li. Detecting Simultaneous Changepoints in Multiple Sequences. Biometrika, 97(3):631–645, 2010. ",
+        "bbox": [
+            171,
+            99,
+            826,
+            553
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX A SYNTHETIC DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            449,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 1-3 show the AUC (Area Under the ROC Curve) results for synthetic data. To detect changepoints, we apply non-maximum suppression with a sliding window of length $\\omega$ and filter the maximum values with a threshold. We evaluate AUC by iterating over this threshold. Since changepoints may not exactly match the true changepoints, we use a tolerance parameter $\\eta$ that sets how close a detected change must be to a true change to be considered a correct detection. We match detected changepoints to the closest true changepoint within $\\eta$ time step. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            218
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows the results for the experiment of “train abrupt and test gradual” for synthetic data.   \nTable 2 shows the results for the experiment of “train gradual and test abrupt” for synthetic data.   \nTable 3 shows the results for the experiment of “train all and test all” for synthetic data. ",
+        "bbox": [
+            174,
+            224,
+            825,
+            266
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/43a3b7f1c6a46324d86158ae4f9bdb177d4fc6651fe1d108467f081596d9f787.jpg",
+        "table_caption": [
+            "Table 1: AUC results for the experiment of “train abrupt and test gradual” for synthetic data for each tolerance (η) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>8</td><td>0.002</td><td>0.003</td><td>0.007</td><td>0.006</td><td>0.005</td><td>0.003</td></tr><tr><td>16</td><td>0.008</td><td>0.011</td><td>0.010</td><td>0.023</td><td>0.016</td><td>0.011</td></tr><tr><td>32</td><td>0.026</td><td>0.042</td><td>0.012</td><td>0.076</td><td>0.063</td><td>0.043</td></tr><tr><td>64</td><td>0.107</td><td>0.153</td><td>0.012</td><td>0.271</td><td>0.213</td><td>0.155</td></tr><tr><td>128</td><td>0.391</td><td>0.421</td><td>0.013</td><td>0.625</td><td>0.546</td><td>0.503</td></tr><tr><td>256</td><td>0.783</td><td>0.757</td><td>0.016</td><td>0.849</td><td>0.822</td><td>0.863</td></tr><tr><td>512</td><td>0.824</td><td>0.801</td><td>0.023</td><td>0.862</td><td>0.835</td><td>0.876</td></tr></table>",
+        "bbox": [
+            269,
+            324,
+            728,
+            430
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/f41c9aab66396106bea05be4bf3eacfa491daf4ca222ddc6d880799f00bbce6f.jpg",
+        "table_caption": [
+            "Table 2: AUC results for the experiment of “train gradual and test abrupt” for synthetic data for each tolerance (η) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>8</td><td>0.001</td><td>0.013</td><td>0.007</td><td>0.033</td><td>0.102</td><td>0.027</td></tr><tr><td>16</td><td>0.003</td><td>0.049</td><td>0.011</td><td>0.115</td><td>0.301</td><td>0.100</td></tr><tr><td>32</td><td>0.014</td><td>0.188</td><td>0.013</td><td>0.347</td><td>0.599</td><td>0.376</td></tr><tr><td>64</td><td>0.269</td><td>0.665</td><td>0.013</td><td>0.689</td><td>0.787</td><td>0.724</td></tr><tr><td>128</td><td>0.650</td><td>0.797</td><td>0.014</td><td>0.811</td><td>0.822</td><td>0.816</td></tr><tr><td>256</td><td>0.795</td><td>0.814</td><td>0.018</td><td>0.833</td><td>0.833</td><td>0.830</td></tr><tr><td>512</td><td>0.817</td><td>0.830</td><td>0.026</td><td>0.834</td><td>0.834</td><td>0.830</td></tr></table>",
+        "bbox": [
+            267,
+            494,
+            728,
+            599
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/14bc3853369456c59d2f55ae1e40241b8316ad9308099f8bedd73c0448d10813.jpg",
+        "table_caption": [
+            "Table 3: AUC results for the experiment of “train all and test all” for synthetic data for each tolerance (η) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>8</td><td>0.039</td><td>0.061</td><td>0.007</td><td>0.027</td><td>0.014</td><td>0.039</td></tr><tr><td>16</td><td>0.093</td><td>0.144</td><td>0.011</td><td>0.100</td><td>0.061</td><td>0.122</td></tr><tr><td>32</td><td>0.204</td><td>0.244</td><td>0.012</td><td>0.249</td><td>0.164</td><td>0.284</td></tr><tr><td>64</td><td>0.390</td><td>0.407</td><td>0.017</td><td>0.496</td><td>0.406</td><td>0.551</td></tr><tr><td>128</td><td>0.582</td><td>0.586</td><td>0.021</td><td>0.737</td><td>0.700</td><td>0.747</td></tr><tr><td>256</td><td>0.788</td><td>0.747</td><td>0.030</td><td>0.863</td><td>0.840</td><td>0.860</td></tr><tr><td>512</td><td>0.852</td><td>0.808</td><td>0.043</td><td>0.874</td><td>0.860</td><td>0.869</td></tr></table>",
+        "bbox": [
+            269,
+            665,
+            728,
+            770
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX B REAL WORLD DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            467,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.1 OPPORTUNITY DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            359,
+            148
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows the results for Opportunity data. ",
+        "bbox": [
+            174,
+            160,
+            480,
+            174
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/0b4863d54c8df072fe84888110118a160e979121fa31ce48c87d7a0cddb313e7.jpg",
+        "table_caption": [
+            "Table 4: AUC results of Opportunity data for each tolerance (η) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>2</td><td>0.036</td><td>0.024</td><td>0.007</td><td>0.007</td><td>0.034</td><td>0.040</td></tr><tr><td>4</td><td>0.077</td><td>0.066</td><td>0.016</td><td>0.024</td><td>0.093</td><td>0.104</td></tr><tr><td>8</td><td>0.213</td><td>0.197</td><td>0.022</td><td>0.068</td><td>0.234</td><td>0.297</td></tr><tr><td>16</td><td>0.513</td><td>0.442</td><td>0.027</td><td>0.236</td><td>0.515</td><td>0.601</td></tr><tr><td>32</td><td>0.713</td><td>0.629</td><td>0.032</td><td>0.418</td><td>0.712</td><td>0.773</td></tr><tr><td>64</td><td>0.744</td><td>0.687</td><td>0.046</td><td>0.471</td><td>0.753</td><td>0.815</td></tr><tr><td>128</td><td>0.771</td><td>0.710</td><td>0.065</td><td>0.507</td><td>0.759</td><td>0.833</td></tr></table>",
+        "bbox": [
+            271,
+            218,
+            727,
+            324
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B.2 BEE WAGGLE DANCE DATA",
+        "text_level": 1,
+        "bbox": [
+            174,
+            347,
+            408,
+            362
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 5 shows the results for Bee Waggle Dance data. ",
+        "bbox": [
+            174,
+            373,
+            526,
+            388
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/65bac6fb9ffd4a3a01e9f1364215a3ebd9bdb136b1930325524894ab707bc698.jpg",
+        "table_caption": [
+            "Table 5: AUC results of Bee Waggle Dance data for each tolerance $( \\eta )$ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Tolerance (n)</td><td>RCN</td><td>CNN</td><td>GGM</td><td>PRNN-S</td><td>DWNN</td><td>PRNN</td></tr><tr><td>2</td><td>0.007</td><td>0.008</td><td>0.019</td><td>0.009</td><td>0.007</td><td>0.025</td></tr><tr><td>4</td><td>0.007</td><td>0.053</td><td>0.023</td><td>0.009</td><td>0.023</td><td>0.145</td></tr><tr><td>8</td><td>0.054</td><td>0.192</td><td>0.041</td><td>0.119</td><td>0.131</td><td>0.400</td></tr><tr><td>16</td><td>0.178</td><td>0.703</td><td>0.077</td><td>0.393</td><td>0.329</td><td>0.608</td></tr><tr><td>32</td><td>0.841</td><td>0.789</td><td>0.083</td><td>0.643</td><td>0.777</td><td>0.932</td></tr><tr><td>64</td><td>0.841</td><td>0.789</td><td>0.083</td><td>0.643</td><td>0.777</td><td>0.932</td></tr><tr><td>128</td><td>0.841</td><td>0.789</td><td>0.083</td><td>0.643</td><td>0.777</td><td>0.932</td></tr></table>",
+        "bbox": [
+            269,
+            431,
+            728,
+            537
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SyeD0RVtvS/SyeD0RVtvS.md

@@ -0,0 +1,324 @@
+# DEEPSFM: STRUCTURE FROM MOTION VIA DEEP BUNDLE ADJUSTMENT
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Structure from motion (SfM) is an essential computer vision problem which has not been well handled by deep learning. One of the promising trends is to apply explicit structural constraint, e.g. 3D cost volume, into the network. In this work, we design a physical driven architecture, namely DeepSFM, inspired by traditional Bundle Adjustment (BA), which consists of two cost volume based architectures for depth and pose estimation respectively, iteratively running to improve both. In each cost volume, we encode not only photo-metric consistency across multiple input images, but also geometric consistency to ensure that depths from multiple views agree with each other. The explicit constraints on both depth (structure) and pose (motion), when combined with the learning components, bring the merit from both traditional BA and emerging deep learning technology. Extensive experiments on various datasets show that our model achieves the state-of-the-art performance on both depth and pose estimation with superior robustness against less number of inputs and the noise in initialization.
+
+# 1 INTRODUCTION
+
+Structure from motion (SfM) is a fundamental human vision functionality which recovers 3D structures from the projected retinal images of moving objects or scenes. It enables machines to sense and understand with the 3D world and is critical in achieving real-world artificial intelligence. Over decades of researches, there has been a lot of great success on SfM; however, the performance is far from perfect.
+
+Conventional SfM approaches (Agarwal et al., 2011; Wu et al., 2011a; Engel et al., 2017; Delaunoy & Pollefeys, 2014) heavily rely on Bundle-Adjustment (BA) (Triggs et al., 1999; Agarwal et al., 2010), in which 3D structures and camera motions of each view are jointly optimized via LevenbergMarquardt (LM) algorithm (Nocedal & Wright, 2006) according to the cross-view correspondence. Though successful in certain scenarios, conventional SfM based approaches are fundamentally restricted by the coverage of the provided multiple views and the overlaps among them. They also typically fail to reconstruct textureless or non-lambertian (e.g. reflective or transparent) surfaces due to the missing of correspondence across views. As a result, selecting sufficiently good input views and the right scene requires excessive caution and is usually non-trivial to even experienced user.
+
+Recent researches resort to deep learning to deal with the typical weakness of conventional SfM. Early effort utilizes deep neural network as a powerful mapping function that directly regresses the structures and motions (Ummenhofer et al., 2017; Vijayanarasimhan et al., 2017; Zhou et al., 2017; Wang et al., 2017). Since the geometric constraints of structures and motions are not explicitly enforced, the network does not learn the underlying physics and prone to overfitting. Consequently, they do not perform as accurate as conventional SfM approaches and suffer from extremely poor generalization capability. Most recently, the 3D cost volume (Teed & Deng, 2018) has been introduced to explicit leveraging photo-consistency in a differentiable way, which significantly boosts the performance of deep learning based 3D reconstruction. However, the camera motion usually has to be known (Yao et al., 2018; Im et al., 2019) or predicted via direct regression (Ummenhofer et al., 2017; Zhou et al., 2017; Teed & Deng, 2018), which still suffer from generalization issue.
+
+In this paper, we explicitly enforce photo-consistency, geometric-consistency, and camera motion constraints in a unified deep learning framework. In particular, our network includes a depth based cost volume (D-CV) and a pose based cost volume (P-CV). D-CV optimizes per-pixel depth values with the current camera poses, while P-CV optimizes camera poses with the current depth estimations. Conventional 3D cost volume enforces photo-consistency by unprojecting pixels into the discrete camera fronto-parallel planes and computing the photometric (i.e. image feature) difference as the cost. In addition to that, our D-CV further enforces geometric-consistency among cameras with their current depth estimations by adding the geometric (i.e. depth) difference to the cost. Note that the initial depth estimation can be obtained using the conventional 3D cost volume. For pose estimation, rather than direct regression, our P-CV discretizes around the current camera positions, and also computes the photometric and/or geometric differences by hypothetically moving the camera into the discretized position. Note that the initial camera pose can be obtained by a rough estimation from the direct regression methods such as (Ummenhofer et al., 2017). Our framework bridges the gap between the conventional and deep learning based SfM by incorporating explicit constraints of photo-consistency, geometric-consistency and camera motions all in the deep network.
+
+The closest work in the literature is the recently proposed BA-Net (Tang & Tan, 2018), which also aims to explicitly incorporate multi-view geometric constraints in a deep learning framework. They achieve this goal by integrating the LM optimization into the network. However, the LM iterations are unrolled with few iterations due to the memory and computational inefficiency, and thus it may lead to non-optimal solutions. In contrast, our method does not have a restriction on the number of iterations and achieves empirically better performance. Furthermore, LM in SfM originally optimizes point and camera positions, and thus direct integration of LM still requires good correspondences. To evade the correspondence issue in typical SfM, their models employ a direct regressor to predict depth at the front end, which heavily relies on prior in the training data. In contrast, our model is a fully physical-driven architecture that less suffers from over-fitting issue for both depth and pose estimation.
+
+To demonstrate the superiority of our method, we conduct extensive experiments on DeMoN datasets, ScanNet and ETH3D. The experiments show that our approach outperforms the state-ofthe-art Schonberger & Frahm (2016); Ummenhofer et al. (2017); Tang & Tan (2018).
+
+# 2 RELATED WORK
+
+There is a large body of work that focuses on inferring depth or motion from color images, ranging from single view, multiple views and monocular video. We discuss them in the context of our work.
+
+Single-view Depth Estimation. While ill-posed, the emerging of deep learning technology enables the estimation of depth from a single color image. The early work directly formulates this into a per-pixel regression problem (Eigen et al., 2014), and follow-up works improve the performance by introducing multi-scale network architectures (Eigen et al., 2014; Eigen & Fergus, 2015), skipconnections (Wang et al., 2015; Liu et al., 2016), powerful decoder and post process (Garg et al., 2016; Laina et al., 2016; Kuznietsov et al., 2017; Wang et al., 2015; Liu et al., 2016), and new loss functions (Fu et al., 2018). Even though single view based methods generate plausible results, the models usually resort heavily to the prior in the training data and suffer from generalization capability. Nevertheless, these methods still act as an important component in some multi-view systems (Tang & Tan, 2018)
+
+Traditional Structure-from-Motion Simultaneously estimating 3d structure and camera motion is a well studied problem which has a traditional tool-chain of techniques (Furukawa et al., 2010; Newcombe et al., 2011; Wu et al., 2011b). Structure from Motion(SfM) has made great progress in many aspects. Lowe (2004); Han et al. (2015) aim at improving features and Snavely (2011) introduce new optimization techniques. More robust structures and data representations are introduced by Gherardi et al. (2010); Schonberger & Frahm (2016). Simultaneous Localization and Sapping(SLAM) systems track the motion of the camera and build 3D structure from video sequence (Newcombe et al., 2011; Engel et al., 2014; Mur-Artal et al., 2015; Mur-Artal & Tardós, 2017). Engel et al. (2014) propose the photometric bundle adjustment algorithm to directly minimize the photometric error of aligned pixels. However, traditional SfM and SLAM methods are sensitive to low texture region, occlusions, moving objects and lighting changes, which limit the performance and stability.
+
+Deep Learning for Structure-from-Motion Deep neural networks have shown great success in stereo matching and Structure-from-Motion problems. Ummenhofer et al. (2017); Wang et al. (2017); Vijayanarasimhan et al. (2017); Zhou et al. (2017) regress depth map and camera pose directly in a supervised manner or by introducing photometric constraints between depth and motion as a self-supervision signal. Such methods solve the camera motion as a regression problem, and the relation between camera motion and depth prediction is neglected.
+
+![](images/8f3457766b539a218a007e3afc9869af94fe3e63eee69596ebe607ac992c5a31.jpg)  
+Figure 1: Overview of our method. 2D CNN is used to extract photometric feature to construct cost volumes. Initial source depth maps are used to introduce geometry consistency. A series of 3D CNN layers are applied for both pose based cost volume and D-CV. Then a context network and depth regression operation are applied to produce predicted depth map of reference image.
+
+Recently, some methods exploit multi-view photometric or feature-metric constraints to enforce the relationship between dense depth map and the camera pose in network. The SE3 transformer layer is introduced by Teed & Deng (2018), which uses geometry to map flow and depth into a camera pose update. Wang et al. (2018) propose the differentiable camera motion estimator based on the Direct Visual Odometry (Steinbrücker et al., 2011). Clark et al. (2018) using a LSTM-RNN (Hochreiter et al., 2001) as the optimizer to solve nonlinear least squares in two-view SfM. Tang & Tan (2018) train a network to generate a set of basis depth maps and optimize depth and camera poses in a BA-layer by minimizing a feature-metric error.
+
+# 3 ARCHITECTURE
+
+Our framework receives frames of a scene from different viewpoints, and produces photo-metrically and geometrically consistent depth maps across all frames and the corresponding camera poses. Similar to BA, we also assume initial structures (i.e depth maps) and motions (i.e. camera poses) are given. Note that the initialization is not necessary to be super accurate for the good performance using our framework and thus can be easily obtained from some direct regression methods (Ummenhofer et al., 2017).
+
+Now we introduce the detail of our model – DeepSFM. Without loss of generality, we describe our model taking two images as input, namely the reference image and the source image, as an example, and all the technical components can be extended for multiple images straightforward. As shown in Figure 1, we first extract feature maps from input images through a shared encoder. We then sample the solution space for depth uniformly in the inverse-depth space between a predefined minimum and maximum range and camera pose around the initialization respectively. After that, we build cost volumes accordingly to reason the confidence of each hypothesis. This is achieved by validating the consistency between the feature of the reference view and the ones warped from the source image. Besides photo-metric consistency that measures the color image similarity, we also take into account the geometric consistency across warped depth maps. Note that depth and pose require different designs of cost volume to efficiently sample the hypothesis space. Gradients can back-propagate through cost volumes, and cost-volume construction does not affect any trainable parameters. The cost volumes are then fed into 3D CNN to regress new depth and pose. These updated value can be used to create new cost volumes, and the model improves the prediction iteratively.
+
+For notations, we denote $\{ \mathbf { I } _ { i } \} _ { i = 1 } ^ { n }$ as the image sequences in one scene, $\{ \mathbf { D } _ { i } \} _ { i = 1 } ^ { n }$ as the corresponding ground truth depth maps, $\{ { \bf K } _ { i } \} _ { i = 1 } ^ { n }$ as the camera intrinsics, $\{ \mathbf { R } _ { i } , \mathbf { t } _ { i } \} _ { i = 1 } ^ { n }$ as the ground truth rotations and translations of camera, $\{ \mathbf { D } _ { i } ^ { * } \} _ { i = 1 } ^ { n }$ and $\{ \mathbf { R } _ { i } ^ { * } , \mathbf { t } _ { i } ^ { * } \} _ { i = 1 } ^ { n }$ as initial depth maps and camera pose parameters for constructing cost volumes, where $n$ is the number of image samples.
+
+# 3.1 2D FEATURE EXTRACTION
+
+Given the input sequences $\{ \mathbf { I } _ { i } \} _ { i = 1 } ^ { n }$ , we extract the 2D CNN feature $\{ \mathbf { F } _ { i } \} _ { i = 1 } ^ { n }$ for each frame. Firstly, a 7 layers’ CNN with kernel size $3 \times 3$ is applied to extract low contextual information. Then we adopt a spatial pyramid pooling (SPP) (Kaiming et al., 2014) module, which can extract hierarchical multiscale features through 4 average pooling blocks with different pooling kernel size $( 4 \times 4 , 8 \times 8$ , $1 6 \times$ $1 6 , 3 2 \times 3 2 )$ . Finally, we pass the concatenated features through 2D CNNs to get the 32-channel image features after upsampling these multi-scale features into the same resolution. These image sequence features are used by the building of both our depth based and pose based cost volumes.
+
+# 3.2 DEPTH BASED COST VOLUME (D-CV)
+
+Traditional plane sweep cost volume aims to back-project the source images onto successive virtual planes in the 3D space and measure photo-consistency error among the warped image features and reference image features for each pixel. Different from the cost volume used in previous multiview and structure-from-motion methods, we construct a D-CV to further utilize the local geometric consistency constraints introduced by depth maps. Inspired by the traditional plane sweep cost volumes, our D-CV is a concatenation of three components: the reference image features, the warped source image features and the homogeneous depth consistency maps.
+
+Hypothesis Sampling To back-project the features and depth maps from source viewpoint to the 3D space in reference viewpoint, we uniformly sample a set of $L$ virtual planes $\{ d _ { l } \} _ { l = 1 } ^ { L }$ in the inverse-depth space which are perpendicular to the forward direction $z$ -axis) of the reference viewpoint. These planes serve as the hypothesis of the output depth map, and the cost volume can be built upon them.
+
+Feature warping. To construct our D-CV, we first warp source image features $\mathbf { F } _ { i }$ (of size $C H a n n e l \times W i d t h \times H e i g h t )$ to each of the hypothetical depth map planes $d _ { l }$ using camera intrinsic matrix $\mathbf { K }$ and initial camera poses $\{ \mathbf { R } _ { i } ^ { * } , \mathbf { t } _ { i } ^ { * } \}$ , according to:
+
+$$
+\tilde { \mathbf { F } } _ { i l } ( u ) = \mathbf { F } _ { i } \left( \tilde { u } _ { l } \right) , \tilde { u } _ { l } \sim \mathbf { K } \left[ \mathbf { R } _ { i } ^ { * } | \mathbf { t } _ { i } ^ { * } \right] \left[ \begin{array} { c } { \left( \mathbf { K } ^ { - 1 } u \right) d _ { l } } \\ { 1 } \end{array} \right]
+$$
+
+where $u$ and $\tilde { u } _ { l }$ are the homogeneous coordinates of each pixel in the reference view and the projected coordinates onto the corresponding source view. $\tilde { \mathbf { F } } _ { i l } ( u )$ denotes the warped feature of the source image through the $l$ -th virtual depth plane. Note that the projected homogeneous coordinates $\tilde { u } _ { l }$ are floating numbers, and we adopt a differentiable bilinear interpolation to generate the warped feature map $\tilde { \mathbf { F } } _ { i l }$ . The pixels with no source view coverage are assigned with zeros. Following Im et al. (2019), we concatenate the reference feature and the warped reference feature together and obtain a $2 C H \times L \times W \times H$ 4D feature volume.
+
+Depth consistency. In addition to photometric consistency, to exploit geometric consistency and promote the quality of depth prediction, we add two more channels on each virtual plane: the warped initial depth maps from the source view and the depth map of the virtual plane from the perspective of the source view. Note that the former is the same as image feature warping, while the latter requires a coordinate transformation from the reference camera to the source camera.
+
+In particular, the first channel is computed as follows. The initial depth map of source image is first down-sampled and then warped to hypothetical depth planes based on initial camera pose similarly to the image feature warping:
+
+$$
+\tilde { \mathbf { D } } _ { i l } ^ { * } ( u ) = \mathbf { D } _ { i } ^ { * } \left( \tilde { u } _ { l } \right)
+$$
+
+where the coordinates $u$ and $\tilde { u } _ { l }$ are defined in Eq. 1 and $\tilde { \mathbf { D } } _ { i l } ^ { * } ( u )$ represents the warped one-channel depth map on the $l$ -th depth plane. One distinction between depth warping and feature warping is that we adopt nearest neighbor sampling for depth warping, instead of bilinear interpolation. A comparison between the two methods are provided in Appendix C.
+
+The second channel contains the depth values of the virtual planes in the reference view by seeing them from the source view. To transform the virtual planes to the source view coordinate system, we apply a $T$ function on each virtual plane $d _ { l }$ in the following:
+
+$$
+T ( d _ { l } ) \sim [ \mathbf { R } _ { i } ^ { * } | \mathbf { t } _ { i } ^ { * } ] \left[ \begin{array} { c } { \left( \mathbf { K } ^ { - 1 } u \right) d _ { l } } \\ { 1 } \end{array} \right]
+$$
+
+We stack the warped initial depth maps and the transformed depth planes together, and get a depth volume of size $2 \times L \times W \times H$ .
+
+By concatenating the feature volume and depth volume together, we obtain a 4D cost tensor of size $( 2 C H + 2 ) \times L \times W \times H$ . Given the 4D cost volume, our network learns a cost volume of size $L \times W \times H$ using several 3D convolutional layers with kernel size $3 \times 3 \times 3$ . When there is more than one source image, we get the final cost volume by averaging over multiple input source views.
+
+# 3.3 POSE BASED COST VOLUME (P-CV)
+
+In addition to the construction of D-CV, we also propose a P-CV, aiming at optimizing initial camera poses through both photometric and geometric consistency. Instead of building a cost volume based on hypothetical depth map planes, our novel P-CV is constructed based on a set of assumptive camera poses. Similar to D-CV, P-CV is also concatenated by three components: the reference image features, the warped source image features and the homogeneous depth consistency maps. Given initial camera pose parameters $\{ \mathbf { R } _ { i } ^ { * } , \mathbf { t } _ { i } ^ { * } \}$ , we uniformly sample a batch of discrete candidate camera poses around. Since jointly sampling camera rotation and translation along 6-DoF is costly, we shift rotation and translation separately by keeping one frozen while sampling the other one. In the end, a group of $P$ virtual camera poses noted as $\{ \bar { \mathbf { R } } _ { i p } ^ { * } | \mathbf { t } _ { i p } ^ { * } \} _ { p = 1 } ^ { P }$ around input pose are obtained for cost volume construction.
+
+The posed-based cost volume is also constructed by concatenating image features and homogeneous depth maps. However, source view features and depth maps are warped based on sampled camera poses. For feature warping, we compute $\tilde { u } _ { p }$ as following equations:
+
+$$
+\tilde { u } _ { p } \sim { \bf K } \left[ { \bf R } _ { i p } ^ { * } | \mathbf { t } _ { i p } ^ { * } \right] \left[ \begin{array} { c } { \left( { \bf K } ^ { - 1 } u \right) { \bf D } _ { i } ^ { * } } \\ { 1 } \end{array} \right]
+$$
+
+where $\mathbf { D } _ { i } ^ { * }$ is the initial reference view depth. Similar to D-CV, we get warped source feature map $\tilde { \mathbf { F } } _ { i p }$ after bilinear sampling and concatenate it with reference view feature map. We also transform the initial reference view depth and source view depth into one homogeneous coordinate system, which enhances the geometric consistency between camera pose and multi view depth maps.
+
+After concatenating the above feature maps and depth maps together, we again build a 4D cost volume of size $( 2 C H + 2 ) \times P \times W \times H$ , where $W$ and $H$ are the width and height of feature map, $C H$ is the number of channels. We get output of size $1 \times P \times 1 \times 1$ from the above 4-D tensor after eight 3D convolutional layers with kernel size $3 \times 3 \times 3$ , three 3D average pooling layers with stride size $2 \times 2 \times 1$ and one global average pooling at the end.
+
+# 3.4 COST AGGREGATION AND REGRESSION
+
+For depth prediction, we follow the cost aggregation technique introduced by Im et al. (2019). We adopt a context network, which takes reference image features and each slice of the coarse cost volume after 3D convolution as input and produce the refined cost slice. The final aggregated depth based volume is obtained by adding coarse and refined cost slices together. The last step to get depth prediction of reference image is depth regression. We pass each slice of D-CV through a soft-max function to get the probability of every depth value $l$ . Then the weighted sum of all hypothetical depth values is regarded as predicted depth map; this operation is called soft-argmax. We can also get the predicted coarse depth map by the same way using coarse D-CV. For camera poses prediction, we also apply a soft-argmax function on pose cost volume and get the estimated output rotation and translation vectors.
+
+# 3.5 TRAINING
+
+The DeepSFM learns the feature extractor, cost aggregation, and the regression layers in a supervised way. We denote $\hat { { \bf R } } _ { i }$ and $\hat { \mathbf { t } } _ { i }$ as predicted rotation angles and translation vectors of camera pose. Then the pose loss function is defined as the $L 1$ distance between prediction and groundtruth: $\mathcal { L } _ { r o t a t i o n } =$ $\left| \hat { \mathbf { R } } _ { i } - \mathbf { R } _ { i } \right|$ and $\mathcal { L } _ { t r a n s l a t i o n } = \left| \hat { \mathbf { t } } _ { i } - \mathbf { t } _ { i } \right|$ . We denote $\hat { D } _ { i } ^ { 0 }$ and $\hat { D } _ { i }$ as predicted coarse depth map and refined depth map for the $i$ -th image, then the depth loss function is defined as following equation:
+
+$$
+\mathcal { L } _ { d e p t h } = \sum _ { i } \lambda H ( \hat { D } _ { i } ^ { 0 } , \mathbf { D } _ { i } ) + H ( \hat { D } _ { i } , \mathbf { D } _ { i } )
+$$
+
+where $\lambda$ is weight parameter and function $H$ is Huber loss.
+
+Our final objective becomes
+
+$$
+\mathcal { L } _ { f i n a l } = \lambda _ { r } \mathcal { L } _ { r o t a t i o n } + \lambda _ { t } \mathcal { L } _ { t r a n s l a t i o n } + \lambda _ { d } \mathcal { L } _ { d e p t h }
+$$
+
+We follow two rules to set $\lambda _ { r }$ , $\lambda _ { t }$ and $\lambda _ { d } \colon 1 \ \mathrm { , }$ ) the loss term provides gradient on the same order of numerical value range, such that no single loss term could dominate the training process, since accuracy in depth and camera pose are both important to reach a good consensus. 2) we found in practice the camera rotation has higher impact on the accuracy of the depth but not the opposite. To encourage better performance of pose, we set a relatively large $\lambda _ { r }$ . In practice, the weight parameter $\lambda$ to balance loss objective is set to 0.7, while $\lambda _ { r } = 0 . 8$ , $\lambda _ { t } = 0 . 1$ and $\lambda _ { d } = 0 . 1$ .
+
+The RGB sequences, corresponding ground-truth depth maps and camera intrinsics and extrinsics are fed as input samples. We initialize the 2D feature extraction layers with pre-trained DPSNet weight. The initial depth maps and camera poses $\{ \mathbf { D } _ { i } ^ { * } \} _ { i = 1 } ^ { n }$ and $\{ \mathbf { R } _ { i } ^ { * } , \mathbf { \bar { t } } _ { i } ^ { * } \} _ { i = 1 } ^ { n }$ are obtained from DeMoN. To keep correct scale, we multiply translation vectors and depth maps by the norm of the ground truth camera translation vector. The whole training and testing procedure are performed as four iterations. During each iteration, we take the predicted depth maps and camera poses of previous iteration as new $\mathbf { \bar { \{ D } }  _ { i } ^ { * } \} _ { i = 1 } ^ { n }$ and $\{ \mathbf { R } _ { i } ^ { * } , \mathbf { t } _ { i } ^ { * } \} _ { i = 1 } ^ { n }$ for cost volume construction.
+
+We implement our system using PyTorch framework. The training procedure takes 6 days on 3 NVIDIA TITAN GPUs on all 160k training sequences. The training batch size is set to 4, and the Adam optimizer $( \beta _ { 1 } = 0 . 9 , \beta _ { 2 } = 0 . 9 9 9 )$ is used with learning rate $2 \times 1 0 ^ { - 4 }$ , which decreases to $4 \times 1 0 ^ { - 5 }$ after 2 epochs. Within the first two epochs, the parameters in 2D CNN feature extraction module are frozen, and the ground truth depth maps for source images are used to construct D-CV and P-CV, which are replaced with predicted depth maps from network in latter epochs. During training process, the length of input sequences is 2 (one reference image and one source image). The $L$ for D-CV is set to 64 and the $\mathbf { N }$ for P-CV is 10. The range of both cost volumes is adapted during training and testing.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS
+
+We evaluate DeepSFM on widely used datasets and compare to state-of-the-art methods on accuracy and generalization capability.
+
+DeMoN Datasets Proposed in DeMoN (Ummenhofer et al., 2017), this dataset contains data from various sources, including SUN3D (Xiao et al., 2013), RGB-D SLAM (Sturm et al., 2012), and Scenes11 (Chang et al., 2015). To test the generalization capability, we also evaluate on MVS (Fuhrmann et al., 2014) dataset but not use it for the training. In all four datasets, RGB image sequences and the ground truth depth maps are provided with the camera intrinsics and camera poses. Note that those datasets together provide a diverse set of both indoor and outdoor, synthetic and real-world scenes. Specifically, Scenes11 consists of synthetic images rendered from random scenes, on which ground truth camera poses and depth are perfect, but objects are lack of reality in scale and semantics. For training and testing, we use the same setting as DeMoN.
+
+ETH3D Dataset ETH3D dataset provides a variety of indoor and outdoor scenes with highprecision ground truth 3D points captured by laser scanners, which is a more solid benchmark
+
+dataset. Ground truth depth maps are obtained by projecting the point clouds to each camera view. Raw images are in high resolution but resized to $8 1 0 \times 5 4 0$ pixels for evaluation due to memory constraint. Again, all the models are trained on DeMoN and tested here.   
+
+<table><tr><td>MVS</td><td colspan="3">Depth</td><td colspan="2">Motion</td><td>Scenes11</td><td colspan="2">Depth</td><td colspan="3"></td></tr><tr><td>Method</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td><td>Method</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td></tr><tr><td>Base-Oracle</td><td>0.019</td><td>0.197</td><td>0.105</td><td>0</td><td>0</td><td>Base-Oracle</td><td>0.023</td><td>0.618</td><td>0.349</td><td>0</td><td>0</td></tr><tr><td>Base-SIFT</td><td>0.056</td><td>0.309</td><td>0.361</td><td>21.180</td><td>60.516</td><td>Base-SIFT</td><td>0.051</td><td>0.900</td><td>1.027</td><td>6.179</td><td>56.650</td></tr><tr><td>Base-FF</td><td>0.055</td><td>0.308</td><td>0.322</td><td>4.834</td><td>17.252</td><td>Base-FF</td><td>0.038</td><td>0.793</td><td>0.776</td><td>1.309</td><td>19.426</td></tr><tr><td>Base-Matlab</td><td>-</td><td>-</td><td>-</td><td>10.843</td><td>32.736</td><td>Base-Matlab</td><td>-</td><td>-</td><td>-</td><td>0.917</td><td>14.639</td></tr><tr><td>DeMoN</td><td>0.047</td><td>0.202</td><td>0.305</td><td>5.156</td><td>14.447</td><td>DeMoN</td><td>0.019</td><td>0.315</td><td>0.248</td><td>0.809</td><td>8.918</td></tr><tr><td>LS-Net</td><td>0.051</td><td>0.221</td><td>0.311</td><td>4.653</td><td>11.221</td><td>LS-Net</td><td>0.010</td><td>0.410</td><td>0.210</td><td>4.653</td><td>8.210</td></tr><tr><td>BANet</td><td>0.030</td><td>0.150</td><td>0.080</td><td>3.499</td><td>11.238</td><td>BANet</td><td>0.080</td><td>0.210</td><td>0.130</td><td>3.499</td><td>10.370</td></tr><tr><td>Ours</td><td>0.021</td><td>0.129</td><td>0.079</td><td>2.824</td><td>9.881</td><td>Ours</td><td>0.007</td><td>0.112</td><td>0.064</td><td>0.403</td><td>5.828</td></tr><tr><td>RGB-D</td><td></td><td>Depth</td><td></td><td colspan="2">Motion</td><td>Sun3D</td><td></td><td>Depth</td><td></td><td colspan="2">Motion</td></tr><tr><td>Method</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td><td>Method</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td></tr><tr><td>Base-Oracle</td><td>0.026</td><td>0.398</td><td>0.36</td><td>0</td><td>0</td><td>Base-Oracle</td><td>0.020</td><td>0.241</td><td>0.220</td><td>0</td><td>0</td></tr><tr><td>Base-SIFT</td><td>0.050</td><td>0.577</td><td>0.703</td><td>12.010</td><td>56.021</td><td>Base-SIFT</td><td>0.029</td><td>0.290</td><td>0.286</td><td>7.702</td><td>41.825</td></tr><tr><td>Base-FF</td><td>0.045</td><td>0.548</td><td>0.613</td><td>4.709</td><td>46.058</td><td>Base-FF</td><td>0.029</td><td>0.284</td><td>0.297</td><td>3.681</td><td>33.301</td></tr><tr><td>Base-Matlab</td><td>-</td><td>-</td><td>-</td><td>12.813</td><td>49.612</td><td>Base-Matlab</td><td>-</td><td>-</td><td>-</td><td>5.920</td><td>32.298</td></tr><tr><td>DeMoN</td><td>0.028</td><td>0.130</td><td>0.212</td><td>2.641</td><td>20.585</td><td>DeMoN</td><td>0.019</td><td>0.114</td><td>0.172</td><td>1.801</td><td>18.811</td></tr><tr><td>LS-Net</td><td>0.019</td><td>0.090</td><td>0.301</td><td>1.010</td><td>22.100</td><td>LS-Net</td><td>0.015</td><td>0.189</td><td>0.650</td><td>1.521</td><td>14.347</td></tr><tr><td>BANet</td><td>0.008</td><td>0.087</td><td>0.050</td><td>2.459</td><td>14.900</td><td>BANet</td><td>0.015</td><td>0.110</td><td>0.060</td><td>1.729</td><td>13.260</td></tr><tr><td>Ours</td><td>0.011</td><td>0.071</td><td>0.126</td><td>1.862</td><td>14.570</td><td>Ours</td><td>0.013</td><td>0.093</td><td>0.072</td><td>1.704</td><td>13.107</td></tr></table>
+
+Table 1: Results on MVS, SUN3D, RGBD and Scenes11, the best results are noted by Bold.
+
+# 4.2 EVALUATION
+
+DeMoN Datasets Our results on DeMoN datasets and the comparison to other methods are shown in Table 1. We cite results of some strong baseline methods from DeMoN paper, named as Base-Oracle, Base-SIFT, Base-FF and Base-Matlab respectively (Ummenhofer et al., 2017). Base-Oracle estimate depth with the ground truth camera motion using SGM (Hirschmuller, 2005). Base-SIFT, BaseFF and Base-Matlab solve camera motion and depth using feature, optical flow, and KLT tracking correspondence from 8-pt algorithm (Hartley, 1997). We also compare to some most recent stateof-the-art methods LS-Net (Clark et al., 2018) and BA-Net (Tang & Tan, 2018). LS-Net introduces the learned LSTM-RNN optimizer to minimizing photometric error for stereo reconstruction. BANet is the most recent work that minimizes the feature-metric error between multi-view via the differentiable Levenberg-Marquardt (Lourakis & Argyros, 2005) algorithm.
+
+To make a fair comparison, we adopt the same error metrics as DeMoN for depth and camera pose evaluation. L1-inv computes the disparity map errors, and sc-inv is a scale-invariant error metric.
+
+<table><tr><td rowspan="2">Method</td><td colspan="5">Error metric</td><td colspan="3">Accuracy metric(δ &lt;αt)</td></tr><tr><td>abs_rel</td><td>abs_diff</td><td>sq_rel</td><td>rms</td><td>log_rms</td><td>a</td><td>q</td><td>a3</td></tr><tr><td>COLMAP</td><td>0.324</td><td>0.615</td><td>36.71</td><td>2.370</td><td>0.349</td><td>86.5</td><td>90.3</td><td>92.7</td></tr><tr><td>DeMoN</td><td>0.191</td><td>0.726</td><td>0.365</td><td>1.059</td><td>0.240</td><td>73.3</td><td>89.8</td><td>95.1</td></tr><tr><td>Ours</td><td>0.127</td><td>0.661</td><td>0.278</td><td>1.003</td><td>0.195</td><td>84.1</td><td>93.8</td><td>96.9</td></tr></table>
+
+Table 2: Results on ETH3D (Bold: best; $\alpha = 1 . 2 5$ ). abs_rel, abs_diff, sq_rel, rms, and log_rms, are absolute relative error, absolute difference, square relative difference, root mean square and log root mean square, respectively.
+
+L1-rel measures the depth errors relative to the ground truth depth, which emphasize depth estimation of close range in the scene. For camera poses evaluation, the angles between the prediction and the ground truth rotation and translation are shown as Rot and Trans respectively.
+
+Our method outperforms all traditional baseline methods and DeMoN on both depth and camera poses. When compared to more recent LS-Net and BA-Net, our method produces better results in most metrics of the four datasets. On RGB-D dataset, our performance is comparable to the stateof-the-art due to relatively higher noise in the RGB-D ground truth. LS-Net trains an initialization network which regresses depth and motion directly before adding the LSTM-RNN optimizer. The performance of the RNN optimizer is highly affected by the accuracy of the regressed initialization. The depth results of LS-Net are consistently poorer than BA-Net and our method, despite better rotation parameters are estimated by LS-Net on RGB-D and Sun3D datasets with very good initialization. Our method is slightly inferior to BA-Net on the L1-rel metric, which is probably due to that we sample 64 virtual planes uniformly as the hypothetical depth set, while BA-Net optimizes depth prediction based on a set of 128-channel estimated basis depth maps that are more memory consuming but have more fine-grained results empirically. Despite all that, it is shown that our learned cost volumes with geometric consistency work better than the photometric bundle adjustment (e.g. used in BA-Net) in most scenes. In particular, we improve mostly on the Scenes11 dataset, where the ground truth is perfect but the input images contain a lot of texture-less regions, which are challenging to photo-consistency based methods.
+
+ETH3D We further test the generalization capability on ETH3D. We provide comparisons to COLMAP (Schonberger & Frahm, 2016) and DeMoN on ETH3D. COLMAP is a state-of-the-art Structure-from-Motion method, while DeMoN introduces a classical deep network architecture that fined as $\begin{array} { r } { \operatorname* { m a x } \Bigl ( \frac { y _ { i } ^ { * } } { y _ { i } } , \frac { y _ { i } } { y _ { i } ^ { * } } \Bigr ) } \end{array}$ , and the thresholds are typically set as $[ 1 . 2 5 , 1 . 2 5 ^ { 2 } , 1 . 2 5 ^ { 3 } ]$ . In Table $\delta$ 2, our method shows the best performance overall among all the comparison methods. Our method produces better results than DeMoN consistently, since we impose geometric and physical constraints onto network rather than learning to regress directly. When compared with COLMAP, our method performs better on most metrics. COLMAP behaves well in the accuracy metric (i.e. abs_diff). However, the presence of outliers is often observed in the predictions of COLMAP, which leads to poor performance in other metrics such as abs_rel and sq_rel, since those metrics are sensitive to outliers. We put more qualitative comparisons with COLMAP in Appendix C. For more comparison on generalization, another experiment on ScanNet is provided in Appendix B.
+
+# 4.3 MODEL ANALYSIS
+
+In this section, we analyze our model on several aspects to verify the optimality and show advantages over previous methods.
+
+![](images/ef4b4efad999e3c3cdf431ef5f34c8301c4c1741ef44f24d2018370517f7635b.jpg)  
+Figure 2: Comparison with baseline during iterations. Our work converges at a better position. (a) abs relative error and log RMSE. (b) rotation and translation degree error.
+
+Iterative Improvement Our model can run iteratively to reduce the prediction error. Figure 2 (solid lines) shows our performance over iterations when initialized with the prediction from DeMoN. As can be seen, our model effectively reduces both depth and pose errors upon the DeMoN output.
+
+Throughout the iterations, better depth and pose benefit each other by building more accurate cost volume, and both are consistently improved. The whole process is similar to coordinate descent algorithm, and finally converges at iteration 4.
+
+Effect of P-CV We compare DeepSFM to a baseline method for our P-CV. In this baseline, the depth prediction is the same as DeepSFM, but the pose prediction network is replaced by a direct visual odometry model Steinbrücker et al. (2011), which updates camera parameters by minimizing pixel-wise photometric error between image features. Both methods are initialized with DeMoN results. As provided in Figure 2, DeepSFM consistently produces lower errors on both depth and pose over all the iterations. This shows that our P-CV predicts more accurate pose and performs more robust against noise depth at early stages.
+
+![](images/6b91aa781c2bca13017105bf80c05ab026ebc2968c1bafec058c3e3a8f268d6a.jpg)  
+Figure 3: Depth map results w.r.t. the number of images.
+
+View Number DeepSFM works still reasonably well with fewer views due to the free from optimization based components. To show this, we compare to COLMAP with respect to the number of input views on ETH3D. As depicted in Figure 3, more images yield better results for both methods as expected. However, our performance drops significantly slower than COLMAP with fewer number of inputs. Numerically, DeepSFM cuts the depth error by half under the same number of views as COLMAP, or achieves similar error with half number of views required by COLMAP. This clearly demonstrates that DeepSFM is more robust when fewer inputs are available.
+
+# 5 CONCLUSIONS
+
+We present a deep learning framework for Structure-from-Motion, which explicitly enforces photometric consistency, geometric consistency and camera motion constraints all in the deep network. This is achieved by two key components - namely D-CV and P-CV. Both cost volumes measure the photo-metric errors and geometric errors but hypothetically move reconstructed scene points (structure) or camera (motion) respectively. Our deep network can be considered as an enhanced learning based BA algorithm, which takes the best benefits from both learnable priors and geometric rules. Consequently, our method outperforms conventional BA and state-of-the-art deep learning based methods for SfM.
+
+# REFERENCES
+
+Sameer Agarwal, Noah Snavely, Steven M Seitz, and Richard Szeliski. Bundle adjustment in the large. In European conference on computer vision, pp. 29–42. Springer, 2010.
+
+Sameer Agarwal, Yasutaka Furukawa, Noah Snavely, Ian Simon, Brian Curless, Steven M Seitz, and Richard Szeliski. Building rome in a day. Communications of the ACM, 54(10):105–112, 2011.
+
+Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015.
+
+Ronald Clark, Michael Bloesch, Jan Czarnowski, Stefan Leutenegger, and Andrew J Davison. Learning to solve nonlinear least squares for monocular stereo. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 284–299, 2018.
+
+Amaël Delaunoy and Marc Pollefeys. Photometric bundle adjustment for dense multi-view 3d modeling. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1486–1493, 2014.
+
+David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multi-scale convolutional architecture. In The IEEE International Conference on Computer Vision (ICCV), December 2015.
+
+David Eigen, Christian Puhrsch, and Rob Fergus. Depth map prediction from a single image using a multi-scale deep network. In Advances in neural information processing systems, pp. 2366–2374, 2014.
+
+Jakob Engel, Thomas Schöps, and Daniel Cremers. Lsd-slam: Large-scale direct monocular slam. In European conference on computer vision, pp. 834–849. Springer, 2014.
+
+Jakob Engel, Vladlen Koltun, and Daniel Cremers. Direct sparse odometry. IEEE transactions on pattern analysis and machine intelligence, 40(3):611–625, 2017.
+
+Huan Fu, Mingming Gong, Chaohui Wang, Kayhan Batmanghelich, and Dacheng Tao. Deep ordinal regression network for monocular depth estimation. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018.
+
+Simon Fuhrmann, Fabian Langguth, and Michael Goesele. Mve-a multi-view reconstruction environment. In GCH, pp. 11–18, 2014.
+
+Yasutaka Furukawa, Brian Curless, Steven M Seitz, and Richard Szeliski. Towards internet-scale multi-view stereo. In 2010 IEEE computer society conference on computer vision and pattern recognition, pp. 1434–1441. IEEE, 2010.
+
+Ravi Garg, Vijay Kumar BG, Gustavo Carneiro, and Ian Reid. Unsupervised cnn for single view depth estimation: Geometry to the rescue. In European Conference on Computer Vision (ECCV), pp. 740–756. Springer, 2016.
+
+Riccardo Gherardi, Michela Farenzena, and Andrea Fusiello. Improving the efficiency of hierarchical structure-and-motion. In 2010 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, pp. 1594–1600. IEEE, 2010.
+
+Xufeng Han, Thomas Leung, Yangqing Jia, Rahul Sukthankar, and Alexander C Berg. Matchnet: Unifying feature and metric learning for patch-based matching. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3279–3286, 2015.
+
+Richard I Hartley. In defense of the eight-point algorithm. IEEE Transactions on pattern analysis and machine intelligence, 19(6):580–593, 1997.
+
+Heiko Hirschmuller. Accurate and efficient stereo processing by semi-global matching and mutual information. In 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’05), volume 2, pp. 807–814. IEEE, 2005.
+
+Sepp Hochreiter, A Steven Younger, and Peter R Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, pp. 87–94. Springer, 2001.
+
+Sunghoon Im, Hae-Gon Jeon, Stephen Lin, and In So Kweon. Dpsnet: End-to-end deep plane sweep stereo. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $=$ ryeYHi0ctQ.
+
+He Kaiming, Zhang Xiangyu, Ren Shaoqing, and Jian Sun. Spatial pyramid pooling in deep convolutional networks for visual recognition. In European Conference on Computer Vision (ECCV), 2014.
+
+Yevhen Kuznietsov, Jorg Stuckler, and Bastian Leibe. Semi-supervised deep learning for monocular depth map prediction. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Iro Laina, Christian Rupprecht, Vasileios Belagiannis, Federico Tombari, and Nassir Navab. Deeper depth prediction with fully convolutional residual networks. In 2016 Fourth International Conference on 3D Vision (3DV), pp. 239–248. IEEE, 2016.
+
+Fayao Liu, Chunhua Shen, Guosheng Lin, and Ian Reid. Learning depth from single monocular images using deep convolutional neural fields. IEEE transactions on pattern analysis and machine intelligence, 38(10):2024–2039, 2016.
+
+MLA Lourakis and Antonis A Argyros. Is levenberg-marquardt the most efficient optimization algorithm for implementing bundle adjustment? In Tenth IEEE International Conference on Computer Vision (ICCV’05) Volume 1, volume 2, pp. 1526–1531. IEEE, 2005.
+
+David G Lowe. Distinctive image features from scale-invariant keypoints. International journal of computer vision, 60(2):91–110, 2004.
+
+Raul Mur-Artal and Juan D Tardós. Orb-slam2: An open-source slam system for monocular, stereo, and rgb-d cameras. IEEE Transactions on Robotics, 33(5):1255–1262, 2017.
+
+Raul Mur-Artal, Jose Maria Martinez Montiel, and Juan D Tardos. Orb-slam: a versatile and accurate monocular slam system. IEEE transactions on robotics, 31(5):1147–1163, 2015.
+
+Richard A Newcombe, Steven J Lovegrove, and Andrew J Davison. Dtam: Dense tracking and mapping in real-time. In 2011 international conference on computer vision, pp. 2320–2327. IEEE, 2011.
+
+Jorge Nocedal and Stephen Wright. Numerical optimization. Springer Science & Business Media, 2006.
+
+Johannes L Schonberger and Jan-Michael Frahm. Structure-from-motion revisited. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4104–4113, 2016.
+
+Noah Snavely. Scene reconstruction and visualization from internet photo collections: A survey. IPSJ Transactions on Computer Vision and Applications, 3:44–66, 2011.
+
+Frank Steinbrücker, Jürgen Sturm, and Daniel Cremers. Real-time visual odometry from dense rgb-d images. In 2011 IEEE International Conference on Computer Vision Workshops (ICCV Workshops), pp. 719–722. IEEE, 2011.
+
+Jürgen Sturm, Nikolas Engelhard, Felix Endres, Wolfram Burgard, and Daniel Cremers. A benchmark for the evaluation of rgb-d slam systems. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 573–580. IEEE, 2012.
+
+Chengzhou Tang and Ping Tan. Ba-net: Dense bundle adjustment network. arXiv preprint arXiv:1806.04807, 2018.
+
+Zachary Teed and Jia Deng. Deepv2d: Video to depth with differentiable structure from motion. arXiv preprint arXiv:1812.04605, 2018.
+
+Bill Triggs, Philip F McLauchlan, Richard I Hartley, and Andrew W Fitzgibbon. Bundle adjustment—a modern synthesis. In International workshop on vision algorithms, pp. 298–372. Springer, 1999.
+
+Benjamin Ummenhofer, Huizhong Zhou, Jonas Uhrig, Nikolaus Mayer, Eddy Ilg, Alexey Dosovitskiy, and Thomas Brox. Demon: Depth and motion network for learning monocular stereo. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5038– 5047, 2017.
+
+Sudheendra Vijayanarasimhan, Susanna Ricco, Cordelia Schmid, Rahul Sukthankar, and Katerina Fragkiadaki. Sfm-net: Learning of structure and motion from video. arXiv preprint arXiv:1704.07804, 2017.
+
+Chaoyang Wang, José Miguel Buenaposada, Rui Zhu, and Simon Lucey. Learning depth from monocular videos using direct methods. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2022–2030, 2018.
+
+Peng Wang, Xiaohui Shen, Zhe Lin, Scott Cohen, Brian Price, and Alan L. Yuille. Towards unified depth and semantic prediction from a single image. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.
+
+Sen Wang, Ronald Clark, Hongkai Wen, and Niki Trigoni. Deepvo: Towards end-to-end visual odometry with deep recurrent convolutional neural networks. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pp. 2043–2050. IEEE, 2017.
+
+Changchang Wu, Sameer Agarwal, Brian Curless, and Steven M Seitz. Multicore bundle adjustment. In CVPR 2011, pp. 3057–3064. IEEE, 2011a.
+
+Changchang Wu et al. Visualsfm: A visual structure from motion system. 2011b.
+
+Jianxiong Xiao, Andrew Owens, and Antonio Torralba. Sun3d: A database of big spaces reconstructed using sfm and object labels. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1625–1632, 2013.
+
+Yao Yao, Zixin Luo, Shiwei Li, Tian Fang, and Long Quan. Mvsnet: Depth inference for unstructured multi-view stereo. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 767–783, 2018.
+
+Tinghui Zhou, Matthew Brown, Noah Snavely, and David G Lowe. Unsupervised learning of depth and ego-motion from video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1851–1858, 2017.
+
+![](images/82aa82d94f6cdad0bad2a4bfbc9a3ef894b5ee7c833ffa4f7e8ab2cfaef8e7c6.jpg)  
+Figure 4: Detail architecture of feature extractor.
+
+# A IMPLEMENTATION DETAILS
+
+Feature extraction module As shown in Figure 4, we build our feature extraction module referring to DPSNet (Im et al., 2019). The module takes $4 W \times 4 H \times 3$ images as input and output feature maps of size $W \times H \times 3 2$ , which are used to build D-CV and P-CV.
+
+Cost volumes Figure 5 shows the detailed components for the P-CV and D-CV. Each channel of cost volume is composed of four components: reference view feature maps, warped source view feature maps, the warped source view initial depth map and the projected reference view depth plane or initial depth map. For P-CV construction, we take each sampled hypothetical camera pose, and carry out the warping process on source view depth maps and initial depth map based on the camera pose. And the initial reference view depth map is projected to align numeric values with the warped source view depth map. Finally those four components are concatenated as one channel of 4D P-CV. We do this on all P sampled camera poses, and get the P channel P-CV. The building approach for D-CV is similar, we take each sampled hypothetical depth plane, and carry out warping process on source view feature maps and the initial depth map. And the depth plane is projected to align with the source view depth map. After concatenation, one channel in D-CV is got. Same computation is done based on all L virtual depth planes, and the L channel D-CV is built up.
+
+![](images/3ba50161d35ea26d1065e2a10ed33e236b8823d86d19b9b271a570432fc77675.jpg)  
+Figure 5: Four components in D-CV or P-CV.
+
+<table><tr><td rowspan="3">Method</td><td colspan="5">Depth</td><td colspan="2">Motion</td></tr><tr><td>abs_rel</td><td>sq_rel</td><td>rms</td><td>log_rms</td><td>sc_inv</td><td>Rot</td><td>Trans</td></tr><tr><td>Ours</td><td>0.227</td><td>0.170</td><td>0.479</td><td>0.271</td><td>0.268</td><td>1.588</td><td>30.613</td></tr><tr><td>BA-Net</td><td>0.238</td><td>0.176</td><td>0.488</td><td>0.279</td><td>0.276</td><td>1.587</td><td>31.005</td></tr><tr><td>DeMoN</td><td>0.231</td><td>0.520</td><td>0.761</td><td>0.289</td><td>0.284</td><td>3.791</td><td>31.626</td></tr><tr><td>LSD-SLAM</td><td>0.268</td><td>0.427</td><td>0.788</td><td>0.330</td><td>0.323</td><td>4.409</td><td>34.360</td></tr><tr><td>Geometric BA</td><td>0.382</td><td>1.163</td><td>0.876</td><td>0.366</td><td>0.357</td><td>8.560</td><td>39.392</td></tr></table>
+
+Table 3: Results on ScanNet. (sc_inv: scale invariant log rms; Bold: best.)
+
+3D convolutional layers The detail architecture of 3D convolutional layers after D-CV is almost the same as DPSNet (Im et al., 2019), except for the fist convolution layer. In order to compatible with the newly introduced depth consistent components in D-CV, We adjust the input channel number to 66 instead of 64. As shown in Figure 6, for 3D convolutional layers after P-CV, the architecture is similar to D-CV 3D convolution layers with three extra 3D average pooling layers and finally there is one global average pooling in the dimensions of image width and height, after which we get a $P \times 1 \times 1$ tensor.
+
+# B EVALUATION ON SCANNET
+
+ScanNet provides a large set of indoor sequences with camera poses and depth maps captured from a commodity RGBD sensor. Following BA-Net, we leverage this dataset to evaluate the generalization capability by training models on DeMoN and testing here. The testing set is the same as BA-Net, which takes 2000 pairs filtered from 100 sequences.
+
+We evaluate the generalization capability of DeepSFM on ScanNet. Table 3 shows the quantitative evaluation results for models trained on DeMoN. The results of BA-Net, DeMoN, LSD-SLAM and Geometric BA are obtained from Tang & Tan (2018). As can be seen, our method significantly outperforms all previous work, which indicates that our model generalizes well to general indoor environments.
+
+![](images/fca6b0e5f5130467df98ed3f4fd31833a302b11d8ee0e4c40341da6e3f63944f.jpg)  
+Figure 6: 3D convolutional layers After P-CV.
+
+Table 4: The performance of the optimization iterations for testing.   
+
+<table><tr><td></td><td>Initialization</td><td>Iteration 2</td><td>Iteration 4</td><td>Iteration 6</td><td>Iteration 10</td><td>Iteration 20</td></tr><tr><td>abs relative</td><td>0.254</td><td>0.153</td><td>0.126</td><td>0.121</td><td>0.120</td><td>0.120</td></tr><tr><td>log rms</td><td>0.248</td><td>0.195</td><td>0.191</td><td>0.190</td><td>0.190</td><td>0.191</td></tr><tr><td>translation</td><td>15.20</td><td>9.75</td><td>9.73</td><td>9.73</td><td>9.73</td><td>9.73</td></tr><tr><td>rotation</td><td>2.38</td><td>1.43</td><td>1.40</td><td>1.39</td><td>1.39</td><td>1.39</td></tr></table>
+
+# C SUPPLEMENTAL ABLATION STUDY
+
+More Iterations for Testing. We take up to four iterations when we train DeepSFM. During inference, the predicted depth maps and camera poses of previous iteration are taken as initialization of next iteration. To show how DeepSFM performs with more iterations than it is trained with, we show results in Table 4. We tested with up to 20 iterations, and it converges at the 6-th iteration.
+
+Bilinear Interpolation vs Nearest Neighbor Sampling. For the construction of D-CV and P-CV, depth maps are warped via the nearest neighbor sampling instead of bilinear interpolation. Due to the discontinuity of the depth values in depth maps, the bilinear interpolation may bring some side effects. It may do damage to the geometry consistency and smooth the depth boundaries. As a comparison, we replace the nearest neighbor sampling with the bilinear interpolation. As shown in Table 5, the performance of our model gains a slight drop with the bilinear interpolation, which indicates that the nearest neighbor sampling method is indeed more geometrically meaningful for depth. In contrast, the differentiable bilinear interpolation is required for the warping of image features, whose gradients are back propagated to feature extractor layers. Further exploration will be an interesting future work.
+
+Table 5: The performance with different warping methods.   
+
+<table><tr><td>MVS Dataset</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td></tr><tr><td>Billinear interpolation</td><td>0.023</td><td>0.134</td><td>0.079</td><td>2.867</td><td>9.910</td></tr><tr><td>Nearest neighbor</td><td>0.021</td><td>0.129</td><td>0.076</td><td>2.824</td><td>9.881</td></tr></table>
+
+# D VISUALIZATION
+
+We show some qualitative comparison with the previous methods. Since there are no source code available for BA-Net (Tang & Tan, 2018), we compare the visualization results of our method with DeMoN (Ummenhofer et al., 2017) and COLMAP (Schonberger & Frahm, 2016). Figure 7 shows the predicted dense depth map by our method and DeMoN on the DeMoN datasets. As we can see, demon often miss some details in the scene, such as plants, keyboard and table legs. In contrast, our method reconstructs more shape details. Figure 8 shows some estimated results from COLMAP and our method on the ETH3D dataset. As shown in the figure, the outputs from COLMAP are often incomplete, especially in textureless area. On the other hand, our method performs better and always produce an integral depth map. In Figure 9, more qualitative comparisons with COLMAP on challenging materials are provided.
+
+![](images/d1d8e78470fe8ea9e33858a875cf60eb3ac9db9f442d830215aa50f08f0c7dec.jpg)  
+Figure 7: Qualitative Comparisons with DeMoN (Ummenhofer et al., 2017) on DeMoN datasets.
+
+![](images/f6ce758d60ed49790987198ba31a9f2c749b569adaf7675d4e9bb17289aecf36.jpg)  
+Figure 8: Qualitative Comparisons with COLMAP (Schonberger & Frahm, 2016) on ETH3D datasets.
+
+![](images/eaaa27d867a2a1f0a7855b26aaf316d001b34d4873c902502606794e36f11bb7.jpg)  
+Figure 9: Qualitative Comparisons with COLMAP (Schonberger & Frahm, 2016) on challenging materials. a) Textureless ground and wall. b) Poor illumination scene. c) Reflective and transparent glass wall. d) Reflective and textureless wall.

parse/train/SyeD0RVtvS/SyeD0RVtvS_content_list.json

@@ -0,0 +1,1747 @@
+[
+    {
+        "type": "text",
+        "text": "DEEPSFM: STRUCTURE FROM MOTION VIA DEEP BUNDLE ADJUSTMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Structure from motion (SfM) is an essential computer vision problem which has not been well handled by deep learning. One of the promising trends is to apply explicit structural constraint, e.g. 3D cost volume, into the network. In this work, we design a physical driven architecture, namely DeepSFM, inspired by traditional Bundle Adjustment (BA), which consists of two cost volume based architectures for depth and pose estimation respectively, iteratively running to improve both. In each cost volume, we encode not only photo-metric consistency across multiple input images, but also geometric consistency to ensure that depths from multiple views agree with each other. The explicit constraints on both depth (structure) and pose (motion), when combined with the learning components, bring the merit from both traditional BA and emerging deep learning technology. Extensive experiments on various datasets show that our model achieves the state-of-the-art performance on both depth and pose estimation with superior robustness against less number of inputs and the noise in initialization. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            458
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            482,
+            336,
+            498
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Structure from motion (SfM) is a fundamental human vision functionality which recovers 3D structures from the projected retinal images of moving objects or scenes. It enables machines to sense and understand with the 3D world and is critical in achieving real-world artificial intelligence. Over decades of researches, there has been a lot of great success on SfM; however, the performance is far from perfect. ",
+        "bbox": [
+            174,
+            512,
+            823,
+            582
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conventional SfM approaches (Agarwal et al., 2011; Wu et al., 2011a; Engel et al., 2017; Delaunoy & Pollefeys, 2014) heavily rely on Bundle-Adjustment (BA) (Triggs et al., 1999; Agarwal et al., 2010), in which 3D structures and camera motions of each view are jointly optimized via LevenbergMarquardt (LM) algorithm (Nocedal & Wright, 2006) according to the cross-view correspondence. Though successful in certain scenarios, conventional SfM based approaches are fundamentally restricted by the coverage of the provided multiple views and the overlaps among them. They also typically fail to reconstruct textureless or non-lambertian (e.g. reflective or transparent) surfaces due to the missing of correspondence across views. As a result, selecting sufficiently good input views and the right scene requires excessive caution and is usually non-trivial to even experienced user. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            715
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent researches resort to deep learning to deal with the typical weakness of conventional SfM. Early effort utilizes deep neural network as a powerful mapping function that directly regresses the structures and motions (Ummenhofer et al., 2017; Vijayanarasimhan et al., 2017; Zhou et al., 2017; Wang et al., 2017). Since the geometric constraints of structures and motions are not explicitly enforced, the network does not learn the underlying physics and prone to overfitting. Consequently, they do not perform as accurate as conventional SfM approaches and suffer from extremely poor generalization capability. Most recently, the 3D cost volume (Teed & Deng, 2018) has been introduced to explicit leveraging photo-consistency in a differentiable way, which significantly boosts the performance of deep learning based 3D reconstruction. However, the camera motion usually has to be known (Yao et al., 2018; Im et al., 2019) or predicted via direct regression (Ummenhofer et al., 2017; Zhou et al., 2017; Teed & Deng, 2018), which still suffer from generalization issue. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we explicitly enforce photo-consistency, geometric-consistency, and camera motion constraints in a unified deep learning framework. In particular, our network includes a depth based cost volume (D-CV) and a pose based cost volume (P-CV). D-CV optimizes per-pixel depth values with the current camera poses, while P-CV optimizes camera poses with the current depth estimations. Conventional 3D cost volume enforces photo-consistency by unprojecting pixels into the discrete camera fronto-parallel planes and computing the photometric (i.e. image feature) difference as the cost. In addition to that, our D-CV further enforces geometric-consistency among cameras with their current depth estimations by adding the geometric (i.e. depth) difference to the cost. Note that the initial depth estimation can be obtained using the conventional 3D cost volume. For pose estimation, rather than direct regression, our P-CV discretizes around the current camera positions, and also computes the photometric and/or geometric differences by hypothetically moving the camera into the discretized position. Note that the initial camera pose can be obtained by a rough estimation from the direct regression methods such as (Ummenhofer et al., 2017). Our framework bridges the gap between the conventional and deep learning based SfM by incorporating explicit constraints of photo-consistency, geometric-consistency and camera motions all in the deep network. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The closest work in the literature is the recently proposed BA-Net (Tang & Tan, 2018), which also aims to explicitly incorporate multi-view geometric constraints in a deep learning framework. They achieve this goal by integrating the LM optimization into the network. However, the LM iterations are unrolled with few iterations due to the memory and computational inefficiency, and thus it may lead to non-optimal solutions. In contrast, our method does not have a restriction on the number of iterations and achieves empirically better performance. Furthermore, LM in SfM originally optimizes point and camera positions, and thus direct integration of LM still requires good correspondences. To evade the correspondence issue in typical SfM, their models employ a direct regressor to predict depth at the front end, which heavily relies on prior in the training data. In contrast, our model is a fully physical-driven architecture that less suffers from over-fitting issue for both depth and pose estimation. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            430
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the superiority of our method, we conduct extensive experiments on DeMoN datasets, ScanNet and ETH3D. The experiments show that our approach outperforms the state-ofthe-art Schonberger & Frahm (2016); Ummenhofer et al. (2017); Tang & Tan (2018). ",
+        "bbox": [
+            176,
+            438,
+            823,
+            479
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            506,
+            339,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There is a large body of work that focuses on inferring depth or motion from color images, ranging from single view, multiple views and monocular video. We discuss them in the context of our work. ",
+        "bbox": [
+            174,
+            540,
+            823,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Single-view Depth Estimation. While ill-posed, the emerging of deep learning technology enables the estimation of depth from a single color image. The early work directly formulates this into a per-pixel regression problem (Eigen et al., 2014), and follow-up works improve the performance by introducing multi-scale network architectures (Eigen et al., 2014; Eigen & Fergus, 2015), skipconnections (Wang et al., 2015; Liu et al., 2016), powerful decoder and post process (Garg et al., 2016; Laina et al., 2016; Kuznietsov et al., 2017; Wang et al., 2015; Liu et al., 2016), and new loss functions (Fu et al., 2018). Even though single view based methods generate plausible results, the models usually resort heavily to the prior in the training data and suffer from generalization capability. Nevertheless, these methods still act as an important component in some multi-view systems (Tang & Tan, 2018) ",
+        "bbox": [
+            174,
+            575,
+            825,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Traditional Structure-from-Motion Simultaneously estimating 3d structure and camera motion is a well studied problem which has a traditional tool-chain of techniques (Furukawa et al., 2010; Newcombe et al., 2011; Wu et al., 2011b). Structure from Motion(SfM) has made great progress in many aspects. Lowe (2004); Han et al. (2015) aim at improving features and Snavely (2011) introduce new optimization techniques. More robust structures and data representations are introduced by Gherardi et al. (2010); Schonberger & Frahm (2016). Simultaneous Localization and Sapping(SLAM) systems track the motion of the camera and build 3D structure from video sequence (Newcombe et al., 2011; Engel et al., 2014; Mur-Artal et al., 2015; Mur-Artal & Tardós, 2017). Engel et al. (2014) propose the photometric bundle adjustment algorithm to directly minimize the photometric error of aligned pixels. However, traditional SfM and SLAM methods are sensitive to low texture region, occlusions, moving objects and lighting changes, which limit the performance and stability. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep Learning for Structure-from-Motion Deep neural networks have shown great success in stereo matching and Structure-from-Motion problems. Ummenhofer et al. (2017); Wang et al. (2017); Vijayanarasimhan et al. (2017); Zhou et al. (2017) regress depth map and camera pose directly in a supervised manner or by introducing photometric constraints between depth and motion as a self-supervision signal. Such methods solve the camera motion as a regression problem, and the relation between camera motion and depth prediction is neglected. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f3457766b539a218a007e3afc9869af94fe3e63eee69596ebe607ac992c5a31.jpg",
+        "image_caption": [
+            "Figure 1: Overview of our method. 2D CNN is used to extract photometric feature to construct cost volumes. Initial source depth maps are used to introduce geometry consistency. A series of 3D CNN layers are applied for both pose based cost volume and D-CV. Then a context network and depth regression operation are applied to produce predicted depth map of reference image. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            98,
+            800,
+            295
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            392,
+            823,
+            434
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, some methods exploit multi-view photometric or feature-metric constraints to enforce the relationship between dense depth map and the camera pose in network. The SE3 transformer layer is introduced by Teed & Deng (2018), which uses geometry to map flow and depth into a camera pose update. Wang et al. (2018) propose the differentiable camera motion estimator based on the Direct Visual Odometry (Steinbrücker et al., 2011). Clark et al. (2018) using a LSTM-RNN (Hochreiter et al., 2001) as the optimizer to solve nonlinear least squares in two-view SfM. Tang & Tan (2018) train a network to generate a set of basis depth maps and optimize depth and camera poses in a BA-layer by minimizing a feature-metric error. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            553
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            573,
+            339,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our framework receives frames of a scene from different viewpoints, and produces photo-metrically and geometrically consistent depth maps across all frames and the corresponding camera poses. Similar to BA, we also assume initial structures (i.e depth maps) and motions (i.e. camera poses) are given. Note that the initialization is not necessary to be super accurate for the good performance using our framework and thus can be easily obtained from some direct regression methods (Ummenhofer et al., 2017). ",
+        "bbox": [
+            174,
+            603,
+            825,
+            688
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Now we introduce the detail of our model – DeepSFM. Without loss of generality, we describe our model taking two images as input, namely the reference image and the source image, as an example, and all the technical components can be extended for multiple images straightforward. As shown in Figure 1, we first extract feature maps from input images through a shared encoder. We then sample the solution space for depth uniformly in the inverse-depth space between a predefined minimum and maximum range and camera pose around the initialization respectively. After that, we build cost volumes accordingly to reason the confidence of each hypothesis. This is achieved by validating the consistency between the feature of the reference view and the ones warped from the source image. Besides photo-metric consistency that measures the color image similarity, we also take into account the geometric consistency across warped depth maps. Note that depth and pose require different designs of cost volume to efficiently sample the hypothesis space. Gradients can back-propagate through cost volumes, and cost-volume construction does not affect any trainable parameters. The cost volumes are then fed into 3D CNN to regress new depth and pose. These updated value can be used to create new cost volumes, and the model improves the prediction iteratively. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For notations, we denote $\\{ \\mathbf { I } _ { i } \\} _ { i = 1 } ^ { n }$ as the image sequences in one scene, $\\{ \\mathbf { D } _ { i } \\} _ { i = 1 } ^ { n }$ as the corresponding ground truth depth maps, $\\{ { \\bf K } _ { i } \\} _ { i = 1 } ^ { n }$ as the camera intrinsics, $\\{ \\mathbf { R } _ { i } , \\mathbf { t } _ { i } \\} _ { i = 1 } ^ { n }$ as the ground truth rotations and translations of camera, $\\{ \\mathbf { D } _ { i } ^ { * } \\} _ { i = 1 } ^ { n }$ and $\\{ \\mathbf { R } _ { i } ^ { * } , \\mathbf { t } _ { i } ^ { * } \\} _ { i = 1 } ^ { n }$ as initial depth maps and camera pose parameters for constructing cost volumes, where $n$ is the number of image samples. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 2D FEATURE EXTRACTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            401,
+            164
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given the input sequences $\\{ \\mathbf { I } _ { i } \\} _ { i = 1 } ^ { n }$ , we extract the 2D CNN feature $\\{ \\mathbf { F } _ { i } \\} _ { i = 1 } ^ { n }$ for each frame. Firstly, a 7 layers’ CNN with kernel size $3 \\times 3$ is applied to extract low contextual information. Then we adopt a spatial pyramid pooling (SPP) (Kaiming et al., 2014) module, which can extract hierarchical multiscale features through 4 average pooling blocks with different pooling kernel size $( 4 \\times 4 , 8 \\times 8$ , $1 6 \\times$ $1 6 , 3 2 \\times 3 2 )$ . Finally, we pass the concatenated features through 2D CNNs to get the 32-channel image features after upsampling these multi-scale features into the same resolution. These image sequence features are used by the building of both our depth based and pose based cost volumes. ",
+        "bbox": [
+            173,
+            174,
+            825,
+            273
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 DEPTH BASED COST VOLUME (D-CV) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            290,
+            482,
+            305
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Traditional plane sweep cost volume aims to back-project the source images onto successive virtual planes in the 3D space and measure photo-consistency error among the warped image features and reference image features for each pixel. Different from the cost volume used in previous multiview and structure-from-motion methods, we construct a D-CV to further utilize the local geometric consistency constraints introduced by depth maps. Inspired by the traditional plane sweep cost volumes, our D-CV is a concatenation of three components: the reference image features, the warped source image features and the homogeneous depth consistency maps. ",
+        "bbox": [
+            173,
+            316,
+            825,
+            415
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hypothesis Sampling To back-project the features and depth maps from source viewpoint to the 3D space in reference viewpoint, we uniformly sample a set of $L$ virtual planes $\\{ d _ { l } \\} _ { l = 1 } ^ { L }$ in the inverse-depth space which are perpendicular to the forward direction $z$ -axis) of the reference viewpoint. These planes serve as the hypothesis of the output depth map, and the cost volume can be built upon them. ",
+        "bbox": [
+            173,
+            429,
+            825,
+            500
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Feature warping. To construct our D-CV, we first warp source image features $\\mathbf { F } _ { i }$ (of size $C H a n n e l \\times W i d t h \\times H e i g h t )$ to each of the hypothetical depth map planes $d _ { l }$ using camera intrinsic matrix $\\mathbf { K }$ and initial camera poses $\\{ \\mathbf { R } _ { i } ^ { * } , \\mathbf { t } _ { i } ^ { * } \\}$ , according to: ",
+        "bbox": [
+            173,
+            515,
+            823,
+            559
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb434cd6d512b7ee55e2d12addf5b776c653a95a2260d22c434751e6b79668b4.jpg",
+        "text": "$$\n\\tilde { \\mathbf { F } } _ { i l } ( u ) = \\mathbf { F } _ { i } \\left( \\tilde { u } _ { l } \\right) , \\tilde { u } _ { l } \\sim \\mathbf { K } \\left[ \\mathbf { R } _ { i } ^ { * } | \\mathbf { t } _ { i } ^ { * } \\right] \\left[ \\begin{array} { c } { \\left( \\mathbf { K } ^ { - 1 } u \\right) d _ { l } } \\\\ { 1 } \\end{array} \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            565,
+            668,
+            601
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $u$ and $\\tilde { u } _ { l }$ are the homogeneous coordinates of each pixel in the reference view and the projected coordinates onto the corresponding source view. $\\tilde { \\mathbf { F } } _ { i l } ( u )$ denotes the warped feature of the source image through the $l$ -th virtual depth plane. Note that the projected homogeneous coordinates $\\tilde { u } _ { l }$ are floating numbers, and we adopt a differentiable bilinear interpolation to generate the warped feature map $\\tilde { \\mathbf { F } } _ { i l }$ . The pixels with no source view coverage are assigned with zeros. Following Im et al. (2019), we concatenate the reference feature and the warped reference feature together and obtain a $2 C H \\times L \\times W \\times H$ 4D feature volume. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            708
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Depth consistency. In addition to photometric consistency, to exploit geometric consistency and promote the quality of depth prediction, we add two more channels on each virtual plane: the warped initial depth maps from the source view and the depth map of the virtual plane from the perspective of the source view. Note that the former is the same as image feature warping, while the latter requires a coordinate transformation from the reference camera to the source camera. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            794
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In particular, the first channel is computed as follows. The initial depth map of source image is first down-sampled and then warped to hypothetical depth planes based on initial camera pose similarly to the image feature warping: ",
+        "bbox": [
+            173,
+            799,
+            825,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ae79777b8be47e06d385838ecffefb98c0495abe9abc1678baf2ed4ca53a12c.jpg",
+        "text": "$$\n\\tilde { \\mathbf { D } } _ { i l } ^ { * } ( u ) = \\mathbf { D } _ { i } ^ { * } \\left( \\tilde { u } _ { l } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            840,
+            558,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the coordinates $u$ and $\\tilde { u } _ { l }$ are defined in Eq. 1 and $\\tilde { \\mathbf { D } } _ { i l } ^ { * } ( u )$ represents the warped one-channel depth map on the $l$ -th depth plane. One distinction between depth warping and feature warping is that we adopt nearest neighbor sampling for depth warping, instead of bilinear interpolation. A comparison between the two methods are provided in Appendix C. ",
+        "bbox": [
+            174,
+            866,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The second channel contains the depth values of the virtual planes in the reference view by seeing them from the source view. To transform the virtual planes to the source view coordinate system, we apply a $T$ function on each virtual plane $d _ { l }$ in the following: ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b416881f855ec64179cc7d9169365fc14b90ad5a4e19b0b5c5b8f5934e19d1b7.jpg",
+        "text": "$$\nT ( d _ { l } ) \\sim [ \\mathbf { R } _ { i } ^ { * } | \\mathbf { t } _ { i } ^ { * } ] \\left[ \\begin{array} { c } { \\left( \\mathbf { K } ^ { - 1 } u \\right) d _ { l } } \\\\ { 1 } \\end{array} \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            157,
+            611,
+            194
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We stack the warped initial depth maps and the transformed depth planes together, and get a depth volume of size $2 \\times L \\times W \\times H$ . ",
+        "bbox": [
+            171,
+            204,
+            823,
+            233
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By concatenating the feature volume and depth volume together, we obtain a 4D cost tensor of size $( 2 C H + 2 ) \\times L \\times W \\times H$ . Given the 4D cost volume, our network learns a cost volume of size $L \\times W \\times H$ using several 3D convolutional layers with kernel size $3 \\times 3 \\times 3$ . When there is more than one source image, we get the final cost volume by averaging over multiple input source views. ",
+        "bbox": [
+            174,
+            239,
+            825,
+            296
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 POSE BASED COST VOLUME (P-CV) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            319,
+            468,
+            334
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In addition to the construction of D-CV, we also propose a P-CV, aiming at optimizing initial camera poses through both photometric and geometric consistency. Instead of building a cost volume based on hypothetical depth map planes, our novel P-CV is constructed based on a set of assumptive camera poses. Similar to D-CV, P-CV is also concatenated by three components: the reference image features, the warped source image features and the homogeneous depth consistency maps. Given initial camera pose parameters $\\{ \\mathbf { R } _ { i } ^ { * } , \\mathbf { t } _ { i } ^ { * } \\}$ , we uniformly sample a batch of discrete candidate camera poses around. Since jointly sampling camera rotation and translation along 6-DoF is costly, we shift rotation and translation separately by keeping one frozen while sampling the other one. In the end, a group of $P$ virtual camera poses noted as $\\{ \\bar { \\mathbf { R } } _ { i p } ^ { * } | \\mathbf { t } _ { i p } ^ { * } \\} _ { p = 1 } ^ { P }$ around input pose are obtained for cost volume construction. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            488
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The posed-based cost volume is also constructed by concatenating image features and homogeneous depth maps. However, source view features and depth maps are warped based on sampled camera poses. For feature warping, we compute $\\tilde { u } _ { p }$ as following equations: ",
+        "bbox": [
+            174,
+            494,
+            825,
+            536
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60507974328199071613aa16551a92bf5ecece6eb78a1e57a1cc3482427823ce.jpg",
+        "text": "$$\n\\tilde { u } _ { p } \\sim { \\bf K } \\left[ { \\bf R } _ { i p } ^ { * } | \\mathbf { t } _ { i p } ^ { * } \\right] \\left[ \\begin{array} { c } { \\left( { \\bf K } ^ { - 1 } u \\right) { \\bf D } _ { i } ^ { * } } \\\\ { 1 } \\end{array} \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            549,
+            617,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { D } _ { i } ^ { * }$ is the initial reference view depth. Similar to D-CV, we get warped source feature map $\\tilde { \\mathbf { F } } _ { i p }$ after bilinear sampling and concatenate it with reference view feature map. We also transform the initial reference view depth and source view depth into one homogeneous coordinate system, which enhances the geometric consistency between camera pose and multi view depth maps. ",
+        "bbox": [
+            173,
+            597,
+            825,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After concatenating the above feature maps and depth maps together, we again build a 4D cost volume of size $( 2 C H + 2 ) \\times P \\times W \\times H$ , where $W$ and $H$ are the width and height of feature map, $C H$ is the number of channels. We get output of size $1 \\times P \\times 1 \\times 1$ from the above 4-D tensor after eight 3D convolutional layers with kernel size $3 \\times 3 \\times 3$ , three 3D average pooling layers with stride size $2 \\times 2 \\times 1$ and one global average pooling at the end. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            733
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 COST AGGREGATION AND REGRESSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            756,
+            490,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For depth prediction, we follow the cost aggregation technique introduced by Im et al. (2019). We adopt a context network, which takes reference image features and each slice of the coarse cost volume after 3D convolution as input and produce the refined cost slice. The final aggregated depth based volume is obtained by adding coarse and refined cost slices together. The last step to get depth prediction of reference image is depth regression. We pass each slice of D-CV through a soft-max function to get the probability of every depth value $l$ . Then the weighted sum of all hypothetical depth values is regarded as predicted depth map; this operation is called soft-argmax. We can also get the predicted coarse depth map by the same way using coarse D-CV. For camera poses prediction, we also apply a soft-argmax function on pose cost volume and get the estimated output rotation and translation vectors. ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The DeepSFM learns the feature extractor, cost aggregation, and the regression layers in a supervised way. We denote $\\hat { { \\bf R } } _ { i }$ and $\\hat { \\mathbf { t } } _ { i }$ as predicted rotation angles and translation vectors of camera pose. Then the pose loss function is defined as the $L 1$ distance between prediction and groundtruth: $\\mathcal { L } _ { r o t a t i o n } =$ $\\left| \\hat { \\mathbf { R } } _ { i } - \\mathbf { R } _ { i } \\right|$ and $\\mathcal { L } _ { t r a n s l a t i o n } = \\left| \\hat { \\mathbf { t } } _ { i } - \\mathbf { t } _ { i } \\right|$ . We denote $\\hat { D } _ { i } ^ { 0 }$ and $\\hat { D } _ { i }$ as predicted coarse depth map and refined depth map for the $i$ -th image, then the depth loss function is defined as following equation: ",
+        "bbox": [
+            173,
+            128,
+            825,
+            212
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2128075f30418c774f93ecfed253ddfceb29ea8f018b5b6dee202788c1e11579.jpg",
+        "text": "$$\n\\mathcal { L } _ { d e p t h } = \\sum _ { i } \\lambda H ( \\hat { D } _ { i } ^ { 0 } , \\mathbf { D } _ { i } ) + H ( \\hat { D } _ { i } , \\mathbf { D } _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            217,
+            633,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is weight parameter and function $H$ is Huber loss. ",
+        "bbox": [
+            173,
+            256,
+            560,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our final objective becomes ",
+        "bbox": [
+            173,
+            277,
+            359,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/52777dfe306a0c6e789ff192e6cc9b4b83dbd2becffa129c220e5e097e0291a3.jpg",
+        "text": "$$\n\\mathcal { L } _ { f i n a l } = \\lambda _ { r } \\mathcal { L } _ { r o t a t i o n } + \\lambda _ { t } \\mathcal { L } _ { t r a n s l a t i o n } + \\lambda _ { d } \\mathcal { L } _ { d e p t h }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            299,
+            671,
+            316
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We follow two rules to set $\\lambda _ { r }$ , $\\lambda _ { t }$ and $\\lambda _ { d } \\colon 1 \\ \\mathrm { , }$ ) the loss term provides gradient on the same order of numerical value range, such that no single loss term could dominate the training process, since accuracy in depth and camera pose are both important to reach a good consensus. 2) we found in practice the camera rotation has higher impact on the accuracy of the depth but not the opposite. To encourage better performance of pose, we set a relatively large $\\lambda _ { r }$ . In practice, the weight parameter $\\lambda$ to balance loss objective is set to 0.7, while $\\lambda _ { r } = 0 . 8$ , $\\lambda _ { t } = 0 . 1$ and $\\lambda _ { d } = 0 . 1$ . ",
+        "bbox": [
+            174,
+            329,
+            825,
+            415
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The RGB sequences, corresponding ground-truth depth maps and camera intrinsics and extrinsics are fed as input samples. We initialize the 2D feature extraction layers with pre-trained DPSNet weight. The initial depth maps and camera poses $\\{ \\mathbf { D } _ { i } ^ { * } \\} _ { i = 1 } ^ { n }$ and $\\{ \\mathbf { R } _ { i } ^ { * } , \\mathbf { \\bar { t } } _ { i } ^ { * } \\} _ { i = 1 } ^ { n }$ are obtained from DeMoN. To keep correct scale, we multiply translation vectors and depth maps by the norm of the ground truth camera translation vector. The whole training and testing procedure are performed as four iterations. During each iteration, we take the predicted depth maps and camera poses of previous iteration as new $\\mathbf { \\bar { \\{ D } }  _ { i } ^ { * } \\} _ { i = 1 } ^ { n }$ and $\\{ \\mathbf { R } _ { i } ^ { * } , \\mathbf { t } _ { i } ^ { * } \\} _ { i = 1 } ^ { n }$ for cost volume construction. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We implement our system using PyTorch framework. The training procedure takes 6 days on 3 NVIDIA TITAN GPUs on all 160k training sequences. The training batch size is set to 4, and the Adam optimizer $( \\beta _ { 1 } = 0 . 9 , \\beta _ { 2 } = 0 . 9 9 9 )$ is used with learning rate $2 \\times 1 0 ^ { - 4 }$ , which decreases to $4 \\times 1 0 ^ { - 5 }$ after 2 epochs. Within the first two epochs, the parameters in 2D CNN feature extraction module are frozen, and the ground truth depth maps for source images are used to construct D-CV and P-CV, which are replaced with predicted depth maps from network in latter epochs. During training process, the length of input sequences is 2 (one reference image and one source image). The $L$ for D-CV is set to 64 and the $\\mathbf { N }$ for P-CV is 10. The range of both cost volumes is adapted during training and testing. ",
+        "bbox": [
+            173,
+            523,
+            825,
+            651
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            670,
+            326,
+            686
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            287,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate DeepSFM on widely used datasets and compare to state-of-the-art methods on accuracy and generalization capability. ",
+        "bbox": [
+            174,
+            728,
+            821,
+            757
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "DeMoN Datasets Proposed in DeMoN (Ummenhofer et al., 2017), this dataset contains data from various sources, including SUN3D (Xiao et al., 2013), RGB-D SLAM (Sturm et al., 2012), and Scenes11 (Chang et al., 2015). To test the generalization capability, we also evaluate on MVS (Fuhrmann et al., 2014) dataset but not use it for the training. In all four datasets, RGB image sequences and the ground truth depth maps are provided with the camera intrinsics and camera poses. Note that those datasets together provide a diverse set of both indoor and outdoor, synthetic and real-world scenes. Specifically, Scenes11 consists of synthetic images rendered from random scenes, on which ground truth camera poses and depth are perfect, but objects are lack of reality in scale and semantics. For training and testing, we use the same setting as DeMoN. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ETH3D Dataset ETH3D dataset provides a variety of indoor and outdoor scenes with highprecision ground truth 3D points captured by laser scanners, which is a more solid benchmark ",
+        "bbox": [
+            173,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b5db52a917ec07b9a43cc58113d0866ed6691311634e205bdabb3f2ff0635838.jpg",
+        "table_caption": [
+            "dataset. Ground truth depth maps are obtained by projecting the point clouds to each camera view. Raw images are in high resolution but resized to $8 1 0 \\times 5 4 0$ pixels for evaluation due to memory constraint. Again, all the models are trained on DeMoN and tested here. "
+        ],
+        "table_footnote": [
+            "Table 1: Results on MVS, SUN3D, RGBD and Scenes11, the best results are noted by Bold. "
+        ],
+        "table_body": "<table><tr><td>MVS</td><td colspan=\"3\">Depth</td><td colspan=\"2\">Motion</td><td>Scenes11</td><td colspan=\"2\">Depth</td><td colspan=\"3\"></td></tr><tr><td>Method</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td><td>Method</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td></tr><tr><td>Base-Oracle</td><td>0.019</td><td>0.197</td><td>0.105</td><td>0</td><td>0</td><td>Base-Oracle</td><td>0.023</td><td>0.618</td><td>0.349</td><td>0</td><td>0</td></tr><tr><td>Base-SIFT</td><td>0.056</td><td>0.309</td><td>0.361</td><td>21.180</td><td>60.516</td><td>Base-SIFT</td><td>0.051</td><td>0.900</td><td>1.027</td><td>6.179</td><td>56.650</td></tr><tr><td>Base-FF</td><td>0.055</td><td>0.308</td><td>0.322</td><td>4.834</td><td>17.252</td><td>Base-FF</td><td>0.038</td><td>0.793</td><td>0.776</td><td>1.309</td><td>19.426</td></tr><tr><td>Base-Matlab</td><td>-</td><td>-</td><td>-</td><td>10.843</td><td>32.736</td><td>Base-Matlab</td><td>-</td><td>-</td><td>-</td><td>0.917</td><td>14.639</td></tr><tr><td>DeMoN</td><td>0.047</td><td>0.202</td><td>0.305</td><td>5.156</td><td>14.447</td><td>DeMoN</td><td>0.019</td><td>0.315</td><td>0.248</td><td>0.809</td><td>8.918</td></tr><tr><td>LS-Net</td><td>0.051</td><td>0.221</td><td>0.311</td><td>4.653</td><td>11.221</td><td>LS-Net</td><td>0.010</td><td>0.410</td><td>0.210</td><td>4.653</td><td>8.210</td></tr><tr><td>BANet</td><td>0.030</td><td>0.150</td><td>0.080</td><td>3.499</td><td>11.238</td><td>BANet</td><td>0.080</td><td>0.210</td><td>0.130</td><td>3.499</td><td>10.370</td></tr><tr><td>Ours</td><td>0.021</td><td>0.129</td><td>0.079</td><td>2.824</td><td>9.881</td><td>Ours</td><td>0.007</td><td>0.112</td><td>0.064</td><td>0.403</td><td>5.828</td></tr><tr><td>RGB-D</td><td></td><td>Depth</td><td></td><td colspan=\"2\">Motion</td><td>Sun3D</td><td></td><td>Depth</td><td></td><td colspan=\"2\">Motion</td></tr><tr><td>Method</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td><td>Method</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td></tr><tr><td>Base-Oracle</td><td>0.026</td><td>0.398</td><td>0.36</td><td>0</td><td>0</td><td>Base-Oracle</td><td>0.020</td><td>0.241</td><td>0.220</td><td>0</td><td>0</td></tr><tr><td>Base-SIFT</td><td>0.050</td><td>0.577</td><td>0.703</td><td>12.010</td><td>56.021</td><td>Base-SIFT</td><td>0.029</td><td>0.290</td><td>0.286</td><td>7.702</td><td>41.825</td></tr><tr><td>Base-FF</td><td>0.045</td><td>0.548</td><td>0.613</td><td>4.709</td><td>46.058</td><td>Base-FF</td><td>0.029</td><td>0.284</td><td>0.297</td><td>3.681</td><td>33.301</td></tr><tr><td>Base-Matlab</td><td>-</td><td>-</td><td>-</td><td>12.813</td><td>49.612</td><td>Base-Matlab</td><td>-</td><td>-</td><td>-</td><td>5.920</td><td>32.298</td></tr><tr><td>DeMoN</td><td>0.028</td><td>0.130</td><td>0.212</td><td>2.641</td><td>20.585</td><td>DeMoN</td><td>0.019</td><td>0.114</td><td>0.172</td><td>1.801</td><td>18.811</td></tr><tr><td>LS-Net</td><td>0.019</td><td>0.090</td><td>0.301</td><td>1.010</td><td>22.100</td><td>LS-Net</td><td>0.015</td><td>0.189</td><td>0.650</td><td>1.521</td><td>14.347</td></tr><tr><td>BANet</td><td>0.008</td><td>0.087</td><td>0.050</td><td>2.459</td><td>14.900</td><td>BANet</td><td>0.015</td><td>0.110</td><td>0.060</td><td>1.729</td><td>13.260</td></tr><tr><td>Ours</td><td>0.011</td><td>0.071</td><td>0.126</td><td>1.862</td><td>14.570</td><td>Ours</td><td>0.013</td><td>0.093</td><td>0.072</td><td>1.704</td><td>13.107</td></tr></table>",
+        "bbox": [
+            173,
+            160,
+            826,
+            487
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            539,
+            305,
+            554
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DeMoN Datasets Our results on DeMoN datasets and the comparison to other methods are shown in Table 1. We cite results of some strong baseline methods from DeMoN paper, named as Base-Oracle, Base-SIFT, Base-FF and Base-Matlab respectively (Ummenhofer et al., 2017). Base-Oracle estimate depth with the ground truth camera motion using SGM (Hirschmuller, 2005). Base-SIFT, BaseFF and Base-Matlab solve camera motion and depth using feature, optical flow, and KLT tracking correspondence from 8-pt algorithm (Hartley, 1997). We also compare to some most recent stateof-the-art methods LS-Net (Clark et al., 2018) and BA-Net (Tang & Tan, 2018). LS-Net introduces the learned LSTM-RNN optimizer to minimizing photometric error for stereo reconstruction. BANet is the most recent work that minimizes the feature-metric error between multi-view via the differentiable Levenberg-Marquardt (Lourakis & Argyros, 2005) algorithm. ",
+        "bbox": [
+            173,
+            565,
+            825,
+            705
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To make a fair comparison, we adopt the same error metrics as DeMoN for depth and camera pose evaluation. L1-inv computes the disparity map errors, and sc-inv is a scale-invariant error metric. ",
+        "bbox": [
+            174,
+            712,
+            823,
+            741
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/09b5bbaba4c27746cd41e5e87503944ec039124ad1e5ab9982b5ee33af9a02e3.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 2: Results on ETH3D (Bold: best; $\\alpha = 1 . 2 5$ ). abs_rel, abs_diff, sq_rel, rms, and log_rms, are absolute relative error, absolute difference, square relative difference, root mean square and log root mean square, respectively. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"5\">Error metric</td><td colspan=\"3\">Accuracy metric(δ &lt;αt)</td></tr><tr><td>abs_rel</td><td>abs_diff</td><td>sq_rel</td><td>rms</td><td>log_rms</td><td>a</td><td>q</td><td>a3</td></tr><tr><td>COLMAP</td><td>0.324</td><td>0.615</td><td>36.71</td><td>2.370</td><td>0.349</td><td>86.5</td><td>90.3</td><td>92.7</td></tr><tr><td>DeMoN</td><td>0.191</td><td>0.726</td><td>0.365</td><td>1.059</td><td>0.240</td><td>73.3</td><td>89.8</td><td>95.1</td></tr><tr><td>Ours</td><td>0.127</td><td>0.661</td><td>0.278</td><td>1.003</td><td>0.195</td><td>84.1</td><td>93.8</td><td>96.9</td></tr></table>",
+        "bbox": [
+            196,
+            765,
+            802,
+            862
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "L1-rel measures the depth errors relative to the ground truth depth, which emphasize depth estimation of close range in the scene. For camera poses evaluation, the angles between the prediction and the ground truth rotation and translation are shown as Rot and Trans respectively. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our method outperforms all traditional baseline methods and DeMoN on both depth and camera poses. When compared to more recent LS-Net and BA-Net, our method produces better results in most metrics of the four datasets. On RGB-D dataset, our performance is comparable to the stateof-the-art due to relatively higher noise in the RGB-D ground truth. LS-Net trains an initialization network which regresses depth and motion directly before adding the LSTM-RNN optimizer. The performance of the RNN optimizer is highly affected by the accuracy of the regressed initialization. The depth results of LS-Net are consistently poorer than BA-Net and our method, despite better rotation parameters are estimated by LS-Net on RGB-D and Sun3D datasets with very good initialization. Our method is slightly inferior to BA-Net on the L1-rel metric, which is probably due to that we sample 64 virtual planes uniformly as the hypothetical depth set, while BA-Net optimizes depth prediction based on a set of 128-channel estimated basis depth maps that are more memory consuming but have more fine-grained results empirically. Despite all that, it is shown that our learned cost volumes with geometric consistency work better than the photometric bundle adjustment (e.g. used in BA-Net) in most scenes. In particular, we improve mostly on the Scenes11 dataset, where the ground truth is perfect but the input images contain a lot of texture-less regions, which are challenging to photo-consistency based methods. ",
+        "bbox": [
+            174,
+            154,
+            825,
+            375
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ETH3D We further test the generalization capability on ETH3D. We provide comparisons to COLMAP (Schonberger & Frahm, 2016) and DeMoN on ETH3D. COLMAP is a state-of-the-art Structure-from-Motion method, while DeMoN introduces a classical deep network architecture that fined as $\\begin{array} { r } { \\operatorname* { m a x } \\Bigl ( \\frac { y _ { i } ^ { * } } { y _ { i } } , \\frac { y _ { i } } { y _ { i } ^ { * } } \\Bigr ) } \\end{array}$ , and the thresholds are typically set as $[ 1 . 2 5 , 1 . 2 5 ^ { 2 } , 1 . 2 5 ^ { 3 } ]$ . In Table $\\delta$ 2, our method shows the best performance overall among all the comparison methods. Our method produces better results than DeMoN consistently, since we impose geometric and physical constraints onto network rather than learning to regress directly. When compared with COLMAP, our method performs better on most metrics. COLMAP behaves well in the accuracy metric (i.e. abs_diff). However, the presence of outliers is often observed in the predictions of COLMAP, which leads to poor performance in other metrics such as abs_rel and sq_rel, since those metrics are sensitive to outliers. We put more qualitative comparisons with COLMAP in Appendix C. For more comparison on generalization, another experiment on ScanNet is provided in Appendix B. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            569
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 MODEL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            585,
+            343,
+            599
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyze our model on several aspects to verify the optimality and show advantages over previous methods. ",
+        "bbox": [
+            173,
+            612,
+            823,
+            640
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/ef4b4efad999e3c3cdf431ef5f34c8301c4c1741ef44f24d2018370517f7635b.jpg",
+        "image_caption": [
+            "Figure 2: Comparison with baseline during iterations. Our work converges at a better position. (a) abs relative error and log RMSE. (b) rotation and translation degree error. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            218,
+            657,
+            779,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Iterative Improvement Our model can run iteratively to reduce the prediction error. Figure 2 (solid lines) shows our performance over iterations when initialized with the prediction from DeMoN. As can be seen, our model effectively reduces both depth and pose errors upon the DeMoN output. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Throughout the iterations, better depth and pose benefit each other by building more accurate cost volume, and both are consistently improved. The whole process is similar to coordinate descent algorithm, and finally converges at iteration 4. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Effect of P-CV We compare DeepSFM to a baseline method for our P-CV. In this baseline, the depth prediction is the same as DeepSFM, but the pose prediction network is replaced by a direct visual odometry model Steinbrücker et al. (2011), which updates camera parameters by minimizing pixel-wise photometric error between image features. Both methods are initialized with DeMoN results. As provided in Figure 2, DeepSFM consistently produces lower errors on both depth and pose over all the iterations. This shows that our P-CV predicts more accurate pose and performs more robust against noise depth at early stages. ",
+        "bbox": [
+            173,
+            152,
+            825,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/6b91aa781c2bca13017105bf80c05ab026ebc2968c1bafec058c3e3a8f268d6a.jpg",
+        "image_caption": [
+            "Figure 3: Depth map results w.r.t. the number of images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            217,
+            275,
+            776,
+            438
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "View Number DeepSFM works still reasonably well with fewer views due to the free from optimization based components. To show this, we compare to COLMAP with respect to the number of input views on ETH3D. As depicted in Figure 3, more images yield better results for both methods as expected. However, our performance drops significantly slower than COLMAP with fewer number of inputs. Numerically, DeepSFM cuts the depth error by half under the same number of views as COLMAP, or achieves similar error with half number of views required by COLMAP. This clearly demonstrates that DeepSFM is more robust when fewer inputs are available. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            582
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            604,
+            328,
+            621
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We present a deep learning framework for Structure-from-Motion, which explicitly enforces photometric consistency, geometric consistency and camera motion constraints all in the deep network. This is achieved by two key components - namely D-CV and P-CV. Both cost volumes measure the photo-metric errors and geometric errors but hypothetically move reconstructed scene points (structure) or camera (motion) respectively. Our deep network can be considered as an enhanced learning based BA algorithm, which takes the best benefits from both learnable priors and geometric rules. Consequently, our method outperforms conventional BA and state-of-the-art deep learning based methods for SfM. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            748
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            772,
+            285,
+            787
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sameer Agarwal, Noah Snavely, Steven M Seitz, and Richard Szeliski. Bundle adjustment in the large. In European conference on computer vision, pp. 29–42. Springer, 2010. ",
+        "bbox": [
+            174,
+            797,
+            823,
+            825
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sameer Agarwal, Yasutaka Furukawa, Noah Snavely, Ian Simon, Brian Curless, Steven M Seitz, and Richard Szeliski. Building rome in a day. Communications of the ACM, 54(10):105–112, 2011. ",
+        "bbox": [
+            171,
+            839,
+            823,
+            867
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, et al. Shapenet: An information-rich 3d model repository. arXiv preprint arXiv:1512.03012, 2015. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ronald Clark, Michael Bloesch, Jan Czarnowski, Stefan Leutenegger, and Andrew J Davison. Learning to solve nonlinear least squares for monocular stereo. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 284–299, 2018. ",
+        "bbox": [
+            179,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Amaël Delaunoy and Marc Pollefeys. Photometric bundle adjustment for dense multi-view 3d modeling. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1486–1493, 2014. ",
+        "bbox": [
+            174,
+            156,
+            825,
+            198
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Eigen and Rob Fergus. Predicting depth, surface normals and semantic labels with a common multi-scale convolutional architecture. In The IEEE International Conference on Computer Vision (ICCV), December 2015. ",
+        "bbox": [
+            173,
+            209,
+            825,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Eigen, Christian Puhrsch, and Rob Fergus. Depth map prediction from a single image using a multi-scale deep network. In Advances in neural information processing systems, pp. 2366–2374, 2014. ",
+        "bbox": [
+            173,
+            262,
+            825,
+            304
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob Engel, Thomas Schöps, and Daniel Cremers. Lsd-slam: Large-scale direct monocular slam. In European conference on computer vision, pp. 834–849. Springer, 2014. ",
+        "bbox": [
+            171,
+            314,
+            821,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jakob Engel, Vladlen Koltun, and Daniel Cremers. Direct sparse odometry. IEEE transactions on pattern analysis and machine intelligence, 40(3):611–625, 2017. ",
+        "bbox": [
+            171,
+            353,
+            823,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Huan Fu, Mingming Gong, Chaohui Wang, Kayhan Batmanghelich, and Dacheng Tao. Deep ordinal regression network for monocular depth estimation. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2018. ",
+        "bbox": [
+            174,
+            392,
+            823,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Simon Fuhrmann, Fabian Langguth, and Michael Goesele. Mve-a multi-view reconstruction environment. In GCH, pp. 11–18, 2014. ",
+        "bbox": [
+            173,
+            445,
+            821,
+            476
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yasutaka Furukawa, Brian Curless, Steven M Seitz, and Richard Szeliski. Towards internet-scale multi-view stereo. In 2010 IEEE computer society conference on computer vision and pattern recognition, pp. 1434–1441. IEEE, 2010. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            529
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ravi Garg, Vijay Kumar BG, Gustavo Carneiro, and Ian Reid. Unsupervised cnn for single view depth estimation: Geometry to the rescue. In European Conference on Computer Vision (ECCV), pp. 740–756. Springer, 2016. ",
+        "bbox": [
+            173,
+            537,
+            823,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Riccardo Gherardi, Michela Farenzena, and Andrea Fusiello. Improving the efficiency of hierarchical structure-and-motion. In 2010 IEEE Computer Society Conference on Computer Vision and Pattern Recognition, pp. 1594–1600. IEEE, 2010. ",
+        "bbox": [
+            173,
+            590,
+            825,
+            633
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xufeng Han, Thomas Leung, Yangqing Jia, Rahul Sukthankar, and Alexander C Berg. Matchnet: Unifying feature and metric learning for patch-based matching. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3279–3286, 2015. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard I Hartley. In defense of the eight-point algorithm. IEEE Transactions on pattern analysis and machine intelligence, 19(6):580–593, 1997. ",
+        "bbox": [
+            171,
+            696,
+            823,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Heiko Hirschmuller. Accurate and efficient stereo processing by semi-global matching and mutual information. In 2005 IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR’05), volume 2, pp. 807–814. IEEE, 2005. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            780
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter, A Steven Younger, and Peter R Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, pp. 87–94. Springer, 2001. ",
+        "bbox": [
+            169,
+            789,
+            823,
+            819
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sunghoon Im, Hae-Gon Jeon, Stephen Lin, and In So Kweon. Dpsnet: End-to-end deep plane sweep stereo. In International Conference on Learning Representations, 2019. URL https: //openreview.net/forum?id $=$ ryeYHi0ctQ. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "He Kaiming, Zhang Xiangyu, Ren Shaoqing, and Jian Sun. Spatial pyramid pooling in deep convolutional networks for visual recognition. In European Conference on Computer Vision (ECCV), 2014. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yevhen Kuznietsov, Jorg Stuckler, and Bastian Leibe. Semi-supervised deep learning for monocular depth map prediction. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Iro Laina, Christian Rupprecht, Vasileios Belagiannis, Federico Tombari, and Nassir Navab. Deeper depth prediction with fully convolutional residual networks. In 2016 Fourth International Conference on 3D Vision (3DV), pp. 239–248. IEEE, 2016. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Fayao Liu, Chunhua Shen, Guosheng Lin, and Ian Reid. Learning depth from single monocular images using deep convolutional neural fields. IEEE transactions on pattern analysis and machine intelligence, 38(10):2024–2039, 2016. ",
+        "bbox": [
+            174,
+            205,
+            823,
+            248
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "MLA Lourakis and Antonis A Argyros. Is levenberg-marquardt the most efficient optimization algorithm for implementing bundle adjustment? In Tenth IEEE International Conference on Computer Vision (ICCV’05) Volume 1, volume 2, pp. 1526–1531. IEEE, 2005. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            301
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David G Lowe. Distinctive image features from scale-invariant keypoints. International journal of computer vision, 60(2):91–110, 2004. ",
+        "bbox": [
+            173,
+            309,
+            823,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Raul Mur-Artal and Juan D Tardós. Orb-slam2: An open-source slam system for monocular, stereo, and rgb-d cameras. IEEE Transactions on Robotics, 33(5):1255–1262, 2017. ",
+        "bbox": [
+            173,
+            347,
+            821,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Raul Mur-Artal, Jose Maria Martinez Montiel, and Juan D Tardos. Orb-slam: a versatile and accurate monocular slam system. IEEE transactions on robotics, 31(5):1147–1163, 2015. ",
+        "bbox": [
+            173,
+            383,
+            820,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard A Newcombe, Steven J Lovegrove, and Andrew J Davison. Dtam: Dense tracking and mapping in real-time. In 2011 international conference on computer vision, pp. 2320–2327. IEEE, 2011. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            464
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jorge Nocedal and Stephen Wright. Numerical optimization. Springer Science & Business Media, 2006. ",
+        "bbox": [
+            173,
+            473,
+            823,
+            502
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Johannes L Schonberger and Jan-Michael Frahm. Structure-from-motion revisited. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4104–4113, 2016. ",
+        "bbox": [
+            173,
+            511,
+            821,
+            541
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Noah Snavely. Scene reconstruction and visualization from internet photo collections: A survey. IPSJ Transactions on Computer Vision and Applications, 3:44–66, 2011. ",
+        "bbox": [
+            171,
+            547,
+            823,
+            578
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Frank Steinbrücker, Jürgen Sturm, and Daniel Cremers. Real-time visual odometry from dense rgb-d images. In 2011 IEEE International Conference on Computer Vision Workshops (ICCV Workshops), pp. 719–722. IEEE, 2011. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            630
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jürgen Sturm, Nikolas Engelhard, Felix Endres, Wolfram Burgard, and Daniel Cremers. A benchmark for the evaluation of rgb-d slam systems. In 2012 IEEE/RSJ International Conference on Intelligent Robots and Systems, pp. 573–580. IEEE, 2012. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            681
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chengzhou Tang and Ping Tan. Ba-net: Dense bundle adjustment network. arXiv preprint arXiv:1806.04807, 2018. ",
+        "bbox": [
+            169,
+            689,
+            825,
+            718
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Zachary Teed and Jia Deng. Deepv2d: Video to depth with differentiable structure from motion. arXiv preprint arXiv:1812.04605, 2018. ",
+        "bbox": [
+            169,
+            727,
+            823,
+            756
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bill Triggs, Philip F McLauchlan, Richard I Hartley, and Andrew W Fitzgibbon. Bundle adjustment—a modern synthesis. In International workshop on vision algorithms, pp. 298–372. Springer, 1999. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Ummenhofer, Huizhong Zhou, Jonas Uhrig, Nikolaus Mayer, Eddy Ilg, Alexey Dosovitskiy, and Thomas Brox. Demon: Depth and motion network for learning monocular stereo. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5038– 5047, 2017. ",
+        "bbox": [
+            174,
+            815,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sudheendra Vijayanarasimhan, Susanna Ricco, Cordelia Schmid, Rahul Sukthankar, and Katerina Fragkiadaki. Sfm-net: Learning of structure and motion from video. arXiv preprint arXiv:1704.07804, 2017. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chaoyang Wang, José Miguel Buenaposada, Rui Zhu, and Simon Lucey. Learning depth from monocular videos using direct methods. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2022–2030, 2018. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peng Wang, Xiaohui Shen, Zhe Lin, Scott Cohen, Brian Price, and Alan L. Yuille. Towards unified depth and semantic prediction from a single image. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sen Wang, Ronald Clark, Hongkai Wen, and Niki Trigoni. Deepvo: Towards end-to-end visual odometry with deep recurrent convolutional neural networks. In 2017 IEEE International Conference on Robotics and Automation (ICRA), pp. 2043–2050. IEEE, 2017. ",
+        "bbox": [
+            174,
+            205,
+            825,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Changchang Wu, Sameer Agarwal, Brian Curless, and Steven M Seitz. Multicore bundle adjustment. In CVPR 2011, pp. 3057–3064. IEEE, 2011a. ",
+        "bbox": [
+            176,
+            257,
+            820,
+            286
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Changchang Wu et al. Visualsfm: A visual structure from motion system. 2011b. ",
+        "bbox": [
+            173,
+            295,
+            709,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jianxiong Xiao, Andrew Owens, and Antonio Torralba. Sun3d: A database of big spaces reconstructed using sfm and object labels. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1625–1632, 2013. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yao Yao, Zixin Luo, Shiwei Li, Tian Fang, and Long Quan. Mvsnet: Depth inference for unstructured multi-view stereo. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 767–783, 2018. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tinghui Zhou, Matthew Brown, Noah Snavely, and David G Lowe. Unsupervised learning of depth and ego-motion from video. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1851–1858, 2017. ",
+        "bbox": [
+            174,
+            422,
+            825,
+            465
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/82aa82d94f6cdad0bad2a4bfbc9a3ef894b5ee7c833ffa4f7e8ab2cfaef8e7c6.jpg",
+        "image_caption": [
+            "Figure 4: Detail architecture of feature extractor. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            104,
+            787,
+            579
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            657,
+            441,
+            672
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Feature extraction module As shown in Figure 4, we build our feature extraction module referring to DPSNet (Im et al., 2019). The module takes $4 W \\times 4 H \\times 3$ images as input and output feature maps of size $W \\times H \\times 3 2$ , which are used to build D-CV and P-CV. ",
+        "bbox": [
+            173,
+            693,
+            823,
+            734
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Cost volumes Figure 5 shows the detailed components for the P-CV and D-CV. Each channel of cost volume is composed of four components: reference view feature maps, warped source view feature maps, the warped source view initial depth map and the projected reference view depth plane or initial depth map. For P-CV construction, we take each sampled hypothetical camera pose, and carry out the warping process on source view depth maps and initial depth map based on the camera pose. And the initial reference view depth map is projected to align numeric values with the warped source view depth map. Finally those four components are concatenated as one channel of 4D P-CV. We do this on all P sampled camera poses, and get the P channel P-CV. The building approach for D-CV is similar, we take each sampled hypothetical depth plane, and carry out warping process on source view feature maps and the initial depth map. And the depth plane is projected to align with the source view depth map. After concatenation, one channel in D-CV is got. Same computation is done based on all L virtual depth planes, and the L channel D-CV is built up. ",
+        "bbox": [
+            173,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/3ba50161d35ea26d1065e2a10ed33e236b8823d86d19b9b271a570432fc77675.jpg",
+        "image_caption": [
+            "Figure 5: Four components in D-CV or P-CV. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            294,
+            137,
+            738,
+            361
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/586465613c358094a0a8dce9a3069c1b8acb0d627ab70a50a8d0ccf376ab8ac4.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Results on ScanNet. (sc_inv: scale invariant log rms; Bold: best.) "
+        ],
+        "table_body": "<table><tr><td rowspan=\"3\">Method</td><td colspan=\"5\">Depth</td><td colspan=\"2\">Motion</td></tr><tr><td>abs_rel</td><td>sq_rel</td><td>rms</td><td>log_rms</td><td>sc_inv</td><td>Rot</td><td>Trans</td></tr><tr><td>Ours</td><td>0.227</td><td>0.170</td><td>0.479</td><td>0.271</td><td>0.268</td><td>1.588</td><td>30.613</td></tr><tr><td>BA-Net</td><td>0.238</td><td>0.176</td><td>0.488</td><td>0.279</td><td>0.276</td><td>1.587</td><td>31.005</td></tr><tr><td>DeMoN</td><td>0.231</td><td>0.520</td><td>0.761</td><td>0.289</td><td>0.284</td><td>3.791</td><td>31.626</td></tr><tr><td>LSD-SLAM</td><td>0.268</td><td>0.427</td><td>0.788</td><td>0.330</td><td>0.323</td><td>4.409</td><td>34.360</td></tr><tr><td>Geometric BA</td><td>0.382</td><td>1.163</td><td>0.876</td><td>0.366</td><td>0.357</td><td>8.560</td><td>39.392</td></tr></table>",
+        "bbox": [
+            222,
+            444,
+            776,
+            569
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3D convolutional layers The detail architecture of 3D convolutional layers after D-CV is almost the same as DPSNet (Im et al., 2019), except for the fist convolution layer. In order to compatible with the newly introduced depth consistent components in D-CV, We adjust the input channel number to 66 instead of 64. As shown in Figure 6, for 3D convolutional layers after P-CV, the architecture is similar to D-CV 3D convolution layers with three extra 3D average pooling layers and finally there is one global average pooling in the dimensions of image width and height, after which we get a $P \\times 1 \\times 1$ tensor. ",
+        "bbox": [
+            173,
+            631,
+            825,
+            729
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B EVALUATION ON SCANNET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            756,
+            436,
+            771
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "ScanNet provides a large set of indoor sequences with camera poses and depth maps captured from a commodity RGBD sensor. Following BA-Net, we leverage this dataset to evaluate the generalization capability by training models on DeMoN and testing here. The testing set is the same as BA-Net, which takes 2000 pairs filtered from 100 sequences. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            847
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the generalization capability of DeepSFM on ScanNet. Table 3 shows the quantitative evaluation results for models trained on DeMoN. The results of BA-Net, DeMoN, LSD-SLAM and Geometric BA are obtained from Tang & Tan (2018). As can be seen, our method significantly outperforms all previous work, which indicates that our model generalizes well to general indoor environments. ",
+        "bbox": [
+            176,
+            853,
+            823,
+            922
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/fca6b0e5f5130467df98ed3f4fd31833a302b11d8ee0e4c40341da6e3f63944f.jpg",
+        "image_caption": [
+            "Figure 6: 3D convolutional layers After P-CV. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            325,
+            113,
+            686,
+            585
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/bca87bb8f57a5475c551b273765d85a82750834e8e32f8545234f2310b57e546.jpg",
+        "table_caption": [
+            "Table 4: The performance of the optimization iterations for testing. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Initialization</td><td>Iteration 2</td><td>Iteration 4</td><td>Iteration 6</td><td>Iteration 10</td><td>Iteration 20</td></tr><tr><td>abs relative</td><td>0.254</td><td>0.153</td><td>0.126</td><td>0.121</td><td>0.120</td><td>0.120</td></tr><tr><td>log rms</td><td>0.248</td><td>0.195</td><td>0.191</td><td>0.190</td><td>0.190</td><td>0.191</td></tr><tr><td>translation</td><td>15.20</td><td>9.75</td><td>9.73</td><td>9.73</td><td>9.73</td><td>9.73</td></tr><tr><td>rotation</td><td>2.38</td><td>1.43</td><td>1.40</td><td>1.39</td><td>1.39</td><td>1.39</td></tr></table>",
+        "bbox": [
+            173,
+            633,
+            825,
+            724
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C SUPPLEMENTAL ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            784,
+            500,
+            801
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "More Iterations for Testing. We take up to four iterations when we train DeepSFM. During inference, the predicted depth maps and camera poses of previous iteration are taken as initialization of next iteration. To show how DeepSFM performs with more iterations than it is trained with, we show results in Table 4. We tested with up to 20 iterations, and it converges at the 6-th iteration. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Bilinear Interpolation vs Nearest Neighbor Sampling. For the construction of D-CV and P-CV, depth maps are warped via the nearest neighbor sampling instead of bilinear interpolation. Due to the discontinuity of the depth values in depth maps, the bilinear interpolation may bring some side effects. It may do damage to the geometry consistency and smooth the depth boundaries. As a comparison, we replace the nearest neighbor sampling with the bilinear interpolation. As shown in Table 5, the performance of our model gains a slight drop with the bilinear interpolation, which indicates that the nearest neighbor sampling method is indeed more geometrically meaningful for depth. In contrast, the differentiable bilinear interpolation is required for the warping of image features, whose gradients are back propagated to feature extractor layers. Further exploration will be an interesting future work. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/16f42bbb9e991ec7d0a05278fcaccc0a117d622d15261b2204e7724a0164e132.jpg",
+        "table_caption": [
+            "Table 5: The performance with different warping methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>MVS Dataset</td><td>L1-inv</td><td>sc-inv</td><td>L1-rel</td><td>Rot</td><td>Trans</td></tr><tr><td>Billinear interpolation</td><td>0.023</td><td>0.134</td><td>0.079</td><td>2.867</td><td>9.910</td></tr><tr><td>Nearest neighbor</td><td>0.021</td><td>0.129</td><td>0.076</td><td>2.824</td><td>9.881</td></tr></table>",
+        "bbox": [
+            266,
+            101,
+            730,
+            165
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            219,
+            825,
+            318
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "D VISUALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            338,
+            343,
+            354
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We show some qualitative comparison with the previous methods. Since there are no source code available for BA-Net (Tang & Tan, 2018), we compare the visualization results of our method with DeMoN (Ummenhofer et al., 2017) and COLMAP (Schonberger & Frahm, 2016). Figure 7 shows the predicted dense depth map by our method and DeMoN on the DeMoN datasets. As we can see, demon often miss some details in the scene, such as plants, keyboard and table legs. In contrast, our method reconstructs more shape details. Figure 8 shows some estimated results from COLMAP and our method on the ETH3D dataset. As shown in the figure, the outputs from COLMAP are often incomplete, especially in textureless area. On the other hand, our method performs better and always produce an integral depth map. In Figure 9, more qualitative comparisons with COLMAP on challenging materials are provided. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            508
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1d8e78470fe8ea9e33858a875cf60eb3ac9db9f442d830215aa50f08f0c7dec.jpg",
+        "image_caption": [
+            "Figure 7: Qualitative Comparisons with DeMoN (Ummenhofer et al., 2017) on DeMoN datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            194,
+            794,
+            806
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/f6ce758d60ed49790987198ba31a9f2c749b569adaf7675d4e9bb17289aecf36.jpg",
+        "image_caption": [
+            "Figure 8: Qualitative Comparisons with COLMAP (Schonberger & Frahm, 2016) on ETH3D datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            193,
+            794,
+            801
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/eaaa27d867a2a1f0a7855b26aaf316d001b34d4873c902502606794e36f11bb7.jpg",
+        "image_caption": [
+            "Figure 9: Qualitative Comparisons with COLMAP (Schonberger & Frahm, 2016) on challenging materials. a) Textureless ground and wall. b) Poor illumination scene. c) Reflective and transparent glass wall. d) Reflective and textureless wall. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            319,
+            790,
+            656
+        ],
+        "page_idx": 18
+    }
+]

parse/train/p2XgjS3Qp4X/p2XgjS3Qp4X.md

@@ -0,0 +1,417 @@
+# baller2vec++: A Look-Ahead Multi-Entity Transformer For Modeling Coordinated Agents
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 In many multi-agent spatiotemporal systems, agents operate under the influence of   
+2 shared, unobserved variables (e.g., the play a team is executing in a game of bas  
+3 ketball). As a result, the trajectories of the agents are often statistically dependent   
+4 at any given time step; however, almost universally, multi-agent models implicitly   
+5 assume the agents’ trajectories are statistically independent at each time step. In   
+6 this paper, we introduce baller2vec $+ + ^ { 1 }$ , a multi-entity Transformer that can effec  
+7 tively model coordinated agents. Specifically, baller2vec $^ { + + }$ applies a specially   
+8 designed self-attention mask to a mixture of location and “look-ahead” trajectory   
+9 sequences to learn the distributions of statistically dependent agent trajectories. We   
+10 show that, unlike baller2vec (baller2vec $^ { + + }$ ’s predecessor), baller2vec++   
+11 can learn to emulate the behavior of perfectly coordinated agents in a simulated   
+12 toy dataset. Additionally, when modeling the trajectories of professional basketball   
+13 players, baller2vec $^ { + + }$ outperforms baller2vec by a wide margin.
+
+# 14 1 Introduction and Related Work
+
+15 Whether it is a team executing a play in a game of basketball, a family navigating to an attraction in a   
+16 theme park, or friends posting about a birthday party on a social media platform, humans frequently   
+17 coordinate their behavior in response to shared information. When this coordinating information is   
+18 unobserved (which is often the case in many machine learning datasets), the individuals’ observed   
+19 behaviors become correlated, i.e., the behavior of one individual at a specific moment contains   
+20 information about the behavior of another individual at the same time. In the context of modeling   
+21 agent trajectories in multi-agent spatiotemporal systems, this property translates to the trajectories   
+22 being statistically dependent at each time step. However, nearly all multi-agent spatiotemporal models   
+23 (e.g., [1–6]) implicitly (through their loss functions) assume the trajectories of the agents at each time   
+24 step are statistically independent given the agents’ previous locations (Figure 1).   
+25 Zhan et al. [7] explicitly focused on modeling coordinated multi-agent trajectories, using “macro  
+26 intents” [8] that are shared across agents to do so. The macro-intents are generated from a   
+27 separately trained recurrent neural network (RNN) that learns to predict a future, coarse, “sta  
+28 tionary” location for each agent at each time step. The macro-intents for all of the agents at   
+29 a specific time step are concatenated together to form a single, shared, macro-intent variable,   
+30 which is then provided as input to the trajectories-generating model at that time step. However,   
+31 similar to the previously mentioned multi-agent trajectory models, the macro-intents model im
+
+32 plicitly assumes the macro-intents for the agents at each time step are statistically independent, i.e., the macro-intent for one agent does not depend on the macro-intents of the other agents.233
+
+![](images/b32f76fd282f7da950743adfdc0395bc86b165cd3b520f45bb89c658e417dcec.jpg)  
+Figure 1: Left: most multi-agent systems implicitly assume the trajectories of the agents at each time step $( \Delta x _ { t , k } )$ are conditionally independent given the agents’ previous locations $( x _ { 1 : t , k } )$ . Right: however, the various decompositions of the joint probability of the trajectories, e.g., $p ( \Delta x _ { t , 1 } ) p ( \Delta x _ { t , 2 } | \Delta x _ { t , 1 } ) p ( \Delta x _ { t , 3 } | \Delta x _ { t , 1 } \Delta x _ { t , 2 } )$ (note, we omit the conditional $x _ { 1 : t , k }$ terms for brevity), suggest more complex statistical dependencies between the agents’ trajectories can exist (i.e., the independence assumption is an extremely strong one). Indeed, there are often shared unobserved variables influencing the spatiotemporal behaviors of agents—such as the play that the players on a basketball team are executing, or events occurring in a pedestrian environment—which suggests statistical dependencies between the agents’ trajectories are likely.
+
+Further, the trajectories-generating model still implicitly assumes the trajectories of the agents at each time step are independent, which is only true if the shared macro-intent variable perfectly captures all of the unobserved information that could cause the agents’ trajectories to be correlated.
+
+Notably, Social-BiGAT [9] does partially account for trajectory correlations through a global adversarial loss. Specifically, the trajectories for each agent are separately passed through an encoder RNN, and the final hidden states for each agent are then processed with a graph attention network (GAT) [10]. The output of the GAT is then used as an input to a discriminator that classifies whether or not the input trajectories are real or generated. This global adversarial loss, however, is only a single component of the full Social-BiGAT loss function, and other components of the loss function do implicitly make the independence assumption. Further, inter
+
+estingly, adding the global discriminator to a baseline model only improved the model’s performance for one out of six pedestrian datasets.
+
+63 In this paper, we describe a novel multi-agent spatiotemporal model that integrates information about   
+64 concurrent actions of agents to predict statistically dependent distributions of trajectories. Specifically,   
+65 we extend the recently introduced multi-entity Transformer baller2vec [6] by: (1) augmenting its   
+66 input with a parallel sequence of “look-ahead” agent trajectories and (2) using a specially designed   
+67 self-attention mask, which allows our model to exploit the chain rule of probability (Section 3). We   
+68 find that:   
+69 1. baller2vec $^ { + + }$ is an effective learning algorithm for modeling coordinated agents. Unlike   
+70 baller2vec, baller2vec++ can learn to emulate perfectly coordinated agents from a   
+71 simulated toy dataset (Section 5.1). Further, baller2vec $^ { + + }$ outperforms baller2vec by   
+72 a wide margin $( 8 . 9 \% )$ when modeling the trajectories of professional basketball players   
+73 (Section 5.1).
+
+2. baller2vec $^ { + + }$ makes better predictions when conditioned on concurrent trajectory information from other agents, supporting our proposition that the commonly used independence assumption for agent trajectories is overly strong (Section 5.2).
+
+3. Lastly, the joint probability assigned to a sequence by baller2vec $^ { + + }$ is approximately permutation invariant with respect to the order of the agents, i.e., baller2vec $^ { + + }$ respects the properties of the chain rule (Section 5.3).
+
+# 80 2 Background
+
+# 2.1 Multi-agent trajectory modelling
+
+2 Our problem description closely follows Alcorn and Nguyen [6], whom we quote here:
+
+Let $A = \{ 1 , 2 , \dots , B \}$ be a set indexing $B$ agents and $P = \{ p _ { 1 } , p _ { 2 } , . . . , p _ { K } \} \subset$ $A$ be the $K$ agents involved in a particular sequence. [Let] $\begin{array} { r l } { C _ { t } } & { { } = } \end{array}$ $\{ ( x _ { t , 1 } , y _ { t , 1 } ) , ( x _ { t , 2 } , y _ { t , 2 } ) , \ldots , ( x _ { t , K } , y _ { t , K } ) \}$ [be] an unordered set of $K$ coordinate pairs such that $( x _ { t , k } , y _ { t , k } )$ are the coordinates for agent $p _ { k }$ at time step $t$ . The ordered sequence of sets of coordinates $\mathcal { C } = ( C _ { 1 } , C _ { 2 } , \ldots , C _ { T } )$ , together with $P$ , thus defines the trajectories for the $K$ agents over $T$ time steps.
+
+89 In multi-agent trajectory modeling, the goal is to model a joint probability of the form:
+
+$$
+p ( \Delta x _ { t , 1 } , \Delta x _ { t , 2 } , \dots , \Delta x _ { t , K } | x _ { 1 : t , 1 } , x _ { 1 : t , 2 } , \dots , x _ { 1 : t , K } )
+$$
+
+90 i.e., the joint probability of the $K$ agents’ trajectories $\Delta x _ { t , k }$ at time step $t$ given the agents’ location   
+91 histories $x _ { 1 : t , k }$ . We note here that the common practice of simultaneously predicting the trajectories   
+92 for all of the agents at a specific time step is not required by theory. Using the chain rule of probability,   
+93 the joint probability of the agents’ trajectories can be factorized as, e.g.:
+
+$$
+\begin{array} { r } { \phantom { \frac { 1 } { 2 } } p ( \Delta x _ { t , 1 } , \Delta x _ { t , 2 } , \dots , \Delta x _ { t , K } ) = p ( \Delta x _ { t , 1 } ) p ( \Delta x _ { t , 2 } | \Delta x _ { t , 1 } ) \dots p ( \Delta x _ { t , K } | \Delta x _ { t , 1 } , \Delta x _ { t , 2 } , \dots , \Delta x _ { t , K - 1 } ) } \end{array}
+$$
+
+94 where we omit the conditional historical trajectories for brevity. As a result, it is perfectly acceptable to   
+95 generate trajectories agent-wise, using the previously generated trajectories as additional conditioning   
+96 information when generating the trajectories for later agents (see Figure 2).
+
+![](images/ed386a62f73d652f761de1b44b4e63782f1cdf1c2bca079869acca63fff1bec1.jpg)  
+Figure 2: At inference time, a model is not required to simultaneously generate the trajectories for all of the agents at a specific time step. An alternative strategy is to allow the model to generate the agents’ trajectories one at a time, and let the model use the previously generated trajectories to inform the trajectories it generates for the remaining agents.
+
+# 97 2.2 baller2vec is a (conditional) generative model.
+
+98 baller2vec is a recently described multi-entity Transformer that can model sequences of sets   
+99 (the underlying data structure for multi-agent spatiotemporal systems), as opposed to sequences   
+100 of individual inputs (like words in a sentence). When used to model the game of basketball, the   
+101 input at each time step for baller2vec is a set of feature vectors where each feature vector contains   
+102 information about the identity and location of a player on the court. baller2vec maps each input   
+103 feature vector to an output feature vector, which is then used to “classify” the binned trajectory for   
+104 that specific player at that specific time step.   
+105 Here, we provide a probabilistic interpretation of baller2vec, which establishes the theoret  
+106 ical grounds for using the chain rule to generate trajectories agent-wise at each time step in   
+107 baller2vec++. Without loss of generality, we only consider one-dimensional trajectories for   
+108 a single agent here. To briefly summarize, the outputs of the softmax function over the $n$ binned   
+109 trajectories in baller2vec can be interpreted as mixture proportions for a mixture of uniform distri  
+110 butions with predetermined bounds that partition the Euclidean trajectory space. Further, because   
+111 $x _ { t + 1 } = x _ { t } + \Delta x _ { t }$ , baller2vec is in fact a conditional generative model that assigns a probability   
+112 to a sequence of trajectories given the initial position of the agent, i.e., $p ( \Delta x _ { 1 } , \Delta x _ { 2 } , \dots , \Delta x _ { T } | x _ { 1 } )$ .   
+113 Using the chain rule, we decompose the joint probability of the trajectories as:
+
+$$
+p ( \Delta x _ { 1 } , \Delta x _ { 2 } , . . . , \Delta x _ { T } ) = p ( \Delta x _ { 1 } ) p ( \Delta x _ { 2 } | \Delta x _ { 1 } ) . . . p ( \Delta x _ { T } | \Delta x _ { 1 } , \Delta x _ { 2 } , . . . , \Delta x _ { T - 1 } )
+$$
+
+114 to reflect their temporal structure (we omit the conditional initial position term for brevity). Therefore,   
+115 new trajectories can be generated from baller2vec with the following procedure (see Figure 3):
+
+1. First, sample one of the $n$ different mixture components using the mixture proportions output from the classifier $f$ (i.e., baller2vec) conditioned on the agent’s current position, i.e., $i \sim$ Categorica $\left( \pi _ { 1 } , \pi _ { 2 } , \ldots , \pi _ { n } \right)$ where $[ \pi _ { 1 } , \pi _ { 2 } , . . . , \pi _ { n } ] = f ( x _ { t } )$ .   
+2. Next, sample a trajectory from the uniform distribution associated with the sampled component, i.e., $\Delta x _ { t } \sim \mathcal { U } ( a _ { i } , b _ { i } )$ .   
+3. Finally, add the sampled trajectory to the agent’s input position to generate the agent’s position at the start of the next time step, i.e., $x _ { t + 1 } = x _ { t } + \Delta x _ { t }$ .
+
+123 Let $[ \Delta x _ { m i n } , \Delta x _ { m a x } )$ be an interval on the real line such that any trajectory $\Delta x \_ <$   
+124 $\Delta x _ { m i n }$ or $\Delta x ~ \ge ~ \Delta x _ { m a x }$ has zero density (i.e., such trajectories are humanly impossible).   
+125 Let $\{ [ a _ { i } , b _ { i } ) \} _ { i = 1 } ^ { n }$ be a set of $n$ intervals that par  
+126 tition the interval $[ \Delta x _ { m i n } , \Delta x _ { m a x } )$ into $n$ bins,   
+127 i.e., $\cup _ { i = 1 } ^ { n } [ a _ { i } , b _ { i } ) = [ \Delta x _ { m i n } , \Delta x _ { m a x } )$ and $i \neq$   
+128 $j \implies [ a _ { i } , b _ { i } ) \cap [ a _ { j } , b _ { j } ) = \emptyset$ . Recall that the   
+129 probability density function (PDF) for a uniform   
+130 distribution with bounds $- \infty < a < b < \infty$ is:
+
+$$
+p ( \Delta x ) = { \left\{ \begin{array} { l l } { { \frac { 1 } { b - a } } } & { { \mathrm { f o r } } \Delta x \in [ a , b ) } \\ { 0 } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+
+Letting 131 $\begin{array} { r } { c _ { i } = \frac { 1 } { b _ { i } - a _ { i } } } \end{array}$ , the PDF for a mixture of 132 uniforms with these bounds is thus:
+
+$$
+p ( \Delta x ) = \sum _ { i = 1 } ^ { n } \pi _ { i } \mathcal { U } ( \Delta x ; a _ { i } , b _ { i } ) = \sum _ { i = 1 } ^ { n } \pi _ { i } c _ { i }
+$$
+
+133 where $p ( \Delta x )$ is the density assigned to $\Delta x$   
+134 by the mixture, $\pi _ { i }$ is the mixture proportion   
+135 for the mixture component indexed by $i$ (i.e.,   
+136 $0 \leq \pi _ { i } \leq 1$ and $\sum \bar { \pi } _ { i } = 1 )$ , and $\mathcal { U } ( \Delta x ; a _ { i } , b _ { i } )$   
+137 is the density assigned to $\Delta x$ by the uniform dis  
+138 tribution with bounds $- \infty < a _ { i } < b _ { i } < \infty$   
+139 Because the bounds of the uniform distribu  
+140 tions partition $[ \Delta x _ { m i n } , \Delta x _ { m a x } )$ , Equation (1)   
+141 reduces to:
+
+$$
+p ( \Delta x ) = \pi _ { i ^ { \prime } } c _ { i ^ { \prime } }
+$$
+
+142 where $\Delta x \in \left[ a _ { i ^ { \prime } } , b _ { i ^ { \prime } } \right)$ (because the other uni  
+143 form distributions will assign a density of zero to   
+144 $\Delta x )$ . The likelihood for data $D$ (with $| D | = N ,$ )   
+145 is then:
+
+![](images/ad895eefce963b6b76b539b3ea83e433059fd418cd546f46723f400b873f96a9.jpg)
+
+Figure 3: baller2vec can be viewed as a conditional generative model that assigns a probability to a sequence of trajectories given the initial positions of the agents. Here, we show a graphical model depiction of a baller2vec model that generates a sequence of one-dimensional trajectories for a single agent. Given the initial position of the agent (the circle containing $x _ { 1 }$ ), one of $n$ different uniform distributions (the square containing $i _ { 1 }$ ) is sampled using the mixture proportions $( \pi _ { i } )$ output by baller2vec $( f )$ . The agent’s trajectory (the diamond containing $\Delta x _ { 1 }$ ) is then sampled from the selected uniform distribution, which has bounds $- \infty < a _ { i } < b _ { i } < \infty$ . At the start of the next time step, the agent’s position is $x _ { 2 } = x _ { 1 } + \Delta x _ { 1 }$ Maximizing the likelihood of baller2vec as a classifier over the binned trajectories is thus equivalent to maximizing its likelihood when assuming the trajectories are generated from a mixture of uniform distributions that partition the Euclidean trajectory space (see Section 2.2 for details).
+
+$$
+\mathcal { L } ( D ) = \prod _ { j = 1 } ^ { N } p ( \Delta x _ { j } ) = \prod _ { j = 1 } ^ { N } \pi _ { j , i ^ { \prime } } c _ { j , i ^ { \prime } }
+$$
+
+146 where $\pi _ { j , i ^ { \prime } }$ is the mixture proportion assigned to the component with $\Delta x _ { j } \in \left[ a _ { i ^ { \prime } } , b _ { i ^ { \prime } } \right)$ and $c _ { j , i ^ { \prime } }$ is the   
+147 associated density. Taking the negative logarithm of the likelihood gives:
+
+$$
+- \ln ( \mathcal { L } ( D ) ) = - \sum _ { j = 1 } ^ { N } \ln ( \pi _ { j , i ^ { \prime } } ) - \sum _ { j = 1 } ^ { N } \ln ( c _ { j , i ^ { \prime } } )
+$$
+
+148 Because the bounds are fixed, the second summation is a constant, and Equation (2) becomes:
+
+$$
+- \ln ( \mathcal { L } ( D ) ) = - \sum _ { j = 1 } ^ { N } \ln ( \pi _ { j , i ^ { \prime } } ) + C
+$$
+
+149 where $\begin{array} { r } { C = - \sum _ { j = 1 } ^ { N } \ln ( c _ { j , i ^ { \prime } } ) } \end{array}$ . Therefore, minimizing the loss of baller2vec as a classifier of   
+150 binned trajectories is equivalent to minimizing the loss of the model when assuming the trajectories   
+151 are generated from a mixture of uniform distributions as specified in Equation (1).
+
+# 152 3 Model Architecture
+
+![](images/845c61704d05f32340b681c3a13d1aa8fae16f68d81afff4f0341fc3ce37b75b.jpg)  
+Figure 4: A naive strategy for learning to predict statistically dependent agent trajectories is to adapt the baller2vec self-attention mask so that baller2vec can “look ahead” at future positions of agents whose trajectories are generated prior to the agent being processed in the current time step. However, this look-ahead self-attention mask cannot be used with multi-layer Transformers because doing so necessitates “seeing the future”. For example, after the model attends to the blue agent’s position at time step $t + 1$ when processing the yellow agent at time step $t$ , the yellow agent’s resultant feature vector contains information about the blue agent’s future position. As a result, when the model attends to the yellow agent while processing the blue agent at the next level, the model is seeing the future.
+
+153 We motivate our baller2vec $^ { + + }$ architecture by first highlighting an issue that arises in baller2vec   
+154 when trying to model agent trajectories using the chain rule. The baller2vec self-attention mask   
+155 can be adapted so that baller2vec “looks ahead” at the future positions of agents whose trajectories   
+156 are generated prior to the agent being processed in the current time step (Figure 4). However, this   
+157 look-ahead self-attention mask can only be used with the final layer of the Transformer; otherwise,   
+158 the model needs to see the future (Figure 4). As a result, baller2vec is severely limited in the   
+159 conditional distribution functions it can learn.   
+160 baller2vec++ (Figure 5) overcomes this limitation by: (1) augmenting the baller2vec input with   
+161 two other sets of feature vectors and (2) using a specially designed self-attention mask. The three sets   
+162 of feature vectors in baller2vec++ take the following forms:
+
+$$
+u _ { t , k } = g _ { u } ( [ e ( p _ { k } ) , x _ { t + 1 , k } , y _ { t + 1 , k } , h _ { t , k } , \Delta x _ { t , k } , \Delta y _ { t , k } ] )
+$$
+
+(current location information) (“look-ahead” information) (initial location information)
+
+![](images/341f78788eddb00abb22b730cfa1023fd115a2ba1c459df00257391bef8e724d.jpg)  
+Figure 5: To learn statistically dependent agent trajectories, baller2vec $^ { + + }$ uses a specially designed self-attention mask to simultaneously process three different sets of features vectors in a single Transformer. The three sets of feature vectors consist of location feature vectors like those found in baller2vec $( z _ { t , k } )$ , look-ahead trajectory feature vectors $( u _ { t , k } )$ , and starting location feature vectors $( r _ { k }$ ; not shown). As can be seen in these partial depictions of baller2vec $^ { + + }$ and the baller2vec $^ { + + }$ self-attention mask, this design allows the model to integrate information about concurrent agent trajectories through multiple Transformer layers without seeing the future.
+
+166 where $g _ { z } , g _ { u }$ , and $g _ { r }$ are multilayer perceptrons (MLPs), $e$ is an agent embedding layer, and $h _ { t , k }$ is a   
+167 vector of optional contextual features for agent $p _ { k }$ at time step $t$ . $z _ { t , k }$ is the same location feature   
+168 vector used in baller2vec and contains information about a specific agent’s identity and the agent’s   
+169 location at time step $t$ . $u _ { t , k }$ is a “look-ahead” trajectory feature vector that contains information about   
+170 a specific agent’s identity, the agent’s location at the next time step $t + 1$ , and the agent’s trajectory   
+171 at time step $t$ , i.e., $( x _ { t + 1 , k } - x _ { t , k } , y _ { t + 1 , k } - y _ { t , k } )$ . Lastly, $r _ { k }$ is a starting location feature vector that   
+172 contains information about a specific agent’s identity and the agent’s location at time step $t = 1$   
+173 The $r _ { k }$ feature vectors are necessary so that $_ { \mathtt { > a } \mathtt { 1 } \mathtt { 1 e r } 2 \mathtt { v e c } + + }$ can “see” the initial locations of all the   
+174 agents when processing the agents agent-wise in the first time step.   
+175 These three sets of feature vectors are combined to form a $( K + 2 T K ) \times F$ matrix $Z$ such that   
+176 the first $K$ rows consist of the $\textit { K r } _ { k }$ feature vectors, and the remaining $2 T K$ rows consist of the   
+177 $T K z _ { t , k }$ and $T K u _ { t , k }$ feature vectors interleaved with one another, i.e., each $z _ { t , k }$ is followed by its   
+178 corresponding $u _ { t , k }$ in the matrix. This matrix is passed into the Transformer along with the specially   
+179 designed self-attention mask, which encodes the following dependencies (see Figure 5):
+
+1. When processing $r _ { k _ { 1 } }$ , baller2vec $^ { + + }$ is exclusively allowed to “look” at each $r _ { k _ { 2 } }$ (i.e., baller2vec $^ { + + }$ cannot look at any location or look-ahead feature vectors when processing $r _ { k _ { 1 } } )$ ).   
+2. When processing $z _ { t _ { 2 } , k _ { 2 } }$ , baller2vec $^ { + + }$ is allowed to “look” at: (i) each $r _ { k 1 }$ , (ii) any $z _ { t _ { 1 } , k _ { 1 } }$ where (a) $t _ { 1 } < t _ { 2 }$ or (b) $t _ { 1 } = t _ { 2 }$ and $k _ { 1 } \leq k _ { 2 }$ , and (iii) any $\boldsymbol { u } _ { t _ { 1 } , k _ { 1 } }$ where (a) $t _ { 1 } < t _ { 2 }$ or (b) $t _ { 1 } = t _ { 2 }$ and $k _ { 1 } < k _ { 2 }$ .   
+3. When processing $u _ { t _ { 2 } , k _ { 2 } }$ , baller2vec $^ { + + }$ is allowed to “look” at: (i) each $r _ { k _ { 1 } }$ , (ii) any $z _ { t _ { 1 } , k _ { 1 } }$ where (a) $t _ { 1 } < t _ { 2 }$ or (b) $t _ { 1 } = t _ { 2 }$ and $k _ { 1 } \leq k _ { 2 }$ , and (iii) any $\boldsymbol { u } _ { t _ { 1 } , k _ { 1 } }$ where (a) $t _ { 1 } < t _ { 2 }$ or (b) $t _ { 1 } = t _ { 2 }$ and $k _ { 1 } \leq k _ { 2 }$ .
+
+189 Each processed $z _ { t , k }$ feature vector is then passed through a linear layer that is followed by a softmax,   
+190 which gives a probability distribution over the trajectory bins for agent $p _ { k }$ at time step $t$ . Similar to   
+191 baller2vec, the loss for each sample is:
+
+$$
+\mathcal { L } = \sum _ { t = 1 } ^ { T } \sum _ { k = 1 } ^ { K } - \ln ( f ( Z ) _ { t , 2 k - 1 } [ v _ { t , k } ] )
+$$
+
+192 where $f ( Z ) _ { t , 2 k - 1 } [ v _ { t , k } ]$ is the probability assigned to the trajectory bin $v _ { t , k }$ (where $\begin{array} { r l } { v _ { t , k } } & { { } = } \end{array}$   
+193 $\mathbf { B i n } ( \Delta x _ { t , k } , \Delta y _ { t , k } )$ is an integer from one to $n ^ { 2 }$ ) by $f$ , i.e., Equation (3) is the negative log-likelihood   
+194 (NLL) of the data according to the model.   
+195 Because any ordering of a chain rule decomposition of a joint probability produces the same value,   
+196 e.g.:
+
+$$
+p ( \Delta x _ { t , 1 } ) p ( \Delta x _ { t , 2 } | \Delta x _ { t , 1 } ) p ( \Delta x _ { t , 3 } | \Delta x _ { t , 1 } \Delta x _ { t , 2 } ) = p ( \Delta x _ { t , 3 } ) p ( \Delta x _ { t , 2 } | \Delta x _ { t , 3 } ) p ( \Delta x _ { t , 1 } | \Delta x _ { t , 3 } \Delta x _ { t , 2 } )
+$$
+
+97 like [11], we shuffled the order of the agents in each training sequence to encourage the model to   
+98 learn joint probabilities of the agent trajectories that are approximately permutation invariant with   
+199 respect to the ordering of the agents.
+
+# 200 4 Experiments
+
+We tested baller2vec $^ { + + }$ on two different datasets. To highlight the pathological behavior of models that assume agent trajectories are statistically independent at each time step, we trained scaled down versions of baller2vec $^ { + + }$ and baller2vec on a toy dataset consisting of simulated trajectories for two perfectly coordinated agents. Additionally, to demonstrate the efficacy of baller2vec $^ { + + }$ in real world settings, we trained baller2vec $^ { + + }$ and baller2vec on a dataset of trajectories for professional basketball players.
+
+# 4.1 Toy dataset
+
+Each training sample was initialized with the agents starting at $( - 1 , 0 )$ and $( 1 , 0 )$ on a grid in random order (i.e., the first agent could be placed to either the left or the right of the origin). At each time step, one of nine actions (corresponding to the $3 \times 3$ grid surrounding the agent) was sampled from a uniform distribution, and each of the agents was translated along this trajectory. This process was repeated for 20 time steps (see Figure 6(a) for a sample).
+
+# 4.2 Basketball dataset
+
+We used the same National Basketball Association (NBA) dataset3 employed by Alcorn and Nguyen [6], whom we paraphrase here:
+
+The NBA dataset consists of trajectories from 631 games from the 2015-2016 season, which were split into 569/30/32 training/validation/test games, respectively. During training, each sequence was sampled using the following procedure: (1) randomly select a training game, (2) randomly select a starting time from the game, (3) take the following four seconds of data and downsample it to $5 \ : \mathrm { H z }$ from the original $2 5 \ : \mathrm { H z }$ , and then (4) randomly (with a probability of 0.5) rotate the court $1 8 0 ^ { \circ }$ . This sampling procedure gave us access to on the order of ${ \sim } 8 2$ million different (albeit overlapping) training sequences. For both the validation and test sets, $\mathord { \sim } 1 , 0 0 0$ different, non-overlapping sequences were selected for evaluation by dividing each game into $\lceil \frac { 1 , 0 0 0 } { N } \rceil$ non-overlapping chunks (where $N$ is the number of games), and using the starting four seconds from each chunk as the evaluation sequence.
+
+# 4.3 Model
+
+Our baller2vec $^ { + + }$ and baller2vec models for the basketball dataset closely followed [6], and so largely resemble the original Transformer architecture [12]. Specifically, the Transformer settings were: $d _ { \mathrm { m o d e l } } = 5 1 2$ (the dimension of the input and output of each Transformer layer), eight attention heads, $d _ { \mathrm { f f } } = 2 0 4 8$ (the dimension of the inner feedforward layers), six layers, no dropout, and no positional encoding. Each MLP (i.e., $g _ { z } , g _ { u }$ , and $g _ { r }$ ) had 128, 256, and 512 nodes in its three layers, respectively, and a ReLU nonlinearity following each of the first two layers. The player embeddings [13] had 20 dimensions, and $h _ { t , k }$ was a binary variable indicating the side of the frontcourt for player $p _ { k }$ (i.e., the direction of his team’s hoop) at time step $t$ . Lastly, the 11 ft $\times 1 1$ ft 2D Euclidean trajectory space was binned into $1 2 1 1 \mathrm { f t } \times 1$ ft squares.
+
+We used the Adam optimizer [14] with an initial learning rate of $1 0 ^ { - 6 }$ , $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ , and 9 $\epsilon = 1 0 ^ { - 9 }$ to update the model parameters, of which there were ${ \sim } 1 9$ million. The learning rate was
+
+240 reduced to $1 0 ^ { - 7 }$ after 20 epochs of the validation loss not improving. Models were implemented in   
+241 PyTorch and trained on a single NVIDIA GTX 1080 Ti GPU for ${ \sim } 6 5 0$ epochs (seven days) where   
+242 each epoch consisted of 20,000 training samples, and the validation set was used for early stopping.
+
+For the toy dataset, we used scaled down versions of the basketball models with $d _ { \mathrm { m o d e l } } = 1 2 8$ , four attention heads, $d _ { \mathrm { f f } } = 5 1 2$ , and two layers in the Transformer. Additionally, each MLP had two layers with 64 and 128 nodes, respectively. The models were trained for 50 epochs of 500 samples per epoch ( $\mathord { \sim } 1 0 . 5$ minutes) using a single learning rate of $1 0 ^ { - 5 }$ .
+
+# 5 Results
+
+# 5.1 baller2vec $^ { + + }$ can effectively model coordinated agents in both simulated and real settings
+
+For the toy dataset, the training loss for baller2vec converged to ${ \sim } 2 . 2 \approx - \ln ( \frac { 1 } { 9 } )$ , i.e., the model was simply independently guessing the trajectories for both agents at every time step. In contrast, the training loss for baller2vec $^ { + + }$ converged to ${ \sim } 1 . 1 \approx - \ln ( \frac { 1 } { 9 } ) \div 2$ , which is the expected loss for a model that perfectly learns the deterministic relationship between the agents’ trajectories (because the prediction for the second agent will always contribute $- \ln ( 1 . 0 ) { \^ { - } } = 0$ to the loss).
+
+When generating trajectories with baller2vec, the agents are completely uncoordinated, with each agent following an independent random walk around the grid (Figure 6(b)). In contrast, trajectories generated by baller2vec++ display the same coordinated agent behavior as the training data (Figure 6(c)).
+
+267 For the basketball dataset,   
+268 baller2vec $^ { + + }$ achieved   
+269 an average NLL of 0.472   
+270 on the test set, $8 . 9 \%$ better   
+271 than the average NLL for
+
+![](images/a0fb1e90a20bb4250fc54cd8087d4f9f3b791b5feaf43e27c0518a57b1ea6c9a.jpg)  
+Figure 6: When trained on a dataset of perfectly coordinated agent trajectories (a), the trajectories generated by baller2vec are completely uncoordinated (b) while the trajectories generated by baller2vec++ are perfectly coordinated (c). Animated versions can be found in the code repository.
+
+baller2vec (0.518) (see Figure S1 for trajectories generated by baller2vec $^ { + + }$ and baller2vec). As was observed in [6], the trajectory bin distributions for baller2vec become much more certain after observing a portion of the sequence (Figure 7), which suggests baller2vec may be inferring some of the shared hidden variables (e.g., plays) influencing the players. If that hypothesis was true, the performance gap between baller2vec $^ { + + }$ and baller2vec should be largest at the beginning of the sequence (before any shared hidden variables can be inferred by baller2vec). Indeed, the average NLL for baller2vec $^ { + + }$ in the first time step of each test set sequence (1.567) is $1 6 . 1 \%$ better than the average NLL for baller2vec (1.869), while the average NLL for baller2vec $^ { + + }$ in the last time step of each test set sequence (0.420) is only $9 . 7 \%$ better than the average NLL for baller2vec (0.465) (see Figure 7).
+
+# 5.2 baller2vec $^ { + + }$ makes better predictions when conditioned on concurrent trajectory information from other agents
+
+Implicit in much of our discussion has been the intuition that providing a model with additional (relevant) information will improve its performance. To empirically test this conjecture, we compared the performance of baller2vec++ when predicting the trajectory of a specific basketball player placed in the first position of the player order (i.e., when $k = 1$ ) vs. predicting the trajectory for that same player placed in the last position (i.e., when $k = 1 0$ ). Specifically, for each player in each test sequence, we calculated the NLL of the player’s trajectory in the first time step4 with the player in the
+
+![](images/b0c117e5411d835f3b0dd0f04ad0c103bf28bedf51e5aa3f64afb60c928493d1.jpg)  
+Figure 7: Left: when modeling the trajectories of professional basketball players, the performance gap between baller2vec $^ { + + }$ and baller2vec is largest at the beginning of the sequence, before shared unobserved variables can be inferred by baller2vec. Each bar indicates a model’s average NLL over the entire test set for that particular time step. For full sequences, baller2vec++ outperforms baller2vec by $8 . 9 \%$ . Right: the joint probability assigned to a sequence by baller2vec $^ { + + }$ is approximately permutation invariant with respect to the order of the agents. For each point, its $x$ value indicates baller2vec $^ { + + }$ ’s average NLL for a test set sequence using the original order of the agents in the sequence, while its $y$ value indicates baller2vec $^ { + + }$ ’s average NLL for the same sequence with the order of the agents shuffled. The shuffled average NLLs are highly correlated with their corresponding unshuffled average NLLs.
+
+290 first position of the player order. Next, we moved the player to the last position of the player order,   
+291 and then randomly shuffled the remaining nine players 10 times, calculating the NLL for the player   
+292 in the last position each time. Finally, we calculated the average percent change in the last position   
+293 NLLs relative to their corresponding first position NLLs. On average, moving a player from the first   
+294 to the last position improved the NLL for the player’s trajectory by $1 4 . 6 \%$ .
+
+# 5.3 The joint probability assigned to a sequence by baller2vec $^ { + + }$ is approximately permutation invariant with respect to the order of the agents
+
+To determine whether or not baller2vec $^ { + + }$ respects the fact that any ordering of a chain rule decomposition of a joint probability produces the same value, we measured how much the average NLL for each test sequence in the basketball dataset varied when the order of the agents changed. Specifically, for each test set sequence, we shuffled the order of the agents 10 times. Then, for each permuted sequence, we calculated the percent error5 in the average NLL relative to the original, unshuffled sequence. Across all test sequences, the average percent error was only $\pm 1 . 5 \%$ . Further, as can be seen in Figure 7, the shuffled average NLLs are highly correlated with their corresponding unshuffled average NLLs (Pearson correlation coefficient $= 0 . 9 9 7 $ ), i.e., the joint probability assigned to a sequence by baller2vec $^ { + + }$ is approximately permutation invariant with respect to the order of the agents.
+
+# 307 6 Conclusion and Future Work
+
+In this paper, we have shown how the commonly used independence assumption of many multi-agent spatiotemporal models can severely limit their ability to learn to emulate coordinated agents. By relaxing this independence assumption in baller2vec, baller2vec++ was able to more accurately model the trajectories of professional basketball players. Models for other multi-agent spatiotemporal environments, such as pedestrian traffic (see [15] for a survey) and vehicle traffic (e.g., [16–19]), may also benefit from the look-ahead approach used by baller2vec++. Additionally, the interleaved input design of baller2vec++ could be useful when modeling other systems involving many entities interacting through time, such as social media platforms (e.g., [20, 21]). However, confronting the quadratic complexity of the Transformer attention mechanism as the number of entities grows large in these datasets is an open problem, but recent work in sparse Transformers (e.g., [22–27]) shows encouraging progress.
+
+319 References   
+20 [1] Panna Felsen, Patrick Lucey, and Sujoy Ganguly. Where will they go? predicting fine-grained   
+21 adversarial multi-agent motion using conditional variational autoencoders. In Proceedings of   
+22 the European Conference on Computer Vision (ECCV), pages 732–747, 2018.   
+323 [2] Agrim Gupta, Justin Johnson, Li Fei-Fei, Silvio Savarese, and Alexandre Alahi. Social gan:   
+24 Socially acceptable trajectories with generative adversarial networks. In Proceedings of the   
+325 IEEE Conference on Computer Vision and Pattern Recognition, pages 2255–2264, 2018.   
+26 [3] Amir Sadeghian, Vineet Kosaraju, Ali Sadeghian, Noriaki Hirose, Hamid Rezatofighi, and   
+327 Silvio Savarese. Sophie: An attentive gan for predicting paths compliant to social and physical   
+28 constraints. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern   
+29 Recognition, pages 1349–1358, 2019.   
+330 [4] Raymond A Yeh, Alexander G Schwing, Jonathan Huang, and Kevin Murphy. Diverse genera  
+31 tion for multi-agent sports games. In Proceedings of the IEEE Conference on Computer Vision   
+332 and Pattern Recognition, pages 4610–4619, 2019.   
+333 [5] Cunjun Yu, Xiao Ma, Jiawei Ren, Haiyu Zhao, and Shuai Yi. Spatio-temporal graph transformer   
+34 networks for pedestrian trajectory prediction. In Proceedings of the European Conference on   
+35 Computer Vision (ECCV), August 2020.   
+336 [6] Michael A. Alcorn and Anh Nguyen. baller2vec: A multi-entity transformer for multi-agent   
+37 spatiotemporal modeling. arXiv preprint arXiv:2102.03291, 2021.   
+338 [7] Eric Zhan, Stephan Zheng, Yisong Yue, Long Sha, and Patrick Lucey. Generating multi-agent   
+339 trajectories using programmatic weak supervision. In International Conference on Learning   
+40 Representations, 2019. URL https://openreview.net/forum?id $\equiv$ rkxw-hAcFQ.   
+41 [8] Stephan Zheng, Yisong Yue, and Jennifer Hobbs. Generating long-term trajectories using deep   
+342 hierarchical networks. Advances in Neural Information Processing Systems, 29:1543–1551,   
+43 2016.   
+344 [9] Vineet Kosaraju, Amir Sadeghian, Roberto Martín-Martín, Ian Reid, Hamid Rezatofighi, and   
+45 Silvio Savarese. Social-bigat: Multimodal trajectory forecasting using bicycle-gan and graph   
+46 attention networks. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox,   
+47 and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32.   
+348 Curran Associates, Inc., 2019. URL https://proceedings.neurips.cc/paper/2019/   
+49 file/d09bf41544a3365a46c9077ebb5e35c3-Paper.pdf.   
+350 [10] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´   
+51 Bengio. Graph Attention Networks. International Conference on Learning Representations,   
+52 2018. URL https://openreview.net/forum?id=rJXMpikCZ. accepted as poster.   
+53 [11] Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V   
+354 Le. Xlnet: Generalized autoregressive pretraining for language understanding. arXiv preprint   
+55 arXiv:1906.08237, 2019.   
+56 [12] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,   
+357 Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Informa  
+58 tion Processing Systems, pages 5998–6008, 2017.   
+59 [13] Michael A Alcorn. (batter|pitcher)2vec: Statistic-free talent modeling with neural player   
+60 embeddings. In MIT Sloan Sports Analytics Conference, 2018.   
+61 [14] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Interna  
+62 tional Conference on Learning Representations, 2015.   
+63 [15] Andrey Rudenko, Luigi Palmieri, Michael Herman, Kris M Kitani, Dariu M Gavrila, and Kai O   
+64 Arras. Human motion trajectory prediction: A survey. The International Journal of Robotics   
+65 Research, 39(8):895–935, 2020.
+
+[16] Nachiket Deo and Mohan M Trivedi. Convolutional social pooling for vehicle trajectory prediction. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 1468–1476, 2018.   
+[17] Ming-Fang Chang, John Lambert, Patsorn Sangkloy, Jagjeet Singh, Slawomir Bak, Andrew Hartnett, De Wang, Peter Carr, Simon Lucey, Deva Ramanan, and James Hays. Argoverse: 3d tracking and forecasting with rich maps. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   
+[18] Tianyang Zhao, Yifei Xu, Mathew Monfort, Wongun Choi, Chris Baker, Yibiao Zhao, Yizhou Wang, and Ying Nian Wu. Multi-agent tensor fusion for contextual trajectory prediction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   
+[19] Rohan Chandra, Uttaran Bhattacharya, Aniket Bera, and Dinesh Manocha. Traphic: Trajectory prediction in dense and heterogeneous traffic using weighted interactions. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   
+[20] Srijan Kumar, Xikun Zhang, and Jure Leskovec. Predicting dynamic embedding trajectory in temporal interaction networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1269–1278, 2019.   
+[21] Emanuele Rossi, Ben Chamberlain, Fabrizio Frasca, Davide Eynard, Federico Monti, and Michael Bronstein. Temporal graph networks for deep learning on dynamic graphs. In ICML 2020 Workshop on Graph Representation Learning, 2020.   
+[22] Rewon Child, Scott Gray, Alec Radford, and Ilya Sutskever. Generating long sequences with sparse transformers. arXiv preprint arXiv:1904.10509, 2019.   
+[23] Manzil Zaheer, Guru Guruganesh, Kumar Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, and Amr Ahmed. Big bird: Transformers for longer sequences. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 17283–17297. Curran Associates, Inc., 2020. URL https://proceedings.neurips. cc/paper/2020/file/c8512d142a2d849725f31a9a7a361ab9-Paper.pdf.   
+[24] Iz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.   
+[25] Nikita Kitaev, Lukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id $\equiv$ rkgNKkHtvB.   
+[26] Jonathan Ho, Nal Kalchbrenner, Dirk Weissenborn, and Tim Salimans. Axial attention in multidimensional transformers. arXiv preprint arXiv:1912.12180, 2019.   
+[27] Gedas Bertasius, Heng Wang, and Lorenzo Torresani. Is space-time attention all you need for video understanding? arXiv preprint arXiv:2102.05095, 2021.
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 6.   
+(c) Did you discuss any potential negative societal impacts of your work? [No] Our work does not introduce new ethical challenges.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [No] We link directly to the dataset.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/p2XgjS3Qp4X/p2XgjS3Qp4X_content_list.json

@@ -0,0 +1,1212 @@
+[
+    {
+        "type": "text",
+        "text": "baller2vec++: A Look-Ahead Multi-Entity Transformer For Modeling Coordinated Agents ",
+        "text_level": 1,
+        "bbox": [
+            210,
+            122,
+            787,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 In many multi-agent spatiotemporal systems, agents operate under the influence of   \n2 shared, unobserved variables (e.g., the play a team is executing in a game of bas  \n3 ketball). As a result, the trajectories of the agents are often statistically dependent   \n4 at any given time step; however, almost universally, multi-agent models implicitly   \n5 assume the agents’ trajectories are statistically independent at each time step. In   \n6 this paper, we introduce baller2vec $+ + ^ { 1 }$ , a multi-entity Transformer that can effec  \n7 tively model coordinated agents. Specifically, baller2vec $^ { + + }$ applies a specially   \n8 designed self-attention mask to a mixture of location and “look-ahead” trajectory   \n9 sequences to learn the distributions of statistically dependent agent trajectories. We   \n10 show that, unlike baller2vec (baller2vec $^ { + + }$ ’s predecessor), baller2vec++   \n11 can learn to emulate the behavior of perfectly coordinated agents in a simulated   \n12 toy dataset. Additionally, when modeling the trajectories of professional basketball   \n13 players, baller2vec $^ { + + }$ outperforms baller2vec by a wide margin. ",
+        "bbox": [
+            148,
+            354,
+            767,
+            535
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "14 1 Introduction and Related Work ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            574,
+            468,
+            592
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "15 Whether it is a team executing a play in a game of basketball, a family navigating to an attraction in a   \n16 theme park, or friends posting about a birthday party on a social media platform, humans frequently   \n17 coordinate their behavior in response to shared information. When this coordinating information is   \n18 unobserved (which is often the case in many machine learning datasets), the individuals’ observed   \n19 behaviors become correlated, i.e., the behavior of one individual at a specific moment contains   \n20 information about the behavior of another individual at the same time. In the context of modeling   \n21 agent trajectories in multi-agent spatiotemporal systems, this property translates to the trajectories   \n22 being statistically dependent at each time step. However, nearly all multi-agent spatiotemporal models   \n23 (e.g., [1–6]) implicitly (through their loss functions) assume the trajectories of the agents at each time   \n24 step are statistically independent given the agents’ previous locations (Figure 1).   \n25 Zhan et al. [7] explicitly focused on modeling coordinated multi-agent trajectories, using “macro  \n26 intents” [8] that are shared across agents to do so. The macro-intents are generated from a   \n27 separately trained recurrent neural network (RNN) that learns to predict a future, coarse, “sta  \n28 tionary” location for each agent at each time step. The macro-intents for all of the agents at   \n29 a specific time step are concatenated together to form a single, shared, macro-intent variable,   \n30 which is then provided as input to the trajectories-generating model at that time step. However,   \n31 similar to the previously mentioned multi-agent trajectory models, the macro-intents model im",
+        "bbox": [
+            147,
+            611,
+            825,
+            750
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            756,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "32 plicitly assumes the macro-intents for the agents at each time step are statistically independent, i.e., the macro-intent for one agent does not depend on the macro-intents of the other agents.233 ",
+        "bbox": [
+            155,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/b32f76fd282f7da950743adfdc0395bc86b165cd3b520f45bb89c658e417dcec.jpg",
+        "image_caption": [
+            "Figure 1: Left: most multi-agent systems implicitly assume the trajectories of the agents at each time step $( \\Delta x _ { t , k } )$ are conditionally independent given the agents’ previous locations $( x _ { 1 : t , k } )$ . Right: however, the various decompositions of the joint probability of the trajectories, e.g., $p ( \\Delta x _ { t , 1 } ) p ( \\Delta x _ { t , 2 } | \\Delta x _ { t , 1 } ) p ( \\Delta x _ { t , 3 } | \\Delta x _ { t , 1 } \\Delta x _ { t , 2 } )$ (note, we omit the conditional $x _ { 1 : t , k }$ terms for brevity), suggest more complex statistical dependencies between the agents’ trajectories can exist (i.e., the independence assumption is an extremely strong one). Indeed, there are often shared unobserved variables influencing the spatiotemporal behaviors of agents—such as the play that the players on a basketball team are executing, or events occurring in a pedestrian environment—which suggests statistical dependencies between the agents’ trajectories are likely. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            153,
+            123,
+            565,
+            253
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Further, the trajectories-generating model still implicitly assumes the trajectories of the agents at each time step are independent, which is only true if the shared macro-intent variable perfectly captures all of the unobserved information that could cause the agents’ trajectories to be correlated. ",
+        "bbox": [
+            578,
+            119,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notably, Social-BiGAT [9] does partially account for trajectory correlations through a global adversarial loss. Specifically, the trajectories for each agent are separately passed through an encoder RNN, and the final hidden states for each agent are then processed with a graph attention network (GAT) [10]. The output of the GAT is then used as an input to a discriminator that classifies whether or not the input trajectories are real or generated. This global adversarial loss, however, is only a single component of the full Social-BiGAT loss function, and other components of the loss function do implicitly make the independence assumption. Further, inter",
+        "bbox": [
+            578,
+            251,
+            825,
+            497
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "estingly, adding the global discriminator to a baseline model only improved the model’s performance for one out of six pedestrian datasets. ",
+        "bbox": [
+            166,
+            498,
+            820,
+            525
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "63 In this paper, we describe a novel multi-agent spatiotemporal model that integrates information about   \n64 concurrent actions of agents to predict statistically dependent distributions of trajectories. Specifically,   \n65 we extend the recently introduced multi-entity Transformer baller2vec [6] by: (1) augmenting its   \n66 input with a parallel sequence of “look-ahead” agent trajectories and (2) using a specially designed   \n67 self-attention mask, which allows our model to exploit the chain rule of probability (Section 3). We   \n68 find that:   \n69 1. baller2vec $^ { + + }$ is an effective learning algorithm for modeling coordinated agents. Unlike   \n70 baller2vec, baller2vec++ can learn to emulate perfectly coordinated agents from a   \n71 simulated toy dataset (Section 5.1). Further, baller2vec $^ { + + }$ outperforms baller2vec by   \n72 a wide margin $( 8 . 9 \\% )$ when modeling the trajectories of professional basketball players   \n73 (Section 5.1). ",
+        "bbox": [
+            145,
+            532,
+            825,
+            614
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            640,
+            826,
+            710
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2. baller2vec $^ { + + }$ makes better predictions when conditioned on concurrent trajectory information from other agents, supporting our proposition that the commonly used independence assumption for agent trajectories is overly strong (Section 5.2). ",
+        "bbox": [
+            199,
+            729,
+            823,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3. Lastly, the joint probability assigned to a sequence by baller2vec $^ { + + }$ is approximately permutation invariant with respect to the order of the agents, i.e., baller2vec $^ { + + }$ respects the properties of the chain rule (Section 5.3). ",
+        "bbox": [
+            209,
+            791,
+            825,
+            834
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "80 2 Background ",
+        "text_level": 1,
+        "bbox": [
+            153,
+            89,
+            308,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Multi-agent trajectory modelling ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            119,
+            444,
+            136
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 Our problem description closely follows Alcorn and Nguyen [6], whom we quote here: ",
+        "bbox": [
+            158,
+            145,
+            743,
+            161
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $A = \\{ 1 , 2 , \\dots , B \\}$ be a set indexing $B$ agents and $P = \\{ p _ { 1 } , p _ { 2 } , . . . , p _ { K } \\} \\subset$ $A$ be the $K$ agents involved in a particular sequence. [Let] $\\begin{array} { r l } { C _ { t } } & { { } = } \\end{array}$ $\\{ ( x _ { t , 1 } , y _ { t , 1 } ) , ( x _ { t , 2 } , y _ { t , 2 } ) , \\ldots , ( x _ { t , K } , y _ { t , K } ) \\}$ [be] an unordered set of $K$ coordinate pairs such that $( x _ { t , k } , y _ { t , k } )$ are the coordinates for agent $p _ { k }$ at time step $t$ . The ordered sequence of sets of coordinates $\\mathcal { C } = ( C _ { 1 } , C _ { 2 } , \\ldots , C _ { T } )$ , together with $P$ , thus defines the trajectories for the $K$ agents over $T$ time steps. ",
+        "bbox": [
+            232,
+            171,
+            766,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "89 In multi-agent trajectory modeling, the goal is to model a joint probability of the form: ",
+        "bbox": [
+            143,
+            267,
+            740,
+            284
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8812c1572face6ce63ef9f02f36129b3b719094fe83619d10f67caaa523ca189.jpg",
+        "text": "$$\np ( \\Delta x _ { t , 1 } , \\Delta x _ { t , 2 } , \\dots , \\Delta x _ { t , K } | x _ { 1 : t , 1 } , x _ { 1 : t , 2 } , \\dots , x _ { 1 : t , K } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            301,
+            673,
+            319
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "90 i.e., the joint probability of the $K$ agents’ trajectories $\\Delta x _ { t , k }$ at time step $t$ given the agents’ location   \n91 histories $x _ { 1 : t , k }$ . We note here that the common practice of simultaneously predicting the trajectories   \n92 for all of the agents at a specific time step is not required by theory. Using the chain rule of probability,   \n93 the joint probability of the agents’ trajectories can be factorized as, e.g.: ",
+        "bbox": [
+            147,
+            327,
+            826,
+            385
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b5975f4b8bb79309cb6cbeb989557531c6f220c3c050bae78b9ee8cc6962e1e3.jpg",
+        "text": "$$\n\\begin{array} { r } { \\phantom { \\frac { 1 } { 2 } } p ( \\Delta x _ { t , 1 } , \\Delta x _ { t , 2 } , \\dots , \\Delta x _ { t , K } ) = p ( \\Delta x _ { t , 1 } ) p ( \\Delta x _ { t , 2 } | \\Delta x _ { t , 1 } ) \\dots p ( \\Delta x _ { t , K } | \\Delta x _ { t , 1 } , \\Delta x _ { t , 2 } , \\dots , \\Delta x _ { t , K - 1 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            410,
+            826,
+            428
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 where we omit the conditional historical trajectories for brevity. As a result, it is perfectly acceptable to   \n95 generate trajectories agent-wise, using the previously generated trajectories as additional conditioning   \n96 information when generating the trajectories for later agents (see Figure 2). ",
+        "bbox": [
+            142,
+            440,
+            828,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed386a62f73d652f761de1b44b4e63782f1cdf1c2bca079869acca63fff1bec1.jpg",
+        "image_caption": [
+            "Figure 2: At inference time, a model is not required to simultaneously generate the trajectories for all of the agents at a specific time step. An alternative strategy is to allow the model to generate the agents’ trajectories one at a time, and let the model use the previously generated trajectories to inform the trajectories it generates for the remaining agents. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            503,
+            816,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "97 2.2 baller2vec is a (conditional) generative model. ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            727,
+            545,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "98 baller2vec is a recently described multi-entity Transformer that can model sequences of sets   \n99 (the underlying data structure for multi-agent spatiotemporal systems), as opposed to sequences   \n100 of individual inputs (like words in a sentence). When used to model the game of basketball, the   \n101 input at each time step for baller2vec is a set of feature vectors where each feature vector contains   \n102 information about the identity and location of a player on the court. baller2vec maps each input   \n103 feature vector to an output feature vector, which is then used to “classify” the binned trajectory for   \n104 that specific player at that specific time step.   \n105 Here, we provide a probabilistic interpretation of baller2vec, which establishes the theoret  \n106 ical grounds for using the chain rule to generate trajectories agent-wise at each time step in   \n107 baller2vec++. Without loss of generality, we only consider one-dimensional trajectories for   \n108 a single agent here. To briefly summarize, the outputs of the softmax function over the $n$ binned   \n109 trajectories in baller2vec can be interpreted as mixture proportions for a mixture of uniform distri  \n110 butions with predetermined bounds that partition the Euclidean trajectory space. Further, because   \n111 $x _ { t + 1 } = x _ { t } + \\Delta x _ { t }$ , baller2vec is in fact a conditional generative model that assigns a probability   \n112 to a sequence of trajectories given the initial position of the agent, i.e., $p ( \\Delta x _ { 1 } , \\Delta x _ { 2 } , \\dots , \\Delta x _ { T } | x _ { 1 } )$ .   \n113 Using the chain rule, we decompose the joint probability of the trajectories as: ",
+        "bbox": [
+            142,
+            752,
+            825,
+            849
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            826,
+            161
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5c79b950b8686b5f3909e947ac7e0980bf56c0e1d2b917d6f5c1a5b917915d83.jpg",
+        "text": "$$\np ( \\Delta x _ { 1 } , \\Delta x _ { 2 } , . . . , \\Delta x _ { T } ) = p ( \\Delta x _ { 1 } ) p ( \\Delta x _ { 2 } | \\Delta x _ { 1 } ) . . . p ( \\Delta x _ { T } | \\Delta x _ { 1 } , \\Delta x _ { 2 } , . . . , \\Delta x _ { T - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            179,
+            777,
+            196
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "114 to reflect their temporal structure (we omit the conditional initial position term for brevity). Therefore,   \n115 new trajectories can be generated from baller2vec with the following procedure (see Figure 3): ",
+        "bbox": [
+            145,
+            203,
+            825,
+            233
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. First, sample one of the $n$ different mixture components using the mixture proportions output from the classifier $f$ (i.e., baller2vec) conditioned on the agent’s current position, i.e., $i \\sim$ Categorica $\\left( \\pi _ { 1 } , \\pi _ { 2 } , \\ldots , \\pi _ { n } \\right)$ where $[ \\pi _ { 1 } , \\pi _ { 2 } , . . . , \\pi _ { n } ] = f ( x _ { t } )$ .   \n2. Next, sample a trajectory from the uniform distribution associated with the sampled component, i.e., $\\Delta x _ { t } \\sim \\mathcal { U } ( a _ { i } , b _ { i } )$ .   \n3. Finally, add the sampled trajectory to the agent’s input position to generate the agent’s position at the start of the next time step, i.e., $x _ { t + 1 } = x _ { t } + \\Delta x _ { t }$ . ",
+        "bbox": [
+            212,
+            242,
+            825,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "123 Let $[ \\Delta x _ { m i n } , \\Delta x _ { m a x } )$ be an interval on the real line such that any trajectory $\\Delta x \\_ <$   \n124 $\\Delta x _ { m i n }$ or $\\Delta x ~ \\ge ~ \\Delta x _ { m a x }$ has zero density (i.e., such trajectories are humanly impossible).   \n125 Let $\\{ [ a _ { i } , b _ { i } ) \\} _ { i = 1 } ^ { n }$ be a set of $n$ intervals that par  \n126 tition the interval $[ \\Delta x _ { m i n } , \\Delta x _ { m a x } )$ into $n$ bins,   \n127 i.e., $\\cup _ { i = 1 } ^ { n } [ a _ { i } , b _ { i } ) = [ \\Delta x _ { m i n } , \\Delta x _ { m a x } )$ and $i \\neq$   \n128 $j \\implies [ a _ { i } , b _ { i } ) \\cap [ a _ { j } , b _ { j } ) = \\emptyset$ . Recall that the   \n129 probability density function (PDF) for a uniform   \n130 distribution with bounds $- \\infty < a < b < \\infty$ is: ",
+        "bbox": [
+            150,
+            358,
+            823,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            387,
+            485,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3bb0642f643753afea857ee89038a4abf13b90f4ed08aaa703704bd78e270dc9.jpg",
+        "text": "$$\np ( \\Delta x ) = { \\left\\{ \\begin{array} { l l } { { \\frac { 1 } { b - a } } } & { { \\mathrm { f o r } } \\Delta x \\in [ a , b ) } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            484,
+            441,
+            522
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Letting 131 $\\begin{array} { r } { c _ { i } = \\frac { 1 } { b _ { i } - a _ { i } } } \\end{array}$ , the PDF for a mixture of 132 uniforms with these bounds is thus: ",
+        "bbox": [
+            140,
+            530,
+            485,
+            561
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72c08642c2b7e154fd2d7d5e28be1a2b137b0894430220b59f3fe749273cd243.jpg",
+        "text": "$$\np ( \\Delta x ) = \\sum _ { i = 1 } ^ { n } \\pi _ { i } \\mathcal { U } ( \\Delta x ; a _ { i } , b _ { i } ) = \\sum _ { i = 1 } ^ { n } \\pi _ { i } c _ { i }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            580,
+            459,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "133 where $p ( \\Delta x )$ is the density assigned to $\\Delta x$   \n134 by the mixture, $\\pi _ { i }$ is the mixture proportion   \n135 for the mixture component indexed by $i$ (i.e.,   \n136 $0 \\leq \\pi _ { i } \\leq 1$ and $\\sum \\bar { \\pi } _ { i } = 1 )$ , and $\\mathcal { U } ( \\Delta x ; a _ { i } , b _ { i } )$   \n137 is the density assigned to $\\Delta x$ by the uniform dis  \n138 tribution with bounds $- \\infty < a _ { i } < b _ { i } < \\infty$   \n139 Because the bounds of the uniform distribu  \n140 tions partition $[ \\Delta x _ { m i n } , \\Delta x _ { m a x } )$ , Equation (1)   \n141 reduces to: ",
+        "bbox": [
+            140,
+            631,
+            485,
+            756
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4a567f9fad412c51d3594de66f13c356330a85f2ff92de19254ad486b5716dc.jpg",
+        "text": "$$\np ( \\Delta x ) = \\pi _ { i ^ { \\prime } } c _ { i ^ { \\prime } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            775,
+            380,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "142 where $\\Delta x \\in \\left[ a _ { i ^ { \\prime } } , b _ { i ^ { \\prime } } \\right)$ (because the other uni  \n143 form distributions will assign a density of zero to   \n144 $\\Delta x )$ . The likelihood for data $D$ (with $| D | = N ,$ )   \n145 is then: ",
+        "bbox": [
+            140,
+            799,
+            485,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/ad895eefce963b6b76b539b3ea83e433059fd418cd546f46723f400b873f96a9.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            500,
+            401,
+            823,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 3: baller2vec can be viewed as a conditional generative model that assigns a probability to a sequence of trajectories given the initial positions of the agents. Here, we show a graphical model depiction of a baller2vec model that generates a sequence of one-dimensional trajectories for a single agent. Given the initial position of the agent (the circle containing $x _ { 1 }$ ), one of $n$ different uniform distributions (the square containing $i _ { 1 }$ ) is sampled using the mixture proportions $( \\pi _ { i } )$ output by baller2vec $( f )$ . The agent’s trajectory (the diamond containing $\\Delta x _ { 1 }$ ) is then sampled from the selected uniform distribution, which has bounds $- \\infty < a _ { i } < b _ { i } < \\infty$ . At the start of the next time step, the agent’s position is $x _ { 2 } = x _ { 1 } + \\Delta x _ { 1 }$ Maximizing the likelihood of baller2vec as a classifier over the binned trajectories is thus equivalent to maximizing its likelihood when assuming the trajectories are generated from a mixture of uniform distributions that partition the Euclidean trajectory space (see Section 2.2 for details). ",
+        "bbox": [
+            498,
+            553,
+            825,
+            842
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/79716d50d965cb9587dc62158af721c0ef3bf8d05d5fdaf7ea247b5973ca24c9.jpg",
+        "text": "$$\n\\mathcal { L } ( D ) = \\prod _ { j = 1 } ^ { N } p ( \\Delta x _ { j } ) = \\prod _ { j = 1 } ^ { N } \\pi _ { j , i ^ { \\prime } } c _ { j , i ^ { \\prime } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            869,
+            619,
+            915
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "146 where $\\pi _ { j , i ^ { \\prime } }$ is the mixture proportion assigned to the component with $\\Delta x _ { j } \\in \\left[ a _ { i ^ { \\prime } } , b _ { i ^ { \\prime } } \\right)$ and $c _ { j , i ^ { \\prime } }$ is the   \n147 associated density. Taking the negative logarithm of the likelihood gives: ",
+        "bbox": [
+            142,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64689e68a173c1b15ed81fefa6daf5c438f1687d8e15574cf0cc758ca1d1de30.jpg",
+        "text": "$$\n- \\ln ( \\mathcal { L } ( D ) ) = - \\sum _ { j = 1 } ^ { N } \\ln ( \\pi _ { j , i ^ { \\prime } } ) - \\sum _ { j = 1 } ^ { N } \\ln ( c _ { j , i ^ { \\prime } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            137,
+            651,
+            183
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "148 Because the bounds are fixed, the second summation is a constant, and Equation (2) becomes: ",
+        "bbox": [
+            138,
+            193,
+            787,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/150c1fbebba25e5a086c8253ad9dcd17aefc1de1db3adaf7ce122b4237c41f16.jpg",
+        "text": "$$\n- \\ln ( \\mathcal { L } ( D ) ) = - \\sum _ { j = 1 } ^ { N } \\ln ( \\pi _ { j , i ^ { \\prime } } ) + C\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            226,
+            617,
+            271
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "149 where $\\begin{array} { r } { C = - \\sum _ { j = 1 } ^ { N } \\ln ( c _ { j , i ^ { \\prime } } ) } \\end{array}$ . Therefore, minimizing the loss of baller2vec as a classifier of   \n150 binned trajectories is equivalent to minimizing the loss of the model when assuming the trajectories   \n151 are generated from a mixture of uniform distributions as specified in Equation (1). ",
+        "bbox": [
+            142,
+            284,
+            825,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "152 3 Model Architecture ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            349,
+            370,
+            367
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/845c61704d05f32340b681c3a13d1aa8fae16f68d81afff4f0341fc3ce37b75b.jpg",
+        "image_caption": [
+            "Figure 4: A naive strategy for learning to predict statistically dependent agent trajectories is to adapt the baller2vec self-attention mask so that baller2vec can “look ahead” at future positions of agents whose trajectories are generated prior to the agent being processed in the current time step. However, this look-ahead self-attention mask cannot be used with multi-layer Transformers because doing so necessitates “seeing the future”. For example, after the model attends to the blue agent’s position at time step $t + 1$ when processing the yellow agent at time step $t$ , the yellow agent’s resultant feature vector contains information about the blue agent’s future position. As a result, when the model attends to the yellow agent while processing the blue agent at the next level, the model is seeing the future. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            388,
+            789,
+            558
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "153 We motivate our baller2vec $^ { + + }$ architecture by first highlighting an issue that arises in baller2vec   \n154 when trying to model agent trajectories using the chain rule. The baller2vec self-attention mask   \n155 can be adapted so that baller2vec “looks ahead” at the future positions of agents whose trajectories   \n156 are generated prior to the agent being processed in the current time step (Figure 4). However, this   \n157 look-ahead self-attention mask can only be used with the final layer of the Transformer; otherwise,   \n158 the model needs to see the future (Figure 4). As a result, baller2vec is severely limited in the   \n159 conditional distribution functions it can learn.   \n160 baller2vec++ (Figure 5) overcomes this limitation by: (1) augmenting the baller2vec input with   \n161 two other sets of feature vectors and (2) using a specially designed self-attention mask. The three sets   \n162 of feature vectors in baller2vec++ take the following forms: ",
+        "bbox": [
+            140,
+            696,
+            825,
+            795
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            800,
+            825,
+            843
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8d00224629e2a0e61141f5913030113a2ac46c7b3e93512486bf080e7e8d8178.jpg",
+        "text": "$$\nu _ { t , k } = g _ { u } ( [ e ( p _ { k } ) , x _ { t + 1 , k } , y _ { t + 1 , k } , h _ { t , k } , \\Delta x _ { t , k } , \\Delta y _ { t , k } ] )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            873,
+            581,
+            892
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(current location information) (“look-ahead” information) (initial location information) ",
+        "bbox": [
+            612,
+            856,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/341f78788eddb00abb22b730cfa1023fd115a2ba1c459df00257391bef8e724d.jpg",
+        "image_caption": [
+            "Figure 5: To learn statistically dependent agent trajectories, baller2vec $^ { + + }$ uses a specially designed self-attention mask to simultaneously process three different sets of features vectors in a single Transformer. The three sets of feature vectors consist of location feature vectors like those found in baller2vec $( z _ { t , k } )$ , look-ahead trajectory feature vectors $( u _ { t , k } )$ , and starting location feature vectors $( r _ { k }$ ; not shown). As can be seen in these partial depictions of baller2vec $^ { + + }$ and the baller2vec $^ { + + }$ self-attention mask, this design allows the model to integrate information about concurrent agent trajectories through multiple Transformer layers without seeing the future. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            90,
+            769,
+            275
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "166 where $g _ { z } , g _ { u }$ , and $g _ { r }$ are multilayer perceptrons (MLPs), $e$ is an agent embedding layer, and $h _ { t , k }$ is a   \n167 vector of optional contextual features for agent $p _ { k }$ at time step $t$ . $z _ { t , k }$ is the same location feature   \n168 vector used in baller2vec and contains information about a specific agent’s identity and the agent’s   \n169 location at time step $t$ . $u _ { t , k }$ is a “look-ahead” trajectory feature vector that contains information about   \n170 a specific agent’s identity, the agent’s location at the next time step $t + 1$ , and the agent’s trajectory   \n171 at time step $t$ , i.e., $( x _ { t + 1 , k } - x _ { t , k } , y _ { t + 1 , k } - y _ { t , k } )$ . Lastly, $r _ { k }$ is a starting location feature vector that   \n172 contains information about a specific agent’s identity and the agent’s location at time step $t = 1$   \n173 The $r _ { k }$ feature vectors are necessary so that $_ { \\mathtt { > a } \\mathtt { 1 } \\mathtt { 1 e r } 2 \\mathtt { v e c } + + }$ can “see” the initial locations of all the   \n174 agents when processing the agents agent-wise in the first time step.   \n175 These three sets of feature vectors are combined to form a $( K + 2 T K ) \\times F$ matrix $Z$ such that   \n176 the first $K$ rows consist of the $\\textit { K r } _ { k }$ feature vectors, and the remaining $2 T K$ rows consist of the   \n177 $T K z _ { t , k }$ and $T K u _ { t , k }$ feature vectors interleaved with one another, i.e., each $z _ { t , k }$ is followed by its   \n178 corresponding $u _ { t , k }$ in the matrix. This matrix is passed into the Transformer along with the specially   \n179 designed self-attention mask, which encodes the following dependencies (see Figure 5): ",
+        "bbox": [
+            140,
+            402,
+            825,
+            529
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            534,
+            825,
+            603
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1. When processing $r _ { k _ { 1 } }$ , baller2vec $^ { + + }$ is exclusively allowed to “look” at each $r _ { k _ { 2 } }$ (i.e., baller2vec $^ { + + }$ cannot look at any location or look-ahead feature vectors when processing $r _ { k _ { 1 } } )$ ).   \n2. When processing $z _ { t _ { 2 } , k _ { 2 } }$ , baller2vec $^ { + + }$ is allowed to “look” at: (i) each $r _ { k 1 }$ , (ii) any $z _ { t _ { 1 } , k _ { 1 } }$ where (a) $t _ { 1 } < t _ { 2 }$ or (b) $t _ { 1 } = t _ { 2 }$ and $k _ { 1 } \\leq k _ { 2 }$ , and (iii) any $\\boldsymbol { u } _ { t _ { 1 } , k _ { 1 } }$ where (a) $t _ { 1 } < t _ { 2 }$ or (b) $t _ { 1 } = t _ { 2 }$ and $k _ { 1 } < k _ { 2 }$ .   \n3. When processing $u _ { t _ { 2 } , k _ { 2 } }$ , baller2vec $^ { + + }$ is allowed to “look” at: (i) each $r _ { k _ { 1 } }$ , (ii) any $z _ { t _ { 1 } , k _ { 1 } }$ where (a) $t _ { 1 } < t _ { 2 }$ or (b) $t _ { 1 } = t _ { 2 }$ and $k _ { 1 } \\leq k _ { 2 }$ , and (iii) any $\\boldsymbol { u } _ { t _ { 1 } , k _ { 1 } }$ where (a) $t _ { 1 } < t _ { 2 }$ or (b) $t _ { 1 } = t _ { 2 }$ and $k _ { 1 } \\leq k _ { 2 }$ . ",
+        "bbox": [
+            210,
+            613,
+            825,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "189 Each processed $z _ { t , k }$ feature vector is then passed through a linear layer that is followed by a softmax,   \n190 which gives a probability distribution over the trajectory bins for agent $p _ { k }$ at time step $t$ . Similar to   \n191 baller2vec, the loss for each sample is: ",
+        "bbox": [
+            142,
+            757,
+            825,
+            801
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b2058b13dc90418021c1bb09038a6c9a1e3df0638527b6b121b08f521935b0e.jpg",
+        "text": "$$\n\\mathcal { L } = \\sum _ { t = 1 } ^ { T } \\sum _ { k = 1 } ^ { K } - \\ln ( f ( Z ) _ { t , 2 k - 1 } [ v _ { t , k } ] )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            815,
+            619,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "192 where $f ( Z ) _ { t , 2 k - 1 } [ v _ { t , k } ]$ is the probability assigned to the trajectory bin $v _ { t , k }$ (where $\\begin{array} { r l } { v _ { t , k } } & { { } = } \\end{array}$   \n193 $\\mathbf { B i n } ( \\Delta x _ { t , k } , \\Delta y _ { t , k } )$ is an integer from one to $n ^ { 2 }$ ) by $f$ , i.e., Equation (3) is the negative log-likelihood   \n194 (NLL) of the data according to the model.   \n195 Because any ordering of a chain rule decomposition of a joint probability produces the same value,   \n196 e.g.: ",
+        "bbox": [
+            140,
+            867,
+            825,
+            912
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/29ef82fd840c7811fa76ff075dedfaea0fbd39a01d611ab86e18e63fc05189dc.jpg",
+        "text": "$$\np ( \\Delta x _ { t , 1 } ) p ( \\Delta x _ { t , 2 } | \\Delta x _ { t , 1 } ) p ( \\Delta x _ { t , 3 } | \\Delta x _ { t , 1 } \\Delta x _ { t , 2 } ) = p ( \\Delta x _ { t , 3 } ) p ( \\Delta x _ { t , 2 } | \\Delta x _ { t , 3 } ) p ( \\Delta x _ { t , 1 } | \\Delta x _ { t , 3 } \\Delta x _ { t , 2 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            126,
+            816,
+            145
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "97 like [11], we shuffled the order of the agents in each training sequence to encourage the model to   \n98 learn joint probabilities of the agent trajectories that are approximately permutation invariant with   \n199 respect to the ordering of the agents. ",
+        "bbox": [
+            148,
+            154,
+            828,
+            196
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "200 4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            215,
+            312,
+            233
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We tested baller2vec $^ { + + }$ on two different datasets. To highlight the pathological behavior of models that assume agent trajectories are statistically independent at each time step, we trained scaled down versions of baller2vec $^ { + + }$ and baller2vec on a toy dataset consisting of simulated trajectories for two perfectly coordinated agents. Additionally, to demonstrate the efficacy of baller2vec $^ { + + }$ in real world settings, we trained baller2vec $^ { + + }$ and baller2vec on a dataset of trajectories for professional basketball players. ",
+        "bbox": [
+            163,
+            246,
+            825,
+            329
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Toy dataset ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            344,
+            292,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Each training sample was initialized with the agents starting at $( - 1 , 0 )$ and $( 1 , 0 )$ on a grid in random order (i.e., the first agent could be placed to either the left or the right of the origin). At each time step, one of nine actions (corresponding to the $3 \\times 3$ grid surrounding the agent) was sampled from a uniform distribution, and each of the agents was translated along this trajectory. This process was repeated for 20 time steps (see Figure 6(a) for a sample). ",
+        "bbox": [
+            174,
+            371,
+            825,
+            440
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Basketball dataset ",
+        "text_level": 1,
+        "bbox": [
+            163,
+            455,
+            339,
+            469
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We used the same National Basketball Association (NBA) dataset3 employed by Alcorn and Nguyen [6], whom we paraphrase here: ",
+        "bbox": [
+            161,
+            481,
+            823,
+            510
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The NBA dataset consists of trajectories from 631 games from the 2015-2016 season, which were split into 569/30/32 training/validation/test games, respectively. During training, each sequence was sampled using the following procedure: (1) randomly select a training game, (2) randomly select a starting time from the game, (3) take the following four seconds of data and downsample it to $5 \\ : \\mathrm { H z }$ from the original $2 5 \\ : \\mathrm { H z }$ , and then (4) randomly (with a probability of 0.5) rotate the court $1 8 0 ^ { \\circ }$ . This sampling procedure gave us access to on the order of ${ \\sim } 8 2$ million different (albeit overlapping) training sequences. For both the validation and test sets, $\\mathord { \\sim } 1 , 0 0 0$ different, non-overlapping sequences were selected for evaluation by dividing each game into $\\lceil \\frac { 1 , 0 0 0 } { N } \\rceil$ non-overlapping chunks (where $N$ is the number of games), and using the starting four seconds from each chunk as the evaluation sequence. ",
+        "bbox": [
+            232,
+            520,
+            767,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Model ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            704,
+            258,
+            718
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our baller2vec $^ { + + }$ and baller2vec models for the basketball dataset closely followed [6], and so largely resemble the original Transformer architecture [12]. Specifically, the Transformer settings were: $d _ { \\mathrm { m o d e l } } = 5 1 2$ (the dimension of the input and output of each Transformer layer), eight attention heads, $d _ { \\mathrm { f f } } = 2 0 4 8$ (the dimension of the inner feedforward layers), six layers, no dropout, and no positional encoding. Each MLP (i.e., $g _ { z } , g _ { u }$ , and $g _ { r }$ ) had 128, 256, and 512 nodes in its three layers, respectively, and a ReLU nonlinearity following each of the first two layers. The player embeddings [13] had 20 dimensions, and $h _ { t , k }$ was a binary variable indicating the side of the frontcourt for player $p _ { k }$ (i.e., the direction of his team’s hoop) at time step $t$ . Lastly, the 11 ft $\\times 1 1$ ft 2D Euclidean trajectory space was binned into $1 2 1 1 \\mathrm { f t } \\times 1$ ft squares. ",
+        "bbox": [
+            173,
+            729,
+            825,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We used the Adam optimizer [14] with an initial learning rate of $1 0 ^ { - 6 }$ , $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9$ , and 9 $\\epsilon = 1 0 ^ { - 9 }$ to update the model parameters, of which there were ${ \\sim } 1 9$ million. The learning rate was ",
+        "bbox": [
+            158,
+            859,
+            825,
+            888
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "240 reduced to $1 0 ^ { - 7 }$ after 20 epochs of the validation loss not improving. Models were implemented in   \n241 PyTorch and trained on a single NVIDIA GTX 1080 Ti GPU for ${ \\sim } 6 5 0$ epochs (seven days) where   \n242 each epoch consisted of 20,000 training samples, and the validation set was used for early stopping. ",
+        "bbox": [
+            147,
+            92,
+            826,
+            133
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the toy dataset, we used scaled down versions of the basketball models with $d _ { \\mathrm { m o d e l } } = 1 2 8$ , four attention heads, $d _ { \\mathrm { f f } } = 5 1 2$ , and two layers in the Transformer. Additionally, each MLP had two layers with 64 and 128 nodes, respectively. The models were trained for 50 epochs of 500 samples per epoch ( $\\mathord { \\sim } 1 0 . 5$ minutes) using a single learning rate of $1 0 ^ { - 5 }$ . ",
+        "bbox": [
+            161,
+            140,
+            823,
+            195
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Results ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            215,
+            266,
+            232
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 baller2vec $^ { + + }$ can effectively model coordinated agents in both simulated and real settings ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            247,
+            790,
+            275
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For the toy dataset, the training loss for baller2vec converged to ${ \\sim } 2 . 2 \\approx - \\ln ( \\frac { 1 } { 9 } )$ , i.e., the model was simply independently guessing the trajectories for both agents at every time step. In contrast, the training loss for baller2vec $^ { + + }$ converged to ${ \\sim } 1 . 1 \\approx - \\ln ( \\frac { 1 } { 9 } ) \\div 2$ , which is the expected loss for a model that perfectly learns the deterministic relationship between the agents’ trajectories (because the prediction for the second agent will always contribute $- \\ln ( 1 . 0 ) { \\^ { - } } = 0$ to the loss). ",
+        "bbox": [
+            174,
+            285,
+            826,
+            356
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When generating trajectories with baller2vec, the agents are completely uncoordinated, with each agent following an independent random walk around the grid (Figure 6(b)). In contrast, trajectories generated by baller2vec++ display the same coordinated agent behavior as the training data (Figure 6(c)). ",
+        "bbox": [
+            173,
+            356,
+            356,
+            521
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "267 For the basketball dataset,   \n268 baller2vec $^ { + + }$ achieved   \n269 an average NLL of 0.472   \n270 on the test set, $8 . 9 \\%$ better   \n271 than the average NLL for ",
+        "bbox": [
+            142,
+            527,
+            356,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a0fb1e90a20bb4250fc54cd8087d4f9f3b791b5feaf43e27c0518a57b1ea6c9a.jpg",
+        "image_caption": [
+            "Figure 6: When trained on a dataset of perfectly coordinated agent trajectories (a), the trajectories generated by baller2vec are completely uncoordinated (b) while the trajectories generated by baller2vec++ are perfectly coordinated (c). Animated versions can be found in the code repository. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            385,
+            376,
+            807,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "baller2vec (0.518) (see Figure S1 for trajectories generated by baller2vec $^ { + + }$ and baller2vec). As was observed in [6], the trajectory bin distributions for baller2vec become much more certain after observing a portion of the sequence (Figure 7), which suggests baller2vec may be inferring some of the shared hidden variables (e.g., plays) influencing the players. If that hypothesis was true, the performance gap between baller2vec $^ { + + }$ and baller2vec should be largest at the beginning of the sequence (before any shared hidden variables can be inferred by baller2vec). Indeed, the average NLL for baller2vec $^ { + + }$ in the first time step of each test set sequence (1.567) is $1 6 . 1 \\%$ better than the average NLL for baller2vec (1.869), while the average NLL for baller2vec $^ { + + }$ in the last time step of each test set sequence (0.420) is only $9 . 7 \\%$ better than the average NLL for baller2vec (0.465) (see Figure 7). ",
+        "bbox": [
+            156,
+            597,
+            825,
+            734
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 baller2vec $^ { + + }$ makes better predictions when conditioned on concurrent trajectory information from other agents ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            752,
+            792,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Implicit in much of our discussion has been the intuition that providing a model with additional (relevant) information will improve its performance. To empirically test this conjecture, we compared the performance of baller2vec++ when predicting the trajectory of a specific basketball player placed in the first position of the player order (i.e., when $k = 1$ ) vs. predicting the trajectory for that same player placed in the last position (i.e., when $k = 1 0$ ). Specifically, for each player in each test sequence, we calculated the NLL of the player’s trajectory in the first time step4 with the player in the ",
+        "bbox": [
+            173,
+            790,
+            825,
+            873
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b0c117e5411d835f3b0dd0f04ad0c103bf28bedf51e5aa3f64afb60c928493d1.jpg",
+        "image_caption": [
+            "Figure 7: Left: when modeling the trajectories of professional basketball players, the performance gap between baller2vec $^ { + + }$ and baller2vec is largest at the beginning of the sequence, before shared unobserved variables can be inferred by baller2vec. Each bar indicates a model’s average NLL over the entire test set for that particular time step. For full sequences, baller2vec++ outperforms baller2vec by $8 . 9 \\%$ . Right: the joint probability assigned to a sequence by baller2vec $^ { + + }$ is approximately permutation invariant with respect to the order of the agents. For each point, its $x$ value indicates baller2vec $^ { + + }$ ’s average NLL for a test set sequence using the original order of the agents in the sequence, while its $y$ value indicates baller2vec $^ { + + }$ ’s average NLL for the same sequence with the order of the agents shuffled. The shuffled average NLLs are highly correlated with their corresponding unshuffled average NLLs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            792,
+            213
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "290 first position of the player order. Next, we moved the player to the last position of the player order,   \n291 and then randomly shuffled the remaining nine players 10 times, calculating the NLL for the player   \n292 in the last position each time. Finally, we calculated the average percent change in the last position   \n293 NLLs relative to their corresponding first position NLLs. On average, moving a player from the first   \n294 to the last position improved the NLL for the player’s trajectory by $1 4 . 6 \\%$ . ",
+        "bbox": [
+            142,
+            382,
+            823,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 The joint probability assigned to a sequence by baller2vec $^ { + + }$ is approximately permutation invariant with respect to the order of the agents ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            477,
+            766,
+            503
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To determine whether or not baller2vec $^ { + + }$ respects the fact that any ordering of a chain rule decomposition of a joint probability produces the same value, we measured how much the average NLL for each test sequence in the basketball dataset varied when the order of the agents changed. Specifically, for each test set sequence, we shuffled the order of the agents 10 times. Then, for each permuted sequence, we calculated the percent error5 in the average NLL relative to the original, unshuffled sequence. Across all test sequences, the average percent error was only $\\pm 1 . 5 \\%$ . Further, as can be seen in Figure 7, the shuffled average NLLs are highly correlated with their corresponding unshuffled average NLLs (Pearson correlation coefficient $= 0 . 9 9 7 $ ), i.e., the joint probability assigned to a sequence by baller2vec $^ { + + }$ is approximately permutation invariant with respect to the order of the agents. ",
+        "bbox": [
+            171,
+            518,
+            826,
+            657
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "307 6 Conclusion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            684,
+            449,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have shown how the commonly used independence assumption of many multi-agent spatiotemporal models can severely limit their ability to learn to emulate coordinated agents. By relaxing this independence assumption in baller2vec, baller2vec++ was able to more accurately model the trajectories of professional basketball players. Models for other multi-agent spatiotemporal environments, such as pedestrian traffic (see [15] for a survey) and vehicle traffic (e.g., [16–19]), may also benefit from the look-ahead approach used by baller2vec++. Additionally, the interleaved input design of baller2vec++ could be useful when modeling other systems involving many entities interacting through time, such as social media platforms (e.g., [20, 21]). However, confronting the quadratic complexity of the Transformer attention mechanism as the number of entities grows large in these datasets is an open problem, but recent work in sparse Transformers (e.g., [22–27]) shows encouraging progress. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "319 References   \n20 [1] Panna Felsen, Patrick Lucey, and Sujoy Ganguly. Where will they go? predicting fine-grained   \n21 adversarial multi-agent motion using conditional variational autoencoders. In Proceedings of   \n22 the European Conference on Computer Vision (ECCV), pages 732–747, 2018.   \n323 [2] Agrim Gupta, Justin Johnson, Li Fei-Fei, Silvio Savarese, and Alexandre Alahi. Social gan:   \n24 Socially acceptable trajectories with generative adversarial networks. In Proceedings of the   \n325 IEEE Conference on Computer Vision and Pattern Recognition, pages 2255–2264, 2018.   \n26 [3] Amir Sadeghian, Vineet Kosaraju, Ali Sadeghian, Noriaki Hirose, Hamid Rezatofighi, and   \n327 Silvio Savarese. Sophie: An attentive gan for predicting paths compliant to social and physical   \n28 constraints. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern   \n29 Recognition, pages 1349–1358, 2019.   \n330 [4] Raymond A Yeh, Alexander G Schwing, Jonathan Huang, and Kevin Murphy. Diverse genera  \n31 tion for multi-agent sports games. In Proceedings of the IEEE Conference on Computer Vision   \n332 and Pattern Recognition, pages 4610–4619, 2019.   \n333 [5] Cunjun Yu, Xiao Ma, Jiawei Ren, Haiyu Zhao, and Shuai Yi. Spatio-temporal graph transformer   \n34 networks for pedestrian trajectory prediction. In Proceedings of the European Conference on   \n35 Computer Vision (ECCV), August 2020.   \n336 [6] Michael A. Alcorn and Anh Nguyen. baller2vec: A multi-entity transformer for multi-agent   \n37 spatiotemporal modeling. arXiv preprint arXiv:2102.03291, 2021.   \n338 [7] Eric Zhan, Stephan Zheng, Yisong Yue, Long Sha, and Patrick Lucey. Generating multi-agent   \n339 trajectories using programmatic weak supervision. In International Conference on Learning   \n40 Representations, 2019. URL https://openreview.net/forum?id $\\equiv$ rkxw-hAcFQ.   \n41 [8] Stephan Zheng, Yisong Yue, and Jennifer Hobbs. Generating long-term trajectories using deep   \n342 hierarchical networks. Advances in Neural Information Processing Systems, 29:1543–1551,   \n43 2016.   \n344 [9] Vineet Kosaraju, Amir Sadeghian, Roberto Martín-Martín, Ian Reid, Hamid Rezatofighi, and   \n45 Silvio Savarese. Social-bigat: Multimodal trajectory forecasting using bicycle-gan and graph   \n46 attention networks. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché-Buc, E. Fox,   \n47 and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32.   \n348 Curran Associates, Inc., 2019. URL https://proceedings.neurips.cc/paper/2019/   \n49 file/d09bf41544a3365a46c9077ebb5e35c3-Paper.pdf.   \n350 [10] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´   \n51 Bengio. Graph Attention Networks. International Conference on Learning Representations,   \n52 2018. URL https://openreview.net/forum?id=rJXMpikCZ. accepted as poster.   \n53 [11] Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V   \n354 Le. Xlnet: Generalized autoregressive pretraining for language understanding. arXiv preprint   \n55 arXiv:1906.08237, 2019.   \n56 [12] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,   \n357 Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Informa  \n58 tion Processing Systems, pages 5998–6008, 2017.   \n59 [13] Michael A Alcorn. (batter|pitcher)2vec: Statistic-free talent modeling with neural player   \n60 embeddings. In MIT Sloan Sports Analytics Conference, 2018.   \n61 [14] Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In Interna  \n62 tional Conference on Learning Representations, 2015.   \n63 [15] Andrey Rudenko, Luigi Palmieri, Michael Herman, Kris M Kitani, Dariu M Gavrila, and Kai O   \n64 Arras. Human motion trajectory prediction: A survey. The International Journal of Robotics   \n65 Research, 39(8):895–935, 2020. ",
+        "bbox": [
+            150,
+            64,
+            828,
+            914
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[16] Nachiket Deo and Mohan M Trivedi. Convolutional social pooling for vehicle trajectory prediction. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, pages 1468–1476, 2018.   \n[17] Ming-Fang Chang, John Lambert, Patsorn Sangkloy, Jagjeet Singh, Slawomir Bak, Andrew Hartnett, De Wang, Peter Carr, Simon Lucey, Deva Ramanan, and James Hays. Argoverse: 3d tracking and forecasting with rich maps. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   \n[18] Tianyang Zhao, Yifei Xu, Mathew Monfort, Wongun Choi, Chris Baker, Yibiao Zhao, Yizhou Wang, and Ying Nian Wu. Multi-agent tensor fusion for contextual trajectory prediction. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   \n[19] Rohan Chandra, Uttaran Bhattacharya, Aniket Bera, and Dinesh Manocha. Traphic: Trajectory prediction in dense and heterogeneous traffic using weighted interactions. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), June 2019.   \n[20] Srijan Kumar, Xikun Zhang, and Jure Leskovec. Predicting dynamic embedding trajectory in temporal interaction networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pages 1269–1278, 2019.   \n[21] Emanuele Rossi, Ben Chamberlain, Fabrizio Frasca, Davide Eynard, Federico Monti, and Michael Bronstein. Temporal graph networks for deep learning on dynamic graphs. In ICML 2020 Workshop on Graph Representation Learning, 2020.   \n[22] Rewon Child, Scott Gray, Alec Radford, and Ilya Sutskever. Generating long sequences with sparse transformers. arXiv preprint arXiv:1904.10509, 2019.   \n[23] Manzil Zaheer, Guru Guruganesh, Kumar Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, and Amr Ahmed. Big bird: Transformers for longer sequences. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 17283–17297. Curran Associates, Inc., 2020. URL https://proceedings.neurips. cc/paper/2020/file/c8512d142a2d849725f31a9a7a361ab9-Paper.pdf.   \n[24] Iz Beltagy, Matthew E Peters, and Arman Cohan. Longformer: The long-document transformer. arXiv preprint arXiv:2004.05150, 2020.   \n[25] Nikita Kitaev, Lukasz Kaiser, and Anselm Levskaya. Reformer: The efficient transformer. In International Conference on Learning Representations, 2020. URL https://openreview. net/forum?id $\\equiv$ rkgNKkHtvB.   \n[26] Jonathan Ho, Nal Kalchbrenner, Dirk Weissenborn, and Tim Salimans. Axial attention in multidimensional transformers. arXiv preprint arXiv:1912.12180, 2019.   \n[27] Gedas Bertasius, Heng Wang, and Lorenzo Torresani. Is space-time attention all you need for video understanding? arXiv preprint arXiv:2102.05095, 2021. ",
+        "bbox": [
+            148,
+            90,
+            828,
+            715
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Section 6.   \n(c) Did you discuss any potential negative societal impacts of your work? [No] Our work does not introduce new ethical challenges.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            239
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            243,
+            493,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            238,
+            262,
+            735,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            299,
+            393,
+            313
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            316,
+            825,
+            435
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            220,
+            439,
+            823,
+            454
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [No] We link directly to the dataset.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            458,
+            823,
+            565
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            569,
+            705,
+            584
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            588,
+            825,
+            678
+        ],
+        "page_idx": 11
+    }
+]

parse/train/w3x8K0M6sAz/w3x8K0M6sAz.md

@@ -0,0 +1,273 @@
+# Topology-Imbalance Learning for Semi-Supervised Node Classification
+
+Deli Chen1,2, Yankai $\mathbf { L i n } ^ { 1 }$ , Guangxiang Zhao2, Xuancheng Ren2, Peng $\mathbf { L i } ^ { 1 }$ , Jie $\mathbf { Z } \mathbf { h o u } ^ { 1 }$ , $\mathbf { X } \mathbf { u } \mathbf { S } \mathbf { u } \mathbf { n } ^ { 2 }$ 1Pattern Recognition Center, WeChat AI, Tencent Inc., China 2MOE Key Lab of Computational Linguistics, School of EECS, Peking University {delichen, yankailin, patrickpli,withtomzhou}@tencent.com {zhaoguangxiang,renxc,xusun}@pku.edu.cn
+
+# Abstract
+
+The class imbalance problem, as an important issue in learning node representations, has drawn increasing attention from the community. Although the imbalance considered by existing studies roots from the unequal quantity of labeled examples in different classes (quantity imbalance), we argue that graph data expose a unique source of imbalance from the asymmetric topological properties of the labeled nodes, i.e., labeled nodes are not equal in terms of their structural role in the graph (topology imbalance). In this work, we first probe the previously unknown topology-imbalance issue, including its characteristics, causes, and threats to semisupervised node classification learning. We then provide a unified view to jointly analyzing the quantity- and topology- imbalance issues by considering the node influence shift phenomenon with the Label Propagation algorithm. In light of our analysis, we devise an influence conflict detection–based metric Totoro to measure the degree of graph topology imbalance and propose a model-agnostic method ReNode to address the topology-imbalance issue by re-weighting the influence of labeled nodes adaptively based on their relative positions to class boundaries. Systematic experiments demonstrate the effectiveness and generalizability of our method in relieving topology-imbalance issue and promoting semi-supervised node classification. The further analysis unveils varied sensitivity of different graph neural networks (GNNs) to topology imbalance, which may serve as a new perspective in evaluating GNN architectures.1
+
+# 1 Introduction
+
+Graph is a widely-used data structure [51], where the nodes are connected to each other through natural or handcrafted edges. Similar to other data structures, the representation learning for node classification faces the challenge of quantity-imbalance issue, where the labeling size varies among classes and the decision boundaries of trained classifiers are mainly decided by the majority classes [46]. There have been a series of studies [35, 11, 49] handling the Quantity-Imbalance Node Representation Learning (short as QINL). However, different with other data structures, graph-structured data suffers from another aspect of the imbalance problem: the imbalance caused by the asymmetric and uneven topology of labeled nodes, where the decision boundaries are driven by the labeled nodes close to the topological class boundaries (left of Figure 1) thus interfering with the model learning.
+
+Present Work. For the first time, we recognize the Topology-Imbalance Node Representation Learning (short as TINL) as a graph-specific imbalance learning topic, which mainly focus on the decision boundaries shift phenomena driven by the topology imbalance in graph and is an essential component for node imbalance learning. Comparing with the well-explored QINL that studies the imbalance caused by the numbers of labeled nodes, TINL explores the imbalance caused by the positions of labeled nodes and owns the following characteristics:
+
+![](images/3c5d5345b792342769fcf85d480df7dfaf12f9fa1c75f46eec6382748a5fb423.jpg)  
+Figure 1: Schematic diagram of the topology-imbalance issue in node representation learning. The color and the hue denote the type and the intensity of each node’s received influence from the labeled nodes, respectively. The left shows that nodes close to the boundary have the risk of information conflict and nodes far away from labeled nodes have the risk of information insufficient. The right shows that our method can decrease the training weights of labeled nodes (R1) close to the class boundary and increase the weights of labeled nodes (B and R2) close to the class centers, thus relieving the topology-imbalance issue.
+
+• Ubiquity: Due to the complex connections of the graph nodes, the topology structure of nodes in different categories is naturally asymmetric, which makes TINL an essential characteristic in node representation learning. Hence, it is difficult to construct a completely symmetric labeling set even with an abundant annotation budget. • Perniciousness: The influence from labeled nodes decays with the topology distance [3]. The asymmetric topology of labeled nodes in different classes and the uneven distribution of labeled nodes in the same class will cause the influence conflict and influence insufficient problems (left of Figure 1) respectively, resulting in a shift of decision boundaries. • Orthogonality: Quantity-imbalance studies [49, 8, 5] usually treat the labeled nodes of the same class as a whole and devise solutions based on the total numbers of each class, while TINL explores the influence of the unique position of each labeled node on decision boundaries. Thus, TINL is independent of QINL in terms of the object of study.
+
+Exploring TINL is of great importance for node representation learning due to its ubiquity and perniciousness. However, the methods [17, 22] for quantity imbalance can be hardly applied to TINL because of the orthogonality. To remedy the topology-imbalance issue, thus promoting the node classification, we propose a model-agnostic training framework ReNode to re-weight the labeled nodes according to their positions. We devise the conflict detection-based Topology Relative Location (Totoro) metric to leverage the interaction among labeled nodes across the whole graph to locate their structural positions. Based on the Totoro metric, we further increase the training weights of nodes with small conflict that are highly likely to be close to topological class centers to make them play a more pivotal role during training, and vice versa (right of Figure 1). Empirical results of various imbalance scenarios (TINL, QINL, large-scale graph) and multiple graph neural networks (GNNs) demonstrate the effectiveness and generalizability of our method. Besides, we provide the sensitivity to topology imbalance as a new evaluation perspective for different GNN architectures.
+
+# 2 Topology-Imbalance Node Representation Learning
+
+# 2.1 Notations and Preliminary
+
+In this work, we follow the well-established semi-supervised node classification setting [47, 18] to conduct analyses and experiments. Given an undirected and unweighted graph $\mathcal { G } = ( \boldsymbol { \nu } , \pmb { \varepsilon } , \pmb { c } )$ , where $\nu$ is the node set represented by the feature matrix $\boldsymbol { X } \in \mathbb { R } ^ { n * d }$ $\dot { \boldsymbol { n } } = | \boldsymbol { \nu } |$ is the node size and $d$ is the node embedding dimension), $\varepsilon$ is the edge set which is represented by an adjacency matrix $A \in \mathbb { R } ^ { n * n }$ , $\pmb { \mathcal { L } } \subset \nu$ is the labeled node set and usually we have $| \bar { \boldsymbol { L } } | \ll | \boldsymbol { \nu } |$ , the node classification task is to train a classifier $\mathcal { F }$ (usually a GNN) to predict the class label y for the unlabeled node set $u = \nu - c$ . The training sets for different classes are represented by $( \pmb { \mathscr { C } } _ { 1 } , \pmb { \mathscr { C } } _ { 2 } , \cdots , \pmb { \mathscr { C } } _ { k } )$ and $k$ is the number of classes. The labeling ratio $\delta = \angle \mathcal { x } / \nu$ is the proportion of labeled nodes in all nodes. In this work, we focus on TINL in homogeneously-connected graphs and hope to inspire future studies on the critical topology-imbalance issue.
+
+![](images/25999ec10387c1b8ccfbc868ce85fd4adb3997f394bbe9fe5415c3fa41a2bab0.jpg)  
+Figure 2: Node influence and boundary shift caused by quantity- and topology-imbalance. (a): The prediction results of GCN and LP are highly consistent (t-SNE [39] visualization of the $C O R A$ dataset). (b): The node influence boundary (the yellow dotted line) is shifted towards the small class from the true class boundary (the black dotted line) under the quantity- and topology-imbalance scene. (c): The node influence boundary is shifted towards the large class under the quantity-balanced, topology-imbalanced scene. We regard the large class as positive class to indicate the results.
+
+# 2.2 Understanding Topology Imbalance via Label Propagation
+
+From Figure 1, we can intuitively perceive the imbalance brought by the positions of labeled nodes; in this part, we further explore the nature of topology imbalance with the well-known Label Propagation [50] algorithm (short as LP) and provide a uniform analysis framework for the comprehensive node imbalance issue. In LP, labels are propagated from the labeled nodes and aggregated along edges, which can also be viewed as a random walk process from labeled nodes. The convergence result $\mathbf { Y }$ after repeated propagation is regarded as the nodes soft-labels:
+
+$$
+\pmb { Y } = \alpha ( \pmb { I } - ( 1 - \alpha ) \pmb { A } ^ { \prime } ) ^ { - 1 } \pmb { Y } ^ { 0 } ,
+$$
+
+where $\pmb { I }$ is the identity matrix, $\alpha \in ( 0 , 1 ]$ is the random walk restart probability, $A ^ { \prime } = D ^ { - { \frac { 1 } { 2 } } } A D ^ { - { \frac { 1 } { 2 } } }$ is the adjacency matrix normalized by the diagonal degree matrix $_ { D }$ , $\mathbf { \dot { Y } } ^ { 0 }$ is the initial label distribution where labeled nodes are represented by the one-hot vectors. The prediction label for the $i$ -th node is $q _ { i } = \arg \operatorname* { m a x } _ { j } Y _ { i j }$ . LP is a simple yet successful model [37] and can be unified with GNN models owning the message-passing mechanism [41]. From Figure 2(a), we can empirically find that there is a significant correlation between the results of LP and GCN (T/F indicates prediction is True/False).
+
+The LP prediction $\pmb q$ can be viewed as the distribution of the (labeled) node influence [41] (i.e. each node is mostly influenced by which class’s information); hence the boundaries of the node influence can act as an effective reflection for the GNN model decision boundaries considering the high consistency between LP and GNN. Moreover, node influence offers a unified view of TINL and QINL: ideally, the node influence boundaries should be consistent with the true class boundaries, but both the labeled nodes’ numbers (QINL) and positions (TINL) can cause a shift of the node influence boundaries from the true one, resulting in deviation of the model decision boundaries.
+
+Node imbalance issue is composed of topology- and quantity-imbalance. Figure 2 illustrates two examples of node influence boundary shift. In Figure 2(b), when the uniform selection is adopted to generate training set, both the quantity and the topology are imbalanced for model training; then the large class with more total nodes (denotes by blue color) will own stronger influence than the small class with fewer total nodes (denotes by red color) due to the quantity advantage and the node influence boundary is shifted towards the small class. In Figure 2(c), when the quantity-balanced strategy is adopted for sampling training nodes, it will be easier for the small class to has more labeled nodes close to the class boundary and the boundary of the node influence is shifted into the large class. We can find that even when the training set is quantity-balanced, the topology-imbalance issue still exists and hinders the node classification learning. Hence, we can conclude that node imbalance learning is caused by the joint effect of TINL and QINL. Separately considering TINL or QINL will lead to a one-sided solution to node imbalance learning.
+
+![](images/f912716e23c177a4938148c7a1170b81fdfe86390b15dbfd19bd85e1becda3fb.jpg)  
+Figure 3: Effectiveness of Totoro at (a) Node Level: labeled nodes (t-SNE visualization of the CORA dataset) with less influence conflict (lighter color) are farther-away from class boundaries than those with high conflict (darker color), and (b) Dataset Level: There is a significant negative correlation between the GNN (GCN) performance and overall conflict of the training set (the Pearson correlation coefficient is $- 0 . 6 1 8$ over 50 randomly selected training sets with the $p$ value smaller than 0.01).
+
+# 2.3 Measuring Topology Imbalance by Influence Conflict
+
+Although we have realized that the imbalance of node topology interferes with model learning, how to measure the labeled node’s relative topological position to its class (being far away from or close to the class center) remains the key challenge in handling the topology-imbalance issue due to the complex graph connections and the unknown class labels for most nodes in the graph. As the nodes are homogeneously connected when constructing the graph, even nodes close to the class boundaries own similar characteristics to their neighbors. Thus it is unreliable to leverage the difference between the characteristics of one labeled node and its surrounding subgraphs to locate its topological position. Instead, we propose to utilize the node topology information by considering the node influence conflict across the whole graph and devise the Conflict Detection-based Topology Relative Location metric (Totoro).
+
+Similar to Eq (1), we calculate the Personalized PageRank [27] matrix $_ { r }$ to measure node influence distribution from each labeled node:
+
+$$
+P = \alpha ( { \cal I } - ( 1 - \alpha ) A ^ { \prime } ) ^ { - 1 } .
+$$
+
+Node influence conflict denotes topological position. According to related studies [41, 19, 2], $_ { r }$ can be viewed as the distribution of influence exerted outward from each node. We assume that if a labeled node $v \in \nu$ encounters strong heterogeneous influence from the other classes’ labeled nodes in the subgraph around node $v$ where node $v$ itself owns great influence, we have the conclusion that node $v$ meets large influence conflict in message passing and it is close to topological class boundaries, and vice versa. Based on this hypothesis, we take the expectation of the influence conflict between the node $v$ and the labeled nodes from other classes when node $v$ randomly walks across the entire graph as a measurement of how topologically close node $v$ is to the center of the class it belongs to. The Totoro value of node $v$ is computed as:
+
+$$
+\pmb { T } _ { v } = \mathbb { E } _ { \boldsymbol { x } \sim \pmb { P } _ { v , : } } [ \sum _ { \substack { j \in [ 1 , k ] , j \neq y _ { v } } } \frac { 1 } { | \pmb { \mathcal { C } } _ { j } | } \sum _ { i \in \pmb { \mathcal { C } } _ { j } } \pmb { P } _ { i , x } ] ,
+$$
+
+where $\mathbf { \nabla } _ { \mathbf { y } _ { v } }$ is the ground-truth label of node $v$ , $P _ { v }$ indicates the personalized PageRank probability vector for the node $v$ . A larger Totoro value $\mathbf { \delta } _ { \mathbf { \mathcal { T } } _ { v } }$ indicates that node $v$ is topologically closer to class boundaries, and vice versa. The normalization item $1 / | c _ { j } |$ is added to make the influence from the different classes comparable when computing conflict.
+
+We visualize the node labels and the Totoro values (scaled to $[ 0 , 1 ] $ ) of labeled nodes in Figure 3(a). We can find that the labeled nodes with smaller Totoro values are farther away from the class boundaries, demonstrating the effectiveness of Totoro in locating the positions of labeled nodes. Besides, we sum the conflict of all the labeled nodes $\textstyle \sum _ { b \in { \mathcal { L } } } T _ { v }$ to measure the overall conflict of the dataset, which can be viewed as the metric for the overall topology imbalance given the graph $\mathfrak { g }$ and the training set $\mathcal { L }$ . Figure 3(b) shows that there is a significant negative correlation between the overall conflict and the model performance, which further demonstrates the effectiveness of Totoro in measuring the intensity of topology imbalance at the dataset level.
+
+# 2.4 Alleviate Topology Imbalance by Instance-wise Node Re-weighting
+
+In this section, we introduce ReNode, a model-agnostic training weight schedule mechanism to address TINL for general GNN encoder in a plug-and-play manner. Inspired by the analysis in Section 2.2, the ReNode method is devised to promote the training weights of the labeled nodes that are close to the topological class centers, so as to make these nodes play a more active role in model learning, and vice versa. Specifically, we devise a cosine annealing mechanise 2 for the training node weights based on their Totoro values:
+
+$$
+{ \pmb w } _ { v } = w _ { \mathrm { m i n } } + \frac { 1 } { 2 } ( w _ { \mathrm { m a x } } - w _ { \mathrm { m i n } } ) ( 1 + \cos ( \frac { \mathrm { R a n k } ( { \pmb T } _ { v } ) } { | { \pmb L } | } \pi ) ) , \quad v \in { \pmb C }
+$$
+
+where $\pmb { w } _ { v }$ is the modified training weight for the labeled node $v , w _ { \mathrm { m i n } } , w _ { \mathrm { m a x } }$ are the hyper-parameters indicating the lower bound and upper bound of the weight correction factor, $\mathrm { R a n k } ( \pmb { T } _ { v } )$ is the ranking order of $\mathbf { \delta } _ { \mathbf { \mathcal { T } } _ { v } }$ from the smallest to the largest. The training loss $L _ { T }$ for the quantity-balanced, topologyimbalanced node classification task is computed by the following equations:
+
+$$
+L _ { T } = - \frac { 1 } { | { \cal { L } } | } \sum _ { v \in { \cal { L } } } w _ { v } \sum _ { c = 1 } ^ { k } y _ { v } ^ { * c } \log \ g _ { v } ^ { c } , \quad g = \mathrm { s o f t m a x } ( { \mathcal { F } } ( X , A , \theta ) ) ,
+$$
+
+where $\mathcal { F }$ denotes any GNN encoder, $\pmb \theta$ is the parameter of ${ \mathcal { F } } , g _ { i }$ is the GNN output for node $i$ , $\mathbf { \nabla } _ { \mathbf { \boldsymbol { y } } _ { i } ^ { * } }$ is the gold label for node $i$ in one-hot embedding. By encouraging the positive effects of the labeled nodes near the class topological centers, and reducing the negative effects of those near the topological class boundaries, our ReNode method is expected to minimize the deviation between the node influence boundaries and the true class boundaries, so as to correct the class imbalance caused by the positions of labeled nodes.
+
+ReNode to Jointly Handle TINL and QINL In this part, we introduce the application of the ReNode method in a more general graph imbalance scenario where both the topology- and quantityimbalance issues exist. As analyzed in previous sections, the TINL and QINL are orthogonal problems. Therefore, we propose that our ReNode method based on (labeled) node topology can be seamlessly combined with the existing methods designed for the quantity-imbalance learning. Without loss of generality, we present how our ReNode method can be combined with the vanilla class frequency-based re-weight method [17]. The training loss $L _ { Q }$ for the quantity-imbalanced, topology-imbalanced node classification task is formalized in the following equation:
+
+$$
+L _ { Q } = - \frac { 1 } { | \mathcal { L } | } \sum _ { v \in \mathcal { L } } w _ { v } \frac { | \bar { \mathcal { C } } | } { | \mathcal { C } _ { j } | } \sum _ { c = 1 } ^ { k } { y } _ { v } ^ { * c } \log \textbf { \em g } _ { v } ^ { c } ,
+$$
+
+where $| \bar { c } |$ is the average number of the class training sizes. With this method, the final weight of the labeled node is affected by two perspectives: training examples of the minority classes will have higher weights than that of the majority classes; training examples close to the topological class centers will have higher weights than those are close to the topological class boundaries.
+
+ReNode for Large-scale Graph There are mainly two challenges when applying ReNode to largescale graphs: (1) how to calculate the PageRank matrix, and (2) how to train the GNN model in an inductive setting [13]. In this work, we follow the PPRGo method [2] to implement our method on the large-scale graph, which can decouple the feature learning process from the information transmission process to resolve the dependence on the global graph topology structure and can be carried out much efficiently. Following PPRGo, the Personalized PageRank matrix $\hat { P }$ and the corresponding training ReNode factor $\hat { \pmb { w } }$ are generated by the estimation method from Andersen et al. [1] and then $\hat { P }$ is directly employed as the aggregation weights from all the other nodes regardless of their topology distance from the current node:
+
+Table 1: ReNode (short as RN) for the pure topology-imbalance issue. We report Weighted-F1 (W-F, $\%$ ), Macro-F1 (M-F, $\%$ ) and the corresponding standard deviation for each group of experiments. $^ *$ and $^ { \ast \ast }$ represent the result is significant in student t-test with $p < 0 . 0 5$ and $p < 0 . 0 1$ , respectively.   
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Training</td><td colspan="2">CORA</td><td colspan="2">CiteSeer</td><td colspan="2">PubMed</td><td colspan="2">Photo</td><td colspan="2">Computers</td></tr><tr><td>W-F</td><td>M-F</td><td>W-F</td><td>M-F</td><td>W-F</td><td>M-F</td><td>W-F</td><td>M-F</td><td>W-F</td><td>M-F</td></tr><tr><td rowspan="2">GCN</td><td>w/oRN</td><td>79.1±1.1</td><td>77.8±1.5</td><td>66.2±1.0</td><td>62.0±1.3</td><td>74.6±2.1</td><td>74.7±1.9</td><td>86.8±2.0</td><td>84.7±1.7</td><td>74.2±2.6</td><td>73.6±2.9</td></tr><tr><td>w/RN</td><td>79.8**±0.9</td><td>78.6**±1.2</td><td>66.9* ±1.1</td><td>62.8* ±1.4</td><td>76.1** ±1.5</td><td>76.1**±1.8</td><td>87.7**±2.2</td><td>85.4**±1.9</td><td>74.7* ±2.2</td><td>74.5**±2.3</td></tr><tr><td rowspan="2">GAT</td><td>w/o RN</td><td>76.0±1.7</td><td>74.9±1.9</td><td>66.3±2.8</td><td>62.4±2.6</td><td>73.9±2.2</td><td>73.9±2.1</td><td>88.3±2.0</td><td>86.2±2.2</td><td>79.0±2.1</td><td>78.8±2.3</td></tr><tr><td>W/RN</td><td>77.7**±*2.0</td><td>76.2**±1.8</td><td>67.1*±1.9</td><td>63.2*±1.6</td><td>75.2**±2.0</td><td>75.1**±2.5</td><td>89.1**±2.0</td><td>87.1**±2.0</td><td>78.8±1.9</td><td>78.7±2.0</td></tr><tr><td rowspan="2">PPNP</td><td>w/oRN</td><td>80.5±1.6</td><td>79.1±1.4</td><td>67.5±1.8</td><td>63.2±1.6</td><td>74.6±1.9</td><td>74.7±1.7</td><td>89.3±1.3</td><td>86.8±1.4</td><td>78.7±1.5</td><td>77.7±1.7</td></tr><tr><td>w/RN</td><td>81.9**±0.6</td><td>80.5**±0.8</td><td>68.1* ±1.4</td><td>63.7* ±2.0</td><td>76.0**±2.0</td><td>76.1**±2.2</td><td>89.7*±1.0</td><td>87.2* ±1.3</td><td>79.0* ±1.1</td><td>78.3* ±11</td></tr><tr><td rowspan="2">SAGE</td><td>w/o RN</td><td>75.1±1.7</td><td>74.6±1.4</td><td>67.0±1.4</td><td>63.0±1.4</td><td>74.2±2.2</td><td>74.2±2.1</td><td>86.2±2.6</td><td>83.9±2.4</td><td>73.5±3.4</td><td>71.6±2.5</td></tr><tr><td>w/RN</td><td>75.7**±1.7</td><td>75.1**±1.4</td><td>67.3±1.4</td><td>63.5* ±1.2</td><td>74.9**±1.9</td><td>78.2**±2.3</td><td>86.5±1.7</td><td>84.1±1.7</td><td>74.9**±3.0</td><td>72.3**±2.5</td></tr><tr><td rowspan="2">CHEB</td><td>w/oRN</td><td>74.5±1.1</td><td>73.4±1.1</td><td>66.8±1.8</td><td>63.2±1.6</td><td>75.1±1.8</td><td>75.2±1.1</td><td>82.1±2.2</td><td>79.4±3.5</td><td>70.3±4.0</td><td>68.4±3.4</td></tr><tr><td>w/RN</td><td>75.3**±1.1</td><td>74.0**±1.1</td><td>67.5**±1.6</td><td>63.8**±1.5</td><td>76.2**±1.4</td><td>76.3**±1.2</td><td>84.8**±2.4</td><td>82.1**±2.8</td><td>70.5±4.0</td><td>68.6±3.4</td></tr><tr><td rowspan="2">SGC</td><td>w/oRN</td><td>74.9±2.1</td><td>73.8±2.1</td><td>65.7±1.6</td><td>61.8±1.6</td><td>72.9±2.3</td><td>73.1±2.6</td><td>87.1±1.3</td><td>84.9±11</td><td>77.4±1.7</td><td>76.8±1.8</td></tr><tr><td>w/RN</td><td>77.0**±1.1</td><td>76.0**±1.1</td><td>67.2**±1.3</td><td>62.9**±1.8</td><td>73.7**±2.8</td><td>73.8**±2.1</td><td>87.4±1.5</td><td>85.2±1.5</td><td>78.2**±1.8</td><td>77.8**±1.2</td></tr></table>
+
+Table 2: Result of different dataset conflict levels (High/Middle/Low). Our ReNode method improve the GNN (GCN) performance most when the conflict level of graph is high.   
+
+<table><tr><td>W-F(%)</td><td>CORA-H</td><td>CORA-M</td><td>CORA-L</td><td>CiteSeer-H</td><td>CiteSeer-M</td><td>CiteSeer-L</td><td>PubMed-H</td><td>PubMed-M</td><td>|PubMed-L</td></tr><tr><td>w/o RN w/RN</td><td>76.5±1.3 78.7**±0.8</td><td>78.4±0.7 79.3**±0.6</td><td>79.7±0.8 80.4**±0.6</td><td>62.6±1.5 63.8**±1.3</td><td>65.3±0.6 66.0**±0.8</td><td>67.3±1.1 67.5±1.4</td><td>72.1±2.4 74.3**±2.1</td><td>74.7±1.8 75.6**±1.9</td><td>78.3±1.8 78.8* ±1.5</td></tr></table>
+
+$$
+\pmb { g } ^ { \prime } = \mathrm { s o f t m a x } ( \hat { P } \mathcal { F } ^ { \prime } ( \pmb { X } , \pmb { \theta } ^ { \prime } ) ) ,
+$$
+
+where ${ \mathcal { F } } ^ { \prime }$ can be a linear layer or a multi-layer perceptron with parameter $\theta ^ { \prime }$ . The final training loss for large-scale graph $L _ { L }$ follows Eq (5) and (6), and replaces $\pmb { w }$ and $\textbf {  { g } }$ with $\hat { \pmb { w } }$ and $\pmb { g } ^ { \prime }$ .
+
+# 3 Experiments
+
+In this section, we will first introduce the experimental datasets for both transductive and inductive semi-supervised node classification. Then we introduce the experiments to verify the effectiveness of the proposed ReNode method in three different imbalance situations: (1) TINL only, (2) TINL and QINL, (3) Large-scale Graph.
+
+# 3.1 Datasets
+
+We adopt two sets of graph datasets to conduct experiments. For the transductive setting [13], we take the widely-used Plantoid paper citation graphs [33] (CORA,CiteSeer, Pubmed) and the Amazon copurchase graphs [24] (Photo,Computers) to verify the effectiveness of our method. For the inductive setting, we conduct experiments on the popular Reddit dataset [13] and the enormous MAG-Scholar dataset (coarse-grain version) [2] which owns millions of nodes and features. For each of these datasets, we repeat experiments on 5 different datasets splittings [34] and we run 3 times for each splitting to reduce the random variance. More details about the datasets and experiment settings are presented in Appendix A.
+
+# 3.2 ReNode for the Pure Topology-imbalance Issue
+
+Settings When considering topology-imbalance only, the labeling set takes a balanced setting and the annotation size for each class is all equal to $| \dot { \mathcal { L } } | / k$ . Following the most widely-used semisupervised setting in node classification studies [47, 18], we randomly select 20 nodes in each class for training and 30 nodes per class for validation; all the remaining nodes form the test set. We display the experiment results for the 5 transductive datasets on 6 widely-used GNN models: GCN [18], GAT [40], PPNP [19], GraphSAGE [13] (short as SAGE), ChebGCN [9] (short as CHEB) and SGC [43]. We strictly align the hyperparameters in each group of experiments to show the pure improvement brought by our ReNode method (similarly hereinafter). The training loss $L _ { T }$ from section 2.4 is adopted.
+
+Table 3: ReNode method for the compound scene of TINL and QINL. The imbalance ratio $\rho$ is set to different levels ([5, 10]) to test the effect of our method under different imbalance intensities.   
+
+<table><tr><td rowspan=1 colspan=1>Macro-F1(%)</td><td rowspan=1 colspan=2>CORA</td><td rowspan=1 colspan=2>CiteSeer</td><td rowspan=1 colspan=2>PubMed</td><td rowspan=1 colspan=2>Photo</td><td rowspan=1 colspan=2>Computers</td></tr><tr><td rowspan=1 colspan=1>Imbalance Ratio</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>CE</td><td rowspan=1 colspan=1>60.9±1.5</td><td rowspan=1 colspan=1>41.0±3.5</td><td rowspan=1 colspan=1>53.6±2.1</td><td rowspan=1 colspan=1>47.6±2.8</td><td rowspan=1 colspan=1>61.0±1.9</td><td rowspan=1 colspan=1>49.7±2.6</td><td rowspan=1 colspan=1>62.0±2.7</td><td rowspan=1 colspan=1>40.7±3.4</td><td rowspan=1 colspan=1>50.4±2.6</td><td rowspan=1 colspan=1>35.5±3.2</td></tr><tr><td rowspan=1 colspan=1>DR-GCN</td><td rowspan=1 colspan=1>67.7±1.1</td><td rowspan=1 colspan=1>51.3±1.4</td><td rowspan=1 colspan=1>54.7±1.7</td><td rowspan=1 colspan=1>52.5±2.6</td><td rowspan=1 colspan=1>79.4±1.2</td><td rowspan=1 colspan=1>78.0±1.6</td><td rowspan=1 colspan=1>80.8±2.3</td><td rowspan=1 colspan=1>79.5±2.8</td><td rowspan=1 colspan=1>66.9±3.5</td><td rowspan=1 colspan=1>67.4±3.6</td></tr><tr><td rowspan=2 colspan=1>RA-GCNG-SMOTE</td><td rowspan=1 colspan=1>69.0±1.5</td><td rowspan=2 colspan=1>51.7±1.749.6±1.1</td><td rowspan=2 colspan=1>55.6±1.354.0±1.6</td><td rowspan=1 colspan=1>52.7±2.1</td><td rowspan=2 colspan=1>80.6±1.879.7±1.2</td><td rowspan=2 colspan=1>78.1±2.176.4±1.5</td><td rowspan=2 colspan=1>81.4±2.682.2±1.8</td><td rowspan=2 colspan=1>79.4±3.277.5±2.1</td><td rowspan=2 colspan=1>71.2±2.871.9±2.5</td><td rowspan=1 colspan=1>68.7±3.0</td></tr><tr><td rowspan=1 colspan=1>68.1±0.9</td><td rowspan=1 colspan=1>51.8±1.3</td><td rowspan=1 colspan=1>61.3±3.2</td></tr><tr><td rowspan=1 colspan=1>RW (w/o RN)</td><td rowspan=1 colspan=1>69.1±1.4</td><td rowspan=1 colspan=1>49.7±1.6</td><td rowspan=1 colspan=1>53.6±2.3</td><td rowspan=1 colspan=1>52.9±2.6</td><td rowspan=1 colspan=1>80.5±1.5</td><td rowspan=1 colspan=1>78.0±2.0</td><td rowspan=1 colspan=1>80.5±2.7</td><td rowspan=1 colspan=1>80.4±3.3</td><td rowspan=1 colspan=1>70.5±3.2</td><td rowspan=1 colspan=1>67.8±4.2</td></tr><tr><td rowspan=1 colspan=1>RW (w/ RN)</td><td rowspan=1 colspan=1>70.0*±1.3</td><td rowspan=1 colspan=1>50.1±1.7</td><td rowspan=1 colspan=1>55.2**±1.8</td><td rowspan=1 colspan=1>54.0**±2.5</td><td rowspan=1 colspan=1>81.2* ±1.0</td><td rowspan=1 colspan=1>78.5*±2.2</td><td rowspan=1 colspan=1>83.9**±2.1</td><td rowspan=1 colspan=1>81.3**±3.2</td><td rowspan=1 colspan=1>72.4**±2.6</td><td rowspan=1 colspan=1>70.2**±2.4</td></tr><tr><td rowspan=2 colspan=1>FOCAL (w/o RN)FOCAL (w/RN)</td><td rowspan=1 colspan=1>66.4±1.6</td><td rowspan=1 colspan=1>51.9±1.8</td><td rowspan=1 colspan=1>54.3±1.3</td><td rowspan=1 colspan=1>54.0±1.9</td><td rowspan=1 colspan=1>80.5±0.7</td><td rowspan=1 colspan=1>78.0±1.6</td><td rowspan=1 colspan=1>79.3±1.9</td><td rowspan=1 colspan=1>79.2±2.2</td><td rowspan=1 colspan=1>65.8±2.7</td><td rowspan=1 colspan=1>63.9±2.6</td></tr><tr><td rowspan=1 colspan=1>68.7**±0.7</td><td rowspan=1 colspan=1>52.6**±1.9</td><td rowspan=1 colspan=1>54.6±1.2</td><td rowspan=1 colspan=1>54.7*±1.5</td><td rowspan=1 colspan=1>80.9*±0.8</td><td rowspan=1 colspan=1>78.7**±1.4</td><td rowspan=1 colspan=1>80.0**±*2.3</td><td rowspan=1 colspan=1>80.7**±2.9</td><td rowspan=1 colspan=1>68.6**±3.1</td><td rowspan=1 colspan=1>65.5**±3.5</td></tr><tr><td rowspan=2 colspan=1>CB (w/o RN)CB (w/RN)</td><td rowspan=1 colspan=1>69.8±1.5</td><td rowspan=2 colspan=1>51.5±1.551.9*±1.2</td><td rowspan=2 colspan=1>54.1±1.354.7*±1.6</td><td rowspan=2 colspan=1>53.5±0.854.3**±2.3</td><td rowspan=2 colspan=1>80.6±0.881.2*±1.8</td><td rowspan=2 colspan=1>77.6±1.678.3**±2.6</td><td rowspan=2 colspan=1>77.9±2.679.6** ±2.7</td><td rowspan=2 colspan=1>78.8±3.180.4**±3.3</td><td rowspan=2 colspan=1>69.6±2.273.1**±3.1</td><td rowspan=2 colspan=1>64.8±2.966.5**±3.6</td></tr><tr><td rowspan=1 colspan=1>71.1**±0.6</td></tr></table>
+
+Results From Table 1, we can find that our ReNode method can effectively improve the overall performance (Weighted-F1) and the class-balance performance (Macro-F1) for all the 6 experiment GNNs in most cases, which proves the effectiveness and generalizability of our method. Our method considers the graph-specific topology imbalance issue which has been usually neglected in existing methods and conducts a fine-grained and self-adaptive adjustment to the training node weights based on their topological positions. We notice that the improvement for the CiteSeer dataset is less than the other datasets. We analyze the reason lies in that the connectivity of CiteSeer is poor, which makes the conflict detection–based method fail to reflect the node topological position well. To verify the motivation of relieving topology-imbalance, we set training sets with different levels of topologyimbalance to test our method3. Table 2 displays that our ReNode method improves the performance of GNN (GCN) most when the dataset is highly topologically imbalanced, which demonstrates that our method can effectively alleviate topology-imbalance and improve GNN performance.
+
+# 3.3 ReNode for the Compound Scene of TINL and QINL
+
+Settings When jointly considering both topology- and quantity-imbalance issues, following existing studies [5, 4], we take the step imbalance setting, in which all the minority classes have the same labeling size $n _ { i }$ and all the majority classes have the same labeling size $n _ { a } = \rho * n _ { i }$ . The imbalance ratio $\rho$ denotes the intensity of quantity imbalance which is equal to the ratio of the node size of the most frequent to least frequent class. In this work, the imbalance ratio $\rho$ is set to [5, 10] for each dataset. The fraction of the majority classes is $\mu$ , and for all experiments, we set $\mu = 0 . 5$ and round down the result $\mu * k$ . The training loss $L _ { Q }$ from section 2.4 is adopted. We implement two groups of baselines for comparison: (1) Popular quantity-imbalance methods for general scenarios: Re-weight [17] (RW), Focal Loss [22] (Focal) and Class Balanced Loss [8] (CB); (2) Graph-specific quantity-imbalance methods: DR-GCN [35], RA-GCN [11] and GraphSMOTE [49]. To jointly handle the topology- and quantity-imbalance issues and demonstrate the orthogonality of them, we combine our ReNode method with these three general quantity-imbalance methods (RW, Focal, CB)4. The backbone model is GCN [18], and the labeling ratio $\delta$ is set to $5 \%$ .
+
+Results From Table 3 (Macro-F1 is reported here for a fair comparison with these methods designed for class-balance performance), we can find that our ReNode method significantly outperforms both the general and the graph-specific quantity-imbalance methods in most situations by simultaneously alleviating the topology- and quantity-imbalance issues. Even when the training set is severely quantity-imbalanced $\scriptstyle ( \rho = 1 0 )$ , our method still effectively alleviates the imbalance issue and promotes model performance well. The performance of the quantity-imbalance methods from the general field (RW, Focal, CB) is on par with or less effective than the graph-specific quantity-imbalance methods (DR-GCN, RA-GCN, G-SMOTE), while the combination of our ReNode method and these general quantity-imbalance methods can surpass the graph-specific quantity-imbalance methods, which demonstrates that the node imbalance learning can be further solved by jointly handling the topology- and quantity-imbalance issues instead of considering the quantity-imbalance issue only.
+
+![](images/6d160bd3b091be39bb9f07d48335845a9ed9ec4d5bd61d729b2de3828a23d52b.jpg)  
+Figure 4: Experimental results (Weighted-F1, $\%$ ) on the large-scale Reddit and MAG-Scholar graphs. Our ReNode method can effectively improve the model performance under different labeling sizes.
+
+![](images/f5bc5a21a4d8e008c5065041fd9c8ee0bd160c6729bf1cb6c89a70ee0cd10f49.jpg)  
+Figure 5: Evaluating GNNs from the aspect of topology-imbalance sensitivity (Metric: Weighted-F1 $( \% ) ,$ ). We can summarize the ranking of topology-imbalance sensitivity: $\mathrm { G C N } > \mathrm { P P N P } > \mathrm { G A T }$ .
+
+# 3.4 ReNode for Large-scale Graphs
+
+Settings We conduct experiments on the two large-scale datasets: Reddit and MAG-Scholar, to verify the effectiveness of our ReNode method in the inductive setting. We conduct experiments with different labeling sizes (20/50/100 training nodes per class) and imbalance settings (TINL-only, TINL and QINL). The backbone GNN model is PPRGo [2] 5. For QINL, we take the uniform selection to sample training nodes to be consistent with PPRGo. The training loss $L _ { L }$ from section 2.4 is adopted. Both baseline and our methods are not combined with any quantity-imbalance method.
+
+Results In Figure 4, we present the experiment results with different labeling sizes and imbalance settings, we can find that our method can effectively promote the performance on the large-scale graphs comparing to the popular PPRGo model across different settings, which demonstrates the applicability of our method for extremely-large graphs. We also notice that our method can bring greater improvement when the labeling size is large. We explain the reason lies in that when the labeling size is large, the positions located by the conflicts among nodes will be more accurate, thus bringing more reasonable weight adjustments. On the other hand, when the labeling ratio is extremely small (especially for the enormous MAG-Scholar graph) and the influence conflict between the labeled nodes is negligible, our method exhibits the cold start problem.
+
+# 4 Discussions
+
+# 4.1 Evaluating GNNs from the Aspect of Topology-Imbalance Sensitivity
+
+In Figure 5, we evaluate the GNN’s capability for handling topology-imbalance and find that different GNNs present significant difference in the topology-imbalance sensitivity across multiple datasets. The GCN model is susceptible to the topology-imbalance level of the graph and its performance decays greatly when the topology-imbalance increases. On the opposite, the GAT model is less sensitive to the topology-imbalance level and can achieve the best results when the topology-imbalance level is high. The PPNP model can achieve ideal performance when the topology-imbalance level is low, and its performance does not drop as sharply as GCN when the topology-imbalance level is high. We analyze the reason lies in that: (1) the aggregation operation of GCN is equivalent to directly averaging neighbor features [45] that lacks the noise filtering mechanism, so it is more sensitive to the topology-imbalance level of the graph; (2) the GAT model can dynamically adjust the aggregation weight from different neighbors, which increases its robustness to the high topology-imbalance situation but hinders the model performance when the graph topology-imbalance level is low and there is less need to filter neighbor information; (3) the infinite convolution mechanism of the PPNP model makes it possible to aggregate the information from distant nodes to enhance its robustness to the graph topology imbalance.
+
+Shchur et al. [34] notice that the performance ranking of GNNs varies with the training set selection. Hence, existing node classification studies [32, 14] usually repeat experiments multiple times with different training sets to reduce this randomness. The results from Figure 5 inspire us that the topology imbalance can partly explain the randomness of GNN performance caused by the training set selection and we can adopt the topology-imbalance sensitivity as a new aspect in evaluating the performance of different GNN architectures.
+
+# 4.2 Limitations of Method
+
+Although our ReNode method has proven effective in multiple scenarios, we also notice some limitations of it because of the complexity of node imbalance learning. First, the ReNode method is devised for homogeneously-connected graphs (linked nodes are expected to be similar, such as the various datasets in experiments), and it needs a further update for heterogeneously-connected graphs (such as protein networks). Besides, the ReNode method improves less when the graph connectivity is poor (Section 3.2) or the labeling ratio is extremely low (Section 3.3) because in these cases, the conflict level among nodes is low thus the nodes topological positions are insufficiently reflected.
+
+# 5 Related Work
+
+Imbalanced classification problems are widespread in real scenarios and have attracted extensive attention from both academia and industry. Most existing studies on this topic focus on the classimbalanced quantity distribution [15], where the model’s inference ability for the majority classes will be significantly better than that of minority classes [12]. The existing methods for solving the quantity-imbalance issue can be roughly divided into methods for the data selection phase and the model training phase. Active learning [31, 10, 42] and Re-sampling [6, 16, 25] are two classical examples designed to construct a quantity-balanced training set . On the other hand, Re-weighting is a simple but effective solution for the model training phase, which adjusts the weights of training samples in different classes based on the labeling sizes [17, 30, 8, 5]. However, directly applying these methods into the graph scene lacks the consideration for the graph-specific topology-imbalance issue. Unlike the re-weight methods which conduct class-lever re-weighting, our ReNode method is a more fine-grained one and assign weights to each node individually.
+
+There have been quantity-imbalance studies (Tomek links [38], NearMiss [23], One-Sided Selection [20]) trying to exclude the negative influence of labeling samples close to class boundaries by measuring the similarity of sample features. However, in the graph scene, the prior knowledge contained in node connections is more reliable than directly calculating the feature similarity. Besides, the number of labeled nodes is quite small in the semi-supervised setting. Thus it is not robust to locate their positions by computing similarity among a small number of nodes and we propose to leverage the influence conflict across the whole graph to locate node position to boundaries.
+
+Graph data structure owns a wide range of applications, such as social media [13], stock exchange [21], shopping [34], medicine [44], transportation [28] and so on. Similar to other data structures, graph node representation learning also suffer from the quantity-imbalance issue [35]. Apart from the universal quantity-balance approaches introduced in Section 5 which can be transferred to the graph scene, there are some graph-specific quantity-imbalance methods recently proposed. DR-GCN [35] propose two types of regularization to tackle quantity imbalance: class-conditioned adversarial training and unlabeled nodes latent distribution constraint. RA-GCN [11] propose to automatically learn to weight the training samples in different classes in an adversarial training manner. AdaGCN Shi et al. [36] propose to leverage the boosting algorithm to handle the quantity-imbalance issue for the node classification task. GraphSMOTE [49] combines the synthetic node generation and the edge generation to up-sample nodes for the minority classes. However, these studies only pay attention to the quantity imbalance and overlook the topology imbalance.
+
+Different from these studies [48, 29, 26] that try to locate the absolute positions for all the nodes by measuring their distance from the selected anchor nodes, our Totoro metric is devised to locate the relative positions to the class boundary for the labeling nodes by considering the influence conflict and can get rid of the dependence on the anchor nodes. Besides, our relative positions can more accurately reflect node class information because we distinguish the information from different classes while existing studies [48, 29] treat all the anchor nodes the same and ignore the class difference.
+
+# 6 Conclusion and Future Work
+
+In this work, we recognize the topology-imbalance node representation learning (TINL) as a graphspecific imbalance learning problem that has not been studied so far. We find that the topologyimbalance issue widely exists in graphs and severely hinders the learning of node classification. We unify TINL with the quantity-imbalance node representation learning (QINL) by considering the shift of the node influence boundaries from true class boundaries. To measure the degree of topology imbalance, we devise a conflict detection–based metric Totoro to locate node position, and further propose the ReNode method to adaptively adjust the training weights of labeled nodes based on their topological positions. Extensive empirical results have verified the effectiveness of our method in various settings: TINL-only, both TINL and QINL, and large-scale graph. Besides, we also propose the topology-imbalance sensitivity as a new metric to evaluate GNNs.
+
+Considering the importance of the topology-imbalance issue and the limitations of our approach, advanced methods with stronger theoretical or experimental support are expected in future work. Moreover, since topology imbalance is widespread in graph-related tasks other than node classification, how to measure and solve the topology-imbalance issues in broader graph scopes remains a meaningful challenge for future study.
+
+# 7 Acknowledgement
+
+We appreciate all the thoughtful and insightful suggestions from reviews. This work was supported in part by a Tencent Research Grant and National Natural Science Foundation of China (No. 61673028). Xu Sun is the corresponding author of this paper.
+
+# References
+
+[1] Reid Andersen, Fan R. K. Chung, and Kevin J. Lang. Local Graph Partitioning using PageRank Vectors. In 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2006), 21-24 October 2006, Berkeley, California, USA, Proceedings, pages 475–486. IEEE Computer Society, 2006.   
+[2] Aleksandar Bojchevski, Johannes Klicpera, Bryan Perozzi, Amol Kapoor, Martin Blais, Benedek Rózemberczki, Michal Lukasik, and Stephan Günnemann. Scaling Graph Neural Networks with Approximate PageRank. In the 26th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, KDD 2020, pages 2464–2473. ACM, 2020.   
+[3] Eliav Buchnik and Edith Cohen. Bootstrapped Graph Diffusions: Exposing the Power of Nonlinearity. Proc. ACM Meas. Anal. Comput. Syst., 2(1):10:1–10:19, 2018.   
+[4] Mateusz Buda, Atsuto Maki, and Maciej A. Mazurowski. A Systematic Study of the Class Imbalance Problem in Convolutional Neural Networks. Neural Networks, 106:249–259, 2018.   
+[5] Kaidi Cao, Colin Wei, Adrien Gaidon, Nikos Aréchiga, and Tengyu Ma. Learning Imbalanced Datasets with Label-Distribution-Aware Margin Loss. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 1565–1576, 2019.   
+[6] Nitesh V Chawla, Kevin W Bowyer, Lawrence O Hall, and W Philip Kegelmeyer. SMOTE: Synthetic Minority Over-sampling Technique. Journal of artificial intelligence research, 16: 321–357, 2002.
+
+[7] Wei-Lin Chiang, Xuanqing Liu, Si Si, Yang Li, Samy Bengio, and Cho-Jui Hsieh. Cluster-GCN: An Efficient Algorithm for Training Deep and Large Graph Convolutional Networks. In the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 257–266. ACM, 2019.
+
+[8] Yin Cui, Menglin Jia, Tsung-Yi Lin, Yang Song, and Serge J. Belongie. Class-Balanced Loss Based on Effective Number of Samples. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, Long Beach, CA, USA, June 16-20, 2019, pages 9268–9277. Computer Vision Foundation / IEEE, 2019.
+
+[9] Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pages 3837–3845, 2016.
+
+[10] Seyda Ertekin, Jian Huang, and C Lee Giles. Active Learning for Class Imbalance Problem. In the 30th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR 2007, pages 823–824, 2007.
+
+[11] Mahsa Ghorbani, Anees Kazi, Mahdieh Soleymani Baghshah, Hamid R. Rabiee, and Nassir Navab. RA-GCN: Graph Convolutional Network for Disease Prediction Problems with Imbalanced Data. arXiv preprint: 2103.00221, 2021.
+
+[12] Haixiang Guo, Yijing Li, Jennifer Shang, Gu Mingyun, Huang Yuanyue, and Gong Bing. Learning from Class-Imbalanced Data: Review of Methods and Applications. Expert Syst. Appl., 73:220–239, 2017.
+
+[13] William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive Representation Learning on Large Graphs. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 1024–1034, 2017.
+
+[14] Kaveh Hassani and Amir Hosein Khasahmadi. Contrastive Multi-View Representation Learning on Graphs. In the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 4116–4126. PMLR, 2020.
+
+[15] Haibo He and Edwardo A. Garcia. Learning from imbalanced data. IEEE Trans. Knowl. Data Eng., 21(9):1263–1284, 2009.
+
+[16] Haibo He, Yang Bai, Edwardo A. Garcia, and Shutao Li. ADASYN: Adaptive synthetic sampling approach for imbalanced learning. In the International Joint Conference on Neural Networks, IJCNN 2008, part of the IEEE World Congress on Computational Intelligence, WCCI 2008, Hong Kong, China, June 1-6, 2008, pages 1322–1328. IEEE, 2008.
+
+[17] Chen Huang, Yining Li, Chen Change Loy, and Xiaoou Tang. Learning Deep Representation for Imbalanced Classification. In the 29th IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, pages 5375–5384, 2016.
+
+[18] Thomas N Kipf and Max Welling. Semi-supervised Classification with Graph Convolutional Networks. In the 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.
+
+[19] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then Propagate: Graph Neural Networks meet Personalized PageRank. In the 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.
+
+[20] Miroslav Kubat, Stan Matwin, et al. Addressing the Curse of Imbalanced Training Sets: Onesided Selection. In the 14th International Conference on Machine Learning (ICML 1997), Nashville, Tennessee, USA, July 8-12, 1997, volume 97, pages 179–186. Morgan Kaufmann, 1997.
+
+[21] Wei Li, Ruihan Bao, Keiko Harimoto, Deli Chen, Jingjing Xu, and Qi Su. Modeling the Stock Relation with Graph Network for Overnight Stock Movement Prediction. In the 29th International Joint Conference on Artificial Intelligence, IJCAI 2020, pages 4541–4547. ijcai.org, 2020.
+
+[22] Tsung-Yi Lin, Priya Goyal, Ross B. Girshick, Kaiming He, and Piotr Dollár. Focal Loss for Dense Object Detection. In IEEE International Conference on Computer Vision, ICCV 2017, Venice, Italy, October 22-29, 2017, pages 2999–3007. IEEE Computer Society, 2017.
+
+[23] Inderjeet Mani and I Zhang. kNN Approach to Unbalanced Data Distributions: A Case Study Involving Information Extraction. In Workshop on Learning from Imbalanced Datasets, volume 126, 2003.
+
+[24] Julian McAuley, Christopher Targett, Qinfeng Shi, and Anton Van Den Hengel. Image-based Recommendations on Styles and Substitutes. In the 38th International ACM SIGIR Conference on Research and Development in Information Retrieval, Santiago, Chile, August 9-13, 2015, pages 43–52. ACM, 2015.
+
+[25] Iman Nekooeimehr and Susana K Lai-Yuen. Adaptive Semi-unsupervised Weighted Oversampling (A-SUWO) for Imbalanced Datasets. Expert Systems with Applications, 46:405–416, 2016.
+
+[26] Sunil Nishad, Shubhangi Agarwal, Arnab Bhattacharya, and Sayan Ranu. GraphReach: PositionAware Graph Neural Networks using Reachability Estimations. In the 30th International Joint Conference on Artificial Intelligence IJCAI, 2020.
+
+[27] Lawrence Page, Sergey Brin, Rajeev Motwani, and Terry Winograd. The PageRank Citation Ranking: Bringing Order to the Web. Technical report, Stanford InfoLab, 1999.
+
+[28] Nikolay G Prokoptsev, AE Alekseenko, and Yaroslav Aleksandrovich Kholodov. Traffic Flow Speed Prediction on Transportation Graph with Convolutional Neural Networks. Computer research and modeling, 10(3):359–367, 2018.
+
+[29] Zhenyue Qin, Saeed Anwar, Dongwoo Kim, Yang Liu, Pan Ji, and Tom Gedeon. PositionSensing Graph Neural Networks: Proactively Learning Nodes Relative Positions. arXiv preprint: 2105.11346, 2021.
+
+[30] Mengye Ren, Wenyuan Zeng, Bin Yang, and Raquel Urtasun. Learning to Reweight Examples for Robust Deep Learning. In International Conference on Machine Learning, pages 4334–4343. PMLR, 2018.
+
+[31] Pengzhen Ren, Yun Xiao, Xiaojun Chang, Po-Yao Huang, Zhihui Li, Xiaojiang Chen, and Xin Wang. A Survey of Deep Active Learning. arXiv preprint: 2009.00236, 2020.
+
+[32] Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. The Truly Deep Graph Convolutional Networks for Node Classification. arXiv preprint: 1907.10903, 2019.
+
+[33] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective Classification in Network Data. AI magazine, 29(3):93–93, 2008.
+
+[34] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of Graph Neural Network Evaluation. arXiv preprint: 1811.05868, 2018.
+
+[35] Min Shi, Yufei Tang, Xingquan Zhu, David A. Wilson, and Jianxun Liu. Multi-Class Imbalanced Graph Convolutional Network Learning. In the 29th International Joint Conference on Artificial Intelligence, IJCAI 2020, pages 2879–2885. ijcai.org, 2020.
+
+[36] Shuhao Shi, Kai Qiao, Shuai Yang, L Wang, J Chen, and Bin Yan. AdaGCN: Adaptive Boosting Algorithm for Graph Convolutional Networks on Imbalanced Node Classification. arXiv preprint: 2105.11625, 2021.
+
+[37] Marina Sokol, Konstantin Avrachenkov, Paulo Gonçalves, and Alexey Mishenin. Generalized Optimization Framework for Graph-based Semi-supervised Learning. In the 12th SIAM International Conference on Data Mining, Anaheim, California, USA, April 26-28, 2012, pages 966–974. SIAM / Omnipress, 2012.
+
+[38] Ivan Tomek et al. Two Modifications of CNN. IEEE Transactions on Systems, Man, and Cybernetics, 1976.
+
+[39] Laurens Van der Maaten and Geoffrey Hinton. Visualizing Data using t-SNE. Journal of machine learning research, 9(11), 2008.
+
+[40] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and ´ Yoshua Bengio. Graph Attention Networks. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018.
+
+[41] Hongwei Wang and Jure Leskovec. Unifying Graph Convolutional Neural Networks and Label Propagation. arXiv preprint: 2002.06755, 2020.
+
+[42] Xinyue Wang, Bo Liu, Siyu Cao, Liping Jing, and Jian Yu. Important Sampling based Active Learning for Imbalance Classification. Science China Information Sciences, 63(8):1–14, 2020.
+
+[43] Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying Graph Convolutional Networks. In International Conference on Machine Learning, pages 6861–6871. PMLR, 2019.
+
+[44] Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. MoleculeNet: a Benchmark for Molecular Machine Learning. Chemical science, 2018.
+
+[45] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How Powerful are Graph Neural Networks? In the 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019.
+
+[46] Yuzhe Yang and Zhi Xu. Rethinking the Value of Labels for Improving Class-Imbalanced Learning. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020.
+
+[47] Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Revisiting Semi-supervised Learning with Graph Embeddings. In the 33nd International Conference on Machine Learning, ICML 2016, volume 48 of JMLR Workshop and Conference Proceedings, pages 40–48. JMLR.org, 2016.
+
+[48] Jiaxuan You, Rex Ying, and Jure Leskovec. Position-aware Graph Neural Networks. In the 36th International Conference on Machine Learning, ICML 2019, volume 97 of Proceedings of Machine Learning Research, pages 7134–7143. PMLR, 2019.
+
+[49] Tianxiang Zhao, Xiang Zhang, and Suhang Wang. GraphSMOTE: Imbalanced Node Classification on Graphs with Graph Neural Networks. In WSDM ’21, The Fourteenth ACM International Conference on Web Search and Data Mining, Virtual Event, Israel, March 8-12, 2021, pages 833–841. ACM, 2021.
+
+[50] Dengyong Zhou and Christopher J. C. Burges. Spectral Clustering and Transductive Learning with Multiple Views. In the 24th Annual International Conference on Machine Learning, ICML 2007, volume 227, pages 1159–1166. ACM, 2007.
+
+[51] Jie Zhou, Ganqu Cui, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, and Maosong Sun. Graph Neural Networks: A Review of Methods and Applications. AI Open, 1, 2020.

parse/train/w3x8K0M6sAz/w3x8K0M6sAz_content_list.json

@@ -0,0 +1,1479 @@
+[
+    {
+        "type": "text",
+        "text": "Topology-Imbalance Learning for Semi-Supervised Node Classification ",
+        "text_level": 1,
+        "bbox": [
+            253,
+            122,
+            740,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deli Chen1,2, Yankai $\\mathbf { L i n } ^ { 1 }$ , Guangxiang Zhao2, Xuancheng Ren2, Peng $\\mathbf { L i } ^ { 1 }$ , Jie $\\mathbf { Z } \\mathbf { h o u } ^ { 1 }$ , $\\mathbf { X } \\mathbf { u } \\mathbf { S } \\mathbf { u } \\mathbf { n } ^ { 2 }$ 1Pattern Recognition Center, WeChat AI, Tencent Inc., China 2MOE Key Lab of Computational Linguistics, School of EECS, Peking University {delichen, yankailin, patrickpli,withtomzhou}@tencent.com {zhaoguangxiang,renxc,xusun}@pku.edu.cn ",
+        "bbox": [
+            228,
+            224,
+            769,
+            313
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            348,
+            535,
+            364
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The class imbalance problem, as an important issue in learning node representations, has drawn increasing attention from the community. Although the imbalance considered by existing studies roots from the unequal quantity of labeled examples in different classes (quantity imbalance), we argue that graph data expose a unique source of imbalance from the asymmetric topological properties of the labeled nodes, i.e., labeled nodes are not equal in terms of their structural role in the graph (topology imbalance). In this work, we first probe the previously unknown topology-imbalance issue, including its characteristics, causes, and threats to semisupervised node classification learning. We then provide a unified view to jointly analyzing the quantity- and topology- imbalance issues by considering the node influence shift phenomenon with the Label Propagation algorithm. In light of our analysis, we devise an influence conflict detection–based metric Totoro to measure the degree of graph topology imbalance and propose a model-agnostic method ReNode to address the topology-imbalance issue by re-weighting the influence of labeled nodes adaptively based on their relative positions to class boundaries. Systematic experiments demonstrate the effectiveness and generalizability of our method in relieving topology-imbalance issue and promoting semi-supervised node classification. The further analysis unveils varied sensitivity of different graph neural networks (GNNs) to topology imbalance, which may serve as a new perspective in evaluating GNN architectures.1 ",
+        "bbox": [
+            233,
+            380,
+            766,
+            655
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            683,
+            310,
+            700
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph is a widely-used data structure [51], where the nodes are connected to each other through natural or handcrafted edges. Similar to other data structures, the representation learning for node classification faces the challenge of quantity-imbalance issue, where the labeling size varies among classes and the decision boundaries of trained classifiers are mainly decided by the majority classes [46]. There have been a series of studies [35, 11, 49] handling the Quantity-Imbalance Node Representation Learning (short as QINL). However, different with other data structures, graph-structured data suffers from another aspect of the imbalance problem: the imbalance caused by the asymmetric and uneven topology of labeled nodes, where the decision boundaries are driven by the labeled nodes close to the topological class boundaries (left of Figure 1) thus interfering with the model learning. ",
+        "bbox": [
+            174,
+            714,
+            825,
+            839
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Present Work. For the first time, we recognize the Topology-Imbalance Node Representation Learning (short as TINL) as a graph-specific imbalance learning topic, which mainly focus on the decision boundaries shift phenomena driven by the topology imbalance in graph and is an essential component for node imbalance learning. Comparing with the well-explored QINL that studies the imbalance caused by the numbers of labeled nodes, TINL explores the imbalance caused by the positions of labeled nodes and owns the following characteristics: ",
+        "bbox": [
+            176,
+            845,
+            823,
+            873
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c5d5345b792342769fcf85d480df7dfaf12f9fa1c75f46eec6382748a5fb423.jpg",
+        "image_caption": [
+            "Figure 1: Schematic diagram of the topology-imbalance issue in node representation learning. The color and the hue denote the type and the intensity of each node’s received influence from the labeled nodes, respectively. The left shows that nodes close to the boundary have the risk of information conflict and nodes far away from labeled nodes have the risk of information insufficient. The right shows that our method can decrease the training weights of labeled nodes (R1) close to the class boundary and increase the weights of labeled nodes (B and R2) close to the class centers, thus relieving the topology-imbalance issue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            0,
+            784,
+            213
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            347,
+            825,
+            402
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Ubiquity: Due to the complex connections of the graph nodes, the topology structure of nodes in different categories is naturally asymmetric, which makes TINL an essential characteristic in node representation learning. Hence, it is difficult to construct a completely symmetric labeling set even with an abundant annotation budget. • Perniciousness: The influence from labeled nodes decays with the topology distance [3]. The asymmetric topology of labeled nodes in different classes and the uneven distribution of labeled nodes in the same class will cause the influence conflict and influence insufficient problems (left of Figure 1) respectively, resulting in a shift of decision boundaries. • Orthogonality: Quantity-imbalance studies [49, 8, 5] usually treat the labeled nodes of the same class as a whole and devise solutions based on the total numbers of each class, while TINL explores the influence of the unique position of each labeled node on decision boundaries. Thus, TINL is independent of QINL in terms of the object of study. ",
+        "bbox": [
+            217,
+            414,
+            825,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Exploring TINL is of great importance for node representation learning due to its ubiquity and perniciousness. However, the methods [17, 22] for quantity imbalance can be hardly applied to TINL because of the orthogonality. To remedy the topology-imbalance issue, thus promoting the node classification, we propose a model-agnostic training framework ReNode to re-weight the labeled nodes according to their positions. We devise the conflict detection-based Topology Relative Location (Totoro) metric to leverage the interaction among labeled nodes across the whole graph to locate their structural positions. Based on the Totoro metric, we further increase the training weights of nodes with small conflict that are highly likely to be close to topological class centers to make them play a more pivotal role during training, and vice versa (right of Figure 1). Empirical results of various imbalance scenarios (TINL, QINL, large-scale graph) and multiple graph neural networks (GNNs) demonstrate the effectiveness and generalizability of our method. Besides, we provide the sensitivity to topology imbalance as a new evaluation perspective for different GNN architectures. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Topology-Imbalance Node Representation Learning ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            784,
+            638,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Notations and Preliminary ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            398,
+            830
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we follow the well-established semi-supervised node classification setting [47, 18] to conduct analyses and experiments. Given an undirected and unweighted graph $\\mathcal { G } = ( \\boldsymbol { \\nu } , \\pmb { \\varepsilon } , \\pmb { c } )$ , where $\\nu$ is the node set represented by the feature matrix $\\boldsymbol { X } \\in \\mathbb { R } ^ { n * d }$ $\\dot { \\boldsymbol { n } } = | \\boldsymbol { \\nu } |$ is the node size and $d$ is the node embedding dimension), $\\varepsilon$ is the edge set which is represented by an adjacency matrix $A \\in \\mathbb { R } ^ { n * n }$ , $\\pmb { \\mathcal { L } } \\subset \\nu$ is the labeled node set and usually we have $| \\bar { \\boldsymbol { L } } | \\ll | \\boldsymbol { \\nu } |$ , the node classification task is to train a classifier $\\mathcal { F }$ (usually a GNN) to predict the class label y for the unlabeled node set $u = \\nu - c$ . The training sets for different classes are represented by $( \\pmb { \\mathscr { C } } _ { 1 } , \\pmb { \\mathscr { C } } _ { 2 } , \\cdots , \\pmb { \\mathscr { C } } _ { k } )$ and $k$ is the number of classes. The labeling ratio $\\delta = \\angle \\mathcal { x } / \\nu$ is the proportion of labeled nodes in all nodes. In this work, we focus on TINL in homogeneously-connected graphs and hope to inspire future studies on the critical topology-imbalance issue. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/25999ec10387c1b8ccfbc868ce85fd4adb3997f394bbe9fe5415c3fa41a2bab0.jpg",
+        "image_caption": [
+            "Figure 2: Node influence and boundary shift caused by quantity- and topology-imbalance. (a): The prediction results of GCN and LP are highly consistent (t-SNE [39] visualization of the $C O R A$ dataset). (b): The node influence boundary (the yellow dotted line) is shifted towards the small class from the true class boundary (the black dotted line) under the quantity- and topology-imbalance scene. (c): The node influence boundary is shifted towards the large class under the quantity-balanced, topology-imbalanced scene. We regard the large class as positive class to indicate the results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            90,
+            808,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            344,
+            825,
+            415
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 Understanding Topology Imbalance via Label Propagation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            433,
+            620,
+            449
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From Figure 1, we can intuitively perceive the imbalance brought by the positions of labeled nodes; in this part, we further explore the nature of topology imbalance with the well-known Label Propagation [50] algorithm (short as LP) and provide a uniform analysis framework for the comprehensive node imbalance issue. In LP, labels are propagated from the labeled nodes and aggregated along edges, which can also be viewed as a random walk process from labeled nodes. The convergence result $\\mathbf { Y }$ after repeated propagation is regarded as the nodes soft-labels: ",
+        "bbox": [
+            173,
+            459,
+            825,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/42bcb685bc540a9eee6075578f556e2471c48f1ff915ac1c346657af459f487b.jpg",
+        "text": "$$\n\\pmb { Y } = \\alpha ( \\pmb { I } - ( 1 - \\alpha ) \\pmb { A } ^ { \\prime } ) ^ { - 1 } \\pmb { Y } ^ { 0 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            395,
+            550,
+            602,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { I }$ is the identity matrix, $\\alpha \\in ( 0 , 1 ]$ is the random walk restart probability, $A ^ { \\prime } = D ^ { - { \\frac { 1 } { 2 } } } A D ^ { - { \\frac { 1 } { 2 } } }$ is the adjacency matrix normalized by the diagonal degree matrix $_ { D }$ , $\\mathbf { \\dot { Y } } ^ { 0 }$ is the initial label distribution where labeled nodes are represented by the one-hot vectors. The prediction label for the $i$ -th node is $q _ { i } = \\arg \\operatorname* { m a x } _ { j } Y _ { i j }$ . LP is a simple yet successful model [37] and can be unified with GNN models owning the message-passing mechanism [41]. From Figure 2(a), we can empirically find that there is a significant correlation between the results of LP and GCN (T/F indicates prediction is True/False). ",
+        "bbox": [
+            173,
+            579,
+            825,
+            664
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The LP prediction $\\pmb q$ can be viewed as the distribution of the (labeled) node influence [41] (i.e. each node is mostly influenced by which class’s information); hence the boundaries of the node influence can act as an effective reflection for the GNN model decision boundaries considering the high consistency between LP and GNN. Moreover, node influence offers a unified view of TINL and QINL: ideally, the node influence boundaries should be consistent with the true class boundaries, but both the labeled nodes’ numbers (QINL) and positions (TINL) can cause a shift of the node influence boundaries from the true one, resulting in deviation of the model decision boundaries. ",
+        "bbox": [
+            173,
+            669,
+            825,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Node imbalance issue is composed of topology- and quantity-imbalance. Figure 2 illustrates two examples of node influence boundary shift. In Figure 2(b), when the uniform selection is adopted to generate training set, both the quantity and the topology are imbalanced for model training; then the large class with more total nodes (denotes by blue color) will own stronger influence than the small class with fewer total nodes (denotes by red color) due to the quantity advantage and the node influence boundary is shifted towards the small class. In Figure 2(c), when the quantity-balanced strategy is adopted for sampling training nodes, it will be easier for the small class to has more labeled nodes close to the class boundary and the boundary of the node influence is shifted into the large class. We can find that even when the training set is quantity-balanced, the topology-imbalance issue still exists and hinders the node classification learning. Hence, we can conclude that node imbalance learning is caused by the joint effect of TINL and QINL. Separately considering TINL or QINL will lead to a one-sided solution to node imbalance learning. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/f912716e23c177a4938148c7a1170b81fdfe86390b15dbfd19bd85e1becda3fb.jpg",
+        "image_caption": [
+            "Figure 3: Effectiveness of Totoro at (a) Node Level: labeled nodes (t-SNE visualization of the CORA dataset) with less influence conflict (lighter color) are farther-away from class boundaries than those with high conflict (darker color), and (b) Dataset Level: There is a significant negative correlation between the GNN (GCN) performance and overall conflict of the training set (the Pearson correlation coefficient is $- 0 . 6 1 8$ over 50 randomly selected training sets with the $p$ value smaller than 0.01). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            232,
+            90,
+            764,
+            247
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            353,
+            823,
+            381
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Measuring Topology Imbalance by Influence Conflict ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            397,
+            581,
+            412
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Although we have realized that the imbalance of node topology interferes with model learning, how to measure the labeled node’s relative topological position to its class (being far away from or close to the class center) remains the key challenge in handling the topology-imbalance issue due to the complex graph connections and the unknown class labels for most nodes in the graph. As the nodes are homogeneously connected when constructing the graph, even nodes close to the class boundaries own similar characteristics to their neighbors. Thus it is unreliable to leverage the difference between the characteristics of one labeled node and its surrounding subgraphs to locate its topological position. Instead, we propose to utilize the node topology information by considering the node influence conflict across the whole graph and devise the Conflict Detection-based Topology Relative Location metric (Totoro). ",
+        "bbox": [
+            174,
+            421,
+            825,
+            561
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similar to Eq (1), we calculate the Personalized PageRank [27] matrix $_ { r }$ to measure node influence distribution from each labeled node: ",
+        "bbox": [
+            174,
+            568,
+            823,
+            595
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e827f488f2cb6f4bae1776661058118e29eb4a6a3cf0b0275ff28b885f7fb059.jpg",
+        "text": "$$\nP = \\alpha ( { \\cal I } - ( 1 - \\alpha ) A ^ { \\prime } ) ^ { - 1 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            599,
+            591,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Node influence conflict denotes topological position. According to related studies [41, 19, 2], $_ { r }$ can be viewed as the distribution of influence exerted outward from each node. We assume that if a labeled node $v \\in \\nu$ encounters strong heterogeneous influence from the other classes’ labeled nodes in the subgraph around node $v$ where node $v$ itself owns great influence, we have the conclusion that node $v$ meets large influence conflict in message passing and it is close to topological class boundaries, and vice versa. Based on this hypothesis, we take the expectation of the influence conflict between the node $v$ and the labeled nodes from other classes when node $v$ randomly walks across the entire graph as a measurement of how topologically close node $v$ is to the center of the class it belongs to. The Totoro value of node $v$ is computed as: ",
+        "bbox": [
+            173,
+            631,
+            825,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ced03fa0654fa8e24cf5155f24288804077529fb029dcce36ba9dafdf7019461.jpg",
+        "text": "$$\n\\pmb { T } _ { v } = \\mathbb { E } _ { \\boldsymbol { x } \\sim \\pmb { P } _ { v , : } } [ \\sum _ { \\substack { j \\in [ 1 , k ] , j \\neq y _ { v } } } \\frac { 1 } { | \\pmb { \\mathcal { C } } _ { j } | } \\sum _ { i \\in \\pmb { \\mathcal { C } } _ { j } } \\pmb { P } _ { i , x } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            761,
+            638,
+            801
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { \\nabla } _ { \\mathbf { y } _ { v } }$ is the ground-truth label of node $v$ , $P _ { v }$ indicates the personalized PageRank probability vector for the node $v$ . A larger Totoro value $\\mathbf { \\delta } _ { \\mathbf { \\mathcal { T } } _ { v } }$ indicates that node $v$ is topologically closer to class boundaries, and vice versa. The normalization item $1 / | c _ { j } |$ is added to make the influence from the different classes comparable when computing conflict. ",
+        "bbox": [
+            174,
+            806,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We visualize the node labels and the Totoro values (scaled to $[ 0 , 1 ] $ ) of labeled nodes in Figure 3(a). We can find that the labeled nodes with smaller Totoro values are farther away from the class boundaries, demonstrating the effectiveness of Totoro in locating the positions of labeled nodes. Besides, we sum the conflict of all the labeled nodes $\\textstyle \\sum _ { b \\in { \\mathcal { L } } } T _ { v }$ to measure the overall conflict of the dataset, which can be viewed as the metric for the overall topology imbalance given the graph $\\mathfrak { g }$ and the training set $\\mathcal { L }$ . Figure 3(b) shows that there is a significant negative correlation between the overall conflict and the model performance, which further demonstrates the effectiveness of Totoro in measuring the intensity of topology imbalance at the dataset level. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 Alleviate Topology Imbalance by Instance-wise Node Re-weighting ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            176,
+            676,
+            193
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce ReNode, a model-agnostic training weight schedule mechanism to address TINL for general GNN encoder in a plug-and-play manner. Inspired by the analysis in Section 2.2, the ReNode method is devised to promote the training weights of the labeled nodes that are close to the topological class centers, so as to make these nodes play a more active role in model learning, and vice versa. Specifically, we devise a cosine annealing mechanise 2 for the training node weights based on their Totoro values: ",
+        "bbox": [
+            174,
+            202,
+            825,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/97fa692803647ece0e15e8dc9163cbf376d0f9667dfe1963ea76ebb6f2d2a15e.jpg",
+        "text": "$$\n{ \\pmb w } _ { v } = w _ { \\mathrm { m i n } } + \\frac { 1 } { 2 } ( w _ { \\mathrm { m a x } } - w _ { \\mathrm { m i n } } ) ( 1 + \\cos ( \\frac { \\mathrm { R a n k } ( { \\pmb T } _ { v } ) } { | { \\pmb L } | } \\pi ) ) , \\quad v \\in { \\pmb C }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            292,
+            714,
+            327
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { w } _ { v }$ is the modified training weight for the labeled node $v , w _ { \\mathrm { m i n } } , w _ { \\mathrm { m a x } }$ are the hyper-parameters indicating the lower bound and upper bound of the weight correction factor, $\\mathrm { R a n k } ( \\pmb { T } _ { v } )$ is the ranking order of $\\mathbf { \\delta } _ { \\mathbf { \\mathcal { T } } _ { v } }$ from the smallest to the largest. The training loss $L _ { T }$ for the quantity-balanced, topologyimbalanced node classification task is computed by the following equations: ",
+        "bbox": [
+            176,
+            332,
+            825,
+            388
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/40cd7196ef8bd4df78cc3f6c94cf3f60db3b71d839a0cc42b944755b0b8fc868.jpg",
+        "text": "$$\nL _ { T } = - \\frac { 1 } { | { \\cal { L } } | } \\sum _ { v \\in { \\cal { L } } } w _ { v } \\sum _ { c = 1 } ^ { k } y _ { v } ^ { * c } \\log \\ g _ { v } ^ { c } , \\quad g = \\mathrm { s o f t m a x } ( { \\mathcal { F } } ( X , A , \\theta ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            395,
+            723,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { F }$ denotes any GNN encoder, $\\pmb \\theta$ is the parameter of ${ \\mathcal { F } } , g _ { i }$ is the GNN output for node $i$ , $\\mathbf { \\nabla } _ { \\mathbf { \\boldsymbol { y } } _ { i } ^ { * } }$ is the gold label for node $i$ in one-hot embedding. By encouraging the positive effects of the labeled nodes near the class topological centers, and reducing the negative effects of those near the topological class boundaries, our ReNode method is expected to minimize the deviation between the node influence boundaries and the true class boundaries, so as to correct the class imbalance caused by the positions of labeled nodes. ",
+        "bbox": [
+            173,
+            445,
+            826,
+            530
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ReNode to Jointly Handle TINL and QINL In this part, we introduce the application of the ReNode method in a more general graph imbalance scenario where both the topology- and quantityimbalance issues exist. As analyzed in previous sections, the TINL and QINL are orthogonal problems. Therefore, we propose that our ReNode method based on (labeled) node topology can be seamlessly combined with the existing methods designed for the quantity-imbalance learning. Without loss of generality, we present how our ReNode method can be combined with the vanilla class frequency-based re-weight method [17]. The training loss $L _ { Q }$ for the quantity-imbalanced, topology-imbalanced node classification task is formalized in the following equation: ",
+        "bbox": [
+            173,
+            542,
+            826,
+            656
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/550bbdc0f33c4f67fad7538f929d6d585fa604bbd528576f360259da3d083c28.jpg",
+        "text": "$$\nL _ { Q } = - \\frac { 1 } { | \\mathcal { L } | } \\sum _ { v \\in \\mathcal { L } } w _ { v } \\frac { | \\bar { \\mathcal { C } } | } { | \\mathcal { C } _ { j } | } \\sum _ { c = 1 } ^ { k } { y } _ { v } ^ { * c } \\log \\textbf { \\em g } _ { v } ^ { c } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            661,
+            637,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $| \\bar { c } |$ is the average number of the class training sizes. With this method, the final weight of the labeled node is affected by two perspectives: training examples of the minority classes will have higher weights than that of the majority classes; training examples close to the topological class centers will have higher weights than those are close to the topological class boundaries. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            771
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ReNode for Large-scale Graph There are mainly two challenges when applying ReNode to largescale graphs: (1) how to calculate the PageRank matrix, and (2) how to train the GNN model in an inductive setting [13]. In this work, we follow the PPRGo method [2] to implement our method on the large-scale graph, which can decouple the feature learning process from the information transmission process to resolve the dependence on the global graph topology structure and can be carried out much efficiently. Following PPRGo, the Personalized PageRank matrix $\\hat { P }$ and the corresponding training ReNode factor $\\hat { \\pmb { w } }$ are generated by the estimation method from Andersen et al. [1] and then $\\hat { P }$ is directly employed as the aggregation weights from all the other nodes regardless of their topology distance from the current node: ",
+        "bbox": [
+            173,
+            785,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/00496b03416eee86d41061c56867037edfd20150971023a1fb06382e90a276e9.jpg",
+        "table_caption": [
+            "Table 1: ReNode (short as RN) for the pure topology-imbalance issue. We report Weighted-F1 (W-F, $\\%$ ), Macro-F1 (M-F, $\\%$ ) and the corresponding standard deviation for each group of experiments. $^ *$ and $^ { \\ast \\ast }$ represent the result is significant in student t-test with $p < 0 . 0 5$ and $p < 0 . 0 1$ , respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Training</td><td colspan=\"2\">CORA</td><td colspan=\"2\">CiteSeer</td><td colspan=\"2\">PubMed</td><td colspan=\"2\">Photo</td><td colspan=\"2\">Computers</td></tr><tr><td>W-F</td><td>M-F</td><td>W-F</td><td>M-F</td><td>W-F</td><td>M-F</td><td>W-F</td><td>M-F</td><td>W-F</td><td>M-F</td></tr><tr><td rowspan=\"2\">GCN</td><td>w/oRN</td><td>79.1±1.1</td><td>77.8±1.5</td><td>66.2±1.0</td><td>62.0±1.3</td><td>74.6±2.1</td><td>74.7±1.9</td><td>86.8±2.0</td><td>84.7±1.7</td><td>74.2±2.6</td><td>73.6±2.9</td></tr><tr><td>w/RN</td><td>79.8**±0.9</td><td>78.6**±1.2</td><td>66.9* ±1.1</td><td>62.8* ±1.4</td><td>76.1** ±1.5</td><td>76.1**±1.8</td><td>87.7**±2.2</td><td>85.4**±1.9</td><td>74.7* ±2.2</td><td>74.5**±2.3</td></tr><tr><td rowspan=\"2\">GAT</td><td>w/o RN</td><td>76.0±1.7</td><td>74.9±1.9</td><td>66.3±2.8</td><td>62.4±2.6</td><td>73.9±2.2</td><td>73.9±2.1</td><td>88.3±2.0</td><td>86.2±2.2</td><td>79.0±2.1</td><td>78.8±2.3</td></tr><tr><td>W/RN</td><td>77.7**±*2.0</td><td>76.2**±1.8</td><td>67.1*±1.9</td><td>63.2*±1.6</td><td>75.2**±2.0</td><td>75.1**±2.5</td><td>89.1**±2.0</td><td>87.1**±2.0</td><td>78.8±1.9</td><td>78.7±2.0</td></tr><tr><td rowspan=\"2\">PPNP</td><td>w/oRN</td><td>80.5±1.6</td><td>79.1±1.4</td><td>67.5±1.8</td><td>63.2±1.6</td><td>74.6±1.9</td><td>74.7±1.7</td><td>89.3±1.3</td><td>86.8±1.4</td><td>78.7±1.5</td><td>77.7±1.7</td></tr><tr><td>w/RN</td><td>81.9**±0.6</td><td>80.5**±0.8</td><td>68.1* ±1.4</td><td>63.7* ±2.0</td><td>76.0**±2.0</td><td>76.1**±2.2</td><td>89.7*±1.0</td><td>87.2* ±1.3</td><td>79.0* ±1.1</td><td>78.3* ±11</td></tr><tr><td rowspan=\"2\">SAGE</td><td>w/o RN</td><td>75.1±1.7</td><td>74.6±1.4</td><td>67.0±1.4</td><td>63.0±1.4</td><td>74.2±2.2</td><td>74.2±2.1</td><td>86.2±2.6</td><td>83.9±2.4</td><td>73.5±3.4</td><td>71.6±2.5</td></tr><tr><td>w/RN</td><td>75.7**±1.7</td><td>75.1**±1.4</td><td>67.3±1.4</td><td>63.5* ±1.2</td><td>74.9**±1.9</td><td>78.2**±2.3</td><td>86.5±1.7</td><td>84.1±1.7</td><td>74.9**±3.0</td><td>72.3**±2.5</td></tr><tr><td rowspan=\"2\">CHEB</td><td>w/oRN</td><td>74.5±1.1</td><td>73.4±1.1</td><td>66.8±1.8</td><td>63.2±1.6</td><td>75.1±1.8</td><td>75.2±1.1</td><td>82.1±2.2</td><td>79.4±3.5</td><td>70.3±4.0</td><td>68.4±3.4</td></tr><tr><td>w/RN</td><td>75.3**±1.1</td><td>74.0**±1.1</td><td>67.5**±1.6</td><td>63.8**±1.5</td><td>76.2**±1.4</td><td>76.3**±1.2</td><td>84.8**±2.4</td><td>82.1**±2.8</td><td>70.5±4.0</td><td>68.6±3.4</td></tr><tr><td rowspan=\"2\">SGC</td><td>w/oRN</td><td>74.9±2.1</td><td>73.8±2.1</td><td>65.7±1.6</td><td>61.8±1.6</td><td>72.9±2.3</td><td>73.1±2.6</td><td>87.1±1.3</td><td>84.9±11</td><td>77.4±1.7</td><td>76.8±1.8</td></tr><tr><td>w/RN</td><td>77.0**±1.1</td><td>76.0**±1.1</td><td>67.2**±1.3</td><td>62.9**±1.8</td><td>73.7**±2.8</td><td>73.8**±2.1</td><td>87.4±1.5</td><td>85.2±1.5</td><td>78.2**±1.8</td><td>77.8**±1.2</td></tr></table>",
+        "bbox": [
+            176,
+            138,
+            820,
+            275
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/13e36310934705c5781a87916fbfdcec3ac3224954790f2a39226e1b68937f5b.jpg",
+        "table_caption": [
+            "Table 2: Result of different dataset conflict levels (High/Middle/Low). Our ReNode method improve the GNN (GCN) performance most when the conflict level of graph is high. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>W-F(%)</td><td>CORA-H</td><td>CORA-M</td><td>CORA-L</td><td>CiteSeer-H</td><td>CiteSeer-M</td><td>CiteSeer-L</td><td>PubMed-H</td><td>PubMed-M</td><td>|PubMed-L</td></tr><tr><td>w/o RN w/RN</td><td>76.5±1.3 78.7**±0.8</td><td>78.4±0.7 79.3**±0.6</td><td>79.7±0.8 80.4**±0.6</td><td>62.6±1.5 63.8**±1.3</td><td>65.3±0.6 66.0**±0.8</td><td>67.3±1.1 67.5±1.4</td><td>72.1±2.4 74.3**±2.1</td><td>74.7±1.8 75.6**±1.9</td><td>78.3±1.8 78.8* ±1.5</td></tr></table>",
+        "bbox": [
+            176,
+            325,
+            818,
+            366
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            393,
+            821,
+            421
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c1d448c4035fcc19ece2457264f5788047bdd7c12f8b0da0ea4e63a6a5003357.jpg",
+        "text": "$$\n\\pmb { g } ^ { \\prime } = \\mathrm { s o f t m a x } ( \\hat { P } \\mathcal { F } ^ { \\prime } ( \\pmb { X } , \\pmb { \\theta } ^ { \\prime } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            426,
+            594,
+            446
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\mathcal { F } } ^ { \\prime }$ can be a linear layer or a multi-layer perceptron with parameter $\\theta ^ { \\prime }$ . The final training loss for large-scale graph $L _ { L }$ follows Eq (5) and (6), and replaces $\\pmb { w }$ and $\\textbf {  { g } }$ with $\\hat { \\pmb { w } }$ and $\\pmb { g } ^ { \\prime }$ . ",
+        "bbox": [
+            171,
+            454,
+            825,
+            483
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            502,
+            312,
+            520
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we will first introduce the experimental datasets for both transductive and inductive semi-supervised node classification. Then we introduce the experiments to verify the effectiveness of the proposed ReNode method in three different imbalance situations: (1) TINL only, (2) TINL and QINL, (3) Large-scale Graph. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 Datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            272,
+            621
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We adopt two sets of graph datasets to conduct experiments. For the transductive setting [13], we take the widely-used Plantoid paper citation graphs [33] (CORA,CiteSeer, Pubmed) and the Amazon copurchase graphs [24] (Photo,Computers) to verify the effectiveness of our method. For the inductive setting, we conduct experiments on the popular Reddit dataset [13] and the enormous MAG-Scholar dataset (coarse-grain version) [2] which owns millions of nodes and features. For each of these datasets, we repeat experiments on 5 different datasets splittings [34] and we run 3 times for each splitting to reduce the random variance. More details about the datasets and experiment settings are presented in Appendix A. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            743
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 ReNode for the Pure Topology-imbalance Issue ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            761,
+            540,
+            776
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Settings When considering topology-imbalance only, the labeling set takes a balanced setting and the annotation size for each class is all equal to $| \\dot { \\mathcal { L } } | / k$ . Following the most widely-used semisupervised setting in node classification studies [47, 18], we randomly select 20 nodes in each class for training and 30 nodes per class for validation; all the remaining nodes form the test set. We display the experiment results for the 5 transductive datasets on 6 widely-used GNN models: GCN [18], GAT [40], PPNP [19], GraphSAGE [13] (short as SAGE), ChebGCN [9] (short as CHEB) and SGC [43]. We strictly align the hyperparameters in each group of experiments to show the pure improvement brought by our ReNode method (similarly hereinafter). The training loss $L _ { T }$ from section 2.4 is adopted. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/d1bb9abdc48efa57ccfd11940d646394dc2aae52d1d770844156057bc45f9349.jpg",
+        "table_caption": [
+            "Table 3: ReNode method for the compound scene of TINL and QINL. The imbalance ratio $\\rho$ is set to different levels ([5, 10]) to test the effect of our method under different imbalance intensities. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Macro-F1(%)</td><td rowspan=1 colspan=2>CORA</td><td rowspan=1 colspan=2>CiteSeer</td><td rowspan=1 colspan=2>PubMed</td><td rowspan=1 colspan=2>Photo</td><td rowspan=1 colspan=2>Computers</td></tr><tr><td rowspan=1 colspan=1>Imbalance Ratio</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>CE</td><td rowspan=1 colspan=1>60.9±1.5</td><td rowspan=1 colspan=1>41.0±3.5</td><td rowspan=1 colspan=1>53.6±2.1</td><td rowspan=1 colspan=1>47.6±2.8</td><td rowspan=1 colspan=1>61.0±1.9</td><td rowspan=1 colspan=1>49.7±2.6</td><td rowspan=1 colspan=1>62.0±2.7</td><td rowspan=1 colspan=1>40.7±3.4</td><td rowspan=1 colspan=1>50.4±2.6</td><td rowspan=1 colspan=1>35.5±3.2</td></tr><tr><td rowspan=1 colspan=1>DR-GCN</td><td rowspan=1 colspan=1>67.7±1.1</td><td rowspan=1 colspan=1>51.3±1.4</td><td rowspan=1 colspan=1>54.7±1.7</td><td rowspan=1 colspan=1>52.5±2.6</td><td rowspan=1 colspan=1>79.4±1.2</td><td rowspan=1 colspan=1>78.0±1.6</td><td rowspan=1 colspan=1>80.8±2.3</td><td rowspan=1 colspan=1>79.5±2.8</td><td rowspan=1 colspan=1>66.9±3.5</td><td rowspan=1 colspan=1>67.4±3.6</td></tr><tr><td rowspan=2 colspan=1>RA-GCNG-SMOTE</td><td rowspan=1 colspan=1>69.0±1.5</td><td rowspan=2 colspan=1>51.7±1.749.6±1.1</td><td rowspan=2 colspan=1>55.6±1.354.0±1.6</td><td rowspan=1 colspan=1>52.7±2.1</td><td rowspan=2 colspan=1>80.6±1.879.7±1.2</td><td rowspan=2 colspan=1>78.1±2.176.4±1.5</td><td rowspan=2 colspan=1>81.4±2.682.2±1.8</td><td rowspan=2 colspan=1>79.4±3.277.5±2.1</td><td rowspan=2 colspan=1>71.2±2.871.9±2.5</td><td rowspan=1 colspan=1>68.7±3.0</td></tr><tr><td rowspan=1 colspan=1>68.1±0.9</td><td rowspan=1 colspan=1>51.8±1.3</td><td rowspan=1 colspan=1>61.3±3.2</td></tr><tr><td rowspan=1 colspan=1>RW (w/o RN)</td><td rowspan=1 colspan=1>69.1±1.4</td><td rowspan=1 colspan=1>49.7±1.6</td><td rowspan=1 colspan=1>53.6±2.3</td><td rowspan=1 colspan=1>52.9±2.6</td><td rowspan=1 colspan=1>80.5±1.5</td><td rowspan=1 colspan=1>78.0±2.0</td><td rowspan=1 colspan=1>80.5±2.7</td><td rowspan=1 colspan=1>80.4±3.3</td><td rowspan=1 colspan=1>70.5±3.2</td><td rowspan=1 colspan=1>67.8±4.2</td></tr><tr><td rowspan=1 colspan=1>RW (w/ RN)</td><td rowspan=1 colspan=1>70.0*±1.3</td><td rowspan=1 colspan=1>50.1±1.7</td><td rowspan=1 colspan=1>55.2**±1.8</td><td rowspan=1 colspan=1>54.0**±2.5</td><td rowspan=1 colspan=1>81.2* ±1.0</td><td rowspan=1 colspan=1>78.5*±2.2</td><td rowspan=1 colspan=1>83.9**±2.1</td><td rowspan=1 colspan=1>81.3**±3.2</td><td rowspan=1 colspan=1>72.4**±2.6</td><td rowspan=1 colspan=1>70.2**±2.4</td></tr><tr><td rowspan=2 colspan=1>FOCAL (w/o RN)FOCAL (w/RN)</td><td rowspan=1 colspan=1>66.4±1.6</td><td rowspan=1 colspan=1>51.9±1.8</td><td rowspan=1 colspan=1>54.3±1.3</td><td rowspan=1 colspan=1>54.0±1.9</td><td rowspan=1 colspan=1>80.5±0.7</td><td rowspan=1 colspan=1>78.0±1.6</td><td rowspan=1 colspan=1>79.3±1.9</td><td rowspan=1 colspan=1>79.2±2.2</td><td rowspan=1 colspan=1>65.8±2.7</td><td rowspan=1 colspan=1>63.9±2.6</td></tr><tr><td rowspan=1 colspan=1>68.7**±0.7</td><td rowspan=1 colspan=1>52.6**±1.9</td><td rowspan=1 colspan=1>54.6±1.2</td><td rowspan=1 colspan=1>54.7*±1.5</td><td rowspan=1 colspan=1>80.9*±0.8</td><td rowspan=1 colspan=1>78.7**±1.4</td><td rowspan=1 colspan=1>80.0**±*2.3</td><td rowspan=1 colspan=1>80.7**±2.9</td><td rowspan=1 colspan=1>68.6**±3.1</td><td rowspan=1 colspan=1>65.5**±3.5</td></tr><tr><td rowspan=2 colspan=1>CB (w/o RN)CB (w/RN)</td><td rowspan=1 colspan=1>69.8±1.5</td><td rowspan=2 colspan=1>51.5±1.551.9*±1.2</td><td rowspan=2 colspan=1>54.1±1.354.7*±1.6</td><td rowspan=2 colspan=1>53.5±0.854.3**±2.3</td><td rowspan=2 colspan=1>80.6±0.881.2*±1.8</td><td rowspan=2 colspan=1>77.6±1.678.3**±2.6</td><td rowspan=2 colspan=1>77.9±2.679.6** ±2.7</td><td rowspan=2 colspan=1>78.8±3.180.4**±3.3</td><td rowspan=2 colspan=1>69.6±2.273.1**±3.1</td><td rowspan=2 colspan=1>64.8±2.966.5**±3.6</td></tr><tr><td rowspan=1 colspan=1>71.1**±0.6</td></tr></table>",
+        "bbox": [
+            176,
+            125,
+            820,
+            266
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results From Table 1, we can find that our ReNode method can effectively improve the overall performance (Weighted-F1) and the class-balance performance (Macro-F1) for all the 6 experiment GNNs in most cases, which proves the effectiveness and generalizability of our method. Our method considers the graph-specific topology imbalance issue which has been usually neglected in existing methods and conducts a fine-grained and self-adaptive adjustment to the training node weights based on their topological positions. We notice that the improvement for the CiteSeer dataset is less than the other datasets. We analyze the reason lies in that the connectivity of CiteSeer is poor, which makes the conflict detection–based method fail to reflect the node topological position well. To verify the motivation of relieving topology-imbalance, we set training sets with different levels of topologyimbalance to test our method3. Table 2 displays that our ReNode method improves the performance of GNN (GCN) most when the dataset is highly topologically imbalanced, which demonstrates that our method can effectively alleviate topology-imbalance and improve GNN performance. ",
+        "bbox": [
+            173,
+            294,
+            825,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 ReNode for the Compound Scene of TINL and QINL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            479,
+            581,
+            494
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Settings When jointly considering both topology- and quantity-imbalance issues, following existing studies [5, 4], we take the step imbalance setting, in which all the minority classes have the same labeling size $n _ { i }$ and all the majority classes have the same labeling size $n _ { a } = \\rho * n _ { i }$ . The imbalance ratio $\\rho$ denotes the intensity of quantity imbalance which is equal to the ratio of the node size of the most frequent to least frequent class. In this work, the imbalance ratio $\\rho$ is set to [5, 10] for each dataset. The fraction of the majority classes is $\\mu$ , and for all experiments, we set $\\mu = 0 . 5$ and round down the result $\\mu * k$ . The training loss $L _ { Q }$ from section 2.4 is adopted. We implement two groups of baselines for comparison: (1) Popular quantity-imbalance methods for general scenarios: Re-weight [17] (RW), Focal Loss [22] (Focal) and Class Balanced Loss [8] (CB); (2) Graph-specific quantity-imbalance methods: DR-GCN [35], RA-GCN [11] and GraphSMOTE [49]. To jointly handle the topology- and quantity-imbalance issues and demonstrate the orthogonality of them, we combine our ReNode method with these three general quantity-imbalance methods (RW, Focal, CB)4. The backbone model is GCN [18], and the labeling ratio $\\delta$ is set to $5 \\%$ . ",
+        "bbox": [
+            173,
+            506,
+            825,
+            685
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results From Table 3 (Macro-F1 is reported here for a fair comparison with these methods designed for class-balance performance), we can find that our ReNode method significantly outperforms both the general and the graph-specific quantity-imbalance methods in most situations by simultaneously alleviating the topology- and quantity-imbalance issues. Even when the training set is severely quantity-imbalanced $\\scriptstyle ( \\rho = 1 0 )$ , our method still effectively alleviates the imbalance issue and promotes model performance well. The performance of the quantity-imbalance methods from the general field (RW, Focal, CB) is on par with or less effective than the graph-specific quantity-imbalance methods (DR-GCN, RA-GCN, G-SMOTE), while the combination of our ReNode method and these general quantity-imbalance methods can surpass the graph-specific quantity-imbalance methods, which demonstrates that the node imbalance learning can be further solved by jointly handling the topology- and quantity-imbalance issues instead of considering the quantity-imbalance issue only. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            856
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/6d160bd3b091be39bb9f07d48335845a9ed9ec4d5bd61d729b2de3828a23d52b.jpg",
+        "image_caption": [
+            "Figure 4: Experimental results (Weighted-F1, $\\%$ ) on the large-scale Reddit and MAG-Scholar graphs. Our ReNode method can effectively improve the model performance under different labeling sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            89,
+            816,
+            193
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/f5bc5a21a4d8e008c5065041fd9c8ee0bd160c6729bf1cb6c89a70ee0cd10f49.jpg",
+        "image_caption": [
+            "Figure 5: Evaluating GNNs from the aspect of topology-imbalance sensitivity (Metric: Weighted-F1 $( \\% ) ,$ ). We can summarize the ranking of topology-imbalance sensitivity: $\\mathrm { G C N } > \\mathrm { P P N P } > \\mathrm { G A T }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            244,
+            820,
+            372
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4 ReNode for Large-scale Graphs ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            438,
+            433,
+            452
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Settings We conduct experiments on the two large-scale datasets: Reddit and MAG-Scholar, to verify the effectiveness of our ReNode method in the inductive setting. We conduct experiments with different labeling sizes (20/50/100 training nodes per class) and imbalance settings (TINL-only, TINL and QINL). The backbone GNN model is PPRGo [2] 5. For QINL, we take the uniform selection to sample training nodes to be consistent with PPRGo. The training loss $L _ { L }$ from section 2.4 is adopted. Both baseline and our methods are not combined with any quantity-imbalance method. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results In Figure 4, we present the experiment results with different labeling sizes and imbalance settings, we can find that our method can effectively promote the performance on the large-scale graphs comparing to the popular PPRGo model across different settings, which demonstrates the applicability of our method for extremely-large graphs. We also notice that our method can bring greater improvement when the labeling size is large. We explain the reason lies in that when the labeling size is large, the positions located by the conflicts among nodes will be more accurate, thus bringing more reasonable weight adjustments. On the other hand, when the labeling ratio is extremely small (especially for the enormous MAG-Scholar graph) and the influence conflict between the labeled nodes is negligible, our method exhibits the cold start problem. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            686
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 Discussions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            300,
+            723
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.1 Evaluating GNNs from the Aspect of Topology-Imbalance Sensitivity ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            737,
+            689,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5, we evaluate the GNN’s capability for handling topology-imbalance and find that different GNNs present significant difference in the topology-imbalance sensitivity across multiple datasets. The GCN model is susceptible to the topology-imbalance level of the graph and its performance decays greatly when the topology-imbalance increases. On the opposite, the GAT model is less sensitive to the topology-imbalance level and can achieve the best results when the topology-imbalance level is high. The PPNP model can achieve ideal performance when the topology-imbalance level is low, and its performance does not drop as sharply as GCN when the topology-imbalance level is high. We analyze the reason lies in that: (1) the aggregation operation of GCN is equivalent to directly averaging neighbor features [45] that lacks the noise filtering mechanism, so it is more sensitive to the topology-imbalance level of the graph; (2) the GAT model can dynamically adjust the aggregation weight from different neighbors, which increases its robustness to the high topology-imbalance situation but hinders the model performance when the graph topology-imbalance level is low and there is less need to filter neighbor information; (3) the infinite convolution mechanism of the PPNP model makes it possible to aggregate the information from distant nodes to enhance its robustness to the graph topology imbalance. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shchur et al. [34] notice that the performance ranking of GNNs varies with the training set selection. Hence, existing node classification studies [32, 14] usually repeat experiments multiple times with different training sets to reduce this randomness. The results from Figure 5 inspire us that the topology imbalance can partly explain the randomness of GNN performance caused by the training set selection and we can adopt the topology-imbalance sensitivity as a new aspect in evaluating the performance of different GNN architectures. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            277
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2 Limitations of Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            295,
+            369,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Although our ReNode method has proven effective in multiple scenarios, we also notice some limitations of it because of the complexity of node imbalance learning. First, the ReNode method is devised for homogeneously-connected graphs (linked nodes are expected to be similar, such as the various datasets in experiments), and it needs a further update for heterogeneously-connected graphs (such as protein networks). Besides, the ReNode method improves less when the graph connectivity is poor (Section 3.2) or the labeling ratio is extremely low (Section 3.3) because in these cases, the conflict level among nodes is low thus the nodes topological positions are insufficiently reflected. ",
+        "bbox": [
+            174,
+            320,
+            825,
+            417
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            321,
+            454
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Imbalanced classification problems are widespread in real scenarios and have attracted extensive attention from both academia and industry. Most existing studies on this topic focus on the classimbalanced quantity distribution [15], where the model’s inference ability for the majority classes will be significantly better than that of minority classes [12]. The existing methods for solving the quantity-imbalance issue can be roughly divided into methods for the data selection phase and the model training phase. Active learning [31, 10, 42] and Re-sampling [6, 16, 25] are two classical examples designed to construct a quantity-balanced training set . On the other hand, Re-weighting is a simple but effective solution for the model training phase, which adjusts the weights of training samples in different classes based on the labeling sizes [17, 30, 8, 5]. However, directly applying these methods into the graph scene lacks the consideration for the graph-specific topology-imbalance issue. Unlike the re-weight methods which conduct class-lever re-weighting, our ReNode method is a more fine-grained one and assign weights to each node individually. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            636
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There have been quantity-imbalance studies (Tomek links [38], NearMiss [23], One-Sided Selection [20]) trying to exclude the negative influence of labeling samples close to class boundaries by measuring the similarity of sample features. However, in the graph scene, the prior knowledge contained in node connections is more reliable than directly calculating the feature similarity. Besides, the number of labeled nodes is quite small in the semi-supervised setting. Thus it is not robust to locate their positions by computing similarity among a small number of nodes and we propose to leverage the influence conflict across the whole graph to locate node position to boundaries. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            739
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Graph data structure owns a wide range of applications, such as social media [13], stock exchange [21], shopping [34], medicine [44], transportation [28] and so on. Similar to other data structures, graph node representation learning also suffer from the quantity-imbalance issue [35]. Apart from the universal quantity-balance approaches introduced in Section 5 which can be transferred to the graph scene, there are some graph-specific quantity-imbalance methods recently proposed. DR-GCN [35] propose two types of regularization to tackle quantity imbalance: class-conditioned adversarial training and unlabeled nodes latent distribution constraint. RA-GCN [11] propose to automatically learn to weight the training samples in different classes in an adversarial training manner. AdaGCN Shi et al. [36] propose to leverage the boosting algorithm to handle the quantity-imbalance issue for the node classification task. GraphSMOTE [49] combines the synthetic node generation and the edge generation to up-sample nodes for the minority classes. However, these studies only pay attention to the quantity imbalance and overlook the topology imbalance. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Different from these studies [48, 29, 26] that try to locate the absolute positions for all the nodes by measuring their distance from the selected anchor nodes, our Totoro metric is devised to locate the relative positions to the class boundary for the labeling nodes by considering the influence conflict and can get rid of the dependence on the anchor nodes. Besides, our relative positions can more accurately reflect node class information because we distinguish the information from different classes while existing studies [48, 29] treat all the anchor nodes the same and ignore the class difference. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            449,
+            212
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we recognize the topology-imbalance node representation learning (TINL) as a graphspecific imbalance learning problem that has not been studied so far. We find that the topologyimbalance issue widely exists in graphs and severely hinders the learning of node classification. We unify TINL with the quantity-imbalance node representation learning (QINL) by considering the shift of the node influence boundaries from true class boundaries. To measure the degree of topology imbalance, we devise a conflict detection–based metric Totoro to locate node position, and further propose the ReNode method to adaptively adjust the training weights of labeled nodes based on their topological positions. Extensive empirical results have verified the effectiveness of our method in various settings: TINL-only, both TINL and QINL, and large-scale graph. Besides, we also propose the topology-imbalance sensitivity as a new metric to evaluate GNNs. ",
+        "bbox": [
+            174,
+            227,
+            825,
+            366
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Considering the importance of the topology-imbalance issue and the limitations of our approach, advanced methods with stronger theoretical or experimental support are expected in future work. Moreover, since topology imbalance is widespread in graph-related tasks other than node classification, how to measure and solve the topology-imbalance issues in broader graph scopes remains a meaningful challenge for future study. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            462,
+            359,
+            478
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We appreciate all the thoughtful and insightful suggestions from reviews. This work was supported in part by a Tencent Research Grant and National Natural Science Foundation of China (No. 61673028). Xu Sun is the corresponding author of this paper. ",
+        "bbox": [
+            174,
+            493,
+            826,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            266,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Reid Andersen, Fan R. K. Chung, and Kevin J. Lang. Local Graph Partitioning using PageRank Vectors. In 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS 2006), 21-24 October 2006, Berkeley, California, USA, Proceedings, pages 475–486. IEEE Computer Society, 2006.   \n[2] Aleksandar Bojchevski, Johannes Klicpera, Bryan Perozzi, Amol Kapoor, Martin Blais, Benedek Rózemberczki, Michal Lukasik, and Stephan Günnemann. Scaling Graph Neural Networks with Approximate PageRank. In the 26th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, KDD 2020, pages 2464–2473. ACM, 2020.   \n[3] Eliav Buchnik and Edith Cohen. Bootstrapped Graph Diffusions: Exposing the Power of Nonlinearity. Proc. ACM Meas. Anal. Comput. Syst., 2(1):10:1–10:19, 2018.   \n[4] Mateusz Buda, Atsuto Maki, and Maciej A. Mazurowski. A Systematic Study of the Class Imbalance Problem in Convolutional Neural Networks. Neural Networks, 106:249–259, 2018.   \n[5] Kaidi Cao, Colin Wei, Adrien Gaidon, Nikos Aréchiga, and Tengyu Ma. Learning Imbalanced Datasets with Label-Distribution-Aware Margin Loss. In Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Processing Systems 2019, NeurIPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pages 1565–1576, 2019.   \n[6] Nitesh V Chawla, Kevin W Bowyer, Lawrence O Hall, and W Philip Kegelmeyer. SMOTE: Synthetic Minority Over-sampling Technique. Journal of artificial intelligence research, 16: 321–357, 2002. ",
+        "bbox": [
+            178,
+            588,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[7] Wei-Lin Chiang, Xuanqing Liu, Si Si, Yang Li, Samy Bengio, and Cho-Jui Hsieh. Cluster-GCN: An Efficient Algorithm for Training Deep and Large Graph Convolutional Networks. In the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, KDD 2019, Anchorage, AK, USA, August 4-8, 2019, pages 257–266. ACM, 2019. ",
+        "bbox": [
+            183,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[8] Yin Cui, Menglin Jia, Tsung-Yi Lin, Yang Song, and Serge J. Belongie. Class-Balanced Loss Based on Effective Number of Samples. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2019, Long Beach, CA, USA, June 16-20, 2019, pages 9268–9277. Computer Vision Foundation / IEEE, 2019. ",
+        "bbox": [
+            181,
+            156,
+            826,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[9] Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pages 3837–3845, 2016. ",
+        "bbox": [
+            179,
+            223,
+            825,
+            280
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[10] Seyda Ertekin, Jian Huang, and C Lee Giles. Active Learning for Class Imbalance Problem. In the 30th Annual International ACM SIGIR Conference on Research and Development in Information Retrieval, SIGIR 2007, pages 823–824, 2007. ",
+        "bbox": [
+            174,
+            289,
+            823,
+            333
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[11] Mahsa Ghorbani, Anees Kazi, Mahdieh Soleymani Baghshah, Hamid R. Rabiee, and Nassir Navab. RA-GCN: Graph Convolutional Network for Disease Prediction Problems with Imbalanced Data. arXiv preprint: 2103.00221, 2021. ",
+        "bbox": [
+            173,
+            342,
+            823,
+            385
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[12] Haixiang Guo, Yijing Li, Jennifer Shang, Gu Mingyun, Huang Yuanyue, and Gong Bing. Learning from Class-Imbalanced Data: Review of Methods and Applications. Expert Syst. Appl., 73:220–239, 2017. ",
+        "bbox": [
+            174,
+            393,
+            826,
+            436
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[13] William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive Representation Learning on Large Graphs. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, December 4-9, 2017, Long Beach, CA, USA, pages 1024–1034, 2017. ",
+        "bbox": [
+            174,
+            446,
+            826,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[14] Kaveh Hassani and Amir Hosein Khasahmadi. Contrastive Multi-View Representation Learning on Graphs. In the 37th International Conference on Machine Learning, ICML 2020, 13-18 July 2020, Virtual Event, volume 119 of Proceedings of Machine Learning Research, pages 4116–4126. PMLR, 2020. ",
+        "bbox": [
+            174,
+            512,
+            826,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[15] Haibo He and Edwardo A. Garcia. Learning from imbalanced data. IEEE Trans. Knowl. Data Eng., 21(9):1263–1284, 2009. ",
+        "bbox": [
+            169,
+            579,
+            825,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[16] Haibo He, Yang Bai, Edwardo A. Garcia, and Shutao Li. ADASYN: Adaptive synthetic sampling approach for imbalanced learning. In the International Joint Conference on Neural Networks, IJCNN 2008, part of the IEEE World Congress on Computational Intelligence, WCCI 2008, Hong Kong, China, June 1-6, 2008, pages 1322–1328. IEEE, 2008. ",
+        "bbox": [
+            174,
+            617,
+            826,
+            674
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[17] Chen Huang, Yining Li, Chen Change Loy, and Xiaoou Tang. Learning Deep Representation for Imbalanced Classification. In the 29th IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, pages 5375–5384, 2016. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            727
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[18] Thomas N Kipf and Max Welling. Semi-supervised Classification with Graph Convolutional Networks. In the 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017. ",
+        "bbox": [
+            174,
+            736,
+            826,
+            780
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[19] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then Propagate: Graph Neural Networks meet Personalized PageRank. In the 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019. ",
+        "bbox": [
+            174,
+            789,
+            826,
+            844
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[20] Miroslav Kubat, Stan Matwin, et al. Addressing the Curse of Imbalanced Training Sets: Onesided Selection. In the 14th International Conference on Machine Learning (ICML 1997), Nashville, Tennessee, USA, July 8-12, 1997, volume 97, pages 179–186. Morgan Kaufmann, 1997. ",
+        "bbox": [
+            174,
+            856,
+            826,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[21] Wei Li, Ruihan Bao, Keiko Harimoto, Deli Chen, Jingjing Xu, and Qi Su. Modeling the Stock Relation with Graph Network for Overnight Stock Movement Prediction. In the 29th International Joint Conference on Artificial Intelligence, IJCAI 2020, pages 4541–4547. ijcai.org, 2020. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[22] Tsung-Yi Lin, Priya Goyal, Ross B. Girshick, Kaiming He, and Piotr Dollár. Focal Loss for Dense Object Detection. In IEEE International Conference on Computer Vision, ICCV 2017, Venice, Italy, October 22-29, 2017, pages 2999–3007. IEEE Computer Society, 2017. ",
+        "bbox": [
+            173,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[23] Inderjeet Mani and I Zhang. kNN Approach to Unbalanced Data Distributions: A Case Study Involving Information Extraction. In Workshop on Learning from Imbalanced Datasets, volume 126, 2003. ",
+        "bbox": [
+            174,
+            205,
+            823,
+            247
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[24] Julian McAuley, Christopher Targett, Qinfeng Shi, and Anton Van Den Hengel. Image-based Recommendations on Styles and Substitutes. In the 38th International ACM SIGIR Conference on Research and Development in Information Retrieval, Santiago, Chile, August 9-13, 2015, pages 43–52. ACM, 2015. ",
+        "bbox": [
+            173,
+            256,
+            826,
+            311
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[25] Iman Nekooeimehr and Susana K Lai-Yuen. Adaptive Semi-unsupervised Weighted Oversampling (A-SUWO) for Imbalanced Datasets. Expert Systems with Applications, 46:405–416, 2016. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            362
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[26] Sunil Nishad, Shubhangi Agarwal, Arnab Bhattacharya, and Sayan Ranu. GraphReach: PositionAware Graph Neural Networks using Reachability Estimations. In the 30th International Joint Conference on Artificial Intelligence IJCAI, 2020. ",
+        "bbox": [
+            171,
+            369,
+            823,
+            414
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[27] Lawrence Page, Sergey Brin, Rajeev Motwani, and Terry Winograd. The PageRank Citation Ranking: Bringing Order to the Web. Technical report, Stanford InfoLab, 1999. ",
+        "bbox": [
+            171,
+            420,
+            823,
+            450
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[28] Nikolay G Prokoptsev, AE Alekseenko, and Yaroslav Aleksandrovich Kholodov. Traffic Flow Speed Prediction on Transportation Graph with Convolutional Neural Networks. Computer research and modeling, 10(3):359–367, 2018. ",
+        "bbox": [
+            174,
+            457,
+            821,
+            500
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[29] Zhenyue Qin, Saeed Anwar, Dongwoo Kim, Yang Liu, Pan Ji, and Tom Gedeon. PositionSensing Graph Neural Networks: Proactively Learning Nodes Relative Positions. arXiv preprint: 2105.11346, 2021. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            550
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[30] Mengye Ren, Wenyuan Zeng, Bin Yang, and Raquel Urtasun. Learning to Reweight Examples for Robust Deep Learning. In International Conference on Machine Learning, pages 4334–4343. PMLR, 2018. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            601
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[31] Pengzhen Ren, Yun Xiao, Xiaojun Chang, Po-Yao Huang, Zhihui Li, Xiaojiang Chen, and Xin Wang. A Survey of Deep Active Learning. arXiv preprint: 2009.00236, 2020. ",
+        "bbox": [
+            173,
+            608,
+            821,
+            637
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[32] Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. The Truly Deep Graph Convolutional Networks for Node Classification. arXiv preprint: 1907.10903, 2019. ",
+        "bbox": [
+            173,
+            645,
+            821,
+            674
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[33] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina EliassiRad. Collective Classification in Network Data. AI magazine, 29(3):93–93, 2008. ",
+        "bbox": [
+            174,
+            681,
+            823,
+            710
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[34] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of Graph Neural Network Evaluation. arXiv preprint: 1811.05868, 2018. ",
+        "bbox": [
+            173,
+            718,
+            825,
+            747
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[35] Min Shi, Yufei Tang, Xingquan Zhu, David A. Wilson, and Jianxun Liu. Multi-Class Imbalanced Graph Convolutional Network Learning. In the 29th International Joint Conference on Artificial Intelligence, IJCAI 2020, pages 2879–2885. ijcai.org, 2020. ",
+        "bbox": [
+            173,
+            755,
+            823,
+            797
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[36] Shuhao Shi, Kai Qiao, Shuai Yang, L Wang, J Chen, and Bin Yan. AdaGCN: Adaptive Boosting Algorithm for Graph Convolutional Networks on Imbalanced Node Classification. arXiv preprint: 2105.11625, 2021. ",
+        "bbox": [
+            173,
+            804,
+            823,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[37] Marina Sokol, Konstantin Avrachenkov, Paulo Gonçalves, and Alexey Mishenin. Generalized Optimization Framework for Graph-based Semi-supervised Learning. In the 12th SIAM International Conference on Data Mining, Anaheim, California, USA, April 26-28, 2012, pages 966–974. SIAM / Omnipress, 2012. ",
+        "bbox": [
+            174,
+            856,
+            826,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[38] Ivan Tomek et al. Two Modifications of CNN. IEEE Transactions on Systems, Man, and Cybernetics, 1976. ",
+        "bbox": [
+            171,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[39] Laurens Van der Maaten and Geoffrey Hinton. Visualizing Data using t-SNE. Journal of machine learning research, 9(11), 2008. ",
+        "bbox": [
+            173,
+            127,
+            825,
+            157
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[40] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and ´ Yoshua Bengio. Graph Attention Networks. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings. OpenReview.net, 2018. ",
+        "bbox": [
+            174,
+            165,
+            821,
+            223
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[41] Hongwei Wang and Jure Leskovec. Unifying Graph Convolutional Neural Networks and Label Propagation. arXiv preprint: 2002.06755, 2020. ",
+        "bbox": [
+            169,
+            231,
+            825,
+            261
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[42] Xinyue Wang, Bo Liu, Siyu Cao, Liping Jing, and Jian Yu. Important Sampling based Active Learning for Imbalance Classification. Science China Information Sciences, 63(8):1–14, 2020. ",
+        "bbox": [
+            173,
+            268,
+            823,
+            297
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[43] Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying Graph Convolutional Networks. In International Conference on Machine Learning, pages 6861–6871. PMLR, 2019. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            349
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[44] Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. MoleculeNet: a Benchmark for Molecular Machine Learning. Chemical science, 2018. ",
+        "bbox": [
+            173,
+            358,
+            825,
+            401
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How Powerful are Graph Neural Networks? In the 7th International Conference on Learning Representations, ICLR 2019, New Orleans, LA, USA, May 6-9, 2019. OpenReview.net, 2019. ",
+        "bbox": [
+            171,
+            409,
+            823,
+            452
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[46] Yuzhe Yang and Zhi Xu. Rethinking the Value of Labels for Improving Class-Imbalanced Learning. In Advances in Neural Information Processing Systems 33: Annual Conference on Neural Information Processing Systems 2020, NeurIPS 2020, December 6-12, 2020, virtual, 2020. ",
+        "bbox": [
+            173,
+            459,
+            826,
+            516
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[47] Zhilin Yang, William W Cohen, and Ruslan Salakhutdinov. Revisiting Semi-supervised Learning with Graph Embeddings. In the 33nd International Conference on Machine Learning, ICML 2016, volume 48 of JMLR Workshop and Conference Proceedings, pages 40–48. JMLR.org, 2016. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            582
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[48] Jiaxuan You, Rex Ying, and Jure Leskovec. Position-aware Graph Neural Networks. In the 36th International Conference on Machine Learning, ICML 2019, volume 97 of Proceedings of Machine Learning Research, pages 7134–7143. PMLR, 2019. ",
+        "bbox": [
+            173,
+            590,
+            825,
+            633
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[49] Tianxiang Zhao, Xiang Zhang, and Suhang Wang. GraphSMOTE: Imbalanced Node Classification on Graphs with Graph Neural Networks. In WSDM ’21, The Fourteenth ACM International Conference on Web Search and Data Mining, Virtual Event, Israel, March 8-12, 2021, pages 833–841. ACM, 2021. ",
+        "bbox": [
+            173,
+            642,
+            826,
+            699
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[50] Dengyong Zhou and Christopher J. C. Burges. Spectral Clustering and Transductive Learning with Multiple Views. In the 24th Annual International Conference on Machine Learning, ICML 2007, volume 227, pages 1159–1166. ACM, 2007. ",
+        "bbox": [
+            171,
+            707,
+            821,
+            751
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[51] Jie Zhou, Ganqu Cui, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, and Maosong Sun. Graph Neural Networks: A Review of Methods and Applications. AI Open, 1, 2020. ",
+        "bbox": [
+            171,
+            758,
+            823,
+            789
+        ],
+        "page_idx": 12
+    }
+]