Add files using upload-large-folder tool

parse/train/BkUHlMZ0b/BkUHlMZ0b.md

@@ -0,0 +1,393 @@
+# EVALUATING THE ROBUSTNESS OF NEURAL NETWORKS: AN EXTREME VALUE THEORY APPROACH
+
+Tsui-Wei Weng1∗, Huan Zhang2∗, Pin-Yu Chen3, Jinfeng $\mathbf { Y _ { i } ^ { * } }$ , Dong $\mathbf { S } \mathbf { u } ^ { 3 }$ , Yupeng $\mathbf { G a o } ^ { 3 }$ , Cho-Jui Hsieh2, Luca Daniel1
+
+1Massachusetts Institute of Technology, Cambridge, MA 02139   
+2University of California, Davis, CA 95616   
+3IBM Research AI, Yorktown Heights, NY 10598   
+4Tencent AI Lab, Bellevue, WA 98004   
+twweng@mit.edu, ecezhang@ucdavis.edu,   
+pin-yu.chen@ibm.com, jinfengyi.ustc@gmail.com,   
+{dong.su,yupeng.gao}@ibm.com, chohsieh@ucdavis.edu, dluca@mit.edu
+
+# ABSTRACT
+
+The robustness of neural networks to adversarial examples has received great attention due to security implications. Despite various attack approaches to crafting visually imperceptible adversarial examples, little has been developed towards a comprehensive measure of robustness. In this paper, we provide a theoretical justification for converting robustness analysis into a local Lipschitz constant estimation problem, and propose to use the Extreme Value Theory for efficient evaluation. Our analysis yields a novel robustness metric called CLEVER, which is short for Cross Lipschitz Extreme Value for nEtwork Robustness. The proposed CLEVER score is attack-agnostic and computationally feasible for large neural networks. Experimental results on various networks, including ResNet, Inceptionv3 and MobileNet, show that (i) CLEVER is aligned with the robustness indication measured by the $\ell _ { 2 }$ and $\ell _ { \infty }$ norms of adversarial examples from powerful attacks, and (ii) defended networks using defensive distillation or bounded ReLU indeed achieve better CLEVER scores. To the best of our knowledge, CLEVER is the first attack-independent robustness metric that can be applied to any neural network classifier.
+
+# 1 INTRODUCTION
+
+Recent studies have highlighted the lack of robustness in state-of-the-art neural network models, e.g., a visually imperceptible adversarial image can be easily crafted to mislead a well-trained network (Szegedy et al., 2013; Goodfellow et al., 2015; Chen et al., 2017a). Even worse, researchers have identified that these adversarial examples are not only valid in the digital space but also plausible in the physical world (Kurakin et al., 2016a; Evtimov et al., 2017). The vulnerability to adversarial examples calls into question safety-critical applications and services deployed by neural networks, including autonomous driving systems and malware detection protocols, among others.
+
+In the literature, studying adversarial examples of neural networks has twofold purposes: (i) security implications: devising effective attack algorithms for crafting adversarial examples, and (ii) robustness analysis: evaluating the intrinsic model robustness to adversarial perturbations to normal examples. Although in principle the means of tackling these two problems are expected to be independent, that is, the evaluation of a neural network’s intrinsic robustness should be agnostic to attack methods, and vice versa, existing approaches extensively use different attack results as a measure of robustness of a target neural network. Specifically, given a set of normal examples, the attack success rate and distortion of the corresponding adversarial examples crafted from a particular attack algorithm are treated as robustness metrics. Consequently, the network robustness is entangled with the attack algorithms used for evaluation and the analysis is limited by the attack capabilities. More importantly, the dependency between robustness evaluation and attack approaches can cause biased analysis. For example, adversarial training is a commonly used technique for improving the robustness of a neural network, accomplished by generating adversarial examples and retraining the network with corrected labels. However, while such an adversarially trained network is made robust to attacks used to craft adversarial examples for training, it can still be vulnerable to unseen attacks.
+
+Motivated by the evaluation criterion for assessing the quality of text and image generation that is completely independent of the underlying generative processes, such as the BLEU score for texts (Papineni et al., 2002) and the INCEPTION score for images (Salimans et al., 2016), we aim to propose a comprehensive and attack-agnostic robustness metric for neural networks. Stemming from a perturbation analysis of an arbitrary neural network classifier, we derive a universal lower bound on the minimal distortion required to craft an adversarial example from an original one, where the lower bound applies to any attack algorithm and any $\ell _ { p }$ norm for $p \geq 1$ . We show that this lower bound associates with the maximum norm of the local gradients with respect to the original example, and therefore robustness evaluation becomes a local Lipschitz constant estimation problem. To efficiently and reliably estimate the local Lipschitz constant, we propose to use extreme value theory (De Haan & Ferreira, 2007) for robustness evaluation. In this context, the extreme value corresponds to the local Lipschitz constant of our interest, which can be inferred by a set of independently and identically sampled local gradients.With the aid of extreme value theory, we propose a robustness metric called CLEVER, which is short for Cross Lipschitz Extreme Value for nEtwork Robustness. We note that CLEVER is an attack-independent robustness metric that applies to any neural network classifier. In contrast, the robustness metric proposed in Hein & Andriushchenko (2017), albeit attack-agnostic, only applies to a neural network classifier with one hidden layer.
+
+We highlight the main contributions of this paper as follows:
+
+We propose a novel robustness metric called CLEVER, which is short for Cross Lipschitz Extreme Value for nEtwork Robustness. To the best of our knowledge, CLEVER is the first robustness metric that is attack-independent and can be applied to any arbitrary neural network classifier and scales to large networks for ImageNet. The proposed CLEVER score is well supported by our theoretical analysis on formal robustness guarantees and the use of extreme value theory. Our robustness analysis extends the results in Hein & Andriushchenko (2017) from continuously differentiable functions to a special class of non-differentiable functions – neural+ networks with ReLU activations. We corroborate the effectiveness of CLEVER by conducting experiments on state-of-theart models for ImageNet, including ResNet (He et al., 2016), Inception-v3 (Szegedy et al., 2016) and MobileNet (Howard et al., 2017). We also use CLEVER to investigate defended networks against adversarial examples, including the use of defensive distillation (Papernot et al., 2016) and bounded ReLU (Zantedeschi et al., 2017). Experimental results show that our CLEVER score well aligns with the attack-specific robustness indicated by the $\ell _ { 2 }$ and $\ell _ { \infty }$ distortions of adversarial examples.
+
+# 2 BACKGROUND AND RELATED WORK
+
+# 2.1 ATTACKING NEURAL NETWORKS USING ADVERSARIAL EXAMPLES
+
+One of the most popular formulations found in literature for crafting adversarial examples to mislead a neural network is to formulate it as a minimization problem, where the variable $\pmb { \delta } \in \mathbb { R } ^ { d }$ to be optimized refers to the perturbation to the original example, and the objective function takes into account unsuccessful adversarial perturbations as well as a specific norm on $\delta$ for assuring similarity. For instance, the success of adversarial examples can be evaluated by their cross-entropy loss (Szegedy et al., 2013; Goodfellow et al., 2015) or model prediction (Carlini & Wagner, 2017b). The norm constraint on $\delta$ can be implemented in a clipping manner (Kurakin et al., 2016b) or treated as a penalty for any (Carlini & Wagner, 2017b). The , is often used for crafting adve $\ell _ { p }$ norm of rial exa $\pmb { \delta }$ , defined as ples. In pa $\begin{array} { r } { \| \pmb { \delta } \| _ { p } = ( \sum _ { i = 1 } ^ { d } | \pmb { \delta } _ { i } | ^ { p } ) ^ { 1 / p } } \end{array}$ $p \geq 1$ $p ~ = ~ \infty$ $\lVert \delta \rVert _ { \infty } = \mathrm { m a x } _ { i \in \{ 1 , \ldots , d \} } | \delta _ { i } |$ measures the maximal variation among all dimensions in $\delta$ . When $p = 2$ , $\lVert \delta \rVert _ { 2 }$ becomes the Euclidean norm of $\pmb { \delta }$ . When $p = 1$ , $\begin{array} { r } { \| \pmb { \delta } \| _ { 1 } = \sum _ { i = 1 } ^ { p } | \pmb { \delta } _ { i } | } \end{array}$ measures the total variation of $\delta$ . The state-of-the-art attack methods for $\ell _ { \infty }$ , $\ell _ { 2 }$ and $\ell _ { 1 }$ norms are the iterative fast gradient sign method (I-FGSM) (Goodfellow et al., 2015; Kurakin et al., 2016b), Carlini and Wagner’s attack (CW attack) (Carlini & Wagner, 2017b), and elastic-net attacks to deep neural networks (EAD) (Chen et al., 2017b), respectively. These attacks fall into the category of white-box attacks since the network model is assumed to be transparent to an attacker. Adversarial examples can also be crafted from a black-box network model using an ensemble approach (Liu et al., 2016), training a substitute model (Papernot et al., 2017), or employing zeroth-order optimization based attacks (Chen et al., 2017c).
+
+# 2.2 EXISTING DEFENSE METHODS
+
+Since the discovery of vulnerability to adversarial examples (Szegedy et al., 2013), various defense methods have been proposed to improve the robustness of neural networks. The rationale for defense is to make a neural network more resilient to adversarial perturbations, while ensuring the resulting defended model still attains similar test accuracy as the original undefended network. Papernot et al. proposed defensive distillation (Papernot et al., 2016), which uses the distillation technique (Hinton et al., 2015) and a modified softmax function at the final layer to retrain the network parameters with the prediction probabilities (i.e., soft labels) from the original network. Zantedeschi et al. (2017) showed that by changing the ReLU function to a bounded ReLU function, a neural network can be made more resilient. Another popular defense approach is adversarial training, which generates and augments adversarial examples with the original training data during the network training stage. On MNIST, the adversarially trained model proposed by Madry et al. (2017) can successfully defend a majority of adversarial examples at the price of increased network capacity. Model ensemble has also been discussed to increase the robustness to adversarial examples (Tramer et al. \` , 2017; Liu et al., 2017). In addition, detection methods such as feature squeezing (Xu et al., 2017) and example reforming (Meng & Chen, 2017) can also be used to identify adversarial examples. However, the CW attack is shown to be able to bypass 10 different detection methods (Carlini & Wagner, 2017a). In this paper, we focus on evaluating the intrinsic robustness of a neural network model to adversarial examples. The effect of detection methods is beyond our scope.
+
+# 2.3 THEORETICAL ROBUSTNESS GUARANTEES FOR NEURAL NETWORKS
+
+Szegedy et al. (2013) compute global Lipschitz constant for each layer and use their product to explain the robustness issue in neural networks, but the global Lipschitz constant often gives a very loose bound. Hein & Andriushchenko (2017) gave a robustness lower bound using a local Lipschitz continuous condition and derived a closed-form bound for a multi-layer perceptron (MLP) with a single hidden layer and softplus activation. Nevertheless, a closed-form bound is hard to derive for a neural network with more than one hidden layer. Wang et al. (2016) utilized terminologies from topology to study robustness. However, no robustness bounds or estimates were provided for neural networks. On the other hand, works done by Ehlers (2017); Katz et al. (2017a;b); Huang et al. (2017) focus on formally verifying the viability of certain properties in neural networks for any possible input, and transform this formal verification problem into satisfiability modulo theory (SMT) and large-scale linear programming (LP) problems. These SMT or LP based approaches have high computational complexity and are only plausible for very small networks.
+
+Intuitively, we can use the distortion of adversarial examples found by a certain attack algorithm as a robustness metric. For example, Bastani et al. (2016) proposed a linear programming (LP) formulation to find adversarial examples and use the distortions as the robustness metric. They observe that the LP formulation can find adversarial examples with smaller distortions than other gradient-based attacks like L-BFGS (Szegedy et al., 2013). However, the distortion found by these algorithms is an upper bound of the true minimum distortion and depends on specific attack algorithms. These methods differ from our proposed robustness measure CLEVER, because CLEVER is an estimation of the lower bound of the minimum distortion and is independent of attack algorithms. Additionally, unlike LP-based approaches which are impractical for large networks, CLEVER is computationally feasible for large networks like Inception-v3. The concept of minimum distortion and upper/lower bound will be formally defined in Section 3.
+
+# 3 ANALYSIS OF FORMAL ROBUSTNESS GUARANTEES FOR A CLASSIFIER
+
+In this section, we provide formal robustness guarantees of a classifier in Theorem 3.2. Our robustness guarantees are general since they only require a mild assumption on Lipschitz continuity of the classification function. For differentiable classification functions, our results are consistent with the main theorem in (Hein & Andriushchenko, 2017) but are obtained by a much simpler and more intuitive manner1. Furthermore, our robustness analysis can be easily extended to non-differentiable classification functions (e.g. neural networks with ReLU) as in Lemma 3.3, whereas the analysis in Hein & Andriushchenko (2017) is restricted to differentiable functions. Specifically, Corollary 3.2.1 shows that the robustness analysis in (Hein & Andriushchenko, 2017) is in fact a special case of our analysis. We start our analysis by defining the notion of adversarial examples, minimum $\ell _ { p }$ distortions, and lower/upper bounds. All the notations are summarized in Table 1.
+
+Table 1: Table of Notation   
+
+<table><tr><td>Notation d δ∈Rd p</td><td>Definition dimensionality of the input vector number of output classes</td><td>Notation △p,min</td><td>Definition minimum lp distortion of xo lower bound of minimum distortion</td></tr><tr><td>K f:Rd→RK</td><td>adversarial example distortion := xa -xo Bp(xo,R)</td><td>βL</td><td></td></tr><tr><td>xo∈Rd x∈Rd</td><td>neural network classifier original input vector</td><td>βu L</td><td>upper bound of minimum distortion Lipschitz constant local Lipschitz constant</td></tr></table>
+
+Definition 3.1 (perturbed example and adversarial example). Let $\pmb { x _ { 0 } } ~ \in ~ \mathbb { R } ^ { d }$ be an input vector of a $K$ -class classification function $f ~ : ~ \mathbb { R } ^ { d } ~ \to ~ \mathbb { R } ^ { K }$ and the prediction is given as $c ( \pmb { x _ { 0 } } ) \ =$ $\operatorname { a r g m a x } _ { 1 \leq i \leq K } f _ { i } ( { \pmb x } _ { 0 } )$ . Given $\scriptstyle { \mathbf { x _ { 0 } } }$ , we say $\scriptstyle { \mathbf { { \mathit { x } } } } _ { a }$ is a perturbed example of $\scriptstyle { \mathbf { { \vec { x } } } } _ { \mathbf { 0 } }$ with noise $\pmb { \delta } \in \mathbb { R } ^ { d }$ and $\ell _ { p }$ -distortion $\Delta _ { p }$ if ${ \pmb x } _ { \pmb a } = { \pmb x } _ { \mathbf 0 } + \delta$ and $\Delta _ { p } = \| \delta \| _ { p }$ . An adversarial example is a perturbed example $\scriptstyle { \mathbf { { \mathit { x } } } } _ { a }$ that changes $c ( \pmb { x _ { 0 } } )$ . A successful untargeted attack is to find a $\scriptstyle { \mathbf { { \mathit { x } } } } _ { a }$ such that $c ( \pmb { x _ { a } } ) \neq c ( \pmb { x _ { 0 } } )$ while a successful targeted attack is to find a $\scriptstyle { \mathbf { { \mathit { x } } } } _ { a }$ such that $c ( { \pmb x } _ { \pmb a } ) = t$ given a target class $t \neq c ( \pmb { x _ { 0 } } )$ .
+
+Definition 3.2 (minimum adversarial distortion $\Delta _ { p , \mathrm { { m i n } } } ,$ ). Given an input vector $\scriptstyle { \mathbf { { \vec { x } } } } _ { \mathbf { 0 } }$ of a classifier $f$ , the minimum $\ell _ { p }$ adversarial distortion of $\scriptstyle { \mathbf { x _ { 0 } } }$ , denoted as $\Delta _ { p , \mathrm { { m i n } } }$ , is defined as the smallest $\Delta _ { p }$ over all adversarial examples of $\scriptstyle { \mathbf { x _ { 0 } } }$ .
+
+Definition 3.3 (lower bound of $\Delta _ { p , \mathrm { { m i n } } } ,$ ). Suppose $\Delta _ { p , \mathrm { { m i n } } }$ is the minimum adversarial distortion of $\scriptstyle { \mathbf { x _ { 0 } } }$ . A lower bound of $\Delta _ { p , \mathrm { { m i n } } }$ , denoted by $\beta _ { L }$ where $\beta _ { L } \le \Delta _ { p , \mathrm { { m i n } } }$ , is defined such that any perturbed examples of $\scriptstyle { \mathbf { { \vec { x } } } } _ { \mathbf { 0 } }$ with $\| \pmb { \delta } \| _ { p } \leq \beta _ { L }$ are not adversarial examples.
+
+Definition 3.4 (upper bound of $\Delta _ { p , \mathrm { { m i n } } } .$ ). Suppose $\Delta _ { p , \mathrm { { m i n } } }$ is the minimum adversarial distortion of $\scriptstyle { \mathbf { x _ { 0 } } }$ . An upper bound of $\Delta _ { p , \mathrm { { m i n } } }$ , denoted by $\beta _ { U }$ where $\dot { \beta } _ { U } \ge \Delta _ { p , \mathrm { { m i n } } }$ , is defined such that there exists an adversarial example of $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathbf { 0 } }$ with $\| \delta \| _ { p } \ge \beta _ { U }$ .
+
+The lower and upper bounds are instance-specific because they depend on the input $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathbf { 0 } }$ . While $\beta _ { U }$ can be easily given by finding an adversarial example of $\scriptstyle { \mathbf { x _ { 0 } } }$ using any attack method, $\beta _ { L }$ is not easy to find. $\beta _ { L }$ guarantees that the classifier is robust to any perturbations with $\| \delta \| _ { p } \le \beta _ { L }$ , certifying the robustness of the classifier. Below we show how to derive a formal robustness guarantee of a classifier with Lipschitz continuity assumption. Specifically, our analysis obtains a lower bound of $\ell _ { p }$ minimum adversarial distortion $\begin{array} { r } { \beta _ { L } = \operatorname* { m i n } _ { j \neq c } \frac { \bar { f } _ { c } ( \pmb { x _ { 0 } } ) - f _ { j } \bar { ( \pmb { x _ { 0 } } ) } } { L _ { q } ^ { j } } } \end{array}$ .
+
+Lemma 3.1 (Lipschitz continuity and its relationship with gradient norm (Paulavicius & ˇ Zilinskas ˇ , 2006)). Let $\dot { S } \subset \mathbb { R } ^ { d }$ be a convex bounded closed set and let $h ( \pmb { x } ) : S  \mathbb { R }$ be a continuously differentiable function on an open set containing $S$ . Then, $h ( { \pmb x } )$ is a Lipschitz function with Lipschitz constant $L _ { q }$ if the following inequality holds for any $\mathbf { \Delta } _ { \pmb { x } , \pmb { y } } \in S$ :
+
+$$
+| h ( \pmb { x } ) - h ( \pmb { y } ) | \leq L _ { q } \| \pmb { x } - \pmb { y } \| _ { p } ,
+$$
+
+where $\begin{array} { r } { L _ { q } = \operatorname* { m a x } \{ \| \nabla h ( \pmb { x } ) \| _ { q } : \pmb { x } \in S \} , \nabla h ( \pmb { x } ) = ( \frac { \partial h ( \pmb { x } ) } { \partial x _ { 1 } } , \cdot \cdot \cdot , \frac { \partial h ( \pmb { x } ) } { \partial x _ { d } } ) ^ { \top } \ \xi } \end{array}$ , ∂h(x) )> is the gradient of h(x), and $\begin{array} { r } { \frac { 1 } { p } + \frac { 1 } { q } = 1 , 1 \leq p , q \leq \infty } \end{array}$ .
+
+Given Lemma 3.1, we then provide a formal guarantee to the lower bound $\beta _ { L }$ .
+
+Theorem 3.2 (Formal guarantee on lower bound $\beta _ { L }$ for untargeted attack). Let $\pmb { x _ { 0 } } ~ \in ~ \mathbb { R } ^ { d }$ and $f : \mathbb { R } ^ { d }  \mathbb { R } ^ { K }$ be a multi-class classifier with continuously differentiable components $f _ { i }$ and let $c = \operatorname { a r g m a x } _ { 1 \leq i \leq K } f _ { i } ( \pmb { x _ { 0 } } )$ be the class which $f$ predicts for $\scriptstyle { \mathbf { x _ { 0 } } }$ . For all $\pmb { \delta } \in \mathbb { R } ^ { d }$ with
+
+$$
+\| \pmb { \delta } \| _ { p } \leq \operatorname* { m i n } _ { j \neq c } \frac { f _ { c } ( \pmb { x _ { 0 } } ) - f _ { j } ( \pmb { x _ { 0 } } ) } { L _ { q } ^ { j } } ,
+$$
+
+$\operatorname { a r g m a x } _ { 1 \leq i \leq K } f _ { i } ( x _ { 0 } + \delta ) = c$ holds with $\textstyle { \frac { 1 } { p } } + { \frac { 1 } { q } } = 1 , 1 \leq p , q \leq \infty$ and $L _ { q } ^ { j }$ is the Lipschitz constant for the function $f _ { c } ( { \pmb x } ) - f _ { j } ( { \pmb x } )$ in $\ell _ { p }$ norm. In other words, $\begin{array} { r } { \beta _ { L } = \operatorname* { m i n } _ { j \neq c } \frac { f _ { c } ( \pmb { x _ { 0 } } ) - f _ { j } ( \pmb { x _ { 0 } } ) } { L _ { q } ^ { j } } } \end{array}$ fc(x0)−fj (x0) is a lower bound of minimum distortion.
+
+The intuitions behind Theorem 3.2 is shown in Figure 1 with an one-dimensional example. The function value $g ( x ) = f _ { c } ( x ) - f _ { j } ( x )$ near point $x _ { 0 }$ is inside a double cone formed by two lines passing $( x _ { 0 } , g ( x _ { 0 } ) )$ and with slopes equal to $\pm L _ { q }$ , where $L _ { q }$ is the (local) Lipschitz constant of $g ( x )$ near $x _ { 0 }$ . In other words, the function value of $g ( x )$ around $x _ { 0 }$ , i.e. $g ( x _ { 0 } + \delta )$ can be bounded by $g ( x _ { 0 } )$ , $\delta$ and the Lipschitz constant $L _ { q }$ . When $g ( x _ { 0 } + \delta )$ is decreased to 0, an adversarial example is found and the minimal change of $\delta$ is $\frac { g ( x _ { 0 } ) } { L _ { q } }$ . The complete proof is deferred to Appendix A.
+
+![](images/79f34835ec0f121d7b93b45cfc52576e6a0a4dc1df5c37f3e3380a0817faa25e.jpg)  
+Figure 1: Intuitions behind Theorem 3.2.
+
+Remark 1. $L _ { q } ^ { j }$ is the Lipschitz constant of the function involving cross terms: $f _ { c } ( { \pmb x } ) - f _ { j } ( { \pmb x } )$ , hence we also call it cross Lipschitz constant following (Hein & Andriushchenko, 2017).
+
+To distinguish our analysis from (Hein & Andriushchenko, 2017), we show in Corollary 3.2.1 that we can obtain the same result in (Hein & Andriushchenko, 2017) by Theorem 3.2. In fact, the analysis in (Hein & Andriushchenko, 2017) is a special case of our analysis because the authors implicitly assume Lipschitz continuity on $f _ { i } ( { \pmb x } )$ when requiring $f _ { i } ( { \pmb x } )$ to be continuously differentiable. They use local Lipschitz constant $( L _ { q , x _ { 0 } } )$ instead of global Lipschitz constant $( L _ { q } )$ to obtain a tighter bound in the adversarial perturbation $\delta$ .
+
+Corollary 3.2.1 (Formal guarantee on $\beta _ { L }$ for untargeted attack). 2 Let $L _ { q , x _ { 0 } } ^ { j }$ be local Lipschitz constant of function $f _ { c } ( { \pmb x } ) - f _ { j } ( { \pmb x } )$ at $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathbf { 0 } }$ over some fixed ball $B _ { p } ( \pmb { x _ { 0 } } , R ) : = \{ \pmb { x } \in \mathbb { R } ^ { d } \ | \ \| \pmb { x } - \pmb { x _ { 0 } } \| _ { p } \ \leq$ $R \}$ and let $\pmb { \delta } \in B _ { p } ( \mathbf { 0 } , R )$ . By Theorem 3.2, we obtain the bound in (Hein & Andriushchenko, 2017):
+
+$$
+\| \pmb { \delta } \| _ { p } \leq \operatorname* { m i n } \bigg \{ \operatorname* { m i n } _ { j \neq c } \frac { f _ { c } ( \pmb { x _ { 0 } } ) - f _ { j } ( \pmb { x _ { 0 } } ) } { L _ { q , x _ { 0 } } ^ { j } } , R \bigg \} .
+$$
+
+An important use case of Theorem 3.2 and Corollary 3.2.1 is the bound for targeted attack:
+
+Corollary 3.2.2 (Formal guarantee on $\beta _ { L }$ for targeted attack). Assume the same notation as in Theorem 3.2 and Corollary 3.2.1. For a specified target class $j$ , we have $\begin{array} { r l } { \| \delta \| _ { p } } & { { } \leq } \end{array}$ $\begin{array} { r } { \operatorname* { m i n } \left\{ \frac { f _ { c } ( \pmb { x _ { 0 } } ) - f _ { j } ( \pmb { x _ { 0 } } ) } { L _ { q , x _ { 0 } } ^ { j } } , R \right\} } \end{array}$
+
+In addition, we further extend Theorem 3.2 to a special case of non-differentiable functions – neural networks with ReLU activations. In this case the Lipchitz constant used in Lemma 3.1 can be replaced by the maximum norm of directional derivative, and our analysis above will go through.
+
+Lemma 3.3 (Formal guarantee on $\beta _ { L }$ for ReLU networks). 3 Let $h ( \cdot )$ be a $l$ -layer ReLU neural network with $W _ { i }$ as the weights for layer $i$ . We ignore bias terms as they don’t contribute to gradient.
+
+$$
+h ( \pmb { x } ) = \sigma ( W _ { l } \sigma ( W _ { l - 1 } \dots \sigma ( W _ { 1 } \pmb { x } ) ) )
+$$
+
+where $\sigma ( u ) = \operatorname* { m a x } ( 0 , u )$ . Let $S \subset \mathbb { R } ^ { d }$ be a convex bounded closed set, then equation (1) holds with $\begin{array} { r } { L _ { q } = \operatorname* { s u p } _ { \pmb { x } \in S } \{ | \operatorname* { s u p } _ { \| \pmb { d } \| _ { p } = 1 } D ^ { + } h ( \pmb { x } ; \pmb { d } ) | \} } \end{array}$ where $\begin{array} { r } { D ^ { + } h ( { \pmb x } ; { \pmb d } ) : = \operatorname* { l i m } _ { t  0 ^ { + } } \frac { h ( { \pmb x } + t { \pmb d } ) - h ( { \pmb x } ) } { t } } \end{array}$ h(x+td)−h(x) is the one-sided directional direvative, then Theorem 3.2, Corollary 3.2.1 and Corollary 3.2.2 still hold.
+
+# 4 THE CLEVER ROBUSTNESS METRIC VIA EXTREME VALUE THEORY
+
+In this section, we provide an algorithm to compute the robustness metric CLEVER with the aid of extreme value theory, where CLEVER can be viewed as an efficient estimator of the lower bound $\beta _ { L }$ and is the first attack-agnostic score that applies to any neural network classifiers. Recall in Section 3 we show that the lower bound of network robustness is associated with $g ( x _ { 0 } )$ and its cross Lipschitz constant $L _ { q , x _ { 0 } } ^ { j }$ , where $g ( \pmb { x _ { 0 } } ) = f _ { c } ( \pmb { x _ { 0 } } ) - f _ { j } ( \pmb { x _ { 0 } } )$ is readily available at the output of a classifier and $L _ { q , x _ { 0 } } ^ { j }$ is defined as $\mathrm { m a x } _ { \pmb { x } \in B _ { p } ( { \pmb x } _ { 0 } , R ) } \| \nabla g ( { \pmb x } ) \| _ { q }$ . Although $\nabla g ( { \pmb x } )$ can be calculated easily via back propagation, computing $L _ { q , x _ { 0 } } ^ { j }$ is more involved because it requires to obtain the maximum value of $\| \nabla g ( \pmb { x } ) \| _ { q }$ in a ball. Exhaustive search on low dimensional $_ { \textbf { \em x } }$ in $B _ { p } ( { \pmb x } _ { 0 } , R )$ seems already infeasible, not to mention the image classifiers with large feature dimensions of our interest. For instance, the feature dimension $d = 7 8 4 , 3 0 7 2 , 1 5 0 5 2 8$ for MNIST, CIFAR and ImageNet respectively.
+
+One approach to compute $L _ { q , x _ { 0 } } ^ { j }$ is through sampling a set of points $\pmb { x } ^ { ( i ) }$ in a ball $B _ { p } ( { \pmb x } _ { 0 } , R )$ around $\scriptstyle { \mathbf { { \mathit { x } } } } _ { 0 }$ and taking the maximum value of $\| \nabla g ( \pmb { x } ^ { ( i ) } ) \| _ { q }$ . However, a significant amount of samples might be needed to obtain a good estimate of max $| | \vec { \nabla } \dot { g } ( { \pmb x } ) | | _ { q }$ and it is unknown how good the estimate is compared to the true maximum. Fortunately, Extreme Value Theory ensures that the maximum value of random variables can only follow one of the three extreme value distributions, which is useful to estimate max $\| \nabla g ( { \pmb x } ) \| _ { q }$ with only a tractable number of samples.
+
+It is worth noting that although Wood & Zhang (1996) also applied extreme value theory to estimate the Lipschitz constant. However, there are two main differences between their work and this paper. First of all, the sampling methodology is entirely different. Wood & Zhang (1996) calculates the slopes between pairs of sample points whereas we directly take samples on the norm of gradient as in Lemma 3.1. Secondly, the functions considered in Wood & Zhang (1996) are only one-dimensional as opposed to the high-dimensional classification functions considered in this paper. For comparison, we show in our experiment that the approach in Wood & Zhang (1996), denoted as SLOPE in Table 3 and Figure 4, perform poorly for high-dimensional classifiers such as deep neural networks.
+
+# 4.1 ESTIMATE $L _ { q , x _ { 0 } } ^ { j }$ VIA EXTREME VALUE THEORY
+
+When sampling a point $_ { \textbf { \em x } }$ uniformly in $B _ { p } ( { \pmb x } _ { 0 } , R )$ , $\| \nabla g ( { \pmb x } ) \| _ { q }$ can be viewed as a random variable characterized by a cumulative distribution function (CDF). For the purpose of illustration, we derived the CDF for a 2-layer neural network in Theorem D.1.4 For any neural networks, suppose we have $n$ samples $\{ \| \nabla g ( \pmb { x } ^ { ( i ) } ) \| _ { q } \}$ , and denote them as a sequence of independent and identically distributed (iid) random variables $Y _ { 1 } , Y _ { 2 } , \cdots , Y _ { n }$ , each with CDF $F _ { Y } ( y )$ . The CDF of $\operatorname* { m a x } \{ Y _ { 1 } , \cdot \cdot \cdot , Y _ { n } \}$ , denoted as $F _ { Y } ^ { n } ( y )$ , is called the limit distribution of $F _ { Y } ( y )$ . Fisher-TippettGnedenko theorem says that $F _ { Y } ^ { n } ( y )$ , if exists, can only be one of the three family of extreme value distributions – the Gumbel class, the Frechet class and the reverse Weibull class. ´
+
+Theorem 4.1 (Fisher-Tippett-Gnedenko Theorem). If there exists a sequence of pairs of real numbers $\left( a _ { n } , b _ { n } \right)$ such that $a _ { n } > 0$ and $\begin{array} { r } { \operatorname* { l i m } _ { n \to \infty } F _ { Y } ^ { n } ( a _ { n } y + b _ { n } ) = G ( y ) } \end{array}$ , where $G$ is a non-degenerate distribution function, then $G$ belongs to either the Gumbel class (Type $I )$ , the Frechet class (Type II) ´ or the Reverse Weibull class (Type III) with their CDFs as follows:
+
+$$
+\begin{array} { r l r } & { } & { \mathrm { G u m b e l ~ c l a s s ~ ( T y p e ~ I ) } ; \quad G ( y ) = \exp \big \{ - \exp \big [ - \frac { y - a _ { W } } { b _ { W } } \big ] \big \} , \quad y \in \mathbb { R } , } \\ & { } & { \mathrm { F r } { \ ' e c h e t ~ c l a s s ~ ( T y p e ~ I I ) } ; \quad G ( y ) = \Big \{ \begin{array} { l l } { 0 , } & { \mathrm { ~ i f ~ } y < a _ { W } , } \\ { \exp \{ - \big ( \frac { y - a _ { W } } { b _ { W } } \big ) ^ { - c _ { w } } \} , } & { \mathrm { ~ i f ~ } y \geq a _ { W } , } \end{array} } \\ & { } & { \mathrm { \it ~ r e r s e ~ W e i b u l l ~ c l a s s ~ ( T y p e ~ I I I ) } ; \quad G ( y ) = \Big \{ \begin{array} { l l } { \exp \{ - \big ( \frac { a _ { W } - y } { b _ { W } } \big ) ^ { c _ { w } } \} , } & { \mathrm { ~ i f ~ } y < a _ { W } , } \\ { 1 , } & { \mathrm { ~ i f ~ } y \geq a _ { W } , } \end{array} \Big \} , } \\ & { } & { \mathrm { \it ~ i f ~ } y \geq a _ { W } , } \end{array}
+$$
+
+where $a _ { W } \in \mathbb { R } ,$ $b _ { W } > 0$ and $c _ { W } > 0$ are the location, scale and shape parameters, respectively. Theorem 4.1 implies that the maximum values of the samples follow one of the three families of distributions. If $g ( { \pmb x } )$ has a bounded Lipschitz constant, $\| \nabla g ( \pmb { x } ^ { ( i ) } ) \| _ { q }$ is also bounded, thus its limit distribution must have a finite right end-point. We are particularly interested in the reverse Weibull class, as its CDF has a finite right end-point (denoted as $a w$ ). The right end-point reveals the upper limit of the distribution, cross Lipschitz constant $L _ { q , \pmb { x } _ { 0 } } ^ { j }$ as the extreme value. The extreme value is exactly thewe would like to estimate in this paper. To estimate Ljq,x0 own local, we first generate $N _ { s }$ samples of $\mathbf { \boldsymbol { x } } ^ { ( i ) }$ over a fixed ball $B _ { p } ( { \pmb x } _ { \mathbf { 0 } } , R )$ uniformly and independently in each batch with a total of $N _ { b }$ batches. We then compute $\| \nabla g ( \pmb { x } ^ { ( i ) } ) \| _ { q }$ and store the maximum values of each batch in set $S$ . Next, with samples in $S$ , we perform a maximum likelihood estimation of reverse Weibull distribution parameters, and the location estimate $\hat { a } _ { W }$ is used as an estimate of $L _ { q , \pmb { x } _ { 0 } } ^ { j }$ .
+
+Given an instance $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathbf { 0 } }$ , its classifier $f ( x _ { 0 } )$ and a target class $j$ , a targeted CLEVER score of the classifier’s robustness can be computed via $g ( x _ { 0 } )$ and $L _ { q , x _ { 0 } } ^ { j }$ . Similarly, untargeted CLEVER scores can be computed. With the proposed procedure of estimating $L _ { q , x _ { 0 } } ^ { j }$ described in Section 4.1, we summarize the flow of computing CLEVER score for both targeted attacks and un-targeted attacks in Algorithm 1 and 2, respectively.
+
+# Algorithm 1: CLEVER-t, compute CLEVER score for targeted attack
+
+Input: a $K$ -class classifier $f ( { \pmb x } )$ , data example $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathbf { 0 } }$ with predicted class $c$ , target class $j$ , batch size $N _ { b }$ , number of samples per batch $N _ { s }$ , perturbation norm $p$ , maximum perturbation $R$ Result: CLEVER Score $\mu \in \mathbb { R } _ { + }$ for target class $j$ 1 $S \gets \{ \emptyset \}$ $\begin{array} { r } { \cdot \{ \emptyset \} , g ( { \pmb x } )  f _ { c } ( { \pmb x } ) - f _ { j } ( { \pmb x } ) , q  \frac { p } { p - 1 } , } \end{array}$ . 2 for $i \gets 1$ to $N _ { b }$ do 3 for $k \gets 1$ to $N _ { s }$ do 4 randomly select a point $\pmb { x } ^ { ( i , k ) } \in B _ { p } ( \pmb { x } _ { 0 } , R )$ 5 compute $b _ { i k }  \| \nabla g ( \pmb { x } ^ { ( i , k ) } ) \| _ { q }$ via back propagation 6 end 7 $S \gets S \cup \{ \operatorname* { m a x } _ { k } \{ b _ { i k } \} \}$ 8 end 9 $\hat { a } _ { W } \gets \mathbf { M } \mathbf { L } \mathbf { E }$ of location parameter of reverse Weibull distribution on $S$ 10 $\begin{array} { r } { \mu  \operatorname* { m i n } ( \frac { g ( \pmb { x _ { 0 } } ) } { \hat { a } } , R ) } \end{array}$
+
+# Algorithm 2: CLEVER-u, compute CLEVER score for un-targeted attack
+
+Input: Same as Algorithm 1, but without a target class $j$ Result: CLEVER score $\nu \in \mathbb { R } _ { + }$ for un-targeted attack 1 for $j  1$ to $K$ , $j \neq c$ do 2 $| \quad \mu _ { j } \gets \mathrm { C L E V E R - t } ( f , \boldsymbol { x } _ { 0 } , c , j , N _ { b } , N _ { s } , p , R )$ 3 end 4 $\nu \gets \operatorname* { m i n } _ { j } \{ \mu _ { j } \}$
+
+# 5 EXPERIMENTAL RESULTS
+
+# 5.1 NETWORKS AND PARAMETER SETUP
+
+We conduct experiments on CIFAR-10 (CIFAR for short), MNIST, and ImageNet data sets. For the former two smaller datasets CIFAR and MNIST, we evaluate CLEVER scores on four relatively small networks: a single hidden layer MLP with softplus activation (with the same number of hidden units as in (Hein & Andriushchenko, 2017)), a 7-layer AlexNet-like CNN (with the same structure as in (Carlini & Wagner, 2017b)), and the 7-layer CNN with defensive distillation (Papernot et al., 2016) (DD) and bounded ReLU (Zantedeschi et al., 2017) (BReLU) defense techniques employed.
+
+For ImageNet data set, we use three popular deep network architectures: a 50-layer Residual Network (He et al., 2016) (ResNet-50), Inception-v3 (Szegedy et al., 2016) and MobileNet (Howard et al., 2017). They were chosen for the following reasons: (i) they all yield (close to) state-of-theart performance among equal-sized networks; and (ii) their architectures are significantly different with unique building blocks, i.e., residual block in ResNet, inception module in Inception net, and depthwise separable convolution in MobileNet. Therefore, their diversity in network architectures is appropriate to test our robustness metric. For MobileNet, we set the width multiplier to 1.0, achieving a ${ \bar { 7 } } 0 . 6 \%$ accuracy on ImageNet. We used public pretrained weights for all ImageNet models5.
+
+In all our experiments, we set the sampling parameters $N _ { b } = 5 0 0$ , $N _ { s } = 1 0 2 4$ and $R = 5$ . For targeted attacks, we use 500 test-set images for CIFAR and MNIST and use 100 test-set images for ImageNet; for each image, we evaluate its targeted CLEVER score for three targets: a random target class, a least likely class (the class with lowest probability when predicting the original example), and the top-2 class (the class with largest probability except for the true class, which is usually the easiest target to attack). We also conduct untargeted attacks on MNIST and CIFAR for 100 test-set images, and evaluate their untargeted CLEVER scores. Our experiment code is publicly available6.
+
+5.2 FITTING GRADIENT NORM SAMPLES WITH REVERSE WEIBULL DISTRIBUTIONS
+
+We fit the cross Lipschitz constant samples in $S$ (see Algorithm 1) with reverse Weibull class distribution to obtain the maximum likelihood estimate of the location parameter $\hat { a } _ { W }$ , scale parameter $\hat { b } _ { W }$ and shape parameter $\hat { c } _ { W }$ , as introduced in Theorem 4.1. To validate that reverse Weibull distribution is a good fit to the empirical distribution of the cross Lipschitz constant samples, we conduct Kolmogorov-Smirnov goodness-of-fit test (a.k.a. K-S test) to calculate the K-S test statistics $D$ and corresponding $p$ -values. The null hypothesis is that samples $S$ follow a reverse Weibull distribution.
+
+Figure 2 plots the probability distribution function of the cross Lipschitz constant samples and the fitted Reverse Weibull distribution for images from various data sets and network architectures. The estimated MLE parameters, $p$ -values, and the K-S test statistics $D$ are also shown. We also calculate the percentage of examples whose estimation have $p$ -values greater than 0.05, as illustrated in Figure 3. If the $p$ -value is greater than 0.05, the null hypothesis cannot be rejected, meaning that the underlying data samples fit a reverse Weibull distribution well. Figure 3 shows that all numbers are close to $100 \%$ , validating the use of reverse Weibull distribution as an underlying distribution of gradient norm samples empirically. Therefore, the fitted location parameter of reverse Weibull distribution (i.e., the extreme value), $\hat { a } _ { W }$ , can be used as a good estimation of local cross Lipschitz constant to calculate the CLEVER score. The exact numbers are shown in Table 5 in Appendix E.
+
+![](images/1594e63d524ab271966776e460313e84135394152f920d2f7c78c1d759846c0b.jpg)  
+Figure 2: The cross Lipschitz constant samples for three images from CIFAR, MNIST and ImageNet datasets, and their fitted Reverse Weibull distributions with the corresponding MLE estimates of location, scale and shape parameters $\left( a _ { W } , b _ { W } , c _ { W } \right)$ shown on the top of each plot. The $D$ -statistics of K-S test and p-values are denoted as $k s$ and pval. With small $k s$ and high p-value, the hypothesized reverse Weibull distribution fits the empirical distribution of cross Lipschitz constant samples well.
+
+![](images/0cf944bfbb1a233a359e6510ba5e6a25da12f69cf0636e763b81b369a014a232.jpg)  
+Figure 3: The percentage of examples whose null hypothesis (the samples $S$ follow a reverse Weibull distribution) cannot be rejected by K-S test with a significance level of 0.05 for $p = 2$ and $p = \infty$ . All numbers for each model are close to $100 \%$ , indicating $S$ fits reverse Weibull distributions well.
+
+# 5.3 COMPARING CLEVER SCORE WITH ATTACK-SPECIFIC NETWORK ROBUSTNESS
+
+We apply the state-of-the-art white-box attack methods, iterative fast gradient sign method (IFGSM) (Goodfellow et al., 2015; Kurakin et al., 2016b) and Carlini and Wagner’s attack (CW) (Carlini & Wagner, 2017b), to find adversarial examples for 11 networks, including 4 networks trained on CIFAR, 4 networks trained on MNIST, and 3 networks trained on ImageNet. For CW attack, we run 1000 iterations for ImageNet and CIFAR, and 2000 iterations for MNIST, as MNIST has shown to be more difficult to attack (Chen et al., 2017b). Attack learning rate is individually tuned for each model: 0.001 for Inception-v3 and ResNet-50, 0.0005 for MobileNet and 0.01 for all other networks. For I-FGSM, we run 50 iterations and choose the optimal $\epsilon \in \{ 0 . 0 1 , 0 . 0 2 5 , 0 . 0 5 , 0 . 1 , 0 . 3 , 0 . 5 , 0 . 8 , 1 . 0 \}$ to achieve the smallest $\ell _ { \infty }$ distortion for each individual image. For defensively distilled (DD) networks, 50 iterations of I-FGSM are not sufficient; we use 250 iterations for CIFAR-DD and 500 iterations for MNIST-DD to achieve a $100 \%$ success rate. For the problem to be non-trivial, images that are classified incorrectly are skipped. We report $100 \%$ attack success rates for all the networks, and thus the average distortion of adversarial examples can indicate the attack-specific robustness of each network. For comparison, we compute the CLEVER scores for the same set of images and attack targets. To the best of our knowledge, CLEVER is the first attack-independent robustness score that is capable of handling the large networks studied in this paper, so we directly compare it with the attack-induced distortion metrics in our study.
+
+We evaluate the effectiveness of our CLEVER score by comparing the upper bound $\beta _ { U }$ (found by attacks) and CLEVER score, where CLEVER serves as an estimated lower bound, $\beta _ { L }$ . Table 3 compares the average $\ell _ { 2 }$ and $\ell _ { \infty }$ distortions of adversarial examples found by targeted CW and I-FGSM attacks and the corresponding average targeted CLEVER scores for $\ell _ { 2 }$ and $\ell _ { \infty }$ norms, and Figure 4 visualizes the results for $\ell _ { \infty }$ norm. Similarly, Table 2 compares untargeted CW and I-FGSM attacks with untargeted CLEVER scores. As expected, CLEVER is smaller than the distortions of adversarial images in most cases. More importantly, since CLEVER is independent of attack algorithms, the reported CLEVER scores can roughly indicate the distortion of the best possible attack in terms of a specific $\ell _ { p }$ distortion. The average $\ell _ { 2 }$ distortion found by CW attack is close to the $\ell _ { 2 }$ CLEVER score, indicating CW is a strong $\ell _ { 2 }$ attack. In addition, when a defense mechanism (Defensive Distillation or Bounded ReLU) is used, the corresponding CLEVER scores are consistently increased (except for CIFAR-BReLU), indicating that the network is indeed made more resilient to adversarial perturbations. For CIFAR-BReLU, both CLEVER scores and $\ell _ { p }$ norm of adversarial examples found by CW attack decrease, implying that bound ReLU is an ineffective defense for CIFAR. CLEVER scores can be seen as a security checkpoint for unseen attacks. For example, if there is a substantial gap in distortion between the CLEVER score and the considered attack algorithms, it may suggest the existence of a more effective attack that can close the gap.
+
+Since CLEVER score is derived from an estimation of the robustness lower bound, we further verify the viability of CLEVER per each example, i.e., whether it is usually smaller than the upper bound found by attacks. Table 4 shows the percentage of inaccurate estimations where the CLEVER score is larger than the distortion of adversarial examples found by CW and I-FGSM attacks in three ImageNet networks. We found that CLEVER score provides an accurate estimation for most of the examples. For MobileNet and Resnet-50, our CLEVER score is a strict lower bound of these two attacks for more than $96 \%$ of tested examples. For Inception-v3, the condition of strict lower bound
+
+Table 2: Comparison between the average untargeted CLEVER score and distortion found by CW and I-FGSM untargeted attacks. DD and BReLU represent Defensive Distillation and Bounded ReLU defending methods applied to the baseline CNN network.   
+
+<table><tr><td></td><td colspan="2">CW</td><td colspan="2">I-FGSM</td><td colspan="2">CLEVER</td></tr><tr><td></td><td>l2</td><td>lo</td><td>l2</td><td>lo</td><td>l2</td><td>l</td></tr><tr><td>MNIST-MLP</td><td>1.113</td><td>0.215</td><td>3.564</td><td>0.178</td><td>0.819</td><td>0.041</td></tr><tr><td>MNIST-CNN</td><td>1.500</td><td>0.455</td><td>4.439</td><td>0.288</td><td>0.721</td><td>0.057</td></tr><tr><td>MNIST-DD</td><td>1.548</td><td>0.409</td><td>5.617</td><td>0.283</td><td>0.865</td><td>0.063</td></tr><tr><td>MNIST-BReLU</td><td>1.337</td><td>0.433</td><td>3.851</td><td>0.285</td><td>0.833</td><td>0.065</td></tr><tr><td>CIFAR-MLP</td><td>0.253</td><td>0.018</td><td>0.885</td><td>0.016</td><td>0.219</td><td>0.005</td></tr><tr><td>CIFAR-CNN</td><td>0.195</td><td>0.023</td><td>0.721</td><td>0.018</td><td>0.072</td><td>0.002</td></tr><tr><td>CIFAR-DD</td><td>0.285</td><td>0.032</td><td>1.136</td><td>0.024</td><td>0.130</td><td>0.004</td></tr><tr><td>CIFAR-BReLU</td><td>0.159</td><td>0.019</td><td>0.519</td><td>0.013</td><td>0.045</td><td>0.001</td></tr></table>
+
+Table 3: Comparison of the average targeted CLEVER scores with average $\ell _ { \infty }$ and $\ell _ { 2 }$ distortions found by CW, I-FSGM attacks, and the average scores calculated by using the algorithm in Wood & Zhang (1996) (denoted as SLOPE) to estimate Lipschitz constant. DD and BReLU denote Defensive Distillation and Bounded ReLU defending methods applied to the CNN network. We did not include SLOPE in ImageNet networks because it has been shown to be ineffective even for smaller networks.
+
+(a) avergage $\ell _ { \infty }$ distortion of CW and I-FGSM targeted attacks, and CLEVER and SLOPE estimation. Some very large SLOPE estimates (in parentheses) exceeding the maximum possible $\ell _ { \infty }$ distortion are reported as 1.   
+
+<table><tr><td rowspan="2"></td><td colspan="4">LeastLikely Target</td><td colspan="4">Random Target</td><td colspan="4">Top-2 Target</td></tr><tr><td>CW</td><td>I-FGSM</td><td>CLEVER</td><td>SLOPE</td><td>CW</td><td>I-FGSM</td><td>CLEVER</td><td>SLOPE</td><td>CW</td><td>I-FGSM</td><td>CLEVER</td><td>SLOPE</td></tr><tr><td>MNIST-MLP</td><td>0.475</td><td>0.223</td><td>0.071</td><td>0.808</td><td>0.337</td><td>0.173</td><td>0.072</td><td>0.813</td><td>0.218</td><td>0.119</td><td>0.069</td><td>0.786</td></tr><tr><td>MNIST-CNN</td><td>0.601</td><td>0.313</td><td>0.090</td><td>0.996</td><td>0.550</td><td>0.264</td><td>0.088</td><td>0.982</td><td>0.451</td><td>0.211</td><td>0.070</td><td>0.826</td></tr><tr><td>MNIST-DD</td><td>0.578</td><td>0.283</td><td>0.103</td><td>1 (1.090)</td><td>0.531</td><td>0.238</td><td>0.091</td><td>0.953</td><td>0.412</td><td>0.165</td><td>0.091</td><td>0.984</td></tr><tr><td>MNIST-BReLU</td><td>0.601</td><td>0.276</td><td>0.257</td><td>1 (5.327)</td><td>0.544</td><td>0.238</td><td>0.187</td><td>3.907</td><td>0.442</td><td>0.196</td><td>0.117</td><td>1 (2.470)</td></tr><tr><td>CIFAR-MLP</td><td>0.086</td><td>0.039</td><td>0.014</td><td>0.294</td><td>0.051</td><td>0.024</td><td>0.014</td><td>0.284</td><td>0.019</td><td>0.013</td><td>0.014</td><td>0.286</td></tr><tr><td>CIFAR-CNN</td><td>0.053</td><td>0.033</td><td>0.005</td><td>0.153</td><td>0.042</td><td>0.023</td><td>0.005</td><td>0.148</td><td>0.022</td><td>0.013</td><td>0.004</td><td>0.129</td></tr><tr><td>CIFAR-DD</td><td>0.091</td><td>0.053</td><td>0.011</td><td>0.278</td><td>0.066</td><td>0.032</td><td>0.010</td><td>0.255</td><td>0.033</td><td>0.014</td><td>0.007</td><td>0.184</td></tr><tr><td>CIFAR-BReLU</td><td>0.045</td><td>0.030</td><td>0.004</td><td>0.250</td><td>0.034</td><td>0.022</td><td>0.003</td><td>0.173</td><td>0.018</td><td>0.012</td><td>0.002</td><td>0.095</td></tr><tr><td>Inception-v3</td><td>0.023</td><td>0.011</td><td>0.002</td><td>-</td><td>0.021</td><td>0.012</td><td>0.002</td><td>-</td><td>0.010</td><td>0.011</td><td>0.001</td><td>-</td></tr><tr><td>Resnet-50</td><td>0.031</td><td>0.015</td><td>0.002</td><td>-</td><td>0.025</td><td>0.012</td><td>0.002</td><td>-</td><td>0.010</td><td>0.010</td><td>0.001</td><td>-</td></tr><tr><td>MobileNet</td><td>0.025</td><td>0.010</td><td>0.003</td><td>-</td><td>0.018</td><td>0.010</td><td>0.002</td><td>-</td><td>0.006</td><td>0.010</td><td>0.001</td><td>=</td></tr></table>
+
+(b) average $\ell _ { 2 }$ distortion of CW and I-FGSM targeted attacks, and CLEVER and SLOPE estimation. Some very large SLOPE estimates (in parentheses) exceeding the sampling radius $R = 5$ are reported as 5.   
+
+<table><tr><td rowspan="2"></td><td colspan="4">LeastLikely Target</td><td colspan="4">Random Target</td><td colspan="4">Top-2 Target</td></tr><tr><td>CW</td><td>I-FGSM</td><td>CLEVER</td><td>SLOPE</td><td>CW</td><td>I-FGSM</td><td>CLEVER</td><td>SLOPE</td><td>CW</td><td>I-FGSM</td><td>CLEVER</td><td>SLOPE</td></tr><tr><td>MNIST-MLP</td><td>2.575</td><td>4.273</td><td>1.409</td><td>5(8.028)</td><td>1.833</td><td>3.369</td><td>1.432</td><td>5(8.102)</td><td>1.128</td><td>2.374</td><td>1.383</td><td>5(7.853)</td></tr><tr><td>MNIST-CNN</td><td>2.377</td><td>4.417</td><td>1.257</td><td>5 (9.947)</td><td>2.005</td><td>3.902</td><td>1.227</td><td>5 (9.619)</td><td>1.504</td><td>3.242</td><td>0.987</td><td>5 (7.921)</td></tr><tr><td>MNIST-DD</td><td>2.644</td><td>4.957</td><td>1.532</td><td>5 (10.628)</td><td>2.240</td><td>4.253</td><td>1.340</td><td>5 (9.493)</td><td>1.542</td><td>3.010</td><td>1.330</td><td>5 (9.646)</td></tr><tr><td>MNIST-BReLU</td><td>2.349</td><td>5.170</td><td>3.312</td><td>5(52.058)</td><td>1.923</td><td>4.544</td><td>2.565</td><td>5 (37.531)</td><td>1.404</td><td>3.778</td><td>1.583</td><td>5(23.548)</td></tr><tr><td>CIFAR-MLP</td><td>1.123</td><td>1.896</td><td>0.620</td><td>5 (5.013)</td><td>0.673</td><td>1.214</td><td>0.597</td><td>4.806</td><td>0.262</td><td>0.689</td><td>0.599</td><td>4.949</td></tr><tr><td>CIFAR-CNN</td><td>0.836</td><td>1.067</td><td>0.156</td><td>2.630</td><td>0.372</td><td>0.837</td><td>0.146</td><td>2.497</td><td>0.188</td><td>0.552</td><td>0.123</td><td>2.195</td></tr><tr><td>CIFAR-DD</td><td>2.065</td><td>1.540</td><td>0.347</td><td>4.735</td><td>0.624</td><td>1.097</td><td>0.307</td><td>4.279</td><td>0.296</td><td>0.582</td><td>0.220</td><td>3.083</td></tr><tr><td>CIFAR-BReLU</td><td>0.407</td><td>0.928</td><td>0.140</td><td>4.125</td><td>0.303</td><td>0.732</td><td>0.103</td><td>2.944</td><td>0.152</td><td>0.494</td><td>0.052</td><td>1.564</td></tr><tr><td>Inception-v3</td><td>0.628</td><td>2.244</td><td>0.524</td><td>-</td><td>0.595</td><td>2.261</td><td>0.466</td><td>-</td><td>0.287</td><td>2.073</td><td>0.234</td><td>-</td></tr><tr><td>Resnet-50</td><td>0.767</td><td>2.410</td><td>0.357</td><td>=</td><td>0.647</td><td>2.098</td><td>0.299</td><td>·</td><td>0.212</td><td>1.682</td><td>0.134</td><td>=</td></tr><tr><td>MobileNet</td><td>0.837</td><td>2.195</td><td>0.617</td><td>-</td><td>0.603</td><td>2.066</td><td>0.439</td><td>=</td><td>0.190</td><td>1.771</td><td>0.144</td><td>=</td></tr></table>
+
+![](images/bfd96f9277bcc8ece64b8c64329fc08b3906f8ddb874b4ac1e0980e7e17d51d8.jpg)  
+Figure 4: Comparison of $\ell _ { \infty }$ distortion obtained by CW and I-FGSM attacks, CLEVER score and the slope based Lipschitz constant estimation (SLOPE) by Wood & Zhang (1996). SLOPE significantly exceeds the distortions found by attacks, thus it is an inappropriate estimation of lower bound $\beta _ { L }$ .
+
+is worse (still more than $7 5 \%$ ), but we found that in these cases the attack distortion only differs from our CLEVER score by a fairly small amount. In Figure 5 we show the empirical CDF of the gap between CLEVER score and the $\ell _ { 2 }$ norm of adversarial distortion generated by CW attack for the same set of images in Table 4. In Figure 6, we plot the $\ell _ { 2 }$ distortion and CLEVER scores for each individual image. A positive gap indicates that CLEVER (estimated lower bound) is indeed less than the upper bound found by CW attack. Most images have a small positive gap, which signifies the near-optimality of CW attack in terms of $\ell _ { 2 }$ distortion, as CLEVER suffices for an estimated capacity of the best possible attack.
+
+![](images/dc5c8a9647fb400eddcbbc9fc76bdc4f9d782d4b0ece480d60712f2f60e93286.jpg)  
+Figure 5: The empirical CDF of the gap between CLEVER score and the $\ell _ { 2 }$ norm of adversarial distortion generated by CW attack with random targets for 100 images on 3 ImageNet networks.
+
+![](images/64df8c749987404a647a215080bebd611c3baa46d20ee8e2ee1ac1445ed26d51.jpg)  
+Figure 6: Comparison of the CLEVER scores (circle) and the $\ell _ { 2 }$ norm of adversarial distortion generated by CW attack (triangle) with random targets for 100 images. The x-axis is image ID and the y-axis is the $\ell _ { 2 }$ distortion metric.
+
+![](images/e357a021ac2d2f266a10dfddaf24380546875e34e83cf83af83ca69168b2c398.jpg)  
+Figure 7: Comparison of the CLEVER score calculated by $N _ { b } = \{ 5 0 , 1 0 0 , 2 5 0 , 5 0 0 \}$ and the $\ell _ { 2 }$ norm of adversarial distortion found by CW attack (CW) on 3 ImageNet models and 3 target types.
+
+# 5.4 TIME V.S. ESTIMATION ACCURACY
+
+In Figure 7, we vary the number of samples $( N _ { b } = 5 0 , 1 0 0 , 2 5 0 , 5 0 0 )$ and compute the $\ell _ { 2 }$ CLEVER scores for three large ImageNet models, Inception-v3, ResNet-50 and MobileNet. We observe that
+
+50 or 100 samples are usually sufficient to obtain a reasonably accurate robustness estimation despite using a smaller number of samples. On a single GTX 1080 Ti GPU, the cost of 1 sample (with $N _ { s } = 1 0 2 4 )$ is measured as $2 . 9 \ : \mathrm { s }$ for MobileNet, 5.0 s for ResNet-50 and $8 . 9 \ : \mathrm { s }$ for Inception-v3, thus the computational cost of CLEVER is feasible for state-of-the-art large-scale deep neural networks. Additional figures for MNIST and CIFAR datasets are given in Appendix E.
+
+# 6 CONCLUSION
+
+In this paper, we propose the CLEVER score, a novel and generic metric to evaluate the robustness of a target neural network classifier to adversarial examples. Compared to the existing robustness evaluation approaches, our metric has the following advantages: (i) attack-agnostic; (ii) applicable to any neural network classifier; (iii) comes with strong theoretical guarantees; and (iv) is computationally feasible for large neural networks. Our extensive experiments show that the CLEVER score well matches the practical robustness indication of a wide range of natural and defended networks.
+
+Acknowledgment. Luca Daniel and Tsui-Wei Weng are partially supported by MIT-Skoltech program and MIT-IBM Watson AI Lab. Cho-Jui Hsieh and Huan Zhang acknowledge the support of NSF via IIS-1719097.
+
+# REFERENCES
+
+Osbert Bastani, Yani Ioannou, Leonidas Lampropoulos, Dimitrios Vytiniotis, Aditya Nori, and Antonio Criminisi. Measuring neural net robustness with constraints. In Advances in Neural Information Processing Systems, pp. 2613–2621, 2016.
+
+Nicholas Carlini and David Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. arXiv preprint arXiv:1705.07263, 2017a.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy (SP), pp. 39–57, 2017b.
+
+Hongge Chen, Huan Zhang, Pin-Yu Chen, Jinfeng Yi, and Cho-Jui Hsieh. Show-and-fool: Crafting adversarial examples for neural image captioning. CoRR, abs/1712.02051, 2017a.
+
+Pin-Yu Chen, Yash Sharma, Huan Zhang, Jinfeng Yi, and Cho-Jui Hsieh. Ead: Elastic-net attacks to deep neural networks via adversarial examples. arXiv preprint arXiv:1709.04114, 2017b.
+
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. arXiv preprint arXiv:1708.03999, 2017c.
+
+Laurens De Haan and Ana Ferreira. Extreme value theory: an introduction. Springer Science & Business Media, 2007.
+
+Ruediger Ehlers. Formal verification of piece-wise linear feed-forward neural networks. arXiv preprint arXiv:1705.01320, 2017.
+
+Ivan Evtimov, Kevin Eykholt, Earlence Fernandes, Tadayoshi Kohno, Bo Li, Atul Prakash, Amir Rahmati, and Dawn Song. Robust physical-world attacks on machine learning models. arXiv preprint arXiv:1707.08945, 2017.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. ICLR’15; arXiv preprint arXiv:1412.6572, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Matthias Hein and Maksym Andriushchenko. Formal guarantees on the robustness of a classifier against adversarial manipulation. arXiv preprint arXiv:1705.08475, 2017.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. Mobilenets: Efficient convolutional neural networks for mobile vision applications. arXiv preprint arXiv:1704.04861, 2017.
+
+Xiaowei Huang, Marta Kwiatkowska, Sen Wang, and Min Wu. Safety verification of deep neural networks. In International Conference on Computer Aided Verification, pp. 3–29. Springer, 2017.
+
+Guy Katz, Clark Barrett, David Dill, Kyle Julian, and Mykel Kochenderfer. Reluplex: An efficient smt solver for verifying deep neural networks. arXiv preprint arXiv:1702.01135, 2017a.
+
+Guy Katz, Clark Barrett, David L Dill, Kyle Julian, and Mykel J Kochenderfer. Towards proving the adversarial robustness of deep neural networks. arXiv preprint arXiv:1709.02802, 2017b.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016a.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. ICLR’17; arXiv preprint arXiv:1611.01236, 2016b.
+
+Xuanqing Liu, Minhao Cheng, Huan Zhang, and Cho-Jui Hsieh. Towards robust neural networks via random self-ensemble. arXiv preprint arXiv:1712.00673, 2017.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. arXiv preprint arXiv:1611.02770, 2016.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Dongyu Meng and Hao Chen. Magnet: a two-pronged defense against adversarial examples. arXiv preprint arXiv:1705.09064, 2017.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In IEEE Symposium on Security and Privacy (SP), pp. 582–597, 2016.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In ACM Asia Conference on Computer and Communications Security, pp. 506–519, 2017.
+
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting on association for computational linguistics, pp. 311–318. Association for Computational Linguistics, 2002.
+
+Remigijus Paulavicius and Julius ˇ Zilinskas. Analysis of different norms and corresponding lipschitz ˇ constants for global optimization. Technological and Economic Development of Economy, 12(4): 301–306, 2006.
+
+Tim Salimans, Ian Goodfellow, Wojciech Zaremba, Vicki Cheung, Alec Radford, and Xi Chen. Improved techniques for training gans. In Advances in Neural Information Processing Systems, pp. 2234–2242, 2016.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble \` adversarial training: Attacks and defenses. arXiv preprint arXiv:1705.07204, 2017.
+
+Beilun Wang, Ji Gao, and Yanjun Qi. A theoretical framework for robustness of (deep) classifiers under adversarial noise. arXiv preprint arXiv:1612.00334, 2016.   
+GR Wood and BP Zhang. Estimation of the lipschitz constant of a function. Journal of Global Optimization, 8(1):91–103, 1996.   
+Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017.   
+Valentina Zantedeschi, Maria-Irina Nicolae, and Ambrish Rawat. Efficient defenses against adversarial attacks. arXiv preprint arXiv:1707.06728, 2017.
+
+# APPENDIX
+
+A PROOF OF THEOREM 3.2
+
+Proof. According to Lemma 3.1, the assumption that $g ( { \pmb x } ) : = f _ { c } ( { \pmb x } ) - f _ { j } ( { \pmb x } )$ is Lipschitz continuous with Lipschitz constant $L _ { q } ^ { j }$ gives
+
+$$
+| g ( \pmb { x } ) - g ( \pmb { y } ) | \leq L _ { q } ^ { j } \| \pmb { x } - \pmb { y } \| _ { p } .
+$$
+
+Let ${ \pmb x } = { \pmb x } _ { \mathbf { 0 } } + \delta$ and $\mathbf { \mu } _ { y } = \mathbf { \mathcal { x } } _ { \mathbf { 0 } }$ in (4), we get
+
+$$
+| g ( \pmb { x _ { 0 } } + \pmb { \delta } ) - g ( \pmb { x _ { 0 } } ) | \leq L _ { q } ^ { j } \| \pmb { \delta } \| _ { p } ,
+$$
+
+which can be rearranged into the following form
+
+$$
+g ( { \pmb x _ { 0 } } ) - L _ { q } ^ { j } \| \pmb \delta \| _ { p } \leq g ( { \pmb x _ { 0 } } + { \pmb \delta } ) \leq g ( { \pmb x _ { 0 } } ) + L _ { q } ^ { j } \| \pmb \delta \| _ { p } .
+$$
+
+When $g ( \pmb { x _ { 0 } } + \pmb { \delta } ) = 0$ , an adversarial example is found. As indicated by (5), $g ( \pmb { x _ { 0 } } + \pmb { \delta } )$ is lower bounded by $g ( \pmb { x _ { 0 } } ) - L _ { q } ^ { j } \| \delta \| _ { p }$ . If $\| \delta \| _ { p }$ is small enough such that $g ( \pmb { x _ { 0 } } ) - L _ { q } ^ { j } \| \pmb { \delta } \| _ { p } \geq 0$ , no adversarial examples can be found:
+
+$$
+g ( { \pmb x _ { 0 } } ) - L _ { q } ^ { j } \| \delta \| _ { p } \geq 0 \Rightarrow \| \delta \| _ { p } \leq \frac { g ( { \pmb x _ { 0 } } ) } { L _ { q } ^ { j } } \Rightarrow \| \delta \| _ { p } \leq \frac { f _ { c } ( { \pmb x _ { 0 } } ) - f _ { j } ( { \pmb x _ { 0 } } ) } { L _ { q } ^ { j } } ,
+$$
+
+Finally, to achieve $\begin{array} { r } { \mathrm { a r g m a x } _ { 1 \le i \le K } f _ { i } ( { \pmb x } _ { 0 } + { \pmb \delta } ) = c } \end{array}$ , we take the minimum of the bound on $\| \delta \| _ { p }$ in (A) over $j \neq c$ . I.e. if
+
+$$
+\| \pmb { \delta } \| _ { p } \leq \operatorname* { m i n } _ { j \neq c } \frac { f _ { c } ( \pmb { x _ { 0 } } ) - f _ { j } ( \pmb { x _ { 0 } } ) } { L _ { q } ^ { j } } ,
+$$
+
+the classifier decision can never be changed and the attack will never succeed.
+
+# B PROOF OF COROLLARY 3.2.1
+
+Proof. By Lemma 3.1 and let $\mathit { \Pi } _ { g } ~ = ~ f _ { c } - f _ { j }$ , we get $\begin{array} { r } { L _ { q , x _ { 0 } } ^ { j } \ = \ \operatorname* { m a x } _ { y \in B _ { p } ( x _ { 0 } , R ) } \| \nabla g ( y ) \| _ { q } \ = \ } \end{array}$ $\begin{array} { r } { \operatorname* { m a x } _ { y \in B _ { p } ( x _ { 0 } , R ) } \| \nabla f _ { j } ( y ) - \nabla f _ { c } ( y ) \| _ { q } } \end{array}$ , which then gives the bound in Theorem 2.1 of (Hein & Andriushchenko, 2017).
+
+# C PROOF OF LEMMA 3.3
+
+Proof. For any $\mathbf { \nabla } _ { \mathbf { x } , \mathbf { y } }$ , let $\begin{array} { r } { \pmb { d } = \frac { \pmb { y } - \pmb { x } } { \Vert \pmb { y } - \pmb { x } \Vert _ { p } } } \end{array}$ be the unit vector pointing from $_ { \textbf { \em x } }$ to $\textbf {  { y } }$ and $r = \| \pmb { y } - \pmb { x } \| _ { p }$ . Define uni-variate function $u ( z ) = \dot { h } ( \pmb { x } + z \pmb { d } )$ , then $u ( 0 ) = h ( \pmb { x } )$ and $u ( r ) = h ( \pmb { y } )$ and observe that $D ^ { + } h ( { \pmb x } + z d ; d )$ and $D ^ { + } h ( { \pmb x } + z { \pmb d } ; - { \pmb d } )$ are the right-hand and left-hand derivatives of $u ( z )$ , we have
+
+$$
+u ^ { \prime } ( z ) = { \left\{ \begin{array} { l l } { D ^ { + } h ( { \boldsymbol { x } } + { \boldsymbol { z } } d ; d ) \leq L _ { q } } & { { \mathrm { ~ i f ~ } } D ^ { + } h ( { \boldsymbol { x } } + { \boldsymbol { z } } d ; d ) = D ^ { + } h ( { \boldsymbol { x } } + { \boldsymbol { z } } d ; - d ) } \\ { { \mathrm { u n d e f i n e d } } } & { { \mathrm { ~ i f ~ } } D ^ { + } h ( { \boldsymbol { x } } + { \boldsymbol { z } } d ; d ) \neq D ^ { + } h ( { \boldsymbol { x } } + { \boldsymbol { z } } d ; - d ) } \end{array} \right. }
+$$
+
+For ReLU network, there can be at most finite number of points in $z \in ( 0 , r )$ such that $g ^ { \prime } ( z )$ does not exist. This can be shown because each discontinuous $z$ is caused by some ReLU activation, and there are only finite combinations. Let $0 = z _ { 0 } < z _ { 1 } < \dots < z _ { k - 1 } < z _ { k } = 1$ be those points. Then, using the fundamental theorem of calculus on each interval separately, there exists $\bar { z } _ { i } \in \mathsf { \Gamma } ( z _ { i } , z _ { i - 1 } )$ for each $i$ such that
+
+$$
+\begin{array} { l } { \displaystyle u ( r ) - u ( 0 ) \le \sum _ { i = 1 } ^ { k } | u ( z _ { i } ) - u ( z _ { i - 1 } ) | } \\ { \displaystyle \le \sum _ { i = 1 } ^ { k } | u ^ { \prime } ( \bar { z } _ { i } ) ( z _ { i } - z _ { i - 1 } ) | } \\ { \displaystyle \le \sum _ { i = 1 } ^ { k } L _ { q } | z _ { i } - z _ { i - 1 } | _ { p } } \\ { \displaystyle = L _ { q } | | x - y | | _ { p } . } \end{array}
+$$
+
+(Mean value theorem)
+
+Theorem 3.2 and its corollaries remain valid after replacing Lemma 3.1 with Lemma 3.3.
+
+# D THEOREM D.1 AND ITS PROOF
+
+Theorem D.1 $( F _ { Y } ( y )$ of one-hidden-layer neural network). Consider a neural network $f : \mathbb { R } ^ { d } $ $\mathbb { R } ^ { K }$ with input $\pmb { x _ { 0 } } \in \mathbb { R } ^ { d }$ , a hidden layer with $U$ hidden neurons, and rectified linear unit (ReLU) activation function. If we sample uniformly in a ball $B _ { p } ( { \pmb x } _ { \mathbf { 0 } } , R )$ , then the cumulative distribution function of $\| \nabla g ( { \pmb x } ) \| _ { q }$ , denoted as $F _ { Y } ( y )$ , is piece-wise linear with at most $\begin{array} { r } { M = \sum _ { i = 0 } ^ { d } \binom { U } { i } } \end{array}$ pieces, where $g ( { \pmb x } ) = f _ { c } ( { \pmb x } ) - f _ { j } ( { \pmb x } )$ for some given $c$ and $j$ , and $\begin{array} { r } { \frac { 1 } { p } + \frac { 1 } { q } = 1 , 1 \leq p , q \leq \infty } \end{array}$ .
+
+Proof. The $j _ { \mathrm { t h } }$ output of a one-hidden-layer neural network can be written as
+
+$$
+f _ { j } ( \pmb { x } ) = \sum _ { r = 1 } ^ { U } V _ { j r } \cdot \sigma \left( \sum _ { i = 1 } ^ { d } W _ { r i } \cdot x _ { i } + b _ { r } \right) = \sum _ { r = 1 } ^ { U } V _ { j r } \cdot \sigma \left( { \pmb { w } } _ { r } { \pmb { x } } + b _ { r } \right) ,
+$$
+
+where $\sigma ( z ) = \operatorname* { m a x } ( z , 0 )$ is ReLU activation function, $W$ and $V$ are the weight matrices of the first and second layer respectively, and ${ \pmb w } _ { r }$ is the $r _ { \mathrm { t h } }$ row of $W$ . Thus, we can compute $g ( { \pmb x } )$ and $\| \nabla g ( { \pmb x } ) \| _ { q }$ below:
+
+$$
+\begin{array} { l } { { \displaystyle g ( { \pmb x } ) = f _ { c } ( { \pmb x } ) - f _ { j } ( { \pmb x } ) = \sum _ { r = 1 } ^ { U } V _ { c r } \cdot \sigma \left( { \pmb w } _ { r } { \pmb x } + b _ { r } \right) - \sum _ { r = 1 } ^ { U } V _ { j r } \cdot \sigma \left( { \pmb w } _ { r } { \pmb x } + b _ { r } \right) } } \\ { { \displaystyle ~ = \sum _ { r = 1 } ^ { U } ( V _ { c r } - V _ { j r } ) \cdot \sigma \left( { \pmb w } _ { r } { \pmb x } + b _ { r } \right) } } \end{array}
+$$
+
+and
+
+$$
+\| \nabla g ( \pmb { x } ) \| _ { q } = \left\| \sum _ { r = 1 } ^ { U } \mathbb { I } ( \pmb { w } _ { r } \pmb { x } + b _ { r } ) ( \pmb { V } _ { c r } - \pmb { V } _ { j r } ) \pmb { w } _ { r } ^ { \top } \right\| _ { q } ,
+$$
+
+where $\mathbb { I } ( z )$ is an univariate indicator function:
+
+$$
+\mathbb { I } ( z ) = { \left\{ \begin{array} { l l } { 1 , } & { { \mathrm { ~ i f ~ } } z > 0 , } \\ { 0 , } & { { \mathrm { ~ i f ~ } } z \leq 0 . } \end{array} \right. }
+$$
+
+![](images/56b620730d75efaa9d614cdfb55ac36793f6aa4d7027323b0f00242d9ba8da42.jpg)  
+Figure 8: Illustration of Theorem D.1 with $d = 2$ , $q = 2$ and $U = 3$ . The three hyperplanes ${ \pmb w } _ { i } { \pmb x } + b _ { i } = 0$ divide the space into seven regions (with different colors). The red dash line encloses the ball $B _ { 2 } ( { \pmb x } _ { \mathbf 0 } , R _ { 1 } )$ and the blue dash line encloses a larger ball $B _ { 2 } ( { \pmb x } _ { \mathbf 0 } , R _ { 2 } )$ . If we draw samples uniformly within the balls, the probability of $\| \nabla g ( { \pmb x } ) \| _ { 2 } = y$ is proportional to the intersected volumes of the ball and the regions with $\| \nabla g ( { \pmb x } ) \| _ { 2 } = y$ .
+
+As illustrated in Figure 8, the hyperplanes ${ \pmb w } _ { r } { \pmb x } + b _ { r } = 0 , r \in \{ 1 , . . . , U \}$ divide the $d$ dimensional spaces $\mathbb { R } ^ { d }$ into different regions, with the interior of each region satisfying a different set of inequality constraints, e.g. ${ \pmb w } _ { r _ { + } } { \pmb x } + b _ { r _ { + } } > 0$ and ${ \pmb w } _ { r _ { - } } { \pmb x } + b _ { r _ { - } } < 0$ . Given $_ { \textbf { \em x } }$ , we can identify which region it belongs to by checking the sign of ${ \pmb w } _ { r } { \pmb x } + b _ { r }$ for each $r$ . Notice that the gradient norm is the same for all the points in the same region, i.e. for any $\scriptstyle { \mathbf { { \vec { x } } } } _ { 1 }$ , $\mathbf { \boldsymbol { x } } _ { 2 }$ satisfying $\mathbb { I } ( \pmb { w } _ { r } \pmb { x } _ { 1 } + b _ { r } ) = \mathbb { I } ( \pmb { w } _ { r } \pmb { x } _ { 2 } + b _ { r } ) \ \forall r$ , we hfor a e -d $\| \nabla g ( \pmb { x } _ { 1 } ) \| _ { q } = \| \nabla g ( \pmb { x } _ { 2 } ) \| _ { q }$ . Since theperplanes, t most can ta $\begin{array} { r } { M = \sum _ { i = 0 } ^ { d } \binom { U } { i } } \end{array}$ different regionserent values. $d$ $U$ $\| \nabla g ( { \pmb x } ) \| _ { q }$ $M$
+
+Therefore, if we perform uniform sampling in a ball $B _ { p } ( { \pmb x } _ { 0 } , R )$ centered at $\scriptstyle { \mathbf { { \mathit { x } } } } _ { \mathbf { 0 } }$ with radius $R$ and denote $\| \nabla g ( { \pmb x } ) \| _ { q }$ as a random variable $Y$ , the probability distribution of $Y$ is discrete and its CDF is piece-wise constant with at most $M$ pieces. Without loss of generality, assume there are $M _ { 0 } \leq M$ distinct values for $Y$ and denote them as ${ \mathfrak { m } } _ { ( 1 ) } , { \mathfrak { m } } _ { ( 2 ) } , \ldots , { \mathfrak { m } } _ { ( M _ { 0 } ) }$ in an increasing order, the CDF of $Y$ , denoted as $F _ { Y } ( y )$ , is the following:
+
+$$
+F _ { Y } ( m _ { ( i ) } ) = F _ { Y } ( m _ { ( i - 1 ) } ) + \frac { \mathbb { V } _ { d } ( \{ x \mid \| \nabla g ( x ) \| _ { q } = m _ { ( i ) } \} ) \cap \mathbb { V } _ { d } ( B _ { p } ( x _ { 0 } , R ) ) ) } { \mathbb { V } _ { d } ( B _ { p } ( x _ { 0 } , R ) ) } , i = 1 , \ldots , M _ { 0 } ,
+$$
+
+where $F _ { Y } ( m _ { ( 0 ) } ) = 0$ with $m _ { ( 0 ) } < m _ { ( 1 ) } , \mathbb { V } _ { d } ( E )$ is the volume of $E$ in a $d$ dimensional space.
+
+# E ADDITIONAL EXPERIMENTAL RESULTS
+
+# E.1 PERCENTAGE OF EXAMPLES HAVING P VALUE $> 0 . 0 5$
+
+Table 5 shows the percentage of examples where the null hypothesis cannot be rejected by K-S test, indicating that the maximum gradient norm samples fit reverse Weibull distribution well.
+
+Table 5: Percentage of estimations where the null hypothesis cannot be rejected by K-S test for a significance level of 0.05. The bar plots of this table are illustrated in Figure 3.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">Least Likely</td><td colspan="2">Random</td><td colspan="2">Top-2</td></tr><tr><td>L2</td><td>L8</td><td>L2</td><td>Lo</td><td>L2</td><td>L8</td></tr><tr><td>MNIST-MLP</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td></tr><tr><td>MNIST-CNN</td><td>99.6</td><td>99.8</td><td>99.2</td><td>100.0</td><td>99.4</td><td>100.0</td></tr><tr><td>MNIST-DD</td><td>99.8</td><td>100.0</td><td>99.6</td><td>99.8</td><td>99.8</td><td>99.8</td></tr><tr><td>MNIST-BReLU</td><td>93.3</td><td>95.4</td><td>96.8</td><td>96.8</td><td>97.6</td><td>98.2</td></tr><tr><td>CIFAR-MLP</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td></tr><tr><td>CIFAR-CNN</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td></tr><tr><td>CIFAR-DD</td><td>99.7</td><td>99.5</td><td>100.0</td><td>100.0</td><td>99.7</td><td>99.7</td></tr><tr><td>CIFAR-BReLU</td><td>99.5</td><td>99.2</td><td>100.0</td><td>100.0</td><td>99.7</td><td>99.7</td></tr><tr><td>Inception-v3</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td></tr><tr><td>Resnet-50</td><td>99.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td></tr><tr><td>MobileNet</td><td>100.0</td><td>100.0</td><td>100.0</td><td>100.0</td><td>98.0</td><td>99.0</td></tr></table>
+
+# E.2 CLEVER V.S. NUMBER OF SAMPLES
+
+Figure 9 shows the $\ell _ { 2 }$ CLEVER score with different number of samples $( N _ { b } = 5 0 , 1 0 0 , 2 5 0 , 5 0 0 )$ for MNIST and CIFAR models. For most models except MNIST-BReLU, reducing the number of samples only change CLEVER scores very slightly. For MNIST-BReLU, increasing the number of samples improves the estimated lower bound, suggesting that a larger number of samples is preferred. In practice, we can start with a relatively small $N _ { b } = a$ , and also try $2 a , 4 a , \cdots$ samples to see if CLEVER scores change significantly. If CLEVER scores stay roughly the same despite increasing $N _ { b }$ , we can conclude that using $N _ { b } = a$ is sufficient.
+
+![](images/8d8d92c68e248fd5bbce1188fe6900b0788983f16c652d8097c4b743abcac4fc.jpg)  
+Figure 9: Comparison of the CLEVER score calculated by $N _ { b } = \{ 5 0 , 1 0 0 , 2 5 0 , 5 0 0 \}$ and the $\ell _ { 2 }$ norm of adversarial distortion found by CW attack (CW) on MNIST and CIFAR models with 3 target types.

parse/train/ByMHvs0cFQ/ByMHvs0cFQ.md

@@ -0,0 +1,672 @@
+# QUATERNION RECURRENT NEURAL NETWORKS
+
+Titouan Parcollet1,4, Mirco Ravanelli2, Mohamed Morchid1, Georges Linarès1, Chiheb Trabelsi2,5, Renato De Mori1,3, Yoshua Bengio2 ∗
+
+1LIA, Université d’Avignon, France   
+2MILA, Université de Montréal, Québec, Canada   
+3McGill University, Québec, Canada   
+4Orkis, Aix-en-provence, France   
+5Element AI, Montréal, Québec, Canada   
+titouan.parcollet@alumni.univ-avignon.fr,   
+mirco.ravanelli@gmail.com,   
+firstname.lastname@univ-avignon.fr,   
+chiheb.trabelsi@polymtl.ca, rdemori@cs.mcgill.ca
+
+# ABSTRACT
+
+Recurrent neural networks (RNNs) are powerful architectures to model sequential data, due to their capability to learn short and long-term dependencies between the basic elements of a sequence. Nonetheless, popular tasks such as speech or images recognition, involve multi-dimensional input features that are characterized by strong internal dependencies between the dimensions of the input vector. We propose a novel quaternion recurrent neural network (QRNN), alongside with a quaternion long-short term memory neural network (QLSTM), that take into account both the external relations and these internal structural dependencies with the quaternion algebra. Similarly to capsules, quaternions allow the QRNN to code internal dependencies by composing and processing multidimensional features as single entities, while the recurrent operation reveals correlations between the elements composing the sequence. We show that both QRNN and QLSTM achieve better performances than RNN and LSTM in a realistic application of automatic speech recognition. Finally, we show that QRNN and QLSTM reduce by a maximum factor of $3 . 3 \mathrm { x }$ the number of free parameters needed, compared to real-valued RNNs and LSTMs to reach better results, leading to a more compact representation of the relevant information.
+
+# 1 INTRODUCTION
+
+In the last few years, deep neural networks (DNN) have encountered a wide success in different domains due to their capability to learn highly complex input to output mapping. Among the different DNN-based models, the recurrent neural network (RNN) is well adapted to process sequential data. Indeed, RNNs build a vector of activations at each timestep to code latent relations between input vectors. Deep RNNs have been recently used to obtain hidden representations of speech unit sequences (Ravanelli et al., 2018a) or text word sequences (Conneau et al., 2018), and to achieve state-of-the-art performances in many speech recognition tasks (Graves et al., 2013a;b; Amodei et al., 2016; Povey et al., 2016; Chiu et al., 2018). However, many recent tasks based on multi-dimensional input features, such as pixels of an image, acoustic features, or orientations of 3D models, require to represent both external dependencies between different entities, and internal relations between the features that compose each entity. Moreover, RNN-based algorithms commonly require a huge number of parameters to represent sequential data in the hidden space.
+
+Quaternions are hypercomplex numbers that contain a real and three separate imaginary components, perfectly fitting to 3 and 4 dimensional feature vectors, such as for image processing and robot kinematics (Sangwine, 1996; Pei & Cheng, 1999; Aspragathos & Dimitros, 1998). The idea of bundling groups of numbers into separate entities is also exploited by the recent manifold and capsule networks (Chakraborty et al., 2018; Sabour et al., 2017). Contrary to traditional homogeneous representations, capsule and quaternion networks bundle sets of features together. Thereby, quaternion numbers allow neural network based models to code latent inter-dependencies between groups of input features during the learning process with fewer parameters than RNNs, by taking advantage of the Hamilton product as the equivalent of the ordinary product, but between quaternions. Early applications of quaternion-valued backpropagation algorithms (Arena et al., 1994; 1997) have efficiently solved quaternion functions approximation tasks. More recently, neural networks of complex and hypercomplex numbers have received an increasing attention (Hirose & Yoshida, 2012; Tygert et al., 2016; Danihelka et al., 2016; Wisdom et al., 2016), and some efforts have shown promising results in different applications. In particular, a deep quaternion network (Parcollet et al., 2016; 2017a;b), a deep quaternion convolutional network (Gaudet & Maida, 2018; Parcollet et al., 2018), or a deep complex convolutional network (Trabelsi et al., 2017) have been employed for challenging tasks such as images and language processing. However, these applications do not include recurrent neural networks with operations defined by the quaternion algebra.
+
+This paper proposes to integrate local spectral features in a novel model called quaternion recurrent neural network1 (QRNN), and its gated extension called quaternion long-short term memory neural network (QLSTM). The model is proposed along with a well-adapted parameters initialization and turned out to learn both inter- and intra-dependencies between multidimensional input features and the basic elements of a sequence with drastically fewer parameters (Section 3), making the approach more suitable for low-resource applications. The effectiveness of the proposed QRNN and QLSTM is evaluated on the realistic TIMIT phoneme recognition task (Section 4.2) that shows that both QRNN and QLSTM obtain better performances than RNNs and LSTMs with a best observed phoneme error rate (PER) of $1 8 . 5 \%$ and $1 5 . 1 \%$ for QRNN and QLSTM, compared to $1 9 . 0 \%$ and $\bar { 1 } 5 . 3 \%$ for RNN and LSTM. Moreover, these results are obtained alongside with a reduction of 3.3 times of the number of free parameters. Similar results are observed with the larger Wall Street Journal (WSJ) dataset, whose detailed performances are reported in the Appendix 6.1.1.
+
+# 2 MOTIVATIONS
+
+A major challenge of current machine learning models is to well-represent in the latent space the astonishing amount of data available for recent tasks. For this purpose, a good model has to efficiently encode local relations within the input features, such as between the Red, Green, and Blue (R,G,B) channels of a single image pixel, as well as structural relations, such as those describing edges or shapes composed by groups of pixels. Moreover, in order to learn an adequate representation with the available set of training data and to avoid overfitting, it is convenient to conceive a neural architecture with the smallest number of parameters to be estimated. In the following, we detail the motivations to employ a quaternion-valued RNN instead of a real-valued one to code inter and intra features dependencies with fewer parameters.
+
+As a first step, a better representation of multidimensional data has to be explored to naturally capture internal relations within the input features. For example, an efficient way to represent the information composing an image is to consider each pixel as being a whole entity of three strongly related elements, instead of a group of uni-dimensional elements that could be related to each other, as in traditional real-valued neural networks. Indeed, with a real-valued RNN, the latent relations between the RGB components of a given pixel are hardly coded in the latent space since the weight has to find out these relations among all the pixels composing the image. This problem is effectively solved by replacing real numbers with quaternion numbers. Indeed, quaternions are fourth dimensional and allow one to build and process entities made of up to four related features. The quaternion algebra and more precisely the Hamilton product allows quaternion neural network to capture these internal latent relations within the features encoded in a quaternion. It has been shown that QNNs are able to restore the spatial relations within 3D coordinates (Matsui et al., 2004), and within color pixels (Isokawa et al., 2003), while real-valued NN failed. This is easily explained by the fact that the quaternion-weight components are shared through multiple quaternion-input parts during the Hamilton product , creating relations within the elements. Indeed, Figure 1 shows that the multiple weights required to code latent relations within a feature are considered at the same level as for learning global relations between different features, while the quaternion weight $w$ codes these internal relations within a unique quaternion $Q _ { o u t }$ during the Hamilton product (right).
+
+![](images/f350090e831c58abd807ca1072b750a05c3aa436d52552126db28ff9a1d25277.jpg)  
+Figure 1: Illustration of the input features $( Q _ { i n } )$ latent relations learning ability of a quaternion-valued layer (right) due to the quaternion weight sharing of the Hamilton product (Eq. 5), compared to a standard real-valued layer (left).
+
+Then, while bigger neural networks allow better performances, quaternion neural networks make it possible to deal with the same signal dimension but with four times less neural parameters. Indeed, a 4-number quaternion weight linking two 4-number quaternion units only has 4 degrees of freedom, whereas a standard neural net parametrization has $4 \times 4 = 1 6$ , i.e., a 4-fold saving in memory. Therefore, the natural multidimensional representation of quaternions alongside with their ability to drastically reduce the number of parameters indicate that hyper-complex numbers are a better fit than real numbers to create more efficient models in multidimensional spaces. Based on the success of previous deep quaternion convolutional neural networks and smaller quaternion feed-forward architectures (Kusamichi et al., 2004; Isokawa et al., 2009; Parcollet et al., 2017a), this work proposes to adapt the representation of hyper-complex numbers to the capability of recurrent neural networks in a natural and efficient framework to multidimensional sequential tasks such as speech recognition.
+
+Modern automatic speech recognition systems usually employ input sequences composed of multidimensional acoustic features, such as log Mel features, that are often enriched with their first, second and third time derivatives (Davis & Mermelstein, 1990; Furui, 1986), to integrate contextual information. In standard RNNs, static features are simply concatenated with their derivatives to form a large input vector, without effectively considering that signal derivatives represent different views of the same input. Nonetheless, it is crucial to consider that time derivatives of the spectral energy in a given frequency band at a specific time frame represent a special state of a time-frame, and are linearly correlated (Tokuda et al., 2003). Based on the above motivations and the results observed on previous works about quaternion neural networks, we hypothesize that quaternion RNNs naturally provide a more suitable representation of the input sequence, since these multiple views can be directly embedded in the multiple dimensions space of the quaternion, leading to better generalization.
+
+# 3 QUATERNION RECURRENT NEURAL NETWORKS
+
+This Section describes the quaternion algebra (Section 3.1), the internal quaternion representation (Section 3.2), the backpropagation through time (BPTT) for quaternions (Section 3.3.2), and proposes an adapted weight initialization to quaternion-valued neurons (Section 3.4).
+
+# 3.1 QUATERNION ALGEBRA
+
+The quaternion algebra $\mathbb { H }$ defines operations between quaternion numbers. A quaternion Q is an extension of a complex number defined in a four dimensional space as:
+
+$$
+Q = r 1 + x \mathbf { i } + y \mathbf { j } + z \mathbf { k } ,
+$$
+
+where $r , x , y$ , and $z$ are real numbers, and 1, i, j, and $\mathbf { k }$ are the quaternion unit basis. In a quaternion, $r$ is the real part, while $x { \mathbf i } + y { \mathbf j } + z { \mathbf k }$ with $\mathbf { i } ^ { 2 } = \mathbf { j } ^ { 2 } = \mathbf { k } ^ { 2 } = \mathbf { i j } \mathbf { \bar { k } } = - 1$ is the imaginary part, or the vector part. Such a definition can be used to describe spatial rotations. The information embedded in the quaterion $Q$ can be summarized into the following matrix of real numbers:
+
+$$
+Q _ { m a t } = \left[ \begin{array} { c c c c } { r } & { - x } & { - y } & { - z } \\ { x } & { r } & { - z } & { y } \\ { y } & { z } & { r } & { - x } \\ { z } & { - y } & { x } & { r } \end{array} \right] .
+$$
+
+The conjugate $Q ^ { * }$ of $Q$ is defined as:
+
+$$
+Q ^ { * } = r 1 - x \mathbf { i } - y \mathbf { j } - z \mathbf { k } .
+$$
+
+Then, a normalized or unit quaternion $Q ^ { \triangleleft }$ is expressed as:
+
+$$
+Q ^ { \triangleleft } = { \frac { Q } { \sqrt { r ^ { 2 } + x ^ { 2 } + y ^ { 2 } + z ^ { 2 } } } } .
+$$
+
+Finally, the Hamilton product $\otimes$ between two quaternions $Q _ { 1 }$ and $Q _ { 2 }$ is computed as follows:
+
+$$
+\begin{array} { r } { Q _ { 1 } \otimes Q _ { 2 } = ( r _ { 1 } r _ { 2 } - x _ { 1 } x _ { 2 } - y _ { 1 } y _ { 2 } - z _ { 1 } z _ { 2 } ) + ( r _ { 1 } x _ { 2 } + x _ { 1 } r _ { 2 } + y _ { 1 } z _ { 2 } - z _ { 1 } y _ { 2 } ) i + } \\ { ( r _ { 1 } y _ { 2 } - x _ { 1 } z _ { 2 } + y _ { 1 } r _ { 2 } + z _ { 1 } x _ { 2 } ) j + ( r _ { 1 } z _ { 2 } + x _ { 1 } y _ { 2 } - y _ { 1 } x _ { 2 } + z _ { 1 } r _ { 2 } ) k . } \end{array}
+$$
+
+The Hamilton product (a graphical view is depicted in Figure 1) is used in QRNNs to perform transformations of vectors representing quaternions, as well as scaling and interpolation between two rotations following a geodesic over a sphere in the $\mathbb { R } ^ { 3 }$ space as shown in (Minemoto et al., 2017).
+
+# 3.2 QUATERNION REPRESENTATION
+
+The QRNN is an extension of the real-valued (Medsker & Jain, 2001) and complex-valued (Hu & Wang, 2012; Song & Yam, 1998) recurrent neural networks to hypercomplex numbers. In a quaternion dense layer, all parameters are quaternions, including inputs, outputs, weights, and biases. The quaternion algebra is ensured by manipulating matrices of real numbers (Gaudet & Maida, 2018). Consequently, for each input vector of size $N$ , output vector of size $M$ , dimensions are split into four parts: the first one equals to $r$ , the second is $x \mathbf { i }$ , the third one equals to $y { \bf j }$ , and the last one to $z \mathbf { k }$ to compose a quaternion $Q = r 1 + x \mathbf { i } + y \mathbf { j } + z \mathbf { k }$ . The inference process of a fully-connected layer is defined in the real-valued space by the dot product between an input vector and a real-valued $M \times N$ weight matrix. In a QRNN, this operation is replaced with the Hamilton product (Eq. 5) with quaternion-valued matrices (i.e. each entry in the weight matrix is a quaternion). The computational complexity of quaternion-valued models is discussed in Appendix 6.1.2
+
+# 3.3 LEARNING ALGORITHM
+
+The QRNN differs from the real-valued RNN in each learning sub-processes. Therefore, let $x _ { t }$ be the input vector at timestep $t$ , $h _ { t }$ the hidden state, $W _ { h x }$ , $W _ { h y }$ and $W _ { h h }$ the input, output and hidden states weight matrices respectively. The vector $b _ { h }$ is the bias of the hidden state and $p _ { t } , y _ { t }$ are the output and the expected target vectors. More details of the learning process and the parametrization are available on Appendix 6.2.
+
+# 3.3.1 FORWARD PHASE
+
+Based on the forward propagation of the real-valued RNN (Medsker & Jain, 2001), the QRNN forward equations are extended as follows:
+
+$$
+h _ { t } = \alpha ( W _ { h h } \otimes h _ { t - 1 } + W _ { h x } \otimes x _ { t } + b _ { h } ) ,
+$$
+
+where $\alpha$ is a quaternion split activation function $\mathrm { { X u } }$ et al., 2017; Tripathi, 2016) defined as:
+
+$$
+\alpha ( Q ) = f ( r ) + f ( x ) \mathbf { i } + f ( y ) \mathbf { j } + f ( z ) \mathbf { k } ,
+$$
+
+with $f$ corresponding to any standard activation function. The split approach is preferred in this work due to better prior investigations, better stability (i.e. pure quaternion activation functions contain singularities), and simpler computations. The output vector $p _ { t }$ is computed as:
+
+$$
+p _ { t } = \beta ( W _ { h y } \otimes h _ { t } ) ,
+$$
+
+where $\beta$ is any split activation function. Finally, the objective function is a classical loss applied component-wise (e.g., mean squared error, negative log-likelihood).
+
+# 3.3.2 QUATERNION BACKPROPAGATION THROUGH TIME
+
+The backpropagation through time (BPTT) for quaternion numbers (QBPTT) is an extension of the standard quaternion backpropagation (Ni6.3. The gradient with respect to the loss $E _ { t }$ 1995), and its full derivation is availablis expressed for each weight matrix as $\begin{array} { r } { \Delta _ { h y } ^ { t } = \frac { \partial E _ { t } } { \partial W _ { h y } } } \end{array}$ , $\begin{array} { r } { \Delta _ { h h } ^ { t } = \frac { \partial E _ { t } } { \partial W _ { h h } } } \end{array}$ $\begin{array} { r } { \Delta _ { h x } ^ { t } = \frac { \partial E _ { t } } { \partial W _ { h x } } } \end{array}$ , for the bias vector as $\begin{array} { r } { \Delta _ { b } ^ { t } = \frac { \partial E _ { t } } { \partial B _ { h } } } \end{array}$ , and is generalized to $\begin{array} { r } { \Delta ^ { t } = \frac { \partial E _ { t } } { \partial W } } \end{array}$ with:
+
+$$
+\frac { \partial E _ { t } } { \partial W } = \frac { \partial E _ { t } } { \partial W ^ { r } } + \mathbf { i } \frac { \partial E _ { t } } { \partial W ^ { i } } + \mathbf { j } \frac { \partial E _ { t } } { \partial W ^ { j } } + \mathbf { k } \frac { \partial E _ { t } } { \partial W ^ { k } } .
+$$
+
+Each term of the above relation is then computed by applying the chain rule. Indeed, and conversaly to real-valued backpropagation, QBPTT must defines the dynamic of the loss $w . r . t$ to each component of the quaternion neural parameters. As a use-case for the equations, the mean squared error at a timestep $t$ and named $E _ { t }$ is used as the loss function. Moreover, let $\lambda$ be a fixed learning rate. First, the weight matrix $W _ { h y }$ is only seen in the equations of $p _ { t }$ . It is therefore straightforward to update each weight of $W _ { h y }$ at timestep $t$ following:
+
+$$
+W _ { h y } = W _ { h y } - \lambda \Delta _ { h y } ^ { t } \otimes h _ { t } ^ { * } , \mathrm { ~ w i t h ~ } \Delta _ { h y } ^ { t } = \frac { \partial E _ { t } } { \partial W _ { h y } } = ( p _ { t } - y _ { t } ) ,
+$$
+
+where $h _ { t } ^ { * }$ is the conjugate of $h _ { t }$ . Then, the weight matrices $W _ { h h }$ , $W _ { h x }$ and biases $b _ { h }$ are arguments of $h _ { t }$ with $h _ { t - 1 }$ involved, and the update equations are derived as:
+
+$$
+\begin{array} { r } { W _ { h h } = W _ { h h } - \lambda \Delta _ { h h } ^ { t } , W _ { h x } = W _ { h x } - \lambda \Delta _ { h x } ^ { t } , b _ { h } = b _ { h } - \lambda \Delta _ { b } ^ { t } , } \end{array}
+$$
+
+with,
+
+$$
+\Delta _ { h h } ^ { t } = \sum _ { m = 0 } ^ { t } ( \prod _ { n = m } ^ { t } \delta _ { n } ) \otimes h _ { m - 1 } ^ { * } , \quad \Delta _ { h x } ^ { t } = \sum _ { m = 0 } ^ { t } ( \prod _ { n = m } ^ { t } \delta _ { n } ) \otimes x _ { m } ^ { * } , \quad \Delta _ { b } ^ { t } = \sum _ { m = 0 } ^ { t } ( \prod _ { n = m } ^ { t } \delta _ { n } ) ,
+$$
+
+and,
+
+$$
+\delta _ { n } = { \left\{ \begin{array} { l l } { W _ { h h } ^ { * } \otimes \delta _ { n + 1 } \times \alpha ^ { \prime } ( h _ { n } ^ { p r e a c t } ) } & { { \mathrm { i f ~ } } n \neq t } \\ { W _ { h y } ^ { * } \otimes ( p _ { n } - y _ { n } ) \times { \boldsymbol { \beta } } ^ { \prime } ( p _ { n } ^ { p r e a c t } ) } & { { \mathrm { o t h e r w i s e , } } } \end{array} \right. }
+$$
+
+$h _ { n } ^ { p r e a c t }$ and $p _ { n } ^ { p r e a c t }$ the pre-activation values of $h _ { n }$ and $p _ { n }$
+
+# 3.4 PARAMETER INITIALIZATION
+
+A well-designed parameter initialization scheme strongly impacts the efficiency of a DNN. An appropriate initialization, in fact, improves DNN convergence, reduces the risk of exploding or vanishing gradient, and often leads to a substantial performance improvement (Glorot & Bengio, 2010). It has been shown that the backpropagation through time algorithm of RNNs is degraded by an inappropriated parameter initialization (Sutskever et al., 2013). Moreover, an hyper-complex parameter cannot be simply initialized randomly and component-wise, due to the interactions between components. Therefore, this Section proposes a procedure reported in Algorithm 1 to initialize a matrix $W$ of quaternion-valued weights. The proposed initialization equations are derived from the polar form of a weight $w$ of $W$ :
+
+$$
+w = | w | e ^ { q _ { i m a g } ^ { \mathrm { q } } \theta } = | w | ( c o s ( \theta ) + q _ { i m a g } ^ { \mathrm { q } } s i n ( \theta ) ) ,
+$$
+
+and,
+
+$$
+w _ { \mathbf { r } } = \varphi c o s ( \theta ) , \quad w _ { \mathbf { i } } = \varphi q _ { i m a g \mathbf { i } } ^ { \mathrm { q } } s i n ( \theta ) , \quad w _ { \mathbf { j } } = \varphi q _ { i m a g \mathbf { j } } ^ { \mathrm { q } } s i n ( \theta ) , \quad w _ { \mathbf { k } } = \varphi q _ { i m a g \mathbf { k } } ^ { \mathrm { q } } s i n ( \theta ) .
+$$
+
+The angle $\theta$ is randomly generated in the interval $[ - \pi , \pi ]$ . The quaternion $q _ { i m a g } ^ { \mathrm { < } }$ is defined as purely normalized imaginary, and is expressed as $q _ { i m a g } ^ { \triangleleft } = 0 + x { \bf i } + y { \bf j } + z { \bf k }$ . The imaginary components yj, and zk are sampled from(following Eq. 4) to obtain form distribution. The parameter $[ 0 , 1 ]$ to obtain andom nu $q _ { i m a g }$ , which is then normalized generated with respect to $q _ { i m a g } ^ { \mathrm { < } }$ $\varphi$ well-known initialization criterions (such as Glorot or He algorithms) (Glorot & Bengio, 2010; He et al., 2015). However, the equations derived in (Glorot & Bengio, 2010; He et al., 2015) are defined for real-valued weight matrices. Therefore, the variance of $W$ has to be investigated in the quaternion space to obtain $\varphi$ (the full demonstration is provided in Appendix 6.2). The variance of $W$ is:
+
+$$
+V a r ( W ) = \mathbb { E } ( | W | ^ { 2 } ) - [ \mathbb { E } ( | W | ) ] ^ { 2 } , \mathrm { ~ w i t h ~ } [ \mathbb { E } ( | W | ) ] ^ { 2 } = 0 .
+$$
+
+# Algorithm 1 Quaternion-valued weight initialization
+
+<table><tr><td colspan="2">1: procedure QINIT(W, nin, nout)</td><td rowspan="2">w.r.t to Glorot criterion and Eq. 18</td></tr><tr><td>2:</td><td></td></tr><tr><td></td><td></td><td></td></tr><tr><td>3:</td><td>forw in W do</td><td></td></tr><tr><td>4:</td><td>θ ← rand(-π,π)</td><td></td></tr><tr><td>5: 6:</td><td> ← rand(-σ,σ)</td><td></td></tr><tr><td>7:</td><td>x,y,z ←rand(0,1)</td><td></td></tr><tr><td>8:</td><td>qimag ← Quaternion(O,x,y,z) qimag qimag ↑</td><td></td></tr><tr><td>9:</td><td>√x²+y²+z2</td><td>See Eq.15</td></tr><tr><td>10:</td><td>Wr ←  × cos(0) × sin(0)</td><td></td></tr><tr><td>11:</td><td></td><td></td></tr><tr><td>12:</td><td>Wj←×qimagj X sin(0)</td><td></td></tr><tr><td>13:</td><td>X sin(0)</td><td></td></tr><tr><td></td><td>w ← Quaternion(wr,Wi,Wj,Wk)</td><td></td></tr></table>
+
+Indeed, the weight distribution is normalized. The value of $V a r ( W ) = \mathbb { E } ( | W | ^ { 2 } )$ , instead, is not trivial in the case of quaternion-valued matrices. Indeed, $W$ follows a Chi-distribution with four degrees of freedom (DOFs). Consequently, $V a r ( W )$ is expressed and computed as follows:
+
+$$
+V a r ( W ) = \mathbb { E } ( | W | ^ { 2 } ) = \int _ { 0 } ^ { \infty } x ^ { 2 } f ( x ) \mathrm { d } x = 4 \sigma ^ { 2 } .
+$$
+
+The Glorot (Glorot & Bengio, 2010) and He (He et al., 2015) criterions are extended to quaternion as:
+
+$$
+ \sigma = { \frac { 1 } { \sqrt { 2 ( n _ { i n } + n _ { o u t } ) } } } , { \mathrm { ~ a n d ~ } } \sigma = { \frac { 1 } { \sqrt { 2 n _ { i n } } } } ,
+$$
+
+with $n _ { i n }$ and $n _ { o u t }$ the number of neurons of the input and output layers respectively. Finally, $\varphi$ can be sampled from $[ - \sigma , \sigma ]$ to complete the weight initialization of Eq. 15.
+
+# 4 EXPERIMENTS
+
+This Section details the acoustic features extraction (Section 4.1), the experimental setups and the results obtained with QRNNs, QLSTMs, RNNs and LSTMs on the TIMIT speech recognition tasks (Section 4.2). The results reported in bold on tables are obtained with the best configurations of the neural networks observed with the validation set.
+
+# 4.1 QUATERNION ACOUSTIC FEATURES
+
+The raw audio is first splitted every 10ms with a window of $2 5 \mathrm { m s }$ . Then 40-dimensional log Mel-filterbank coefficients with first, second, and third order derivatives are extracted using the pytorch-kaldi2 (Ravanelli et al., 2018b) toolkit and the Kaldi s5 recipes (Povey et al., 2011). An acoustic quaternion $Q ( f , t )$ associated with a frequency $f$ and a time-frame $t$ is formed as follows:
+
+$$
+Q ( f , t ) = e ( f , t ) + \frac { \partial e ( f , t ) } { \partial t } \mathbf { i } + \frac { \partial ^ { 2 } e ( f , t ) } { \partial ^ { 2 } t } \mathbf { j } + \frac { \partial ^ { 3 } e ( f , t ) } { \partial ^ { 3 } t } \mathbf { k } .
+$$
+
+$Q ( f , t )$ represents multiple views of a frequency $f$ at time frame $t$ , consisting of the energy $e ( f , t )$ in the filter band at frequency $f$ , its first time derivative describing a slope view, its second time derivative describing a concavity view, and the third derivative describing the rate of change of the second derivative. Quaternions are used to learn the spatial relations that exist between the 3 described different views that characterize a same frequency (Tokuda et al., 2003). Thus, the quaternion input vector length is $1 6 0 / 4 = 4 0$ . Decoding is based on Kaldi (Povey et al., 2011) and weighted finite state transducers (WFST) (Mohri et al., 2002) that integrate acoustic, lexicon and language model probabilities into a single HMM-based search graph.
+
+# 4.2 THE TIMIT CORPUS
+
+The training process is based on the standard 3, 696 sentences uttered by 462 speakers, while testing is conducted on 192 sentences uttered by 24 speakers of the TIMIT (Garofolo et al., 1993) dataset. A validation set composed of 400 sentences uttered by 50 speakers is used for hyper-parameter tuning. The models are compared on a fixed number of layers $M = 4$ and by varying the number of neurons $N$ from 256 to 2, 048, and 64 to 512 for the RNN and QRNN respectively. Indeed, it is worth underlying that the number of hidden neurons in the quaternion and real spaces do not handle the same amount of real-number values. Indeed, 256 quaternion neurons output are $2 5 6 \times 4 = 1 0 2 4$ real values. Tanh activations are used across all the layers except for the output layer that is based on a softmax function. Models are optimized with RMSPROP with vanilla hyper-parameters and an initial learning rate of $8 \cdot 1 0 ^ { - 4 }$ . The learning rate is progressively annealed using a halving factor of 0.5 that is applied when no performance improvement on the validation set is observed. The models are trained during 25 epochs. All the models converged to a minimum loss, due to the annealed learning rate. A dropout rate of 0.2 is applied over all the hidden layers (Srivastava et al., 2014) except the output one. The negative log-likelihood loss function is used as an objective function. All the experiments are repeated 5 times (5-folds) with different seeds and are averaged to limit any variation due to the random initialization.
+
+Table 1: Phoneme error rate $( \mathrm { P E R } \% )$ of QRNN and RNN models on the development and test sets of the TIMIT dataset. “Params" stands for the total number of trainable parameters.   
+
+<table><tr><td>Models</td><td>Neurons</td><td>Dev.</td><td>Test</td><td>Params</td></tr><tr><td rowspan="4">RNN</td><td>256</td><td>22.4</td><td>23.4</td><td>1M</td></tr><tr><td>512</td><td>19.6</td><td>20.4</td><td>2.8M</td></tr><tr><td>1,024</td><td>17.9</td><td>19.0</td><td>9.4M</td></tr><tr><td>2,048</td><td>20.0</td><td>20.7</td><td>33.4M</td></tr><tr><td rowspan="4">QRNN</td><td>64</td><td>23.6</td><td>23.9</td><td>0.6M</td></tr><tr><td>128</td><td>19.2</td><td>20.1</td><td>1.4M</td></tr><tr><td>256</td><td>17.4</td><td>18.5</td><td>3.8M</td></tr><tr><td>512</td><td>17.5</td><td>18.7</td><td>11.2M</td></tr></table>
+
+The results on the TIMIT task are reported in Table 1. The best PER in realistic conditions (w.r.t to the best validation PER) is $1 8 . 5 \%$ and $1 9 . 0 \%$ on the test set for QRNN and RNN models respectively, highlighting an absolute improvement of $0 . 5 \%$ obtained with QRNN. These results compare favorably with the best results obtained so far with architectures that do not integrate access control in multiple memory layers (Ravanelli et al., 2018a). In the latter, a PER of $1 8 . 3 \%$ is reported on the TIMIT test set with batch-normalized RNNs . Moreover, a remarkable advantage of QRNNs is a drastic reduction (with a factor of $2 . 5 \times $ ) of the parameters needed to achieve these results. Indeed, such PERs are obtained with models that employ the same internal dimensionality corresponding to 1, 024 real-valued neurons and 256 quaternion-valued ones, resulting in a number of parameters of 3.8M for QRNN against the 9.4M used in the real-valued RNN. It is also worth noting that QRNNs consistently need fewer parameters than equivalently sized RNNs, with an average reduction factor of 2.26 times. This is easily explained by considering the content of the quaternion algebra. Indeed, for a fully-connected layer with 2, 048 input values and 2, 048 hidden units, a real-valued RNN has $2 , 0 4 8 ^ { 2 } \overset { \cdot } { \approx } 4 . 2 \mathbf { M }$ parameters, while to maintain equal input and output dimensions the quaternion equivalent has 512 quaternions inputs and 512 quaternion hidden units. Therefore, the number of parameters for the quaternion-valued model is $5 1 \dot { 2 } ^ { 2 } \times 4 \approx 1  { \mathrm { M } }$ . Such a complexity reduction turns out to produce better results and has other advantages such as a smaller memory footprint while saving models on budget memory systems. This characteristic makes our QRNN model particularly suitable for speech recognition conducted on low computational power devices like smartphones (Chen et al., 2014). QRNNs and RNNs accuracies vary accordingly to the architecture with better PER on bigger and wider topologies. Therefore, while good PER are observed with a higher number of parameters, smaller architectures performed at $2 3 . { \bar { 9 } } \%$ and $2 3 . 4 \%$ , with 1M and $0 . 6 { \bf M }$ parameters for the RNN and the QRNN respectively. Such PER are due to a too small number of parameters to solve the task.
+
+# 4.3 QUATERNION LONG-SHORT TERM MEMORY NEURAL NETWORKS
+
+We propose to extend the QRNN to state-of-the-art models such as long-short term memory neural networks (LSTM), to support and improve the results already observed with the QRNN compared to the RNN in more realistic conditions. LSTM (Hochreiter & Schmidhuber, 1997) neural networks were introduced to solve the problems of long-term dependencies learning and vanishing or exploding gradient observed with long sequences. Based on the equations of the forward propagation and back propagation through time of QRNN described in Section 3.3.1, and Section 3.3.2, one can easily derive the equations of a quaternion-valued LSTM. Gates are defined with quaternion numbers following the proposal of Danihelka et al. (2016). Therefore, the gate action is characterized by an independent modification of each component of the quaternion-valued signal following a componentwise product with the quaternion-valued gate potential. Let $f _ { t } , i _ { t } , o _ { t } , c$ , and $h _ { t }$ be the forget, input, output gates, cell states and the hidden state of a LSTM cell at time-step $t$ :
+
+$$
+\begin{array} { r l } & { f _ { t } = \alpha ( W _ { f } \otimes x _ { t } + R _ { f } \otimes h _ { t - 1 } + b _ { f } ) , } \\ & { i _ { t } = \alpha ( W _ { i } \otimes x _ { t } + R _ { i } \otimes h _ { t - 1 } + b _ { i } ) , } \\ & { c _ { t } = f _ { t } \times c _ { t - 1 } + i _ { t } \times t a n h ( W _ { c } \otimes x _ { t } + R _ { c } \otimes h _ { t - 1 } + b _ { c } ) , } \\ & { o _ { t } = \alpha ( W _ { o } \otimes x _ { t } + R _ { o } \otimes h _ { t - 1 } + b _ { o } ) , } \\ & { h _ { t } = o _ { t } \times t a n h ( c _ { t } ) , } \end{array}
+$$
+
+where $W$ are rectangular input weight matrices, $R$ are square recurrent weight matrices, and $b$ are bias vectors. $\alpha$ is the split activation function and $\times$ denotes a component-wise product between two quaternions. Both QLSTM and LSTM are bidirectional and trained on the same conditions than for the QRNN and RNN experiments.
+
+Table 2: Phoneme error rate $( \mathrm { P E R } \% )$ of QLSTM and LSTM models on the development and test sets of the TIMIT dataset. “Params" stands for the total number of trainable parameters.   
+
+<table><tr><td>Models</td><td>Neurons</td><td>Dev.</td><td>Test</td><td>Params</td></tr><tr><td rowspan="4">LSTM</td><td>256</td><td>14.9</td><td>16.5</td><td>3.6M</td></tr><tr><td>512</td><td>14.2</td><td>16.1</td><td>12.6M</td></tr><tr><td>1,024</td><td>14.4</td><td>15.3</td><td>46.2M</td></tr><tr><td>2.048</td><td>14.0</td><td>15.9</td><td>176.3M</td></tr><tr><td rowspan="4">QLSTM</td><td>64</td><td>15.5</td><td>17.0</td><td>1.6M</td></tr><tr><td>128</td><td>14.1</td><td>16.0</td><td>4.6M</td></tr><tr><td>256</td><td>14.0</td><td>15.1</td><td>14.4M</td></tr><tr><td>512</td><td>14.2</td><td>15.1</td><td>49.9M</td></tr></table>
+
+The results on the TIMIT corpus reported on Table 2 support the initial intuitions and the previously established trends. We first point out that the best PER observed is $1 5 . 1 \%$ and $1 5 . 3 \%$ on the test set for QLSTMs and LSTM models respectively with an absolute improvement of $0 . 2 \%$ obtained with QLSTM using 3.3 times fewer parameters compared to LSTM. These results are among the top of the line results (Graves et al., 2013b; Ravanelli et al., 2018a) and prove that the proposed quaternion approach can be used in state-of-the-art models. A deeper investigation of QLSTMs performances with the larger Wall Street Journal (WSJ) dataset can be found in Appendix 6.1.1.
+
+# 5 CONCLUSION
+
+Summary. This paper proposes to process sequences of multidimensional features (such as acoustic data) with a novel quaternion recurrent neural network (QRNN) and quaternion long-short term memory neural network (QLSTM). The experiments conducted on the TIMIT phoneme recognition task show that QRNNs and QLSTMs are more effective to learn a compact representation of multidimensional information by outperforming RNNs and LSTMs with 2 to 3 times less free parameters. Therefore, our initial intuition that the quaternion algebra offers a better and more compact representation for multidimensional features, alongside with a better learning capability of feature internal dependencies through the Hamilton product, have been demonstrated.
+
+Future Work. Future investigations will develop other multi-view features that contribute to decrease ambiguities in representing phonemes in the quaternion space. In this extent, a recent approach based on a quaternion Fourier transform to create quaternion-valued signal has to be investigated. Finally, other high-dimensional neural networks such as manifold and Clifford networks remain mostly unexplored and can benefit from further research.
+
+# REFERENCES
+
+Dario Amodei, Sundaram Ananthanarayanan, Rishita Anubhai, Jingliang Bai, Eric Battenberg, Carl Case, Jared Casper, Bryan Catanzaro, Qiang Cheng, Guoliang Chen, et al. Deep speech 2: Endto-end speech recognition in english and mandarin. In International Conference on Machine Learning, pp. 173–182, 2016.
+
+Paolo Arena, Luigi Fortuna, Luigi Occhipinti, and Maria Gabriella Xibilia. Neural networks for quaternion-valued function approximation. In Circuits and Systems, ISCAS’94., IEEE International Symposium on, volume 6, pp. 307–310. IEEE, 1994.
+
+Paolo Arena, Luigi Fortuna, Giovanni Muscato, and Maria Gabriella Xibilia. Multilayer perceptrons to approximate quaternion valued functions. Neural Networks, 10(2):335–342, 1997.
+
+Nicholas A Aspragathos and John K Dimitros. A comparative study of three methods for robot kinematics. Systems, Man, and Cybernetics, Part B: Cybernetics, IEEE Transactions on, 28(2): 135–145, 1998.
+
+Rudrasis Chakraborty, Jose Bouza, Jonathan Manton, and Baba C. Vemuri. Manifoldnet: A deep network framework for manifold-valued data. arXiv preprint arXiv:1809.06211, 2018.
+
+William Chan and Ian Lane. Deep recurrent neural networks for acoustic modelling. arXiv preprint arXiv:1504.01482, 2015.
+
+G. Chen, C. Parada, and G. Heigold. Small-footprint keyword spotting using deep neural networks. In 2014 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4087–4091, May 2014. doi: 10.1109/ICASSP.2014.6854370.
+
+Chung-Cheng Chiu, Tara N Sainath, Yonghui Wu, Rohit Prabhavalkar, Patrick Nguyen, Zhifeng Chen, Anjuli Kannan, Ron J Weiss, Kanishka Rao, Ekaterina Gonina, et al. State-of-the-art speech recognition with sequence-to-sequence models. In 2018 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pp. 4774–4778. IEEE, 2018.
+
+Alexis Conneau, German Kruszewski, Guillaume Lample, Loïc Barrault, and Marco Baroni. What you can cram into a single vector: Probing sentence embeddings for linguistic properties, 2018.
+
+Ivo Danihelka, Greg Wayne, Benigno Uria, Nal Kalchbrenner, and Alex Graves. Associative long short-term memory. arXiv preprint arXiv:1602.03032, 2016.
+
+Steven B Davis and Paul Mermelstein. Comparison of parametric representations for monosyllabic word recognition in continuously spoken sentences. In Readings in speech recognition, pp. 65–74. Elsevier, 1990.
+
+Sadaoki Furui. Speaker-independent isolated word recognition based on emphasized spectral dynamics. In Acoustics, Speech, and Signal Processing, IEEE International Conference on ICASSP’86., volume 11, pp. 1991–1994. IEEE, 1986.
+
+John S Garofolo, Lori F Lamel, William M Fisher, Jonathan G Fiscus, and David S Pallett. Darpa timit acoustic-phonetic continous speech corpus cd-rom. nist speech disc 1-1.1. NASA STI/Recon technical report n, 93, 1993.
+
+Chase J Gaudet and Anthony S Maida. Deep quaternion networks. In 2018 International Joint Conference on Neural Networks (IJCNN), pp. 1–8. IEEE, 2018.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In International conference on artificial intelligence and statistics, pp. 249–256, 2010.
+
+Alex Graves, Navdeep Jaitly, and Abdel-rahman Mohamed. Hybrid speech recognition with deep bidirectional lstm. In Automatic Speech Recognition and Understanding (ASRU), 2013 IEEE Workshop on, pp. 273–278. IEEE, 2013a.
+
+Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In Acoustics, speech and signal processing (icassp), 2013 ieee international conference on, pp. 6645–6649. IEEE, 2013b.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015.
+
+Akira Hirose and Shotaro Yoshida. Generalization characteristics of complex-valued feedforward neural networks in relation to signal coherence. IEEE Transactions on Neural Networks and learning systems, 23(4):541–551, 2012.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.
+
+Jin Hu and Jun Wang. Global stability of complex-valued recurrent neural networks with time-delays. IEEE Transactions on Neural Networks and Learning Systems, 23(6):853–865, 2012.
+
+Teijiro Isokawa, Tomoaki Kusakabe, Nobuyuki Matsui, and Ferdinand Peper. Quaternion neural network and its application. In International Conference on Knowledge-Based and Intelligent Information and Engineering Systems, pp. 318–324. Springer, 2003.
+
+Teijiro Isokawa, Nobuyuki Matsui, and Haruhiko Nishimura. Quaternionic neural networks: Fundamental properties and applications. Complex-Valued Neural Networks: Utilizing High-Dimensional Parameters, pp. 411–439, 2009.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Hiromi Kusamichi, Teijiro Isokawa, Nobuyuki Matsui, Yuzo Ogawa, and Kazuaki Maeda. A new scheme for color night vision by quaternion neural network. In Proceedings of the 2nd International Conference on Autonomous Robots and Agents, volume 1315, 2004.
+
+Nobuyuki Matsui, Teijiro Isokawa, Hiromi Kusamichi, Ferdinand Peper, and Haruhiko Nishimura. Quaternion neural network with geometrical operators. Journal of Intelligent & Fuzzy Systems, 15 (3, 4):149–164, 2004.
+
+Larry R. Medsker and Lakhmi J. Jain. Recurrent neural networks. Design and Applications, 5, 2001.
+
+Toshifumi Minemoto, Teijiro Isokawa, Haruhiko Nishimura, and Nobuyuki Matsui. Feed forward neural network with random quaternionic neurons. Signal Processing, 136:59–68, 2017.
+
+Mehryar Mohri, Fernando Pereira, and Michael Riley. Weighted finite-state transducers in speech recognition. Computer Speech and Language, 16(1):69 – 88, 2002. ISSN 0885-2308. doi: https: //doi.org/10.1006/csla.2001.0184. URL http://www.sciencedirect.com/science/ article/pii/S0885230801901846.
+
+Mohamed Morchid. Parsimonious memory unit for recurrent neural networks with application to natural language processing. Neurocomputing, 314:48–64, 2018.
+
+Tohru Nitta. A quaternary version of the back-propagation algorithm. In Neural Networks, 1995. Proceedings., IEEE International Conference on, volume 5, pp. 2753–2756. IEEE, 1995.
+
+Titouan Parcollet, Mohamed Morchid, Pierre-Michel Bousquet, Richard Dufour, Georges Linarès, and Renato De Mori. Quaternion neural networks for spoken language understanding. In Spoken Language Technology Workshop (SLT), 2016 IEEE, pp. 362–368. IEEE, 2016.
+
+Titouan Parcollet, Morchid Mohamed, and Georges Linarès. Quaternion denoising encoder-decoder for theme identification of telephone conversations. Proc. Interspeech 2017, pp. 3325–3328, 2017a.
+
+Titouan Parcollet, Mohamed Morchid, and Georges Linares. Deep quaternion neural networks for spoken language understanding. In Automatic Speech Recognition and Understanding Workshop (ASRU), 2017 IEEE, pp. 504–511. IEEE, 2017b.
+
+Titouan Parcollet, Ying Zhang, Mohamed Morchid, Chiheb Trabelsi, Georges Linarès, Renato de Mori, and Yoshua Bengio. Quaternion convolutional neural networks for end-to-end automatic speech recognition. In Interspeech 2018, 19th Annual Conference of the International Speech Communication Association, Hyderabad, India, 2-6 September 2018., pp. 22–26, 2018. doi: 10.21437/Interspeech.2018-1898. URL https://doi.org/10.21437/Interspeech. 2018-1898.
+
+Soo-Chang Pei and Ching-Min Cheng. Color image processing by using binary quaternion-momentpreserving thresholding technique. IEEE Transactions on Image Processing, 8(5):614–628, 1999.
+
+Daniel Povey, Arnab Ghoshal, Gilles Boulianne, Lukas Burget, Ondrej Glembek, Nagendra Goel, Mirko Hannemann, Petr Motlicek, Yanmin Qian, Petr Schwarz, Jan Silovsky, Georg Stemmer, and Karel Vesely. The kaldi speech recognition toolkit. In IEEE 2011 Workshop on Automatic Speech Recognition and Understanding. IEEE Signal Processing Society, December 2011. IEEE Catalog No.: CFP11SRW-USB.
+
+Daniel Povey, Vijayaditya Peddinti, Daniel Galvez, Pegah Ghahremani, Vimal Manohar, Xingyu Na, Yiming Wang, and Sanjeev Khudanpur. Purely sequence-trained neural networks for asr based on lattice-free mmi. In Interspeech, pp. 2751–2755, 2016.
+
+Mirco Ravanelli, Philemon Brakel, Maurizio Omologo, and Yoshua Bengio. Light gated recurrent units for speech recognition. IEEE Transactions on Emerging Topics in Computational Intelligence, 2(2):92–102, 2018a.
+
+Mirco Ravanelli, Titouan Parcollet, and Yoshua Bengio. The pytorch-kaldi speech recognition toolkit. arXiv preprint arXiv:1811.07453, 2018b.
+
+Sara Sabour, Nicholas Frosst, and Geoffrey E Hinton. Dynamic routing between capsules. arXiv preprint arXiv:1710.09829v2, 2017.
+
+Stephen John Sangwine. Fourier transforms of colour images using quaternion or hypercomplex, numbers. Electronics letters, 32(21):1979–1980, 1996.
+
+Jingyan Song and Yeung Yam. Complex recurrent neural network for computing the inverse and pseudo-inverse of the complex matrix. Applied mathematics and computation, 93(2-3):195–205, 1998.
+
+Nitish Srivastava, Geoffrey Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. The Journal of Machine Learning Research, 15(1):1929–1958, 2014.
+
+Ilya Sutskever, James Martens, George Dahl, and Geoffrey Hinton. On the importance of initialization and momentum in deep learning. In International conference on machine learning, pp. 1139–1147, 2013.
+
+Keiichi Tokuda, Heiga Zen, and Tadashi Kitamura. Trajectory modeling based on hmms with the explicit relationship between static and dynamic features. In Eighth European Conference on Speech Communication and Technology, 2003.
+
+Chiheb Trabelsi, Olexa Bilaniuk, Dmitriy Serdyuk, Sandeep Subramanian, João Felipe Santos, Soroush Mehri, Negar Rostamzadeh, Yoshua Bengio, and Christopher J Pal. Deep complex networks. arXiv preprint arXiv:1705.09792, 2017.
+
+Bipin Kumar Tripathi. High Dimensional Neurocomputing. Springer, 2016.
+
+Mark Tygert, Joan Bruna, Soumith Chintala, Yann LeCun, Serkan Piantino, and Arthur Szlam. A mathematical motivation for complex-valued convolutional networks. Neural computation, 28(5): 815–825, 2016.
+
+Scott Wisdom, Thomas Powers, John Hershey, Jonathan Le Roux, and Les Atlas. Full-capacity unitary recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 4880–4888, 2016.
+
+D Xu, L Zhang, and H Zhang. Learning alogrithms in quaternion neural networks using ghr calculus. Neural Network World, 27(3):271, 2017.
+
+# 6 APPENDIX
+
+# 6.1 WALL STREET JOURNAL EXPERIMENTS AND COMPUTATIONAL COMPLEXITY
+
+This Section proposes to validate the scaling of the proposed QLSTMs to a bigger and more realistic corpus, with a speech recognition task on the Wall Street Journal (WSJ) dataset. Finally, it discuses the impact of the quaternion algebra in term of computational compexity.
+
+# 6.1.1 SPEECH RECOGNITION WITH THE WALL STREET JOURNAL CORPUS
+
+We propose to evaluate both QLSTMs and LSTMs with a larger and more realistic corpus to validate the scaling of the observed TIMIT results (Section 4.2). Acoustic input features are described in Section 4.1, and extracted on both the 14 hour subset ‘train-si84’, and the full 81 hour dataset ’train$\sin 2 8 4 '$ of the Wall Street Journal (WSJ) corpus. The ‘test-dev93’ development set is employed for validation, while ’test-eval92’ composes the testing set. Models architectures are fixed with respect to the best results observed with the TIMIT corpus (Section 4.2). Therefore, both QLSTMs and LSTMs contain four bidirectional layers of internal dimension of size 1, 024. Then, an additional layer of internal size 1, 024 is added before the output layer. The only change on the training procedure compared to the TIMIT experiments concerns the model optimizer, which is set to Adam (Kingma & Ba, 2014) instead of RMSPROP. Results are from a 3-folds average.
+
+Table 3: Word error rates (WER $\%$ ) obtained with both training set (WSJ14h and WSJ81h) of the Wall Street Journal corpus. ’test-dev93’ and ’test-eval92’ are used as validation and testing set respectively. $L$ expresses the number of recurrent layers.   
+
+<table><tr><td>Models</td><td>WSJ14 Dev.</td><td>WSJ14 Test</td><td>WSJ81 Dev.</td><td>WSJ81 Test</td><td>Params</td></tr><tr><td>LSTM</td><td>11.2</td><td>7.2</td><td>7.4</td><td>4.5</td><td>53.7M</td></tr><tr><td>QLSTM</td><td>10.9</td><td>6.9</td><td>7.2</td><td>4.3</td><td>18.7M</td></tr></table>
+
+It is important to notice that reported results on Table 3 compare favorably with equivalent architectures (Graves et al., 2013a) (WER of $1 1 . 7 \%$ on ’test-dev93’), and are competitive with state-of-the-art and much more complex models based on better engineered features (Chan & Lane, 2015)(WER of $3 . 8 \%$ with the 81 hours of training data, and on ’test-eval92’). According to Table 3, QLSTMs outperform LSTM in all the training conditions (14 hours and 81 hours) and with respect to both the validation and testing sets. Moreover, QLSTMs still need 2.9 times less neural parameters than LSTMs to achieve such performances. This experiment demonstrates that QLSTMs scale well to larger and more realistic speech datasets and are still more efficient than real-valued LSTMs.
+
+# 6.1.2 NOTES ON COMPUTATIONAL COMPLEXITY
+
+A computational complexity of $O ( n ^ { 2 } )$ with $n$ the number of hidden states has been reported by Morchid (2018) for real-valued LSTMs. QLSTMs just involve 4 times larger matrices during computations. Therefore, the computational complexity remains unchanged and equals to $O ( n ^ { 2 } )$ . Nonetheless, and due to the Hamilton product, a single forward propagation between two quaternion neurons uses 28 operations, compared to a single one for two real-valued neurons, implying a longer training time (up to 3 times slower). However, such worst speed performances could easily be alleviated with a proper engineered cuDNN kernel for the Hamilton product, that would helps QNNs to be more efficient than real-valued ones. A well-adapted CUDA kernel would allow QNNs to perform more computations, with fewer parameters, and therefore less memory copy operations from the CPU to the GPU.
+
+# 6.2 PARAMETERS INITIALIZATION
+
+Let us recall that a generated quaternion weight $w$ from a weight matrix $W$ has a polar form defined as:
+
+$$
+w = | w | e ^ { q _ { i m a g } ^ { \mathrm { q } } \theta } = | w | ( c o s ( \theta ) + q _ { i m a g } ^ { \mathrm { q } } s i n ( \theta ) ) ,
+$$
+
+with q/imag $q _ { i m a g } ^ { \triangleleft } = 0 + x { \bf i } + y { \bf j } + z { \bf k }$ a purely imaginary and normalized quaternion. Therefore, $w$ can be computed following:
+
+$$
+\begin{array} { c } { { w _ { \mathbf { r } } = \varphi c o s ( \theta ) , } } \\ { { w _ { \mathbf { i } } = \varphi q _ { i m a g \mathbf { i } } ^ { \triangleleft } s i n ( \theta ) , } } \\ { { w _ { \mathbf { j } } = \varphi q _ { i m a g \mathbf { j } } ^ { \triangleleft } s i n ( \theta ) , } } \\ { { w _ { \mathbf { k } } = \varphi q _ { i m a g \mathbf { k } } ^ { \triangleleft } s i n ( \theta ) . } } \end{array}
+$$
+
+However, $\varphi$ represents a randomly generated variable with respect to the variance of the quaternion weight and the selected initialization criterion. The initialization process follows (Glorot $\&$ Bengio, 2010) and (He et al., 2015) to derive the variance of the quaternion-valued weight parameters. Indeed, the variance of $\mathbf { W }$ has to be investigated:
+
+$$
+V a r ( W ) = \operatorname { \mathbb { E } } ( | W | ^ { 2 } ) - [ \operatorname { \mathbb { E } } ( | W | ) ] ^ { 2 } .
+$$
+
+$[ \mathbb { E } ( | W | ) ] ^ { 2 }$ is equals to 0 since the weight distribution is symmetric around 0. Nonetheless, the value of $V a r ( \dot { W } ) = \mathbb { E } ( | W | ^ { 2 } )$ is not trivial in the case of quaternion-valued matrices. Indeed, $W$ follows a Chi-distribution with four degrees of freedom (DOFs) and $\mathbb { E } ( | W | ^ { 2 } )$ is expressed and computed as follows:
+
+$$
+\mathbb { E } ( | W | ^ { 2 } ) = \int _ { 0 } ^ { \infty } x ^ { 2 } f ( x ) \mathrm { d } x ,
+$$
+
+With $f ( x )$ is the probability density function with four DOFs. A four-dimensional vector $X =$ $\{ A , B , C , D \}$ is considered to evaluate the density function $f ( x )$ . $X$ has components that are normally distributed, centered at zero, and independent. Then, $A , B ,$ , $C$ and $D$ have density functions:
+
+$$
+f _ { A } ( x ; \sigma ) = f _ { B } ( x ; \sigma ) = f _ { C } ( x ; \sigma ) = f _ { D } ( x ; \sigma ) = \frac { e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } } { \sqrt { 2 \pi \sigma ^ { 2 } } } .
+$$
+
+The four-dimensional vector $X$ has a length $L$ defined as $L \ = \ \sqrt { A ^ { 2 } + B ^ { 2 } + C ^ { 2 } + D ^ { 2 } }$ with a cumulative distribution function $F _ { L } ( x ; \sigma )$ in the 4-sphere (n-sphere with $n = 4$ ) $S _ { x }$ :
+
+$$
+F _ { L } ( x ; \sigma ) = \int \int \int \int _ { S _ { x } } f _ { A } ( x ; \sigma ) f _ { B } ( x ; \sigma ) f _ { C } ( x ; \sigma ) f _ { D } ( x ; \sigma ) \mathrm { d } S _ { x }
+$$
+
+where $S _ { x } = \{ ( a , b , c , d ) : { \sqrt { a ^ { 2 } + b ^ { 2 } + c ^ { 2 } + d ^ { 2 } } } < x \}$ and $\mathrm { d } S _ { x } = \mathrm { d } a \mathrm { d } b \mathrm { d } c \mathrm { d } d$ . The polar representations of the coordinates of $X$ in a 4-dimensional space are defined to compute $\mathrm { d } S _ { x }$ :
+
+$$
+\begin{array} { r l } & { a = \rho \cos \theta , } \\ & { b = \rho \sin \theta \cos \phi , } \\ & { c = \rho \sin \theta \sin \phi \cos \psi , } \\ & { d = \rho \sin \theta \sin \phi \sin \psi , } \end{array}
+$$
+
+where $\rho$ is the magnitude $( \rho = \sqrt { a ^ { 2 } + b ^ { 2 } + c ^ { 2 } + d ^ { 2 } } )$ and $\theta , \phi$ , and $\psi$ are the phases with $0 \leq \theta \leq \pi$ , $0 \leq \phi \leq \pi$ and $0 \leq \psi \leq 2 \pi$ . Then, $\mathrm { d } S _ { x }$ is evaluated with the Jacobian $J _ { f }$ of $f$ defined as:
+
+$$
+J _ { f } = { \frac { \partial ( a , b , c , d ) } { \partial ( \rho , \theta , \phi , \psi ) } } = { \frac { \mathrm { d } a \mathrm { d } b \mathrm { d } c \mathrm { d } d } { \mathrm { d } \rho \mathrm { d } \theta \mathrm { d } \phi \mathrm { d } \psi } } = { \frac { | { \frac { \mathrm { d } a } { \mathrm { d } \rho } } \quad { \frac { \mathrm { d } a } { \mathrm { d } \theta } } \quad { \frac { \mathrm { d } a } { \mathrm { d } \phi } } \quad { \frac { \mathrm { d } a } { \mathrm { d } \psi } } } { \mathrm { d } \rho \mathrm { d } \theta \mathrm { d } \phi \mathrm { d } \psi } } = { \frac { \mathrm { d } a \mathrm { d } b \mathrm { d } c \mathrm { d } d } { { \frac { \mathrm { d } \rho } { \mathrm { d } \rho } } \quad { \frac { \mathrm { d } b } { \mathrm { d } \theta } } \quad { \frac { \mathrm { d } b } { \mathrm { d } \phi } } } } \quad { \frac { \mathrm { d } b } { \mathrm { d } \psi } }
+$$
+
+$$
+= \left| \begin{array} { c c c c } { \cos \theta } & { - \rho \sin \theta } & { 0 } & { 0 } \\ { \sin \theta \cos \phi } & { \rho \sin \theta \cos \phi } & { - \rho \sin \theta \sin \phi } & { 0 } \\ { \sin \theta \sin \phi \cos \psi } & { \rho \cos \theta \sin \phi \cos \psi } & { \rho \sin \theta \cos \phi \cos \psi } & { - \rho \sin \theta \sin \phi \sin \psi } \\ { \sin \theta \sin \phi \sin \psi } & { \rho \cos \theta \sin \phi \sin \psi } & { \rho \sin \theta \cos \phi \sin \psi } & { \rho \sin \theta \sin \phi \cos \psi } \end{array} \right| .
+$$
+
+And,
+
+$$
+J _ { f } = \rho ^ { 3 } \sin ^ { 2 } \theta \sin \phi .
+$$
+
+Therefore, by the Jacobian $J _ { f }$ , we have the polar form:
+
+$$
+\mathrm { d } a \mathrm { d } b \mathrm { d } c \mathrm { d } d = \rho ^ { 3 } \sin ^ { 2 } \theta \sin \phi \mathrm { d } \rho \mathrm { d } \theta \mathrm { d } \phi \mathrm { d } \psi .
+$$
+
+Then, writing Eq.(30) in polar coordinates, we obtain:
+
+$$
+\begin{array} { l } { { \displaystyle F _ { L } ( x , \sigma ) = \left( \frac { 1 } { \sqrt { 2 \pi \sigma ^ { 2 } } } \right) ^ { 4 } \int \int \int \int \left( \int _ { 0 } ^ { x } e ^ { - \alpha ^ { 2 } / 2 \sigma ^ { 2 } } e ^ { - b ^ { 2 } / 2 \sigma ^ { 2 } } e ^ { - c ^ { 2 } / 2 \sigma ^ { 2 } } { \mathrm { d } } ^ { 2 } e ^ { - d ^ { 2 } / 2 \sigma ^ { 2 } } { \mathrm { d } } S _ { x } \right. } } \\ { { \displaystyle \qquad = \frac { 1 } { 4 \pi ^ { 2 } \sigma ^ { 4 } } \int _ { 0 } ^ { 2 \pi } \int _ { 0 } ^ { \pi } \int _ { 0 } ^ { \pi } \int _ { 0 } ^ { \pi } e ^ { - \sigma ^ { 2 } / 2 \sigma ^ { 2 } } \rho ^ { 3 } \sin ^ { 2 } \theta \sin \phi \mathrm { d } \rho \mathrm { d } \theta \mathrm { d } \phi \mathrm { d } \psi } } \\ { { \displaystyle \qquad = \frac { 1 } { 4 \pi ^ { 2 } \sigma ^ { 4 } } \int _ { 0 } ^ { 2 \pi } \mathrm { d } \psi \int _ { 0 } ^ { \pi } \sin \phi \mathrm { d } \phi \int _ { 0 } ^ { \pi } \sin ^ { 2 } \theta \mathrm { d } \theta \int _ { 0 } ^ { x } \rho \mathrm { d } \theta \int _ { 0 } ^ { x } \rho ^ { 3 } e ^ { - \rho ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } \rho } } \\ { { \displaystyle \qquad = \frac { 1 } { 4 \pi ^ { 2 } \sigma ^ { 4 } } 2 \pi 2 \left[ \frac { \theta } { 2 } - \frac { \sin 2 \theta } { 4 } \right] _ { 0 } ^ { \pi } \int _ { 0 } ^ { x } \rho _ { e } ^ { 3 } e ^ { - \rho ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } \rho } } \\ { { \displaystyle \qquad = \frac { 1 } { 4 \pi ^ { 2 } \sigma ^ { 4 } } 4 \pi \frac { \pi } { 2 } \int _ { 0 } ^ { x } \rho ^ { 3 } e ^ { - \rho ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } \rho , } } \end{array}
+$$
+
+Then,
+
+$$
+F _ { L } ( x , \sigma ) = \frac { 1 } { 2 \sigma ^ { 4 } } \int _ { 0 } ^ { x } \rho ^ { 3 } e ^ { - \rho ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } \rho .
+$$
+
+The probability density function for $X$ is the derivative of its cumulative distribution function, which by the fundamental theorem of calculus is:
+
+$$
+\begin{array} { l } { { f _ { L } ( x , \sigma ) = \displaystyle \frac { \mathrm { d } } { \mathrm { d } x } F _ { L } ( x , \sigma ) } } \\ { { \displaystyle ~ = \frac { 1 } { 2 { \sigma } ^ { 4 } } x ^ { 3 } e ^ { - x ^ { 2 } / 2 { \sigma } ^ { 2 } } . } } \end{array}
+$$
+
+The expectation of the squared magnitude becomes:
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } ( | W | ^ { 2 } ) = \int _ { 0 } ^ { \infty } x ^ { 2 } f ( x ) \mathrm { d } x } \\ { \displaystyle \qquad = \int _ { 0 } ^ { \infty } x ^ { 2 } \frac { 1 } { 2 \sigma ^ { 4 } } x ^ { 3 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } x } \\ { \displaystyle \qquad = \frac { 1 } { 2 \sigma ^ { 4 } } \int _ { 0 } ^ { \infty } x ^ { 5 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } x . } \end{array}
+$$
+
+With integration by parts we obtain:
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } ( | W | ^ { 2 } ) = \frac { 1 } { 2 \sigma ^ { 4 } } \left( - x ^ { 4 } \sigma ^ { 2 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } \Big | _ { 0 } ^ { \infty } + \int _ { 0 } ^ { \infty } \sigma ^ { 2 } 4 x ^ { 3 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } { \mathrm { d } } x \right) } \\ { \displaystyle \qquad = \frac { 1 } { 2 \sigma ^ { 2 } } \left( - x ^ { 4 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } \Big | _ { 0 } ^ { \infty } + \int _ { 0 } ^ { \infty } 4 x ^ { 3 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } { \mathrm { d } } x \right) . } \end{array}
+$$
+
+The expectation $\mathbb { E } ( | W | ^ { 2 } )$ is the sum of two terms. The first one:
+
+$$
+\begin{array} { l } { {  - x ^ { 4 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } | _ { 0 } ^ { \infty } = \displaystyle \operatorname* { l i m } _ { x  + \infty } - x ^ { 4 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } - \operatorname* { l i m } _ { x  + 0 } x ^ { 4 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } } } \\ { {  \qquad = \displaystyle \operatorname* { l i m } _ { x  + \infty } - x ^ { 4 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } ,  } } \end{array}
+$$
+
+Based on the L’Hôpital’s rule, the undetermined limit becomes:
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { l i m } _ { x \to + \infty } - x ^ { 4 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } = - \underset { x \to + \infty } { \operatorname* { l i m } } \frac { x ^ { 4 } } { e ^ { x ^ { 2 } / 2 \sigma ^ { 2 } } } } \\ { \displaystyle = . . . } \\ { \displaystyle = - \underset { x \to + \infty } { \operatorname* { l i m } } \frac { 2 4 } { ( 1 / \sigma ^ { 2 } ) ( P ( x ) e ^ { x ^ { 2 } / 2 \sigma ^ { 2 } } ) } } \\ { \displaystyle = 0 . } \end{array}
+$$
+
+With $P ( x )$ is polynomial and has a limit to $+ \infty$ . The second term is calculated in a same way (integration by parts) and $\mathbb { E } ( | W | ^ { 2 } )$ becomes from Eq.(35):
+
+$$
+\begin{array} { l } { \displaystyle \mathbb { E } ( | W | ^ { 2 } ) = \frac { 1 } { 2 \sigma ^ { 2 } } \int _ { 0 } ^ { \infty } 4 x ^ { 3 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } x } \\ { \displaystyle \qquad = \frac { 2 } { \sigma ^ { 2 } } \left( x ^ { 2 } \sigma ^ { 2 } e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } \Big | _ { 0 } ^ { \infty } + \int _ { 0 } ^ { \infty } \sigma ^ { 2 } 2 x e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } x \right) . } \end{array}
+$$
+
+The limit of first term is equals to 0 with the same method than in Eq.(36). Therefore, the expectation is:
+
+$$
+\begin{array} { c } { \displaystyle \mathbb { E } ( | W | ^ { 2 } ) = 4 \left( \int _ { 0 } ^ { \infty } x e ^ { - x ^ { 2 } / 2 \sigma ^ { 2 } } \mathrm { d } x \right) } \\ { = 4 \sigma ^ { 2 } . } \end{array}
+$$
+
+And finally the variance is:
+
+$$
+V a r ( | W | ) = 4 \sigma ^ { 2 } . 
+$$
+
+# 6.3 QUATERNION BACKPROPAGATION THROUGH TIME
+
+Let us recall the forward equations and parameters needed to derive the complete quaternion backpropagation through time (QBPTT) algorithm.
+
+# 6.3.1 RECALL OF THE FORWARD PHASE
+
+Let $x _ { t }$ be the input vector at timestep $t$ , $h _ { t }$ the hidden state, $W _ { h h }$ , $W _ { x h }$ and $W _ { h y }$ the hidden state, input and output weight matrices respectively. Finally $b _ { h }$ is the biases vector of the hidden states and $p _ { t } , y _ { t }$ are the output and the expected target vector.
+
+$$
+h _ { t } = \alpha ( h _ { t } ^ { p r e a c t } ) ,
+$$
+
+with,
+
+$$
+h _ { t } ^ { p r e a c t } = W _ { h h } \otimes h _ { t - 1 } + W _ { x h } \otimes x _ { t } + b _ { h } ,
+$$
+
+and $\alpha$ is the quaternion split activation function ( $\mathrm { X u }$ et al., 2017) of a quaternion $Q$ defined as:
+
+$$
+\alpha ( Q ) = f ( r ) + i f ( x ) + j f ( y ) + k f ( z ) ,
+$$
+
+and $f$ corresponding to any standard activation function. The output vector $p _ { t }$ can be computed as:
+
+$$
+p _ { t } = \beta ( p _ { t } ^ { p r e a c t } ) ,
+$$
+
+with
+
+$$
+p _ { t } ^ { p r e a c t } = W _ { h y } \otimes h _ { t } ,
+$$
+
+and $\beta$ any split activation function. Finally, the objective function is a real-valued loss function applied component-wise. The gradient with respect to the MSE loss is expressed for each weight matrix as $\frac { \partial \hat { E } _ { t } } { \partial W _ { h y } }$ , $\frac { \partial E _ { t } } { \partial W _ { h h } }$ , $\frac { \partial E _ { t } } { \partial W _ { h x } }$ , and for the bias vector as ∂Et∂B . In the real-valued space, the dynamic of the loss is only investigated based on all previously connected neurons. In this extent, the QBPTT differs from BPTT due to the fact that the loss must also be derived with respect to each component of a quaternion neural parameter, making it bi-level. This could act as a regularizer during the training process.
+
+# 6.3.2 OUTPUT WEIGHT MATRIX
+
+The weight matrix $W _ { h y }$ is used only in the computation of $p _ { t }$ . It is therefore straightforward to compute $\frac { \partial E _ { t } } { \partial W _ { h y } }$
+
+$$
+\frac { \partial E _ { t } } { \partial W _ { h y } } = \frac { \partial E _ { t } } { \partial W _ { h y } ^ { r } } + i \frac { \partial E _ { t } } { \partial W _ { h y } ^ { i } } + j \frac { \partial E _ { t } } { \partial W _ { h y } ^ { j } } + k \frac { \partial E _ { t } } { \partial W _ { h y } ^ { k } } .
+$$
+
+Each quaternion component is then derived following the chain rule:
+
+$$
+\begin{array} { r l r } {  { \frac { \partial E _ { t } } { \partial W _ { h y } ^ { r } } = \frac { \partial E _ { t } } { \partial p _ { t } ^ { r } } \frac { \partial p _ { t } ^ { r } } { \partial W _ { h y } ^ { r } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { i } } \frac { \partial p _ { t } ^ { i } } { \partial W _ { h y } ^ { r } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { j } } \frac { \partial p _ { t } ^ { j } } { \partial W _ { h y } ^ { r } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { k } } \frac { \partial p _ { t } ^ { k } } { \partial W _ { h y } ^ { r } } } } \\ & { } & { = ( p _ { t } ^ { r } - y _ { t } ^ { r } ) \times h _ { t } ^ { r } + ( p _ { t } ^ { i } - y _ { t } ^ { i } ) \times h _ { t } ^ { i } + ( p _ { t } ^ { j } - y _ { t } ^ { j } ) \times h _ { t } ^ { j } + ( p _ { t } ^ { k } - y _ { t } ^ { k } ) \times h _ { t } ^ { k } . } \end{array}
+$$
+
+$$
+\begin{array} { r l r } {  { \frac { \partial E _ { t } } { \partial W _ { h y } ^ { i } } = \frac { \partial E _ { t } } { \partial p _ { t } ^ { r } } \frac { \partial p _ { t } ^ { r } } { \partial W _ { h y } ^ { i } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { i } } \frac { \partial p _ { t } ^ { i } } { \partial W _ { h y } ^ { i } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { j } } \frac { \partial p _ { t } ^ { j } } { \partial W _ { h y } ^ { i } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { k } } \frac { \partial p _ { t } ^ { k } } { \partial W _ { h y } ^ { i } } } } \\ & { } & { = ( p _ { t } ^ { r } - y _ { t } ^ { r } ) \times - h _ { t } ^ { i } + ( p _ { t } ^ { i } - y _ { t } ^ { i } ) \times h _ { t } ^ { r } + ( p _ { t } ^ { j } - y _ { t } ^ { j } ) \times h _ { t } ^ { k } + ( p _ { t } ^ { k } - y _ { t } ^ { k } ) \times - h _ { t } ^ { j } . } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \frac { \partial E _ { t } } { \partial W _ { h y } ^ { j } } = \frac { \partial E _ { t } } { \partial p _ { t } ^ { r } } \frac { \partial p _ { t } ^ { r } } { \partial W _ { h y } ^ { j } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { i } } \frac { \partial p _ { t } ^ { i } } { \partial W _ { h y } ^ { j } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { j } } \frac { \partial p _ { t } ^ { j } } { \partial W _ { h y } ^ { j } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { k } } \frac { \partial p _ { t } ^ { k } } { \partial W _ { h y } ^ { j } } } \\ & { \qquad = ( p _ { t } ^ { r } - y _ { t } ^ { r } ) \times - h _ { t } ^ { j } + ( p _ { t } ^ { i } - y _ { t } ^ { i } ) \times - h _ { t } ^ { k } + ( p _ { t } ^ { j } - y _ { t } ^ { j } ) \times h _ { t } ^ { r } + ( p _ { t } ^ { k } - y _ { t } ^ { k } ) \times h _ { t } ^ { i } . } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \frac { \partial E _ { t } } { \partial W _ { h y } ^ { k } } = \frac { \partial E _ { t } } { \partial p _ { t } ^ { r } } \frac { \partial p _ { t } ^ { r } } { \partial W _ { h y } ^ { k } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { i } } \frac { \partial p _ { t } ^ { i } } { \partial W _ { h y } ^ { k } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { j } } \frac { \partial p _ { t } ^ { j } } { \partial W _ { h y } ^ { k } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { k } } \frac { \partial p _ { t } ^ { k } } { \partial W _ { h y } ^ { k } } } \\ & { \qquad = ( p _ { t } ^ { r } - y _ { t } ^ { r } ) \times - h _ { t } ^ { k } + ( p _ { t } ^ { i } - y _ { t } ^ { i } ) \times h _ { t } ^ { j } + ( p _ { t } ^ { j } - y _ { t } ^ { j } ) \times - h _ { t } ^ { i } + ( p _ { t } ^ { k } - y _ { t } ^ { k } ) \times h _ { t } ^ { r } . } \end{array}
+$$
+
+By regrouping in a matrix form the $h _ { t }$ components from these equations, one can define:
+
+$$
+\left[ \begin{array} { l l l l } { h _ { t } ^ { r } } & { h _ { t } ^ { i } } & { h _ { t } ^ { j } } & { h _ { t } ^ { k } } \\ { - h _ { t } ^ { i } } & { h _ { t } ^ { r } } & { h _ { t } ^ { k } } & { - h _ { t } ^ { j } } \\ { - h _ { t } ^ { j } } & { - h _ { t } ^ { k } } & { h _ { t } ^ { r } } & { h _ { t } ^ { i } } \\ { - h _ { t } ^ { k } } & { h _ { t } ^ { j } } & { - h _ { t } ^ { i } } & { h _ { t } ^ { r } } \end{array} \right] = h _ { t } ^ { * } .
+$$
+
+Therefore,
+
+$$
+\frac { \partial E _ { t } } { \partial W _ { h y } } = ( p _ { t } - y _ { t } ) \otimes h _ { t } ^ { * } .
+$$
+
+# 6.3.3 HIDDEN WEIGHT MATRIX
+
+Conversely to $W _ { h y }$ the weight matrix $W _ { h h }$ is an argument of $h _ { t }$ with $h _ { t - 1 }$ involved. The recursive backpropagation can thus be derived as:
+
+$$
+\frac { \partial E } { \partial W _ { h h } } = \sum _ { t = 0 } ^ { N } \frac { \partial E _ { t } } { \partial W _ { h h } } .
+$$
+
+And,
+
+$$
+\frac { \partial E _ { t } } { \partial W _ { h h } } = \sum _ { m = 0 } ^ { t } \frac { \partial E _ { m } } { \partial W _ { h h } ^ { r } } + i \frac { \partial E _ { m } } { \partial W _ { h h } ^ { r } } + j \frac { \partial E _ { m } } { \partial W _ { h h } ^ { i } } + k \frac { \partial E _ { m } } { \partial W _ { h h } ^ { k } } ,
+$$
+
+with $N$ the number of timesteps that compose the sequence. As for $W _ { h y }$ we start with $\frac { \partial E _ { k } } { \partial W _ { h h } ^ { r } }$
+
+$$
+\begin{array} { r } { \displaystyle \sum _ { m = 0 } ^ { t } { \frac { \partial E _ { m } } { \partial W _ { h h } ^ { r } } } = \sum _ { m = 0 } ^ { t } { \frac { \partial E _ { t } } { \partial h _ { t } ^ { r } } \frac { \partial h _ { t } ^ { r } } { \partial h _ { m } ^ { r } } \frac { \partial h _ { m } ^ { r } } { \partial W _ { h h } ^ { r } } } + \frac { \partial E _ { t } } { \partial h _ { t } ^ { i } } \frac { \partial h _ { t } ^ { i } } { \partial h _ { m } ^ { i } } \frac { \partial h _ { m } ^ { i } } { \partial W _ { h h } ^ { r } } } \\ { \displaystyle + \frac { \partial E _ { t } } { \partial h _ { t } ^ { j } } \frac { \partial h _ { t } ^ { j } } { \partial h _ { m } ^ { j } } \frac { \partial h _ { m } ^ { j } } { \partial W _ { h h } ^ { r } } + \frac { \partial E _ { t } } { \partial h _ { t } ^ { k } } \frac { \partial h _ { t } ^ { i } } { \partial h _ { m } ^ { k } } \frac { \partial h _ { m } ^ { k } } { \partial W _ { h h } ^ { r } } . } \end{array}
+$$
+
+Non-recursive elements are derived w.r.t r, i,j, $\mathbf { k }$ :
+
+$$
+\begin{array} { r l } & { \frac { \partial E _ { t } } { \partial h _ { t } ^ { r } } = \frac { \partial E _ { t } } { \partial p _ { t } ^ { r } } \frac { \partial p _ { t } ^ { r } } { \partial h _ { t } ^ { r } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { i } } \frac { \partial p _ { t } ^ { i } } { \partial h _ { t } ^ { r } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { j } } \frac { \partial p _ { t } ^ { j } } { \partial h _ { t } ^ { r } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { k } } \frac { \partial p _ { t } ^ { k } } { \partial h _ { t } ^ { r } } } \\ & { \qquad = ( p _ { t } ^ { r } - y _ { t } ^ { r } ) \times f ^ { ' } ( p _ { t } ^ { r } ) \times W _ { h y } ^ { r } + ( p _ { t } ^ { i } - y _ { t } ^ { i } ) \times f ^ { ' } ( p _ { t } ^ { i } ) \times W _ { h y } ^ { i } } \\ & { \qquad + ( p _ { t } ^ { j } - y _ { t } ^ { j } ) \times f ^ { ' } ( p _ { t } ^ { j } ) \times W _ { h y } ^ { j } + ( p _ { t } ^ { k } - y _ { t } ^ { k } ) \times f ^ { ' } ( p _ { t } ^ { k } ) \times W _ { h y } ^ { k } . } \end{array}
+$$
+
+$$
+\begin{array} { r l r } {  { \frac { \partial E _ { t } } { \partial h _ { t } ^ { i } } = \frac { \partial E _ { t } } { \partial p _ { t } ^ { r } } \frac { \partial p _ { t } ^ { r } } { \partial h _ { t } ^ { i } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { i } } \frac { \partial p _ { t } ^ { i } } { \partial h _ { t } ^ { i } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { j } } \frac { \partial p _ { t } ^ { j } } { \partial h _ { t } ^ { i } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { k } } \frac { \partial p _ { t } ^ { k } } { \partial h _ { t } ^ { i } } } } \\ & { } & { = ( p _ { t } ^ { r } - y _ { t } ^ { r } ) \times f ^ { ' } ( p _ { t } ^ { r } ) \times - W _ { h y } ^ { i } + ( p _ { t } ^ { i } - y _ { t } ^ { i } ) \times f ^ { ' } ( p _ { t } ^ { i } ) \times W _ { h y } ^ { r } } \\ & { } & { + ( p _ { t } ^ { j } - y _ { t } ^ { j } ) \times f ^ { ' } ( p _ { t } ^ { j } ) \times W _ { h y } ^ { k } + ( p _ { t } ^ { k } - y _ { t } ^ { k } ) \times f ^ { ' } ( p _ { t } ^ { k } ) \times - W _ { h y } ^ { j } . } \end{array}
+$$
+
+$$
+\begin{array} { r l r } {  { \frac { \partial E _ { t } } { \partial h _ { t } ^ { j } } = \frac { \partial E _ { t } } { \partial p _ { t } ^ { r } } \frac { \partial p _ { t } ^ { r } } { \partial h _ { t } ^ { j } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { i } } \frac { \partial p _ { t } ^ { i } } { \partial h _ { t } ^ { j } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { j } } \frac { \partial p _ { t } ^ { j } } { \partial h _ { t } ^ { j } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { k } } \frac { \partial p _ { t } ^ { k } } { \partial h _ { t } ^ { j } } } } \\ & { } & { = ( p _ { t } ^ { r } - y _ { t } ^ { r } ) \times f ^ { ' } ( p _ { t } ^ { r } ) \times - W _ { h y } ^ { j } + ( p _ { t } ^ { i } - y _ { t } ^ { i } ) \times f ^ { ' } ( p _ { t } ^ { i } ) \times - W _ { h y } ^ { k } } \\ & { } & { + ( p _ { t } ^ { j } - y _ { t } ^ { j } ) \times f ^ { ' } ( p _ { t } ^ { j } ) \times W _ { h y } ^ { r } + ( p _ { t } ^ { k } - y _ { t } ^ { k } ) \times f ^ { ' } ( p _ { t } ^ { k } ) \times W _ { h y } ^ { i } . } \end{array}
+$$
+
+$$
+\begin{array} { r l } & { \frac { \partial E _ { t } } { \partial h _ { t } ^ { k } } = \frac { \partial E _ { t } } { \partial p _ { t } ^ { r } } \frac { \partial p _ { t } ^ { r } } { \partial h _ { t } ^ { k } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { i } } \frac { \partial p _ { t } ^ { i } } { \partial h _ { t } ^ { k } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { j } } \frac { \partial p _ { t } ^ { j } } { \partial h _ { t } ^ { k } } + \frac { \partial E _ { t } } { \partial p _ { t } ^ { k } } \frac { \partial p _ { t } ^ { k } } { \partial h _ { t } ^ { k } } } \\ & { \qquad = ( p _ { t } ^ { r } - y _ { t } ^ { r } ) \times f ^ { ' } ( p _ { t } ^ { r } ) \times - W _ { h y } ^ { k } + ( p _ { t } ^ { i } - y _ { t } ^ { i } ) \times f ^ { ' } ( p _ { t } ^ { i } ) \times W _ { h y } ^ { j } } \\ & { \qquad + ( p _ { t } ^ { j } - y _ { t } ^ { j } ) \times f ^ { ' } ( p _ { t } ^ { j } ) \times - W _ { h y } ^ { i } + ( p _ { t } ^ { k } - y _ { t } ^ { k } ) \times f ^ { ' } ( p _ { t } ^ { k } ) \times W _ { h y } ^ { r } . } \end{array}
+$$
+
+Then,
+
+$$
+\left[ \begin{array} { l l l l } { \frac { \partial h _ { r , m } } { \partial W _ { r h } ^ { _ { n } } } = h _ { r , t - 1 } } & { \frac { \partial h _ { i , m } } { \partial W _ { r h } ^ { _ { n } } } = h _ { i , t - 1 } } & { \frac { \partial h _ { j , m } } { \partial W _ { r h } ^ { _ { n } } } = h _ { j , t - 1 } } & { \frac { \partial h _ { k , m } } { \partial W _ { h h } ^ { _ { n } } } = h _ { k , t - 1 } } \\ { \frac { \partial h _ { r , m } } { \partial W _ { h h } ^ { _ { n } } } = - h _ { i , t - 1 } } & { \frac { \partial h _ { i , m } } { \partial W _ { h h } ^ { _ { n } } } = h _ { i , t - 1 } } & { \frac { \partial h _ { j , m } } { \partial W _ { h h } ^ { _ { n } } } = h _ { j , t - 1 } } & { \frac { \partial h _ { k , m } } { \partial W _ { h h } ^ { _ { n } } } = h _ { k , t - 1 } } \\ { \frac { \partial h _ { r , m } } { \partial W _ { h h } ^ { _ { n } } } = - h _ { j , t - 1 } } & { \frac { \partial h _ { i , m } } { \partial W _ { h h } ^ { _ { n } } } = - h _ { k , t - 1 } } & { \frac { \partial h _ { j , m } } { \partial W _ { h h } ^ { _ { n } } } = h _ { r , t - 1 } } & { \frac { \partial h _ { k , m } } { \partial W _ { h h } ^ { _ { n } } } = h _ { i , t - 1 } } \\ { \frac { \partial h _ { r , m } } { \partial W _ { h h } ^ { _ { n } } } = - h _ { k , t - 1 } } & { \frac { \partial h _ { i , m } } { \partial W _ { h h } ^ { _ { n } } } = h _ { j , t - 1 } } & { \frac { \partial h _ { j , m } } { \partial W _ { h h } ^ { _ { n } } } = - h _ { i , t - 1 } } & { \frac { \partial h _ { k , m } } { \partial W _ { h h } ^ { _ { n } } } = h _ { r , t - 1 } } \end{array} \right] = h _ { t } ^ { * } .
+$$
+
+The remaining terms $\frac { \partial h _ { t } ^ { r } } { \partial h _ { m } ^ { r } } , \frac { \partial h _ { t } ^ { i } } { \partial h _ { m } ^ { i } } , \frac { \partial h _ { t } ^ { j } } { \partial h _ { m } ^ { j } }$ and $\frac { \partial h _ { t } ^ { k } } { \partial h _ { m } ^ { k } }$ are recursive and are written as:
+
+$$
+\begin{array} { r } { \frac { \partial h _ { r , t } } { \partial h _ { r , m } } = \prod _ { n = m + 1 } ^ { t } \frac { \partial h _ { r , n } } { \partial h _ { r , n } ^ { p r e a c t } } \frac { \partial h _ { r , n } ^ { p r e a c t } } { \partial h _ { r , n - 1 } } + \frac { \partial h _ { r , n } } { \partial h _ { i , n } ^ { p r e a c t } } \frac { \partial h _ { i , n } ^ { p r e a c t } } { \partial h _ { r , n - 1 } } } \\ { + \frac { \partial h _ { r , n } } { \partial h _ { j , n } ^ { p r e a c t } } \frac { \partial h _ { j , n } ^ { p r e a c t } } { \partial h _ { r , n - 1 } } + \frac { \partial h _ { r , n } } { \partial h _ { k , n } ^ { p r e a c t } } \frac { \partial h _ { k , n } ^ { p r e a c t } } { \partial h _ { r , n - 1 } } , } \end{array}
+$$
+
+simplified with,
+
+$$
+\begin{array} { r } { \frac { \partial h _ { r , t } } { \partial h _ { r , m } } = \displaystyle \prod _ { n = m + 1 } ^ { t } \frac { \partial h _ { r , n } } { \partial h _ { r , n } ^ { p r e a c t } } \times W _ { h h } ^ { r } + \frac { \partial h _ { r , n } } { \partial h _ { i , n } ^ { p r e a c t } } \times W _ { h h } ^ { i } } \\ { + \frac { \partial h _ { r , n } } { \partial h _ { j , n } ^ { p r e a c t } } \times W _ { h h } ^ { j } + \frac { \partial h _ { r , n } } { \partial h _ { k , n } ^ { p r e a c t } } \times W _ { h h } ^ { k } . } \end{array}
+$$
+
+Consequently,
+
+$$
+\begin{array} { r } { \frac { \partial h _ { i , t } } { \partial h _ { i , m } } = \displaystyle \prod _ { n = m + 1 } ^ { t } \frac { \partial h _ { i , n } } { \partial h _ { r , n } ^ { p r e a c t } } \times - W _ { h h } ^ { i } + \frac { \partial h _ { i , n } } { \partial h _ { i , n } ^ { p r e a c t } } \times W _ { h h } ^ { r } } \\ { + \frac { \partial h _ { j , n } } { \partial h _ { j , n } ^ { p r e a c t } } \times W _ { h h } ^ { k } + \frac { \partial h _ { i , n } } { \partial h _ { k , n } ^ { p r e a c t } } \times - W _ { h h } ^ { j } . } \end{array}
+$$
+
+$$
+\frac { \partial h _ { j , t } } { \partial h _ { j , m } } = \prod _ { n = m + 1 } ^ { t } \frac { \partial h _ { j , n } } { \partial h _ { r , n } ^ { p r e a c t } } \times - W _ { h h } ^ { j } + \frac { \partial h _ { j , n } } { \partial h _ { i , n } ^ { p r e a c t } } \times - W _ { h h } ^ { k }
+$$
+
+$$
+\begin{array} { r } { \frac { \partial h _ { k , t } } { \partial h _ { k , m } } = \displaystyle \prod _ { n = m + 1 } ^ { t } \frac { \partial h _ { k , n } } { \partial h _ { r , n } ^ { p r e a c t } } \times - W _ { h h } ^ { k } + \frac { \partial h _ { k , n } } { \partial h _ { i , n } ^ { p r e a c t } } \times W _ { h h } ^ { j } } \\ { + \frac { \partial h _ { k , n } } { \partial h _ { j , n } ^ { p r e a c t } } \times - W _ { h h } ^ { i } + \frac { \partial h _ { k , n } } { \partial h _ { k , n } ^ { p r e a c t } } \times W _ { h h } ^ { r } . } \end{array}
+$$
+
+The same operations are performed for i,j,k in Eq. 68 and $\frac { \partial E _ { t } } { \partial W _ { h h } }$ can finally be expressed as:
+
+$$
+\frac { \partial E _ { t } } { \partial W _ { h h } } = \sum _ { m = 0 } ^ { t } ( \prod _ { n = m + 1 } ^ { t } \delta _ { n } ) \otimes h _ { t - 1 } ^ { * } ,
+$$
+
+with,
+
+$$
+\delta _ { n } = \left\{ \begin{array} { l l } { W _ { h h } ^ { * } \otimes \delta _ { n + 1 } \times \alpha ^ { \prime } ( h _ { n } ^ { p r e a c t } ) } & { \mathrm { i f ~ } n \neq t } \\ { W _ { h y } ^ { * } \otimes ( p _ { n } - y _ { n } ) \times \beta ^ { ' } ( p _ { n } ^ { p r e a c t } ) } & { \mathrm { e l s e } . } \end{array} \right.
+$$
+
+# 6.3.4 INPUT WEIGHT MATRIX
+
+∂Et∂W is computed in the exact same manner as $\frac { \partial E _ { t } } { \partial W _ { h h } }$
+
+$$
+\frac { \partial E } { \partial W _ { h x } } = \sum _ { t = 0 } ^ { N } \frac { \partial E _ { t } } { \partial W _ { h x } } .
+$$
+
+And,
+
+$$
+\frac { \partial E _ { t } } { \partial W _ { h x } } = \sum _ { m = 0 } ^ { t } \frac { \partial E _ { m } } { \partial W _ { h x } ^ { r } } + i \frac { \partial E _ { m } } { \partial W _ { h x } ^ { r } } + j \frac { \partial E _ { m } } { \partial W _ { h x } ^ { i } } + k \frac { \partial E _ { m } } { \partial W _ { h x } ^ { k } } .
+$$
+
+Therefore $\frac { \partial E _ { t } } { \partial W _ { h x } }$ is easily extent as:
+
+$$
+\frac { \partial E _ { t } } { \partial W _ { h x } } = \sum _ { m = 0 } ^ { t } ( \prod _ { n = m + 1 } ^ { t } \delta _ { n } ) \otimes x _ { t } ^ { * } .
+$$
+
+# 6.3.5 HIDDEN BIASES
+
+$\frac { \partial E _ { t } } { \partial B _ { h } }$ can easily be extended to:
+
+$$
+\frac { \partial E } { \partial B _ { h } } = \sum _ { t = 0 } ^ { N } \frac { \partial E _ { t } } { \partial B _ { h } } .
+$$
+
+And,
+
+$$
+\frac { \partial E _ { t } } { \partial B _ { h } } = \sum _ { m = 0 } ^ { t } \frac { \partial E _ { m } } { \partial B _ { h } ^ { r } } + i \frac { \partial E _ { m } } { \partial B _ { h } ^ { r } } + j \frac { \partial E _ { m } } { \partial B _ { h } ^ { i } } + k \frac { \partial E _ { m } } { \partial B _ { h } ^ { k } } .
+$$
+
+Nonetheless, since biases are not connected to any inputs or hidden states, the matrix of derivatives defined in Eq. 59 becomes a matrix of 1. Consequently $\frac { \partial E _ { t } } { \partial B _ { h } }$ can be summarized as:
+
+$$
+\frac { \partial E _ { t } } { \partial B _ { h } } = \sum _ { m = 0 } ^ { t } ( \prod _ { n = m + 1 } ^ { t } \delta _ { n } ) .
+$$

parse/train/N51zJ7F3mw/N51zJ7F3mw.md

@@ -0,0 +1,292 @@
+# Dissecting the Diffusion Process in Linear Graph Convolutional Networks
+
+Yifei Wang1 Yisen Wang2,3∗ Jiansheng Yang1 Zhouchen Lin2,3,4 1 School of Mathematical Sciences, Peking University, Beijing, China 2 Key Lab. of Machine Perception, School of Artificial Intelligence, Peking University, Beijing, China 3 Institute for Artificial Intelligence, Peking University, Beijing, China 4 Pazhou Lab, Guangzhou, China yifei_wang@pku.edu.cn, yisen.wang@pku.edu.cn yjs@math.pku.edu.cn, zlin@pku.edu.cn
+
+# Abstract
+
+Graph Convolutional Networks (GCNs) have attracted more and more attentions in recent years. A typical GCN layer consists of a linear feature propagation step and a nonlinear transformation step. Recent works show that a linear GCN can achieve comparable performance to the original non-linear GCN while being much more computationally efficient. In this paper, we dissect the feature propagation steps of linear GCNs from a perspective of continuous graph diffusion, and analyze why linear GCNs fail to benefit from more propagation steps. Following that, we propose Decoupled Graph Convolution (DGC) that decouples the terminal time and the feature propagation steps, making it more flexible and capable of exploiting a very large number of feature propagation steps. Experiments demonstrate that our proposed DGC improves linear GCNs by a large margin and makes them competitive with many modern variants of non-linear GCNs. Code is available at https://github.com/yifeiwang77/DGC.
+
+# 1 Introduction
+
+Recently, Graph Convolutional Networks (GCNs) have successfully extended the powerful representation learning ability of modern Convolutional Neural Networks (CNNs) to the graph data [7]. A graph convolutional layer typically consists of two stages: linear feature propagation and nonlinear feature transformation. Simple Graph Convolution (SGC) [21] simplifies GCNs by removing the nonlinearities between GCN layers and collapsing the resulting function into a single linear transformation, which is followed by a single linear classification layer and then becomes a linear GCN. SGC can achieve comparable performance to canonical GCNs while being much more computationally efficient and using significantly fewer parameters. Thus, we mainly focus on linear GCNs in this paper.
+
+Although being comparable to canonical GCNs, SGC still suffers from a similar issue as non-linear GCNs, that is, more (linear) feature propagation steps $K$ will degrade the performance catastrophically. This issue is widely characterized as the “over-smoothing” phenomenon. Namely, node features become smoothed out and indistinguishable after too many feature propagation steps [10].
+
+In this work, through a dissection of the diffusion process of linear GCNs, we characterize a fundamental limitation of SGC. Specifically, we point out that its feature propagation step amounts to a very coarse finite difference with a fixed step size $\Delta t = 1$ , which results in a large numerical error.
+
+And because the step size is fixed, more feature propagation steps will inevitably lead to a large terminal time $T = K \cdot \Delta t \to \infty$ that over-smooths the node features.
+
+To address these issues, we propose Decoupled Graph Convolution (DGC) by decoupling the terminal time $T$ and propagation steps $K$ . In particular, we can flexibly choose a continuous terminal time $T$ for the optimal tradeoff between under-smoothing and over-smoothing, and then fix the terminal time while adopting more propagation steps $K$ . In this way, different from SGC that over-smooths with more propagation steps, our proposed DGC can obtain a more fine-grained finite difference approximation with more propagation steps, which contributes to the final performance both theoretically and empirically. Extensive experiments show that DGC (as a linear GCN) improves over SGC significantly and obtains state-of-the-art results that are comparable to many modern non-linear GCNs. Our main contributions are summarized as follows:
+
+• We investigate SGC by dissecting its diffusion process from a continuous perspective, and characterize why it cannot benefit from more propagation steps. • We propose Decoupled Graph Convolution (DGC) that decouples the terminal time $T$ and the propagation steps $K$ , which enables us to choose a continuous terminal time flexibly while benefiting from more propagation steps from both theoretical and empirical aspects. • Experiments show that DGC outperforms canonical GCNs significantly and obtains stateof-the-art (SOTA) results among linear GCNs, which is even comparable to many competitive non-linear GCNs. We think DGC can serve as a strong baseline for the future research.
+
+# 2 Related Work
+
+Graph convolutional networks (GCNs). To deal with non-Euclidean graph data, GCNs are proposed for direct convolution operation over graph, and have drawn interests from various domains. GCN is firstly introduced for a spectral perspective [26, 7], but soon it becomes popular as a general message passing algorithm in the spatial domain. Many variants have been proposed to improve its performance, such as GraphSAGE [5] with LSTM and GAT with attention mechanism [19].
+
+Over-smoothing issue. GCNs face a fundamental problem compared to standard CNNs, i.e., the over-smoothing problem. Li et al. [10] offer a theoretical characterization of over-smoothing based on linear feature propagation. After that, many researchers have tried to incorporate effective mechanisms in CNNs to alleviate over-smoothing. DeepGCNs [9] shows that residual connection and dilated convolution can make GCNs go as deep as CNNs, although increased depth does not contribute much. Methods like APPNP [8] and JKNet [25] avoid over-smoothing by aggregating multiscale information from the first hidden layer. DropEdge [16] applies dropout to graph edges and find it enables training GCNs with more layers. PairNorm [27] regularizes the feature distance to be close to the input distance, which will not fail catastrophically but still decrease with more layers.
+
+Continuous GCNs. Deep CNNs have been widely interpreted from a continuous perspective, e.g., ResNet [6] as the Euler discretization of Neural ODEs [11, 3]. This viewpoint has recently been borrowed to understand and improve GCNs. GCDE [15] directly extends GCNs to a Neural ODE, while CGNN [22] devises a GCN variant inspired by a new continuous diffusion. Our method is also inspired by the connection between discrete and continuous graph diffusion, but alternatively, we focus on their numerical gap and characterize how it affects the final performance.
+
+Linear GCNs. SGC [21] simplifies and separates the two stages of GCNs: feature propagation and (non-linear) feature transformation. It finds that utilizing only a simple logistic regression after feature propagation (removing the non-linearities), which makes it a linear GCN, can obtain comparable performance to canonical GCNs. In this paper, we further show that a properly designed linear GCN (DGC) can be on-par with state-of-the-art non-linear GCNs while possessing many desirable properties. For example, as a linear model, DGC requires much fewer parameters than non-linear GCNs, which makes it very memory efficient, and meanwhile, its training is also much faster $( \sim 1 0 0 \times )$ than non-linear models as it could preprocess all features before training.
+
+# 3 Dissecting Linear GCNs from Continuous Dynamics
+
+In this section, we make a brief review of SGC [21] in the context of semi-supervised node classifi cation task, and further point out its fundamental limitations.
+
+# 3.1 Review of Simple Graph Convolution (SGC)
+
+Define a graph as $\mathcal { G } = ( \gamma , \mathbf { A } )$ , where $\mathcal { V } = \{ v _ { 1 } , \ldots , v _ { n } \}$ denotes the vertex set of $n$ nodes, and $\mathbf { A } \in \mathbb { R } ^ { n \times n }$ is an adjacency matrix where $a _ { i j }$ denotes the edge weight between node $v _ { i }$ and $v _ { j }$ . The degree matrix $\mathbf { D } = \mathrm { d i a g } ( d _ { 1 } , \ldots , d _ { n } )$ of $\mathbf { A }$ is a diagonal matrix with its $i$ -th diagonal entry as $\begin{array} { r } { d _ { i } = \sum _ { j } a _ { i j } } \end{array}$ . Each node $v _ { i }$ is represented by a $d$ -dimensional feature vector $\mathbf { x } _ { i } \in \mathbb { R } ^ { d }$ , and we denote the feature matrix as $\mathbf { X } \in \mathbb { R } ^ { n \times d } = [ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { n } ]$ . Each node belongs to one out of $C$ classes, denoted by a one-hot vector $\mathbf { y } _ { i } \in \{ 0 , 1 \} ^ { C }$ . In node classification problems, only a subset of nodes $\nu _ { l } \subset \nu$ is labeled and we want to predict the labels of the rest nodes $\mathcal { V } _ { u } = \mathcal { V } \backslash \mathcal { V } _ { l }$ .
+
+SGC shows that we can obtain similar performance with a simplified GCN,
+
+$$
+\begin{array} { r } { \hat { \mathbf { Y } } _ { \mathrm { S G C } } = \operatorname { s o f t m a x } \left( \mathbf { S } ^ { K } \mathbf { X } \mathbf { \Theta } \right) , } \end{array}
+$$
+
+which pre-processes the node features $\mathbf { X }$ with $K$ linear propagation steps, and then applies a linear classifier with parameter $\Theta$ . Specifically, at the step $k$ , each feature $\mathbf { x } _ { i }$ is computed by aggregating features in its local neighborhood, which can be done in parallel over the whole graph for $K$ steps,
+
+$$
+\mathbf { X } ^ { ( k ) } \longleftarrow \mathbf { S } \mathbf { X } ^ { ( k - 1 ) } , \mathrm { ~ w h e r e ~ } \mathbf { S } = \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } \widetilde { \mathbf { A } } \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } \quad \Longrightarrow \quad \mathbf { X } ^ { ( K ) } = \mathbf { S } ^ { K } \mathbf { X } .
+$$
+
+Here $\widetilde { \mathbf { A } } = \mathbf { A } + \mathbf { I }$ is the adjacency matrix augmented with the self-loop I, $\widetilde { \bf D }$ is the degree matrix of $\widetilde { \bf A }$ , and S denotes the symmetrically normalized adjacency matrix. This step exploits the local graph structure to smooth out the noise in each node.
+
+At last, SGC applies a multinomial logistic regression (a.k.a. softmax regression) with parameter $\Theta$ to predict the node labels $\hat { \mathbf { Y } } _ { \mathrm { S G C } }$ from the node features of the last propagation step $\mathbf { X } ^ { ( K ) }$ :
+
+$$
+\hat { \mathbf { Y } } _ { \mathrm { S G C } } = \mathrm { s o f t m a x } \left( \mathbf { X } ^ { ( K ) } \Theta \right) .
+$$
+
+Because both the feature propagation $( \mathbf { S } ^ { K } \mathbf { X } )$ and classification $( \mathbf { X } ^ { ( K ) } \mathbf { \Theta } _ { \mathbf { \Theta } } ^ { } )$ steps are linear, SGC is essentially a linear version of GCN that only relies on linear features from the input.
+
+# 3.2 Equivalence between SGC and Graph Heat Equation
+
+Previous analysis of linear GCNs focuses on their asymptotic behavior as propagation steps $K  \infty$ (discrete), known as the over-smoothing phenomenon [10]. In this work, we instead provide a novel non-asymptotic characterization of linear GCNs from the corresponding continuous dynamics, graph heat equation [4]. A key insight is that we notice that the propagation of SGC can be seen equivalently as a (coarse) numerical discretization of the graph diffusion equation, as we show below.
+
+Graph Heat Equation (GHE) is a well-known generalization of the heat equation on graph data, which is widely used to model graph dynamics with applications in spectral graph theory [4], time series [12], combinational problems [13], etc. In general, GHE can be formulated as follows:
+
+$$
+\left\{ \begin{array} { l l } { \frac { d \mathbf { X } _ { t } } { d t } } & { = - \mathbf { L } \mathbf { X } _ { t } , } \\ { \mathbf { X } _ { 0 } } & { = \mathbf { X } , } \end{array} \right.
+$$
+
+where $\mathbf { X } _ { t }$ ( $t \geq 0 \}$ ) refers to the evolved input features at time $t$ , and $\mathbf { L }$ refers to the graph Laplacian matrix. Here, for the brevity of analysis, we take the symmetrically normalized graph Laplacian for the augmented adjacency $\widetilde { \bf A }$ and overload the notation as $\mathbf { L } = \widetilde { \mathbf { D } } ^ { - \frac { 1 } { 2 } } \left( \widetilde { \mathbf { D } } - \widetilde { \mathbf { A } } \right) \bar { \widetilde { \mathbf { D } } } ^ { - \frac { 1 } { 2 } } = \bar { \mathbf { I } } - \mathbf { S }$ .
+
+As GHE is a continuous dynamics, in practice we need to rely on numerical methods to solve it. We find that SGC can be seen as a coarse finite difference of GHE. Specifically, we apply the forward Euler method to Eq. (4) with an interval $\Delta t$ :
+
+$$
+\hat { \mathbf { X } } _ { t + \Delta t } = \hat { \mathbf { X } } _ { t } - \Delta t \mathbf { L } \hat { \mathbf { X } } _ { t } = \hat { \mathbf { X } } _ { t } - \Delta t ( \mathbf { I } - \mathbf { S } ) \hat { \mathbf { X } } _ { t } = \left[ ( 1 - \Delta t ) \mathbf { I } + \Delta t \mathbf { S } \right] \hat { \mathbf { X } } _ { t } .
+$$
+
+By involving the update rule for $K$ forward steps, we will get the final features $\hat { \mathbf { X } } _ { T }$ at the terminal time $T = K \cdot \Delta t$ :
+
+$$
+\begin{array} { r } { \hat { \mathbf { X } } _ { T } = [ \mathbf { S } ^ { ( \Delta t ) } ] ^ { K } \mathbf { X } , \mathrm { w h e r e } \mathbf { S } ^ { ( \Delta t ) } = ( 1 - \Delta t ) \mathbf { I } + \Delta t \mathbf { S } . } \end{array}
+$$
+
+Comparing to Eq. (2), we can see that the Euler discretization of GHE becomes SGC when the step size $\Delta t = 1$ . Specifically, the diffusion matrix $\mathbf { S } ^ { ( \Delta t ) }$ reduces to the SGC diffusion matrix S and the final node features, $\hat { \mathbf { X } } _ { T }$ and $\mathbf { X } ^ { ( K ) }$ , become equivalent. Therefore, SGC with $K$ propagation steps is essentially a finite difference approximation to GHE with $K$ forward steps (step size $\Delta t = 1$ and terminal time $T = K$ ).
+
+# 3.3 Revealing the Fundamental Limitations of SGC
+
+Based on the above analysis, we theoretically characterize several fundamental limitations of SGC: feature over-smoothing, large numerical errors and large learning risks. Proofs are in Appendix B.
+
+Theorem 1 (Oversmoothing from a spectral view). Assume that the eigendecomposition of the Laplacian matrix as $\begin{array} { r } { { \bf L } = \breve { \sum _ { i = 1 } ^ { n } \lambda _ { i } } { \bf u } _ { i } \mathbf { \bar { u } } _ { i } ^ { \top } } \end{array}$ , with eigenvalues $\lambda _ { i }$ and eigenvectors $\mathbf { u } _ { i }$ . Then, the heat equation (Eq. (4)) admits a closed-form solution at time $t$ , known as the heat kernel $\mathbf { H } _ { t } = e ^ { - t \mathbf { L } } =$ ${ \bar { \sum _ { i = 1 } ^ { n } } } e ^ { - \lambda _ { i } t } \mathbf { \bar { u } } _ { i } \mathbf { u } _ { i } ^ { \top }$ . As $t  \infty$ , $\mathbf { H } _ { t }$ asymptotically converges to a non-informative equilibrium as $t \to \infty$ , due to the non-trivial (i.e., positive) eigenvalues vanishing:
+
+$$
+\operatorname * { l i m } _ { t \to \infty } e ^ { - \lambda _ { i } t } = \left\{ { 0 , \quad i f \lambda _ { i } > 0 } , i = 1 , \ldots , n . \right.
+$$
+
+Remark 1. In SGC, $T = K \cdot \Delta t = K$ . Thus, according to Theorem 1, a large number of propagation steps $K  \infty$ will inevitably lead to over-smoothed non-informative features.
+
+Theorem 2 (Numerical errors). For the initial value problem in Eq. (4) with finite terminal time $T$ , the numerical error of the forward Euler method in Eq. (5) with $K$ steps can be upper bounded by
+
+$$
+\left\| \mathbf { e } _ { T } ^ { ( K ) } \right\| \leq \frac { T \| \mathbf { L } \| \| \mathbf { X } _ { 0 } \| } { 2 K } \left( e ^ { T \| \mathbf { L } \| } - 1 \right) .
+$$
+
+Remark 2. Since $T = K$ in SGC, the upper bound reduces to $c \cdot \left( e ^ { T \| \mathbf { L } \| } - 1 \right)$ ( $c$ is a constant). We can see that the numerical error will increase exponentially with more propagation steps.
+
+Theorem 3 (Learning risks). Consider a simple linear regression problem $( \mathbf { X } , \mathbf { Y } )$ on graph, where the observed input features $\mathbf { X }$ are generated by corrupting the ground truth features $\mathbf { X } _ { c }$ with the following inverse graph diffusion with time $T ^ { * }$ :
+
+$$
+\frac { d \widetilde { \mathbf { X } } _ { t } } { d t } = \mathbf { L } \widetilde { \mathbf { X } } _ { t } , \ w h e r e \ \widetilde { \mathbf { X } } _ { 0 } = \mathbf { X } _ { c } \ a n d \ \widetilde { \mathbf { X } } _ { T ^ { * } } = \mathbf { X } .
+$$
+
+Denote the population risk with ground truth features as $R ( \mathbf { W } ) = \mathbb { E } \left\| \mathbf { Y } - \mathbf { X } _ { c } \mathbf { W } \right\| ^ { 2 }$ and that of Euler method applied input $\mathbf { X }$ (Eq. (5)) as $\hat { R } ( \mathbf { W } ) = \mathbb { E } \left\| \mathbf { Y } - \left[ \mathbf { S } ^ { ( \Delta t ) } \right] ^ { K } \mathbf { X } \mathbf { W } \right\| ^ { 2 }$ . Supposing that $\mathbb { E } \| \mathbf { X } _ { c } \| ^ { 2 } = M < \infty$ , we have the following upper bound:
+
+$$
+\hat { R } ( \mathbf { W } ) < R ( \mathbf { W } ) + 2 \| \mathbf { W } \| ^ { 2 } \left( \mathbb { E } \left\| \mathbf { e } _ { \hat { T } } ^ { ( K ) } \right\| ^ { 2 } + M \left\| e ^ { T ^ { \star } \mathbf { L } } \right\| ^ { 2 } \cdot \left\| e ^ { - T ^ { \star } \mathbf { L } } - e ^ { - \hat { T } \mathbf { L } } \right\| ^ { 2 } \right) .
+$$
+
+Remark 3. Following Theorem 3, we can see that the upper bound can be minimized by finding an optimal terminal time such that $\hat { T } = T ^ { \star }$ and minimizing the numerical error $\left\| \mathbf { e } _ { \hat { T } } ^ { ( K ) } \right\|$ While SGC fixes the step size $\Delta t = 1$ , thus $T$ and $K$ are coupled together, which makes it less flexible to minimize the risk in Eq. (10).
+
+# 4 The Proposed Decoupled Graph Convolution (DGC)
+
+In this section, we introduce our proposed Decoupled Graph Convolution (DGC) and discuss how it overcomes the above limitations of SGC.
+
+# 4.1 Formulation
+
+Based on the analysis in Section 3.3, we need to resolve the coupling between propagation steps $K$ and terminal time $T$ caused by the fixed time interval $\Delta t = 1$ . Therefore, we regard the terminal time $T$ and the propagation steps $K$ as two free hyperparameters in the numerical integration via a flexible time interval. In this way, the two parameters can play different roles and cooperate together to attain better results: 1) we can flexibly choose $T$ to tradeoff between under-smoothing and oversmoothing to find a sweet spot for each dataset; and 2) given an optimal terminal time $T$ , we can also flexibly increase the propagation steps $K$ for better numerical precision with $\Delta t = T / K \to 0$ .
+
+![](images/dcea162a91211cf5fe380b029cdb87e4b193d61e193bee10e8afb9a912a6d439.jpg)  
+Figure 1: t-SNE input feature visualization and the corresponding test accuracy $( \% )$ under different terminal time $( T )$ and different number of propagation steps $( K )$ . Experiments are conducted with ours DGC-Euler model on the Cora dataset. Each point represents a node in the graph and its color denotes the class of the node.
+
+In practice, a moderate number of steps is sufficient to attain the best classification accuracy, hence we can also choose a minimal $K$ among the best for computation efficiency.
+
+Formally, we propose our Decoupled Graph Convolution (DGC) as follows:
+
+$$
+\hat { \mathbf { Y } } _ { \mathrm { D G C } } = \mathrm { s o f t m a x } \left( \hat { \mathbf { X } } _ { T } \mathbf { \Theta } \right) , \mathrm { w h e r e } \hat { \mathbf { X } } _ { T } = \mathrm { o d e } \_ { \mathrm { i n t } } ( \mathbf { X } , \Delta t , K ) .
+$$
+
+Here ode_ $\mathbf { i n t } ( \mathbf { X } , \Delta t , K )$ refers to the numerical integration of the graph heat equation that starts from $\mathbf { X }$ and runs for $K$ steps with step size $\Delta t$ . Here, we consider two numerical schemes: the forward Euler method and the Runge-Kutta (RK) method.
+
+DGC-Euler. As discussed previously, the forward Euler gives an update rule as in Eq. (5). With terminal time $T$ and step size $\Delta t = T / K$ , we can obtain $\hat { \mathbf { X } } _ { T }$ after $K$ propagation steps:
+
+$$
+\hat { \mathbf { X } } _ { T } = \left[ \mathbf { S } ^ { ( T / K ) } \right] ^ { K } \mathbf { X } , \mathrm { w h e r e } \mathbf { S } ^ { ( T / K ) } = \left( 1 - T / K \right) \cdot \mathbf { I } + \left( T / K \right) \cdot \mathbf { S } .
+$$
+
+DGC-RK. Alternatively, we can apply higher-order finite difference methods to achieve better numerical precision, at the cost of more function evaluations at intermediate points. One classical method is the 4th-order Runge-Kutta (RK) method, which proceeds with
+
+$$
+\hat { \mathbf { X } } _ { t + \Delta t } = \hat { \mathbf { X } } _ { t } + \frac { 1 } { 6 } \Delta t \left( \mathbf { R } _ { 1 } + 2 \mathbf { R } _ { 2 } + 2 \mathbf { R } _ { 3 } + \mathbf { R } _ { 4 } \right) \overset { \Delta } { = } \mathbf { S } _ { \mathrm { R K } } ^ { ( \Delta t ) } \hat { \mathbf { X } } _ { t } ,
+$$
+
+where
+
+$$
+\mathbf { R } _ { 1 } = \hat { \mathbf { X } } _ { k } , \ \mathbf { R } _ { 2 } = \hat { \mathbf { X } } _ { k } - \frac { 1 } { 2 } \Delta t \mathbf { L } \mathbf { R } _ { 1 } , \ \mathbf { R } _ { 3 } = \hat { \mathbf { X } } _ { k } - \frac { 1 } { 2 } \Delta t \mathbf { L } \mathbf { R } _ { 2 } , \ \mathbf { R } _ { 4 } = \hat { \mathbf { X } } _ { k } - \Delta t \mathbf { L } \mathbf { R } _ { 3 } .
+$$
+
+Replacing the propagation matrix $\mathbf { S } ^ { ( T / K ) }$ in DGC-Euler with the RK-matrix ${ \bf S } _ { \mathrm { R K } } ^ { ( T / K ) }$ , we can get a 4th-order model, namely DGC-RK, whose numerical error can be reduced to $O ( 1 / K ^ { 4 } )$ order.
+
+Remark. In GCN [7], a self-loop I is heuristically introduced in the adjacency matrix $\widetilde { \mathbf { A } } = \mathbf { A } + \mathbf { I }$ to prevent numerical instability with more steps $K$ . Here, we notice that the DGC-Euler diffusion matrix $\mathbf { S } ^ { ( \Delta t ) } = ( 1 - \Delta t ) \mathbf { I } + \Delta t \mathbf { S }$ naturally incorporates the self-loop I into the diffusion process as a momentum term, where $\Delta t$ flexibly tradeoffs information from the self-loop and the neighborhood. Therefore, in DGC, we can also remove the self-loop from $\widetilde { \bf A }$ and increasing $K$ is still numerically stable with fixed $T$ . We name the resulting model as DGC-sym with symmetrically normalized adjacency matrix $\mathbf { S } _ { \mathrm { s y m } } = \mathbf { D } ^ { - \frac { 1 } { 2 } } \mathbf { A } \mathbf { D } ^ { - \frac { 1 } { 2 } }$ , which aligns with the canonical normalized graph Laplacian $\mathbf { L } _ { \mathrm { s y m } } = \mathbf { D } ^ { - { \frac { 1 } { 2 } } } \left( \mathbf { D } - \mathbf { A } \right) \mathbf { D } ^ { - { \frac { 1 } { 2 } } } = \mathbf { I } - \mathbf { S } _ { \mathrm { s y m } }$ in the spectral graph theory [4]. Comparing the two Laplacians from a spectral perspective, $\dot { \bf L } = { \bf I } - { \bf S }$ has a smaller spectral range than $\mathbf { L } _ { \mathrm { s y m } }$ [21]. According to Theorem 2, $\mathbf { L }$ will have a faster convergence rate of numerical error.
+
+Table 1: A comparison of propagation rules. Here $\mathbf { X } ^ { ( k ) } \in \mathcal { X }$ represents input features after $k$ feature propagation steps and $\mathbf { X } ^ { ( 0 ) } = \bar { \mathbf { X } }$ ; $\mathbf { H } ^ { ( k ) }$ denotes the hidden features of non-linear GCNs at layer $k$ ; W denotes the weight matrix; $\sigma$ refers to a activation function; $\alpha , \beta$ are coefficients.   
+
+<table><tr><td>Method</td><td>Type</td><td>Propagation rule</td></tr><tr><td>GCN[7]</td><td>Non-linear</td><td>H(k)= σ (SH(k-1)W(k-1))</td></tr><tr><td>APPNP [8]</td><td>Non-linear</td><td>H(k)= (1-α)SH(𝑘-1) +aH(0)</td></tr><tr><td>CGNN [22]</td><td>Non-linear</td><td>H(k)= (1-α)SH(k-1)W+H(0)</td></tr><tr><td>SGC [21]</td><td>Linear</td><td>X(k)= SX(k-1))</td></tr><tr><td>DGC-Euler (ours)</td><td>Linear</td><td>X(k) =(1-T/K)·X(k-1) +(T/K)·SX(k-1)</td></tr></table>
+
+# 4.2 Verifying the Benefits of DGC
+
+Here we demonstrate the advantages of DGC both theoretically and empirically.
+
+Theoretical benefits. Revisiting Section 3.3, DGC can easily alleviate the limitations of existing linear GCNs shown in Remarks 1, 2, 3 by decoupling $T$ and $K$ .
+
+• For Theorem 1, by choosing a fixed terminal time $T$ with optimal tradeoff, increasing the propagation steps $K$ in DGC will not lead to over-smoothing as in SGC; • For Theorem 2, with $T$ is fixed, using more propagation steps ( $K  \infty$ ) in DGC will help minimize the numerical error $\left\| \mathbf { e } _ { T } ^ { ( K ) } \right\|$ with a smaller step size $\Delta t = T / K \to 0$ ; • For Theorem 3, by combining a flexibly chosen optimal terminal time $T ^ { * }$ and minimal numerical error with a large number of steps $K$ , we can get minimal learning risks.
+
+Empirical evidence. To further provide an intuitive understanding of DGC, we visualize the propagated input features of our proposed DGC-Euler on the Cora dataset in Figure 1. The first row shows that there exists an optimal terminal time $T ^ { * }$ for each dataset with the best feature separability (e.g., 5.3 for Cora). Either a smaller $T$ (under-smooth) or a larger $T$ (over-smooth) will mix the features up and make them more indistinguishable, which eventually leads to lower accuracy. From the second row, we can see that, with fixed optimal $T$ , too large step size $\Delta t$ (i.e., too small propagation steps $K$ ) will lead to feature collapse, while gradually increasing the propagation steps $K$ makes the nodes of different classes more separable and improve the overall accuracy.
+
+# 4.3 Discussions
+
+To highlight the difference of DGC to previous methods, we summarize their propagation rules in Table 1. For non-linear methods, GCN [7] uses the canonical propagation rule which has the oversmoothing issue, while APPNP [8] and CGNN [22] address it by further aggregating the initial hidden state $\bar { \mathbf { H } } ^ { ( 0 ) }$ repeatedly at each step. In particular, we emphasize that our DGC-Euler is different from APPNP in terms of the following aspects: 1) DGC-Euler is a linear model and propagates on the input features $\mathbf { X } ^ { ( k - 1 ) }$ , while APPNP is non-linear and propagates on non-linear embedding $\mathbf { H } ^ { ( k - 1 ) }$ ; 2) at each step, APPNP aggregates features from the initial step $\mathbf { H } ^ { ( 0 ) }$ , while DGC-Euler aggregates features from the last step $\bar { \mathbf { X } } ^ { ( k - 1 ) }$ ; 3) APPNP aggregates a large amount $( 1 - \alpha )$ of the propagated features $\mathbf { S H } ^ { ( k - 1 ) }$ while DGC-Euler only takes a small step $\Delta t \left( T / K \right)$ towards the new features $\mathbf { S X } ^ { ( k - 1 ) }$ . For linear methods, SGC has several fundamental limitations as analyzed in Section 3.3, while DGC addresses them by flexible and fine-grained numerical integration of the propagation process.
+
+Our dissection of linear GCNs also suggests a different understanding of the over-smoothing problem. As shown in Theorem 1, over-smoothing is an inevitable phenomenon of (canonical) GCNs, while we can find a terminal time to achieve an optimal tradeoff between under-smoothing and oversmoothing. However, we cannot expect more layers can bring more profit if the terminal time goes to infinity, that is, the benefits of more layers can only be obtained under a proper terminal time.
+
+Table 2: Test accuracy $( \% )$ of semi-supervised node classification on citation networks.   
+
+<table><tr><td>Type</td><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td rowspan="7">Non-linear</td><td>GCN[7]</td><td>81.5</td><td>70.3</td><td>79.0</td></tr><tr><td>GAT[19]</td><td>83.0 ± 0.7</td><td>72.5 ± 0.7</td><td>79.0 ± 0.3</td></tr><tr><td>GraphSAGE[5]</td><td>82.2</td><td>71.4</td><td>75.8</td></tr><tr><td>JKNet [25]</td><td>81.1</td><td>69.8</td><td>78.1</td></tr><tr><td>APPNP[8]</td><td>83.3</td><td>71.8</td><td>80.1</td></tr><tr><td>GWWN [24]</td><td>82.8</td><td>71.7</td><td>79.1</td></tr><tr><td>GraphHeat [23] CGNN [22]</td><td>83.7</td><td>72.5</td><td>80.5</td></tr><tr><td>GCDE [15]</td><td>84.2 ± 0.6 83.8 ± 0.5</td><td>71.8 ± 0.7 72.5 ± 0.5</td><td>76.8 ± 0.6 79.9 ± 0.3</td></tr><tr><td rowspan="6">Linear</td><td></td><td>45.3</td><td></td><td></td></tr><tr><td>Label Propagation [28]</td><td></td><td>68.0</td><td>63.0</td></tr><tr><td>DeepWalk [14] SGC [21]</td><td>70.7 ± 0.6</td><td>51.4 ± 0.5</td><td>76.8 ± 0.6</td></tr><tr><td>SGC-PairNorm [27]</td><td>81.0 ± 0.0</td><td>71.9 ± 0.1</td><td>78.9 ± 0.0</td></tr><tr><td>SIGN-linear [17]</td><td>81.1</td><td>70.6</td><td>78.2</td></tr><tr><td>DGC (ours)</td><td>81.7 83.3 ± 0.0</td><td>72.4 73.3 ± 0.1</td><td>78.6 80.3 ± 0.1</td></tr></table>
+
+# 5 Experiments
+
+In this section, we conduct a comprehensive analysis on DGC and compare it against both linear and non-linear GCN variants on a collection of benchmark datasets.
+
+# 5.1 Performance on Semi-supervised Node Classification
+
+Setup. For semi-supervised node classification, we use three standard citation networks, Cora, Citeseer, and Pubmed [18] and adopt the standard data split as in [7, 19, 24, 23, 15]. Here, we compare our DGC against several representative non-linear and linear methods that also adopts the standard data split. For non-linear GCNs, we include 1) classical baselines like GCN [7], GAT [20], GraphSAGE [5], APPNP [8] and JKNet [25]; 2) spectral methods using graph heat kernel [24, 23]; and 3) continuous GCNs [15, 22]. For linear methods, we present the results of Label Propagation [28], DeepWalk [14], SGC (linear GCN) [21] as well as its regularized version SGC-PairNorm [27]. We also consider a linear version of SIGN [17], SIGN-linear, which extends SGC by aggregating features from multiple propagation stages $( K = 1 , 2 , \dots )$ ). For DGC, we adopt the Euler scheme, i.e., DGC-Euler (Eq. (12)) by default for simplicity. We report results averaged over 10 random runs. Data statistics and training details are in Appendix A.
+
+We compare DGC against both linear and non-linear baselines for the semi-supervised node classification task, and the results are shown in Table 2.
+
+DGC v.s. linear methods. We can see that DGC shows significant improvement over previous linear methods across three datasets. In particular, compared to SGC (previous SOTA methods), DGC obtains $8 3 . 3 ~ \nu . s . ~ 8 1 . 0$ on Cora, $7 3 . 3 ~ \nu . s . ~ 7 1 . 9$ on Citeseer and $8 0 . 3 ~ \nu . s . ~ 7 8 . 9$ on Pubmed. This shows that in real-world datasets, a flexible and fine-grained integration by decoupling $T$ and $K$ indeed helps improve the classification accuracy of SGC by a large margin. Besides, DGC also outperforms the multiscale SGC, SIGN-linear, suggesting that multiscale techniques cannot fully solve the limitations of SGC, while DGC can overcome these limitations by decoupling $T$ and $K$ . As discussed in Appendix C, DGC still shows clear advantages over SIGN when controlling the terminal time $T$ while being more computationally efficient, which indicates that the advantage of DGC is not only a real-valued $T$ , but also the improved numerical precision by adopting a large $K$ .
+
+DGC v.s. non-linear models. Table 2 further shows that DGC, as a linear model, even outperforms many non-linear GCNs on semi-supervised tasks. First, DGC improves over classical GCNs like GCN [7], GAT [19] and GraphSAGE [5] by a large margin. Also, DGC is comparable to, and sometimes outperforms, many modern non-linear GCNs. For example, DGC shows a clear advantage over multiscale methods like JKNet [25] and APPNP [8]. DGC is also comparable to spectral methods based on graph heat kernel, e.g., GWWN [24], GraphHeat [23], while being much more efficient as a simple linear model. Besides, compared to non-linear continuous models like GCDE [15] and CGNN [22], DGC also achieves comparable accuracy only using a simple linear dynamic.
+
+Table 3: Test accuracy $( \% )$ of fully-supervised node classification on citation networks.   
+
+<table><tr><td>Type</td><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td rowspan="6">Non-linear</td><td>GCN[7]</td><td>85.8</td><td>73.6</td><td>88.1</td></tr><tr><td>GAT[19]</td><td>86.4</td><td>74.3</td><td>87.6</td></tr><tr><td>JK-MaxPool [25]</td><td>89.6</td><td>77.7</td><td>-</td></tr><tr><td>JK-Concat [25]</td><td>89.1</td><td>78.3</td><td>-</td></tr><tr><td>JK-LSTM [25]</td><td>85.8</td><td>74.7</td><td>-</td></tr><tr><td>APPNP [8]</td><td>90.2</td><td>79.8</td><td>86.3</td></tr><tr><td rowspan="2">Linear</td><td>SGC [21]</td><td>85.8</td><td>78.1</td><td>83.3</td></tr><tr><td>DGC (ours)</td><td>88.2 ± 0.0</td><td>78.7 ± 0.0</td><td>89.4 ± 0.0</td></tr></table>
+
+# 5.2 Performance on Fully-supervised Node Classification
+
+Setup. For fully-supervised node classification, we also use the three citation networks, Cora, Citeseer and Pubmed, but instead randomly split the nodes in three citation networks into $60 \%$ , $20 \%$ and $20 \%$ for training, validation and testing, following the previous practice in [25]. Here, we include the baselines that also have reported results in the fully supervised setting, such as GCN [7], GAT [19] (reported baselines in [25]), and the three variants of JK-Net: JK-MaxPool, JK-Concat and JK-LSTM [25]. Besides, we also reproduce the result of APPNP [8] for a fair comparison. Dataset statistics and training details are described in Appendix.
+
+Results. The results of the fully-supervised semi-classification task are basically consistent with the semi-supervised setting. As a linear method, DGC not only improves the state-of-the-art linear GCNs by a large margin, but also outperforms GCN [7], GAT [19] significantly. Besides, DGC is also comparable to multiscale methods like JKNet [25] and APPNP [8], showing that a good linear model like DGC is also competitive for fully-supervised tasks.
+
+# 5.3 Performance on Large Scale Datasets
+
+Setup. More rigorously, we also conduct the comparison on a large-scale node classification dataset, the Reddit networks [5]. Following SGC [21], we adopt the inductive setting, where we use the subgraph of training nodes as training data and use the whole graph for the validation/testing data. For a fair comparison, we use the same training configurations as SGC [21] and include its reported baselines, such as GCN [7], FastGCN [2], three variants of GraphSAGE [5], and RandDGI (DGI with randomly initialized encoder) [20]. We also include APPNP [8] for a comprehensive comparison.
+
+Results. We can see DGC still achieves the best accuracy among linear methods and improve $0 . 9 \%$ accuracy over SGC. Meanwhile, it is superior to the three variants of GraphSAGE as well as APPNP. Thus, DGC is still the stateof-the-art linear GCNs and competitive against nonlinear GCNs on large scale datasets.
+
+Table 4: Test accuracy $( \% )$ comparison with inductive methods on on a large scale dataset, Reddit. Reported results are averaged over 10 runs. OOM: out of memory.   
+
+<table><tr><td>Type</td><td>Method</td><td>Acc.</td></tr><tr><td rowspan="3">Non-linear</td><td>GCN [7] FastGCN [2]</td><td rowspan="3">OOM 93.7 93.0 95.0</td></tr><tr><td>GraphSAGE-GCN [5]</td></tr><tr><td>GraphSAGE-mean [5] GraphSAGE-LSTM[5] 95.4 APPNP [8] 95.0</td></tr><tr><td rowspan="3">Linear</td><td>RandDGI [20]</td><td>93.3</td></tr><tr><td>SGC [21]</td><td>94.9</td></tr><tr><td>DGC (ours)</td><td>95.8</td></tr></table>
+
+![](images/8e6b4022ff6ee964a4672c740728b335aae0a31c351dcb95c81a4f356beb1990.jpg)  
+Figure 2: Left: test accuracy $( \% )$ with increasing feature propagation steps on Cora. Middle: comparison of robustness under different noise scales $\sigma$ on three citation networks. Right: a comparison of relative total training time for 100 epochs on the Pubmed dataset.
+
+Table 5: Comparison of explicit computation time of different training stages on the Pubmed dataset with a single NVIDIA GeForce RTX 3090 GPU.   
+
+<table><tr><td>Type</td><td>Method</td><td>Preprocessing Time</td><td>Training Time</td><td>Total Time</td></tr><tr><td rowspan="3">Linear</td><td>SGC(K = 2) [21]</td><td>3.8 ms</td><td>61.5 ms</td><td>65.3 ms</td></tr><tr><td>DGC(K: （= 2) (ours)</td><td>3.8 ms</td><td>61.5 ms</td><td>65.3 ms</td></tr><tr><td>DGC (K = 100) (ours)</td><td>169.2 ms</td><td>55.8 ms</td><td>225.0 ms</td></tr><tr><td>Nonlinear</td><td>GCN [7]</td><td>0</td><td>17.0 s</td><td>17.0 s</td></tr></table>
+
+# 5.4 Empirical Understandings of DGC
+
+Setup. Here we further provide a comprehensive analysis of DGC. First, we compare its oversmoothing behavior and computation time against previous methods. Then we analyze several factors that affect the performance of DGC, including the Laplacian matrix L, the numerical schemes and the terminal time $T$ . Experiments are conducted on the semi-supervised learning tasks, and we adopt DGC-Euler with the default hyperparameters unless specified.
+
+Non-over-smoothing with increasing steps. In the left plot of Figure 2, we compare different GCNs with increasing model depth (non-linear GCNs) or propagation steps (linear GCNs) from 2 to 1000. Baselines include SGC [21], GCN [7], and our DGC with three different terminal time $T$ (1, 5.3, 10). First, we notice that SGC and GCN fail catastrophically when increasing the depth, which is consistent with the previously observed over-smoothing phenomenon. Instead, all three DGC variants can benefit from increased steps. Nevertheless, the final performance will degrade if the terminal time is either too small $T = 1$ , under-smoothing) or too large $T = 1 0$ , over-smoothing). DGC enables us to flexibly find the optimal terminal time $T = 5 . 3 $ ). Thus, we can obtain the optimal accuracy with an optimal tradeoff between under-smoothing and over-smoothing.
+
+Robustness to feature noise. In real-world applications, there are plenty of noise in the collected node attributes, thus it is crucial for GCNs to be robust to input noise [1]. Therefore, we compare the robustness of SGC and DGC against Gaussian noise added to the input features, where $\sigma$ stands for the standard deviation of the noise. Figure 2 (middle) shows that DGC is significantly more robust than SGC across three citation networks, and the advantage is clearer on larger noise scales. As discussed in Theorem 3, the diffusion process in DGC can be seen as a denoising procedure, and consequently, DGC’s robustness to feature noise can be contributed to the optimal tradeoff between over-smoothing and under-smoothing with a flexible choice of $T$ and $K$ . In comparison, SGC is not as good as DGC because it cannot find such a sweet spot accurately.
+
+Computation time. In practice, linear GCNs can accelerate training by pre-processing features with all propagation steps and storing them for the later model training. Since pre-processing costs much fewer time than training ${ < } 5 \%$ in SGC), linear GCNs could be much faster than non-linear ones. As shown in Figure 2 (right), DGC is slightly slower $( 3 \times )$ than SGC, but DGC achieves much higher accuracy. Even so, DGC is still much faster than non-linear GCNs $( > 1 0 0 \times )$ . Indeed, as further shown in Table 5, the computation overhead of DGC over SGC mainly lies in the preprocessing stage, which is very small in SGC and only leads to around twice longer total time. Instead, GCN is much slower as it involves propagation in each training loop, leading to much slower training.
+
+![](images/07f389d3c622e0511e16e2e8c8b8ab7b26d420476972eca681cb5e06d256cb19.jpg)  
+Figure 3: Algorithmic analysis of our proposed DGC. Left: test accuracy $( \% )$ of two kinds of Laplacian, ${ \bf L } = { \bf I } - { \bf S }$ (with self-loop) and ${ \bf L } _ { \mathrm { s y m } } = { \bf I } - { \bf S } _ { \mathrm { s y m } }$ (without self-loop), with increasing steps $K$ and fixed time $T$ on Cora. Middle: test accuracy $( \% )$ of two numerical schemes, Euler and Runge-Kutta, with increasing steps $K$ and fixed $T$ under fixed terminal time on Cora. Right: test accuracy $( \% )$ with varying terminal time $T$ and fixed steps $K$ on Cora.
+
+Graph Laplacian. As shown in Figure 3 (left), in DGC, both the two Laplacians, $\mathbf { L }$ (with self-loop) and $\mathbf { L } _ { \mathrm { s y m } }$ (without self-loop), can consistently benefit from more propagation steps without leading to numerical issues. Further comparing the two Laplacians, we can see that the augmented Laplacian $\mathbf { L }$ obtains higher test accuracy than the canonical Laplacian $\mathbf { L } _ { \mathrm { s y m } }$ and requires fewer propagation steps $K$ to obtain good results, which could also be understood from our analysis in Section 3.3.
+
+Numerical scheme. By comparing different numerical schemes in Figure 3 (middle), we find that the Runge-Kutta method demonstrates better accuracy than the Euler method with a small $K$ . Nevertheless, as $K$ increases, the difference gradually vanishes. Thus, the Euler method is sufficient for DGC to achieve good performance, and it is more desirable in terms of its simplicity and efficiency.
+
+Terminal time $T$ . In Figure 3 (right), we compare the test accuracy with different terminal time $T$ . We show that indeed, in real-world datasets, there exists a sweet spot that achieves the optimal tradeoff between under-smoothing and over-smoothing. In Table 6, we list the best terminal time that we find on two large graph datasets, Pubmed and Reddit. We can see that $T$ is almost consistent across different Laplacians on each dataset, which suggests that the optimal terminal time $T ^ { * }$ is an intrinsic property of the dataset.
+
+Table 6: Optimal terminal time $T ^ { * }$ on the transductive task, Pubmed, and the inductive task, Reddit, with different Laplacians.   
+
+<table><tr><td>Dataset</td><td>Laplacian</td><td>T*</td><td>Acc</td></tr><tr><td rowspan="2">Pubmed</td><td>I-S</td><td>6.0</td><td>80.3</td></tr><tr><td>I-Ssym</td><td>6.0</td><td>79.8</td></tr><tr><td rowspan="2">Reddit</td><td>I-S</td><td>2.7</td><td>95.5</td></tr><tr><td>I-Ssym</td><td>2.6</td><td>95.8</td></tr></table>
+
+# 6 Conclusions
+
+In this paper, we have proposed Decoupled Graph Convolution (DGC), which improves significantly over previous linear GCNs through decoupling the terminal time and feature propagation steps from a continuous perspective. Experiments show that our DGC is competitive with many modern variants of non-linear GCNs while being much more computationally efficient with much fewer parameters to learn.
+
+Our findings suggest that, unfortunately, current GCN variants still have not shown significant advantages over a properly designed linear GCN. We believe that this would attract the attention of the community to reconsider the actual representation ability of current nonlinear GCNs and propose new alternatives that can truly benefit from nonlinear architectures.
+
+# Acknowledgement
+
+Yisen Wang is partially supported by the National Natural Science Foundation of China under Grant 62006153, and Project 2020BD006 supported by PKU-Baidu Fund. Jiansheng Yang is supported by the National Science Foundation of China under Grant No. 11961141007. Zhouchen Lin was supported by the NSF China (No.s 61625301 and 61731018), NSFC Tianyuan Fund for Mathematics (No. 12026606) and Project 2020BD006 supported by PKU-Baidu Fund.
+
+References   
+[1] Aleksandar Bojchevski and Stephan Günnemann. Certifiable robustness to graph perturbations. NeurIPS, 2019. 9   
+[2] Jie Chen, Tengfei Ma, and Cao Xiao. FastGCN: fast learning with graph convolutional networks via importance sampling. ICLR, 2018. 8   
+[3] Ricky TQ Chen, Yulia Rubanova, Jesse Bettencourt, and David K Duvenaud. Neural ordinary differential equations. NeurIPS, 2018. 2   
+[4] Fan RK Chung and Fan Chung Graham. Spectral graph theory. American Mathematical Society, 1997. 3, 5   
+[5] Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. NeurIPS, 2017. 2, 7, 8   
+[6] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2016. 2   
+[7] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2017. 1, 2, 5, 6, 7, 8, 9   
+[8] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. ICLR, 2019. 2, 6, 7, 8   
+[9] Guohao Li, Matthias Muller, Ali Thabet, and Bernard Ghanem. DeepGCNs: Can gcns go as deep as cnns? CVPR, 2019. 2   
+[10] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. AAAI, 2018. 1, 2, 3   
+[11] Yiping Lu, Aoxiao Zhong, Quanzheng Li, and Bin Dong. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. ICML, 2018. 2   
+[12] Georgi S Medvedev. Stochastic stability of continuous time consensus protocols. SIAM Journal on Control and Optimization, 50(4):1859–1885, 2012. 3   
+[13] Georgi S Medvedev. The nonlinear heat equation on dense graphs and graph limits. SIAM Journal on Mathematical Analysis, 46(4):2743–2766, 2014. 3   
+[14] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. DeepWalk: Online learning of social representations. SIGKDD, 2014. 7   
+[15] Michael Poli, Stefano Massaroli, Junyoung Park, Atsushi Yamashita, Hajime Asama, and Jinkyoo Park. Graph neural ordinary differential equations. arXiv preprint arXiv:1911.07532, 2019. 2, 7, 8   
+[16] Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. DropEdge: Towards deep graph convolutional networks on node classification. ICLR, 2019. 2   
+[17] Emanuele Rossi, Fabrizio Frasca, Ben Chamberlain, Davide Eynard, Michael Bronstein, and Federico Monti. SIGN: Scalable inception graph neural networks. arXiv preprint arXiv:2004.11198, 2020. 7   
+[18] 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. 7   
+[19] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and ´ Yoshua Bengio. Graph attention networks. ICLR, 2018. 2, 7, 8   
+[20] Petar Velickovic, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. Deep graph infomax. ICLR, 2019. 7, 8   
+[21] Felix Wu, Tianyi Zhang, Amauri Holanda de Souza Jr, Christopher Fifty, Tao Yu, and Kilian Q Weinberger. Simplifying graph convolutional networks. ICML, 2019. 1, 2, 5, 6, 7, 8, 9   
+[22] Louis-Pascal Xhonneux, Meng Qu, and Jian Tang. Continuous graph neural networks. ICML, 2020. 2, 6, 7, 8   
+[23] Bingbing Xu, Huawei Shen, Qi Cao, Keting Cen, and Xueqi Cheng. Graph convolutional networks using heat kernel for semi-supervised learning. arXiv preprint arXiv:2007.16002, 2020. 7   
+[24] Bingbing Xu, Huawei Shen, Qi Cao, Yunqi Qiu, and Xueqi Cheng. Graph wavelet neural network. ICLR, 2019. 7   
+[25] Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. ICML, 2018. 2, 7, 8   
+[26] Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. ICML, 2016. 2   
+[27] Lingxiao Zhao and Leman Akoglu. PairNorm: Tackling oversmoothing in gnns. ICLR, 2020. 2, 7   
+[28] Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. ICML, 2003. 7

parse/train/N51zJ7F3mw/N51zJ7F3mw_content_list.json

@@ -0,0 +1,1334 @@
+[
+    {
+        "type": "text",
+        "text": "Dissecting the Diffusion Process in Linear Graph Convolutional Networks ",
+        "text_level": 1,
+        "bbox": [
+            263,
+            122,
+            733,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yifei Wang1 Yisen Wang2,3∗ Jiansheng Yang1 Zhouchen Lin2,3,4 1 School of Mathematical Sciences, Peking University, Beijing, China 2 Key Lab. of Machine Perception, School of Artificial Intelligence, Peking University, Beijing, China 3 Institute for Artificial Intelligence, Peking University, Beijing, China 4 Pazhou Lab, Guangzhou, China yifei_wang@pku.edu.cn, yisen.wang@pku.edu.cn yjs@math.pku.edu.cn, zlin@pku.edu.cn ",
+        "bbox": [
+            183,
+            224,
+            854,
+            325
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            361,
+            535,
+            377
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Convolutional Networks (GCNs) have attracted more and more attentions in recent years. A typical GCN layer consists of a linear feature propagation step and a nonlinear transformation step. Recent works show that a linear GCN can achieve comparable performance to the original non-linear GCN while being much more computationally efficient. In this paper, we dissect the feature propagation steps of linear GCNs from a perspective of continuous graph diffusion, and analyze why linear GCNs fail to benefit from more propagation steps. Following that, we propose Decoupled Graph Convolution (DGC) that decouples the terminal time and the feature propagation steps, making it more flexible and capable of exploiting a very large number of feature propagation steps. Experiments demonstrate that our proposed DGC improves linear GCNs by a large margin and makes them competitive with many modern variants of non-linear GCNs. Code is available at https://github.com/yifeiwang77/DGC. ",
+        "bbox": [
+            233,
+            395,
+            764,
+            574
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            310,
+            621
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, Graph Convolutional Networks (GCNs) have successfully extended the powerful representation learning ability of modern Convolutional Neural Networks (CNNs) to the graph data [7]. A graph convolutional layer typically consists of two stages: linear feature propagation and nonlinear feature transformation. Simple Graph Convolution (SGC) [21] simplifies GCNs by removing the nonlinearities between GCN layers and collapsing the resulting function into a single linear transformation, which is followed by a single linear classification layer and then becomes a linear GCN. SGC can achieve comparable performance to canonical GCNs while being much more computationally efficient and using significantly fewer parameters. Thus, we mainly focus on linear GCNs in this paper. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            761
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although being comparable to canonical GCNs, SGC still suffers from a similar issue as non-linear GCNs, that is, more (linear) feature propagation steps $K$ will degrade the performance catastrophically. This issue is widely characterized as the “over-smoothing” phenomenon. Namely, node features become smoothed out and indistinguishable after too many feature propagation steps [10]. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            823
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, through a dissection of the diffusion process of linear GCNs, we characterize a fundamental limitation of SGC. Specifically, we point out that its feature propagation step amounts to a very coarse finite difference with a fixed step size $\\Delta t = 1$ , which results in a large numerical error. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            871
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "And because the step size is fixed, more feature propagation steps will inevitably lead to a large terminal time $T = K \\cdot \\Delta t \\to \\infty$ that over-smooths the node features. ",
+        "bbox": [
+            173,
+            92,
+            821,
+            119
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address these issues, we propose Decoupled Graph Convolution (DGC) by decoupling the terminal time $T$ and propagation steps $K$ . In particular, we can flexibly choose a continuous terminal time $T$ for the optimal tradeoff between under-smoothing and over-smoothing, and then fix the terminal time while adopting more propagation steps $K$ . In this way, different from SGC that over-smooths with more propagation steps, our proposed DGC can obtain a more fine-grained finite difference approximation with more propagation steps, which contributes to the final performance both theoretically and empirically. Extensive experiments show that DGC (as a linear GCN) improves over SGC significantly and obtains state-of-the-art results that are comparable to many modern non-linear GCNs. Our main contributions are summarized as follows: ",
+        "bbox": [
+            174,
+            125,
+            825,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We investigate SGC by dissecting its diffusion process from a continuous perspective, and characterize why it cannot benefit from more propagation steps. • We propose Decoupled Graph Convolution (DGC) that decouples the terminal time $T$ and the propagation steps $K$ , which enables us to choose a continuous terminal time flexibly while benefiting from more propagation steps from both theoretical and empirical aspects. • Experiments show that DGC outperforms canonical GCNs significantly and obtains stateof-the-art (SOTA) results among linear GCNs, which is even comparable to many competitive non-linear GCNs. We think DGC can serve as a strong baseline for the future research. ",
+        "bbox": [
+            217,
+            260,
+            825,
+            378
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            396,
+            321,
+            414
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph convolutional networks (GCNs). To deal with non-Euclidean graph data, GCNs are proposed for direct convolution operation over graph, and have drawn interests from various domains. GCN is firstly introduced for a spectral perspective [26, 7], but soon it becomes popular as a general message passing algorithm in the spatial domain. Many variants have been proposed to improve its performance, such as GraphSAGE [5] with LSTM and GAT with attention mechanism [19]. ",
+        "bbox": [
+            173,
+            426,
+            823,
+            496
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Over-smoothing issue. GCNs face a fundamental problem compared to standard CNNs, i.e., the over-smoothing problem. Li et al. [10] offer a theoretical characterization of over-smoothing based on linear feature propagation. After that, many researchers have tried to incorporate effective mechanisms in CNNs to alleviate over-smoothing. DeepGCNs [9] shows that residual connection and dilated convolution can make GCNs go as deep as CNNs, although increased depth does not contribute much. Methods like APPNP [8] and JKNet [25] avoid over-smoothing by aggregating multiscale information from the first hidden layer. DropEdge [16] applies dropout to graph edges and find it enables training GCNs with more layers. PairNorm [27] regularizes the feature distance to be close to the input distance, which will not fail catastrophically but still decrease with more layers. ",
+        "bbox": [
+            174,
+            502,
+            823,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Continuous GCNs. Deep CNNs have been widely interpreted from a continuous perspective, e.g., ResNet [6] as the Euler discretization of Neural ODEs [11, 3]. This viewpoint has recently been borrowed to understand and improve GCNs. GCDE [15] directly extends GCNs to a Neural ODE, while CGNN [22] devises a GCN variant inspired by a new continuous diffusion. Our method is also inspired by the connection between discrete and continuous graph diffusion, but alternatively, we focus on their numerical gap and characterize how it affects the final performance. ",
+        "bbox": [
+            174,
+            633,
+            823,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Linear GCNs. SGC [21] simplifies and separates the two stages of GCNs: feature propagation and (non-linear) feature transformation. It finds that utilizing only a simple logistic regression after feature propagation (removing the non-linearities), which makes it a linear GCN, can obtain comparable performance to canonical GCNs. In this paper, we further show that a properly designed linear GCN (DGC) can be on-par with state-of-the-art non-linear GCNs while possessing many desirable properties. For example, as a linear model, DGC requires much fewer parameters than non-linear GCNs, which makes it very memory efficient, and meanwhile, its training is also much faster $( \\sim 1 0 0 \\times )$ than non-linear models as it could preprocess all features before training. ",
+        "bbox": [
+            173,
+            723,
+            825,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 Dissecting Linear GCNs from Continuous Dynamics ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            852,
+            642,
+            871
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we make a brief review of SGC [21] in the context of semi-supervised node classifi cation task, and further point out its fundamental limitations. ",
+        "bbox": [
+            173,
+            882,
+            818,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3.1 Review of Simple Graph Convolution (SGC) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            521,
+            107
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Define a graph as $\\mathcal { G } = ( \\gamma , \\mathbf { A } )$ , where $\\mathcal { V } = \\{ v _ { 1 } , \\ldots , v _ { n } \\}$ denotes the vertex set of $n$ nodes, and $\\mathbf { A } \\in \\mathbb { R } ^ { n \\times n }$ is an adjacency matrix where $a _ { i j }$ denotes the edge weight between node $v _ { i }$ and $v _ { j }$ . The degree matrix $\\mathbf { D } = \\mathrm { d i a g } ( d _ { 1 } , \\ldots , d _ { n } )$ of $\\mathbf { A }$ is a diagonal matrix with its $i$ -th diagonal entry as $\\begin{array} { r } { d _ { i } = \\sum _ { j } a _ { i j } } \\end{array}$ . Each node $v _ { i }$ is represented by a $d$ -dimensional feature vector $\\mathbf { x } _ { i } \\in \\mathbb { R } ^ { d }$ , and we denote the feature matrix as $\\mathbf { X } \\in \\mathbb { R } ^ { n \\times d } = [ \\mathbf { x } _ { 1 } , \\ldots , \\mathbf { x } _ { n } ]$ . Each node belongs to one out of $C$ classes, denoted by a one-hot vector $\\mathbf { y } _ { i } \\in \\{ 0 , 1 \\} ^ { C }$ . In node classification problems, only a subset of nodes $\\nu _ { l } \\subset \\nu$ is labeled and we want to predict the labels of the rest nodes $\\mathcal { V } _ { u } = \\mathcal { V } \\backslash \\mathcal { V } _ { l }$ . ",
+        "bbox": [
+            173,
+            114,
+            826,
+            219
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "SGC shows that we can obtain similar performance with a simplified GCN, ",
+        "bbox": [
+            176,
+            224,
+            668,
+            239
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6bdf233fbca18f324ba44eb790d22c590ff50b3dfbba902c3249a70f3c418ec3.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { \\mathbf { Y } } _ { \\mathrm { S G C } } = \\operatorname { s o f t m a x } \\left( \\mathbf { S } ^ { K } \\mathbf { X } \\mathbf { \\Theta } \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            241,
+            598,
+            261
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "which pre-processes the node features $\\mathbf { X }$ with $K$ linear propagation steps, and then applies a linear classifier with parameter $\\Theta$ . Specifically, at the step $k$ , each feature $\\mathbf { x } _ { i }$ is computed by aggregating features in its local neighborhood, which can be done in parallel over the whole graph for $K$ steps, ",
+        "bbox": [
+            173,
+            261,
+            825,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8f62c1503c4d99d12f7ebfe02d4b5f0fb19e6f99d853f85f9e6e5d9101be59c2.jpg",
+        "text": "$$\n\\mathbf { X } ^ { ( k ) } \\longleftarrow \\mathbf { S } \\mathbf { X } ^ { ( k - 1 ) } , \\mathrm { ~ w h e r e ~ } \\mathbf { S } = \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } \\widetilde { \\mathbf { A } } \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } \\quad \\Longrightarrow \\quad \\mathbf { X } ^ { ( K ) } = \\mathbf { S } ^ { K } \\mathbf { X } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            304,
+            728,
+            323
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here $\\widetilde { \\mathbf { A } } = \\mathbf { A } + \\mathbf { I }$ is the adjacency matrix augmented with the self-loop I, $\\widetilde { \\bf D }$ is the degree matrix of $\\widetilde { \\bf A }$ , and S denotes the symmetrically normalized adjacency matrix. This step exploits the local graph structure to smooth out the noise in each node. ",
+        "bbox": [
+            173,
+            327,
+            826,
+            372
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At last, SGC applies a multinomial logistic regression (a.k.a. softmax regression) with parameter $\\Theta$ to predict the node labels $\\hat { \\mathbf { Y } } _ { \\mathrm { S G C } }$ from the node features of the last propagation step $\\mathbf { X } ^ { ( K ) }$ : ",
+        "bbox": [
+            171,
+            377,
+            821,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4820426fdab7f8968805cff7c91d3578b7c2c0183cb66ec7cba45c55122b9d11.jpg",
+        "text": "$$\n\\hat { \\mathbf { Y } } _ { \\mathrm { S G C } } = \\mathrm { s o f t m a x } \\left( \\mathbf { X } ^ { ( K ) } \\Theta \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            410,
+            601,
+            436
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Because both the feature propagation $( \\mathbf { S } ^ { K } \\mathbf { X } )$ and classification $( \\mathbf { X } ^ { ( K ) } \\mathbf { \\Theta } _ { \\mathbf { \\Theta } } ^ { } )$ steps are linear, SGC is essentially a linear version of GCN that only relies on linear features from the input. ",
+        "bbox": [
+            173,
+            439,
+            825,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 Equivalence between SGC and Graph Heat Equation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            482,
+            583,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Previous analysis of linear GCNs focuses on their asymptotic behavior as propagation steps $K  \\infty$ (discrete), known as the over-smoothing phenomenon [10]. In this work, we instead provide a novel non-asymptotic characterization of linear GCNs from the corresponding continuous dynamics, graph heat equation [4]. A key insight is that we notice that the propagation of SGC can be seen equivalently as a (coarse) numerical discretization of the graph diffusion equation, as we show below. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            579
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph Heat Equation (GHE) is a well-known generalization of the heat equation on graph data, which is widely used to model graph dynamics with applications in spectral graph theory [4], time series [12], combinational problems [13], etc. In general, GHE can be formulated as follows: ",
+        "bbox": [
+            173,
+            584,
+            825,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2e190f1b1e66dc6dcfb5713b50d2f0827d6e2aba535cce3644bb9bb09c6c56e.jpg",
+        "text": "$$\n\\left\\{ \\begin{array} { l l } { \\frac { d \\mathbf { X } _ { t } } { d t } } & { = - \\mathbf { L } \\mathbf { X } _ { t } , } \\\\ { \\mathbf { X } _ { 0 } } & { = \\mathbf { X } , } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            627,
+            560,
+            664
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { X } _ { t }$ ( $t \\geq 0 \\}$ ) refers to the evolved input features at time $t$ , and $\\mathbf { L }$ refers to the graph Laplacian matrix. Here, for the brevity of analysis, we take the symmetrically normalized graph Laplacian for the augmented adjacency $\\widetilde { \\bf A }$ and overload the notation as $\\mathbf { L } = \\widetilde { \\mathbf { D } } ^ { - \\frac { 1 } { 2 } } \\left( \\widetilde { \\mathbf { D } } - \\widetilde { \\mathbf { A } } \\right) \\bar { \\widetilde { \\mathbf { D } } } ^ { - \\frac { 1 } { 2 } } = \\bar { \\mathbf { I } } - \\mathbf { S }$ . ",
+        "bbox": [
+            174,
+            665,
+            825,
+            717
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As GHE is a continuous dynamics, in practice we need to rely on numerical methods to solve it. We find that SGC can be seen as a coarse finite difference of GHE. Specifically, we apply the forward Euler method to Eq. (4) with an interval $\\Delta t$ : ",
+        "bbox": [
+            174,
+            723,
+            825,
+            765
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6be59653799d0533fa6f66f81a24ef1efdab8c663e918d7d306702af0a02b903.jpg",
+        "text": "$$\n\\hat { \\mathbf { X } } _ { t + \\Delta t } = \\hat { \\mathbf { X } } _ { t } - \\Delta t \\mathbf { L } \\hat { \\mathbf { X } } _ { t } = \\hat { \\mathbf { X } } _ { t } - \\Delta t ( \\mathbf { I } - \\mathbf { S } ) \\hat { \\mathbf { X } } _ { t } = \\left[ ( 1 - \\Delta t ) \\mathbf { I } + \\Delta t \\mathbf { S } \\right] \\hat { \\mathbf { X } } _ { t } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            766,
+            732,
+            786
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By involving the update rule for $K$ forward steps, we will get the final features $\\hat { \\mathbf { X } } _ { T }$ at the terminal time $T = K \\cdot \\Delta t$ : ",
+        "bbox": [
+            178,
+            790,
+            821,
+            818
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d8fc6eefabbdf7fd72dd6d4b91638ebc819693397ea03d29a1b4678267e4874.jpg",
+        "text": "$$\n\\begin{array} { r } { \\hat { \\mathbf { X } } _ { T } = [ \\mathbf { S } ^ { ( \\Delta t ) } ] ^ { K } \\mathbf { X } , \\mathrm { w h e r e } \\mathbf { S } ^ { ( \\Delta t ) } = ( 1 - \\Delta t ) \\mathbf { I } + \\Delta t \\mathbf { S } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            818,
+            678,
+            837
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Comparing to Eq. (2), we can see that the Euler discretization of GHE becomes SGC when the step size $\\Delta t = 1$ . Specifically, the diffusion matrix $\\mathbf { S } ^ { ( \\Delta t ) }$ reduces to the SGC diffusion matrix S and the final node features, $\\hat { \\mathbf { X } } _ { T }$ and $\\mathbf { X } ^ { ( K ) }$ , become equivalent. Therefore, SGC with $K$ propagation steps is essentially a finite difference approximation to GHE with $K$ forward steps (step size $\\Delta t = 1$ and terminal time $T = K$ ). ",
+        "bbox": [
+            173,
+            838,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.3 Revealing the Fundamental Limitations of SGC ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            545,
+            107
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on the above analysis, we theoretically characterize several fundamental limitations of SGC: feature over-smoothing, large numerical errors and large learning risks. Proofs are in Appendix B. ",
+        "bbox": [
+            173,
+            116,
+            823,
+            145
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Oversmoothing from a spectral view). Assume that the eigendecomposition of the Laplacian matrix as $\\begin{array} { r } { { \\bf L } = \\breve { \\sum _ { i = 1 } ^ { n } \\lambda _ { i } } { \\bf u } _ { i } \\mathbf { \\bar { u } } _ { i } ^ { \\top } } \\end{array}$ , with eigenvalues $\\lambda _ { i }$ and eigenvectors $\\mathbf { u } _ { i }$ . Then, the heat equation (Eq. (4)) admits a closed-form solution at time $t$ , known as the heat kernel $\\mathbf { H } _ { t } = e ^ { - t \\mathbf { L } } =$ ${ \\bar { \\sum _ { i = 1 } ^ { n } } } e ^ { - \\lambda _ { i } t } \\mathbf { \\bar { u } } _ { i } \\mathbf { u } _ { i } ^ { \\top }$ . As $t  \\infty$ , $\\mathbf { H } _ { t }$ asymptotically converges to a non-informative equilibrium as $t \\to \\infty$ , due to the non-trivial (i.e., positive) eigenvalues vanishing: ",
+        "bbox": [
+            173,
+            148,
+            825,
+            220
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93018ac091abe15ea72f3a1e0ceb56245efc608827f5744974881f8c5e119f9d.jpg",
+        "text": "$$\n\\operatorname * { l i m } _ { t \\to \\infty } e ^ { - \\lambda _ { i } t } = \\left\\{ { 0 , \\quad i f \\lambda _ { i } > 0 } , i = 1 , \\ldots , n . \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            227,
+            650,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Remark 1. In SGC, $T = K \\cdot \\Delta t = K$ . Thus, according to Theorem 1, a large number of propagation steps $K  \\infty$ will inevitably lead to over-smoothed non-informative features. ",
+        "bbox": [
+            171,
+            276,
+            823,
+            306
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (Numerical errors). For the initial value problem in Eq. (4) with finite terminal time $T$ , the numerical error of the forward Euler method in Eq. (5) with $K$ steps can be upper bounded by ",
+        "bbox": [
+            173,
+            309,
+            821,
+            339
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ccb4180a38c07e6c0cd43ae2c04dd6e10ffeebf816f2fc130c76799290e5c8c9.jpg",
+        "text": "$$\n\\left\\| \\mathbf { e } _ { T } ^ { ( K ) } \\right\\| \\leq \\frac { T \\| \\mathbf { L } \\| \\| \\mathbf { X } _ { 0 } \\| } { 2 K } \\left( e ^ { T \\| \\mathbf { L } \\| } - 1 \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            344,
+            627,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Remark 2. Since $T = K$ in SGC, the upper bound reduces to $c \\cdot \\left( e ^ { T \\| \\mathbf { L } \\| } - 1 \\right)$ ( $c$ is a constant). We can see that the numerical error will increase exponentially with more propagation steps. ",
+        "bbox": [
+            169,
+            392,
+            825,
+            422
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Learning risks). Consider a simple linear regression problem $( \\mathbf { X } , \\mathbf { Y } )$ on graph, where the observed input features $\\mathbf { X }$ are generated by corrupting the ground truth features $\\mathbf { X } _ { c }$ with the following inverse graph diffusion with time $T ^ { * }$ : ",
+        "bbox": [
+            173,
+            426,
+            823,
+            468
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2d45a38c44e804d709c5e4bc68746a61fd7cc52fc40b993000144561024e584b.jpg",
+        "text": "$$\n\\frac { d \\widetilde { \\mathbf { X } } _ { t } } { d t } = \\mathbf { L } \\widetilde { \\mathbf { X } } _ { t } , \\ w h e r e \\ \\widetilde { \\mathbf { X } } _ { 0 } = \\mathbf { X } _ { c } \\ a n d \\ \\widetilde { \\mathbf { X } } _ { T ^ { * } } = \\mathbf { X } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            474,
+            661,
+            508
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Denote the population risk with ground truth features as $R ( \\mathbf { W } ) = \\mathbb { E } \\left\\| \\mathbf { Y } - \\mathbf { X } _ { c } \\mathbf { W } \\right\\| ^ { 2 }$ and that of Euler method applied input $\\mathbf { X }$ (Eq. (5)) as $\\hat { R } ( \\mathbf { W } ) = \\mathbb { E } \\left\\| \\mathbf { Y } - \\left[ \\mathbf { S } ^ { ( \\Delta t ) } \\right] ^ { K } \\mathbf { X } \\mathbf { W } \\right\\| ^ { 2 }$ . Supposing that $\\mathbb { E } \\| \\mathbf { X } _ { c } \\| ^ { 2 } = M < \\infty$ , we have the following upper bound: ",
+        "bbox": [
+            173,
+            515,
+            826,
+            574
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c7c31da738ea6d1b802b457da3d787912d2c9a02f564cb3dd64aad7e46a1f726.jpg",
+        "text": "$$\n\\hat { R } ( \\mathbf { W } ) < R ( \\mathbf { W } ) + 2 \\| \\mathbf { W } \\| ^ { 2 } \\left( \\mathbb { E } \\left\\| \\mathbf { e } _ { \\hat { T } } ^ { ( K ) } \\right\\| ^ { 2 } + M \\left\\| e ^ { T ^ { \\star } \\mathbf { L } } \\right\\| ^ { 2 } \\cdot \\left\\| e ^ { - T ^ { \\star } \\mathbf { L } } - e ^ { - \\hat { T } \\mathbf { L } } \\right\\| ^ { 2 } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            579,
+            763,
+            614
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Remark 3. Following Theorem 3, we can see that the upper bound can be minimized by finding an optimal terminal time such that $\\hat { T } = T ^ { \\star }$ and minimizing the numerical error $\\left\\| \\mathbf { e } _ { \\hat { T } } ^ { ( K ) } \\right\\|$ While SGC fixes the step size $\\Delta t = 1$ , thus $T$ and $K$ are coupled together, which makes it less flexible to minimize the risk in Eq. (10). ",
+        "bbox": [
+            173,
+            628,
+            825,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 The Proposed Decoupled Graph Convolution (DGC) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            712,
+            642,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce our proposed Decoupled Graph Convolution (DGC) and discuss how it overcomes the above limitations of SGC. ",
+        "bbox": [
+            171,
+            744,
+            825,
+            772
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            300,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Based on the analysis in Section 3.3, we need to resolve the coupling between propagation steps $K$ and terminal time $T$ caused by the fixed time interval $\\Delta t = 1$ . Therefore, we regard the terminal time $T$ and the propagation steps $K$ as two free hyperparameters in the numerical integration via a flexible time interval. In this way, the two parameters can play different roles and cooperate together to attain better results: 1) we can flexibly choose $T$ to tradeoff between under-smoothing and oversmoothing to find a sweet spot for each dataset; and 2) given an optimal terminal time $T$ , we can also flexibly increase the propagation steps $K$ for better numerical precision with $\\Delta t = T / K \\to 0$ . ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/dcea162a91211cf5fe380b029cdb87e4b193d61e193bee10e8afb9a912a6d439.jpg",
+        "image_caption": [
+            "Figure 1: t-SNE input feature visualization and the corresponding test accuracy $( \\% )$ under different terminal time $( T )$ and different number of propagation steps $( K )$ . Experiments are conducted with ours DGC-Euler model on the Cora dataset. Each point represents a node in the graph and its color denotes the class of the node. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            88,
+            820,
+            267
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice, a moderate number of steps is sufficient to attain the best classification accuracy, hence we can also choose a minimal $K$ among the best for computation efficiency. ",
+        "bbox": [
+            173,
+            358,
+            823,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Formally, we propose our Decoupled Graph Convolution (DGC) as follows: ",
+        "bbox": [
+            176,
+            392,
+            671,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9facec1c34f3015ac97dff2f0034e4d6337b6f63d3f3e3ebb7700475173ff1ab.jpg",
+        "text": "$$\n\\hat { \\mathbf { Y } } _ { \\mathrm { D G C } } = \\mathrm { s o f t m a x } \\left( \\hat { \\mathbf { X } } _ { T } \\mathbf { \\Theta } \\right) , \\mathrm { w h e r e } \\hat { \\mathbf { X } } _ { T } = \\mathrm { o d e } \\_ { \\mathrm { i n t } } ( \\mathbf { X } , \\Delta t , K ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            414,
+            710,
+            441
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here ode_ $\\mathbf { i n t } ( \\mathbf { X } , \\Delta t , K )$ refers to the numerical integration of the graph heat equation that starts from $\\mathbf { X }$ and runs for $K$ steps with step size $\\Delta t$ . Here, we consider two numerical schemes: the forward Euler method and the Runge-Kutta (RK) method. ",
+        "bbox": [
+            173,
+            449,
+            826,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "DGC-Euler. As discussed previously, the forward Euler gives an update rule as in Eq. (5). With terminal time $T$ and step size $\\Delta t = T / K$ , we can obtain $\\hat { \\mathbf { X } } _ { T }$ after $K$ propagation steps: ",
+        "bbox": [
+            171,
+            497,
+            825,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2cec7731ec2517c61988ee84215cf67ade9d462e58d529c4585573757cb581b7.jpg",
+        "text": "$$\n\\hat { \\mathbf { X } } _ { T } = \\left[ \\mathbf { S } ^ { ( T / K ) } \\right] ^ { K } \\mathbf { X } , \\mathrm { w h e r e } \\mathbf { S } ^ { ( T / K ) } = \\left( 1 - T / K \\right) \\cdot \\mathbf { I } + \\left( T / K \\right) \\cdot \\mathbf { S } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            535,
+            727,
+            565
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "DGC-RK. Alternatively, we can apply higher-order finite difference methods to achieve better numerical precision, at the cost of more function evaluations at intermediate points. One classical method is the 4th-order Runge-Kutta (RK) method, which proceeds with ",
+        "bbox": [
+            173,
+            578,
+            825,
+            622
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8eeafdd8f8d2a09f2509a795bd6e7727171de1387f2183e701aeab3d74129a6f.jpg",
+        "text": "$$\n\\hat { \\mathbf { X } } _ { t + \\Delta t } = \\hat { \\mathbf { X } } _ { t } + \\frac { 1 } { 6 } \\Delta t \\left( \\mathbf { R } _ { 1 } + 2 \\mathbf { R } _ { 2 } + 2 \\mathbf { R } _ { 3 } + \\mathbf { R } _ { 4 } \\right) \\overset { \\Delta } { = } \\mathbf { S } _ { \\mathrm { R K } } ^ { ( \\Delta t ) } \\hat { \\mathbf { X } } _ { t } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            627,
+            699,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where ",
+        "bbox": [
+            174,
+            665,
+            217,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a3b2b0e07f71fc126fba0f82c4925f1a3af9bdd2f30bb61c4b3353290bcb235c.jpg",
+        "text": "$$\n\\mathbf { R } _ { 1 } = \\hat { \\mathbf { X } } _ { k } , \\ \\mathbf { R } _ { 2 } = \\hat { \\mathbf { X } } _ { k } - \\frac { 1 } { 2 } \\Delta t \\mathbf { L } \\mathbf { R } _ { 1 } , \\ \\mathbf { R } _ { 3 } = \\hat { \\mathbf { X } } _ { k } - \\frac { 1 } { 2 } \\Delta t \\mathbf { L } \\mathbf { R } _ { 2 } , \\ \\mathbf { R } _ { 4 } = \\hat { \\mathbf { X } } _ { k } - \\Delta t \\mathbf { L } \\mathbf { R } _ { 3 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            212,
+            683,
+            758,
+            714
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Replacing the propagation matrix $\\mathbf { S } ^ { ( T / K ) }$ in DGC-Euler with the RK-matrix ${ \\bf S } _ { \\mathrm { R K } } ^ { ( T / K ) }$ , we can get a 4th-order model, namely DGC-RK, whose numerical error can be reduced to $O ( 1 / K ^ { 4 } )$ order. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            755
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark. In GCN [7], a self-loop I is heuristically introduced in the adjacency matrix $\\widetilde { \\mathbf { A } } = \\mathbf { A } + \\mathbf { I }$ to prevent numerical instability with more steps $K$ . Here, we notice that the DGC-Euler diffusion matrix $\\mathbf { S } ^ { ( \\Delta t ) } = ( 1 - \\Delta t ) \\mathbf { I } + \\Delta t \\mathbf { S }$ naturally incorporates the self-loop I into the diffusion process as a momentum term, where $\\Delta t$ flexibly tradeoffs information from the self-loop and the neighborhood. Therefore, in DGC, we can also remove the self-loop from $\\widetilde { \\bf A }$ and increasing $K$ is still numerically stable with fixed $T$ . We name the resulting model as DGC-sym with symmetrically normalized adjacency matrix $\\mathbf { S } _ { \\mathrm { s y m } } = \\mathbf { D } ^ { - \\frac { 1 } { 2 } } \\mathbf { A } \\mathbf { D } ^ { - \\frac { 1 } { 2 } }$ , which aligns with the canonical normalized graph Laplacian $\\mathbf { L } _ { \\mathrm { s y m } } = \\mathbf { D } ^ { - { \\frac { 1 } { 2 } } } \\left( \\mathbf { D } - \\mathbf { A } \\right) \\mathbf { D } ^ { - { \\frac { 1 } { 2 } } } = \\mathbf { I } - \\mathbf { S } _ { \\mathrm { s y m } }$ in the spectral graph theory [4]. Comparing the two Laplacians from a spectral perspective, $\\dot { \\bf L } = { \\bf I } - { \\bf S }$ has a smaller spectral range than $\\mathbf { L } _ { \\mathrm { s y m } }$ [21]. According to Theorem 2, $\\mathbf { L }$ will have a faster convergence rate of numerical error. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/12f8fd40307e52b8cfc32faff3564a6db0e1e5fe48bf9b7617d32b9fc38d697a.jpg",
+        "table_caption": [
+            "Table 1: A comparison of propagation rules. Here $\\mathbf { X } ^ { ( k ) } \\in \\mathcal { X }$ represents input features after $k$ feature propagation steps and $\\mathbf { X } ^ { ( 0 ) } = \\bar { \\mathbf { X } }$ ; $\\mathbf { H } ^ { ( k ) }$ denotes the hidden features of non-linear GCNs at layer $k$ ; W denotes the weight matrix; $\\sigma$ refers to a activation function; $\\alpha , \\beta$ are coefficients. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Type</td><td>Propagation rule</td></tr><tr><td>GCN[7]</td><td>Non-linear</td><td>H(k)= σ (SH(k-1)W(k-1))</td></tr><tr><td>APPNP [8]</td><td>Non-linear</td><td>H(k)= (1-α)SH(𝑘-1) +aH(0)</td></tr><tr><td>CGNN [22]</td><td>Non-linear</td><td>H(k)= (1-α)SH(k-1)W+H(0)</td></tr><tr><td>SGC [21]</td><td>Linear</td><td>X(k)= SX(k-1))</td></tr><tr><td>DGC-Euler (ours)</td><td>Linear</td><td>X(k) =(1-T/K)·X(k-1) +(T/K)·SX(k-1)</td></tr></table>",
+        "bbox": [
+            191,
+            142,
+            789,
+            256
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Verifying the Benefits of DGC ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            284,
+            421,
+            300
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we demonstrate the advantages of DGC both theoretically and empirically. ",
+        "bbox": [
+            174,
+            311,
+            699,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Theoretical benefits. Revisiting Section 3.3, DGC can easily alleviate the limitations of existing linear GCNs shown in Remarks 1, 2, 3 by decoupling $T$ and $K$ . ",
+        "bbox": [
+            173,
+            333,
+            818,
+            362
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• For Theorem 1, by choosing a fixed terminal time $T$ with optimal tradeoff, increasing the propagation steps $K$ in DGC will not lead to over-smoothing as in SGC; • For Theorem 2, with $T$ is fixed, using more propagation steps ( $K  \\infty$ ) in DGC will help minimize the numerical error $\\left\\| \\mathbf { e } _ { T } ^ { ( K ) } \\right\\|$ with a smaller step size $\\Delta t = T / K \\to 0$ ; • For Theorem 3, by combining a flexibly chosen optimal terminal time $T ^ { * }$ and minimal numerical error with a large number of steps $K$ , we can get minimal learning risks. ",
+        "bbox": [
+            215,
+            375,
+            828,
+            488
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Empirical evidence. To further provide an intuitive understanding of DGC, we visualize the propagated input features of our proposed DGC-Euler on the Cora dataset in Figure 1. The first row shows that there exists an optimal terminal time $T ^ { * }$ for each dataset with the best feature separability (e.g., 5.3 for Cora). Either a smaller $T$ (under-smooth) or a larger $T$ (over-smooth) will mix the features up and make them more indistinguishable, which eventually leads to lower accuracy. From the second row, we can see that, with fixed optimal $T$ , too large step size $\\Delta t$ (i.e., too small propagation steps $K$ ) will lead to feature collapse, while gradually increasing the propagation steps $K$ makes the nodes of different classes more separable and improve the overall accuracy. ",
+        "bbox": [
+            173,
+            500,
+            825,
+            612
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Discussions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            632,
+            292,
+            647
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To highlight the difference of DGC to previous methods, we summarize their propagation rules in Table 1. For non-linear methods, GCN [7] uses the canonical propagation rule which has the oversmoothing issue, while APPNP [8] and CGNN [22] address it by further aggregating the initial hidden state $\\bar { \\mathbf { H } } ^ { ( 0 ) }$ repeatedly at each step. In particular, we emphasize that our DGC-Euler is different from APPNP in terms of the following aspects: 1) DGC-Euler is a linear model and propagates on the input features $\\mathbf { X } ^ { ( k - 1 ) }$ , while APPNP is non-linear and propagates on non-linear embedding $\\mathbf { H } ^ { ( k - 1 ) }$ ; 2) at each step, APPNP aggregates features from the initial step $\\mathbf { H } ^ { ( 0 ) }$ , while DGC-Euler aggregates features from the last step $\\bar { \\mathbf { X } } ^ { ( k - 1 ) }$ ; 3) APPNP aggregates a large amount $( 1 - \\alpha )$ of the propagated features $\\mathbf { S H } ^ { ( k - 1 ) }$ while DGC-Euler only takes a small step $\\Delta t \\left( T / K \\right)$ towards the new features $\\mathbf { S X } ^ { ( k - 1 ) }$ . For linear methods, SGC has several fundamental limitations as analyzed in Section 3.3, while DGC addresses them by flexible and fine-grained numerical integration of the propagation process. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our dissection of linear GCNs also suggests a different understanding of the over-smoothing problem. As shown in Theorem 1, over-smoothing is an inevitable phenomenon of (canonical) GCNs, while we can find a terminal time to achieve an optimal tradeoff between under-smoothing and oversmoothing. However, we cannot expect more layers can bring more profit if the terminal time goes to infinity, that is, the benefits of more layers can only be obtained under a proper terminal time. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ee95156a4faa5f61aea9758cf35b146bbfe74ed3e435ae35a319c0d0fbd6385c.jpg",
+        "table_caption": [
+            "Table 2: Test accuracy $( \\% )$ of semi-supervised node classification on citation networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Type</td><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td rowspan=\"7\">Non-linear</td><td>GCN[7]</td><td>81.5</td><td>70.3</td><td>79.0</td></tr><tr><td>GAT[19]</td><td>83.0 ± 0.7</td><td>72.5 ± 0.7</td><td>79.0 ± 0.3</td></tr><tr><td>GraphSAGE[5]</td><td>82.2</td><td>71.4</td><td>75.8</td></tr><tr><td>JKNet [25]</td><td>81.1</td><td>69.8</td><td>78.1</td></tr><tr><td>APPNP[8]</td><td>83.3</td><td>71.8</td><td>80.1</td></tr><tr><td>GWWN [24]</td><td>82.8</td><td>71.7</td><td>79.1</td></tr><tr><td>GraphHeat [23] CGNN [22]</td><td>83.7</td><td>72.5</td><td>80.5</td></tr><tr><td>GCDE [15]</td><td>84.2 ± 0.6 83.8 ± 0.5</td><td>71.8 ± 0.7 72.5 ± 0.5</td><td>76.8 ± 0.6 79.9 ± 0.3</td></tr><tr><td rowspan=\"6\">Linear</td><td></td><td>45.3</td><td></td><td></td></tr><tr><td>Label Propagation [28]</td><td></td><td>68.0</td><td>63.0</td></tr><tr><td>DeepWalk [14] SGC [21]</td><td>70.7 ± 0.6</td><td>51.4 ± 0.5</td><td>76.8 ± 0.6</td></tr><tr><td>SGC-PairNorm [27]</td><td>81.0 ± 0.0</td><td>71.9 ± 0.1</td><td>78.9 ± 0.0</td></tr><tr><td>SIGN-linear [17]</td><td>81.1</td><td>70.6</td><td>78.2</td></tr><tr><td>DGC (ours)</td><td>81.7 83.3 ± 0.0</td><td>72.4 73.3 ± 0.1</td><td>78.6 80.3 ± 0.1</td></tr></table>",
+        "bbox": [
+            230,
+            113,
+            764,
+            361
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            386,
+            312,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct a comprehensive analysis on DGC and compare it against both linear and non-linear GCN variants on a collection of benchmark datasets. ",
+        "bbox": [
+            174,
+            419,
+            823,
+            446
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Performance on Semi-supervised Node Classification ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            463,
+            578,
+            479
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Setup. For semi-supervised node classification, we use three standard citation networks, Cora, Citeseer, and Pubmed [18] and adopt the standard data split as in [7, 19, 24, 23, 15]. Here, we compare our DGC against several representative non-linear and linear methods that also adopts the standard data split. For non-linear GCNs, we include 1) classical baselines like GCN [7], GAT [20], GraphSAGE [5], APPNP [8] and JKNet [25]; 2) spectral methods using graph heat kernel [24, 23]; and 3) continuous GCNs [15, 22]. For linear methods, we present the results of Label Propagation [28], DeepWalk [14], SGC (linear GCN) [21] as well as its regularized version SGC-PairNorm [27]. We also consider a linear version of SIGN [17], SIGN-linear, which extends SGC by aggregating features from multiple propagation stages $( K = 1 , 2 , \\dots )$ ). For DGC, we adopt the Euler scheme, i.e., DGC-Euler (Eq. (12)) by default for simplicity. We report results averaged over 10 random runs. Data statistics and training details are in Appendix A. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare DGC against both linear and non-linear baselines for the semi-supervised node classification task, and the results are shown in Table 2. ",
+        "bbox": [
+            174,
+            648,
+            821,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DGC v.s. linear methods. We can see that DGC shows significant improvement over previous linear methods across three datasets. In particular, compared to SGC (previous SOTA methods), DGC obtains $8 3 . 3 ~ \\nu . s . ~ 8 1 . 0$ on Cora, $7 3 . 3 ~ \\nu . s . ~ 7 1 . 9$ on Citeseer and $8 0 . 3 ~ \\nu . s . ~ 7 8 . 9$ on Pubmed. This shows that in real-world datasets, a flexible and fine-grained integration by decoupling $T$ and $K$ indeed helps improve the classification accuracy of SGC by a large margin. Besides, DGC also outperforms the multiscale SGC, SIGN-linear, suggesting that multiscale techniques cannot fully solve the limitations of SGC, while DGC can overcome these limitations by decoupling $T$ and $K$ . As discussed in Appendix C, DGC still shows clear advantages over SIGN when controlling the terminal time $T$ while being more computationally efficient, which indicates that the advantage of DGC is not only a real-valued $T$ , but also the improved numerical precision by adopting a large $K$ . ",
+        "bbox": [
+            174,
+            683,
+            825,
+            821
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DGC v.s. non-linear models. Table 2 further shows that DGC, as a linear model, even outperforms many non-linear GCNs on semi-supervised tasks. First, DGC improves over classical GCNs like GCN [7], GAT [19] and GraphSAGE [5] by a large margin. Also, DGC is comparable to, and sometimes outperforms, many modern non-linear GCNs. For example, DGC shows a clear advantage over multiscale methods like JKNet [25] and APPNP [8]. DGC is also comparable to spectral methods based on graph heat kernel, e.g., GWWN [24], GraphHeat [23], while being much more efficient as a simple linear model. Besides, compared to non-linear continuous models like GCDE [15] and CGNN [22], DGC also achieves comparable accuracy only using a simple linear dynamic. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/67b10e0393425a415cc84dc9eac7f1689568c4e304bc9b95b56826f370e51e1d.jpg",
+        "table_caption": [
+            "Table 3: Test accuracy $( \\% )$ of fully-supervised node classification on citation networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Type</td><td>Method</td><td>Cora</td><td>Citeseer</td><td>Pubmed</td></tr><tr><td rowspan=\"6\">Non-linear</td><td>GCN[7]</td><td>85.8</td><td>73.6</td><td>88.1</td></tr><tr><td>GAT[19]</td><td>86.4</td><td>74.3</td><td>87.6</td></tr><tr><td>JK-MaxPool [25]</td><td>89.6</td><td>77.7</td><td>-</td></tr><tr><td>JK-Concat [25]</td><td>89.1</td><td>78.3</td><td>-</td></tr><tr><td>JK-LSTM [25]</td><td>85.8</td><td>74.7</td><td>-</td></tr><tr><td>APPNP [8]</td><td>90.2</td><td>79.8</td><td>86.3</td></tr><tr><td rowspan=\"2\">Linear</td><td>SGC [21]</td><td>85.8</td><td>78.1</td><td>83.3</td></tr><tr><td>DGC (ours)</td><td>88.2 ± 0.0</td><td>78.7 ± 0.0</td><td>89.4 ± 0.0</td></tr></table>",
+        "bbox": [
+            248,
+            113,
+            745,
+            265
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            303,
+            823,
+            332
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Performance on Fully-supervised Node Classification ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            362,
+            581,
+            377
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Setup. For fully-supervised node classification, we also use the three citation networks, Cora, Citeseer and Pubmed, but instead randomly split the nodes in three citation networks into $60 \\%$ , $20 \\%$ and $20 \\%$ for training, validation and testing, following the previous practice in [25]. Here, we include the baselines that also have reported results in the fully supervised setting, such as GCN [7], GAT [19] (reported baselines in [25]), and the three variants of JK-Net: JK-MaxPool, JK-Concat and JK-LSTM [25]. Besides, we also reproduce the result of APPNP [8] for a fair comparison. Dataset statistics and training details are described in Appendix. ",
+        "bbox": [
+            173,
+            393,
+            825,
+            491
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. The results of the fully-supervised semi-classification task are basically consistent with the semi-supervised setting. As a linear method, DGC not only improves the state-of-the-art linear GCNs by a large margin, but also outperforms GCN [7], GAT [19] significantly. Besides, DGC is also comparable to multiscale methods like JKNet [25] and APPNP [8], showing that a good linear model like DGC is also competitive for fully-supervised tasks. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            566
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Performance on Large Scale Datasets ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            472,
+            612
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Setup. More rigorously, we also conduct the comparison on a large-scale node classification dataset, the Reddit networks [5]. Following SGC [21], we adopt the inductive setting, where we use the subgraph of training nodes as training data and use the whole graph for the validation/testing data. For a fair comparison, we use the same training configurations as SGC [21] and include its reported baselines, such as GCN [7], FastGCN [2], three variants of GraphSAGE [5], and RandDGI (DGI with randomly initialized encoder) [20]. We also include APPNP [8] for a comprehensive comparison. ",
+        "bbox": [
+            174,
+            628,
+            483,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results. We can see DGC still achieves the best accuracy among linear methods and improve $0 . 9 \\%$ accuracy over SGC. Meanwhile, it is superior to the three variants of GraphSAGE as well as APPNP. Thus, DGC is still the stateof-the-art linear GCNs and competitive against nonlinear GCNs on large scale datasets. ",
+        "bbox": [
+            174,
+            814,
+            485,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/69c91a91e03cb6871a16018206c2f333529ef34f4ee9763e6e6416d1d965d9cd.jpg",
+        "table_caption": [
+            "Table 4: Test accuracy $( \\% )$ comparison with inductive methods on on a large scale dataset, Reddit. Reported results are averaged over 10 runs. OOM: out of memory. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Type</td><td>Method</td><td>Acc.</td></tr><tr><td rowspan=\"3\">Non-linear</td><td>GCN [7] FastGCN [2]</td><td rowspan=\"3\">OOM 93.7 93.0 95.0</td></tr><tr><td>GraphSAGE-GCN [5]</td></tr><tr><td>GraphSAGE-mean [5] GraphSAGE-LSTM[5] 95.4 APPNP [8] 95.0</td></tr><tr><td rowspan=\"3\">Linear</td><td>RandDGI [20]</td><td>93.3</td></tr><tr><td>SGC [21]</td><td>94.9</td></tr><tr><td>DGC (ours)</td><td>95.8</td></tr></table>",
+        "bbox": [
+            498,
+            710,
+            823,
+            877
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8e6b4022ff6ee964a4672c740728b335aae0a31c351dcb95c81a4f356beb1990.jpg",
+        "image_caption": [
+            "Figure 2: Left: test accuracy $( \\% )$ with increasing feature propagation steps on Cora. Middle: comparison of robustness under different noise scales $\\sigma$ on three citation networks. Right: a comparison of relative total training time for 100 epochs on the Pubmed dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            87,
+            823,
+            217
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/9291dabcac3666534d09b6636d437f491629e918752bf3810fce3ece64d4d734.jpg",
+        "table_caption": [
+            "Table 5: Comparison of explicit computation time of different training stages on the Pubmed dataset with a single NVIDIA GeForce RTX 3090 GPU. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Type</td><td>Method</td><td>Preprocessing Time</td><td>Training Time</td><td>Total Time</td></tr><tr><td rowspan=\"3\">Linear</td><td>SGC(K = 2) [21]</td><td>3.8 ms</td><td>61.5 ms</td><td>65.3 ms</td></tr><tr><td>DGC(K: （= 2) (ours)</td><td>3.8 ms</td><td>61.5 ms</td><td>65.3 ms</td></tr><tr><td>DGC (K = 100) (ours)</td><td>169.2 ms</td><td>55.8 ms</td><td>225.0 ms</td></tr><tr><td>Nonlinear</td><td>GCN [7]</td><td>0</td><td>17.0 s</td><td>17.0 s</td></tr></table>",
+        "bbox": [
+            187,
+            319,
+            805,
+            410
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.4 Empirical Understandings of DGC ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            436,
+            455,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Setup. Here we further provide a comprehensive analysis of DGC. First, we compare its oversmoothing behavior and computation time against previous methods. Then we analyze several factors that affect the performance of DGC, including the Laplacian matrix L, the numerical schemes and the terminal time $T$ . Experiments are conducted on the semi-supervised learning tasks, and we adopt DGC-Euler with the default hyperparameters unless specified. ",
+        "bbox": [
+            174,
+            462,
+            823,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Non-over-smoothing with increasing steps. In the left plot of Figure 2, we compare different GCNs with increasing model depth (non-linear GCNs) or propagation steps (linear GCNs) from 2 to 1000. Baselines include SGC [21], GCN [7], and our DGC with three different terminal time $T$ (1, 5.3, 10). First, we notice that SGC and GCN fail catastrophically when increasing the depth, which is consistent with the previously observed over-smoothing phenomenon. Instead, all three DGC variants can benefit from increased steps. Nevertheless, the final performance will degrade if the terminal time is either too small $T = 1$ , under-smoothing) or too large $T = 1 0$ , over-smoothing). DGC enables us to flexibly find the optimal terminal time $T = 5 . 3 $ ). Thus, we can obtain the optimal accuracy with an optimal tradeoff between under-smoothing and over-smoothing. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            664
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Robustness to feature noise. In real-world applications, there are plenty of noise in the collected node attributes, thus it is crucial for GCNs to be robust to input noise [1]. Therefore, we compare the robustness of SGC and DGC against Gaussian noise added to the input features, where $\\sigma$ stands for the standard deviation of the noise. Figure 2 (middle) shows that DGC is significantly more robust than SGC across three citation networks, and the advantage is clearer on larger noise scales. As discussed in Theorem 3, the diffusion process in DGC can be seen as a denoising procedure, and consequently, DGC’s robustness to feature noise can be contributed to the optimal tradeoff between over-smoothing and under-smoothing with a flexible choice of $T$ and $K$ . In comparison, SGC is not as good as DGC because it cannot find such a sweet spot accurately. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            794
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Computation time. In practice, linear GCNs can accelerate training by pre-processing features with all propagation steps and storing them for the later model training. Since pre-processing costs much fewer time than training ${ < } 5 \\%$ in SGC), linear GCNs could be much faster than non-linear ones. As shown in Figure 2 (right), DGC is slightly slower $( 3 \\times )$ than SGC, but DGC achieves much higher accuracy. Even so, DGC is still much faster than non-linear GCNs $( > 1 0 0 \\times )$ . Indeed, as further shown in Table 5, the computation overhead of DGC over SGC mainly lies in the preprocessing stage, which is very small in SGC and only leads to around twice longer total time. Instead, GCN is much slower as it involves propagation in each training loop, leading to much slower training. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/07f389d3c622e0511e16e2e8c8b8ab7b26d420476972eca681cb5e06d256cb19.jpg",
+        "image_caption": [
+            "Figure 3: Algorithmic analysis of our proposed DGC. Left: test accuracy $( \\% )$ of two kinds of Laplacian, ${ \\bf L } = { \\bf I } - { \\bf S }$ (with self-loop) and ${ \\bf L } _ { \\mathrm { s y m } } = { \\bf I } - { \\bf S } _ { \\mathrm { s y m } }$ (without self-loop), with increasing steps $K$ and fixed time $T$ on Cora. Middle: test accuracy $( \\% )$ of two numerical schemes, Euler and Runge-Kutta, with increasing steps $K$ and fixed $T$ under fixed terminal time on Cora. Right: test accuracy $( \\% )$ with varying terminal time $T$ and fixed steps $K$ on Cora. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            825,
+            215
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Graph Laplacian. As shown in Figure 3 (left), in DGC, both the two Laplacians, $\\mathbf { L }$ (with self-loop) and $\\mathbf { L } _ { \\mathrm { s y m } }$ (without self-loop), can consistently benefit from more propagation steps without leading to numerical issues. Further comparing the two Laplacians, we can see that the augmented Laplacian $\\mathbf { L }$ obtains higher test accuracy than the canonical Laplacian $\\mathbf { L } _ { \\mathrm { s y m } }$ and requires fewer propagation steps $K$ to obtain good results, which could also be understood from our analysis in Section 3.3. ",
+        "bbox": [
+            174,
+            305,
+            825,
+            375
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Numerical scheme. By comparing different numerical schemes in Figure 3 (middle), we find that the Runge-Kutta method demonstrates better accuracy than the Euler method with a small $K$ . Nevertheless, as $K$ increases, the difference gradually vanishes. Thus, the Euler method is sufficient for DGC to achieve good performance, and it is more desirable in terms of its simplicity and efficiency. ",
+        "bbox": [
+            174,
+            381,
+            825,
+            438
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Terminal time $T$ . In Figure 3 (right), we compare the test accuracy with different terminal time $T$ . We show that indeed, in real-world datasets, there exists a sweet spot that achieves the optimal tradeoff between under-smoothing and over-smoothing. In Table 6, we list the best terminal time that we find on two large graph datasets, Pubmed and Reddit. We can see that $T$ is almost consistent across different Laplacians on each dataset, which suggests that the optimal terminal time $T ^ { * }$ is an intrinsic property of the dataset. ",
+        "bbox": [
+            174,
+            443,
+            483,
+            608
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/90fbc315630b0a05478c0d3430123c8015d9d51ddb49da09d8c50720e46eb5df.jpg",
+        "table_caption": [
+            "Table 6: Optimal terminal time $T ^ { * }$ on the transductive task, Pubmed, and the inductive task, Reddit, with different Laplacians. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Laplacian</td><td>T*</td><td>Acc</td></tr><tr><td rowspan=\"2\">Pubmed</td><td>I-S</td><td>6.0</td><td>80.3</td></tr><tr><td>I-Ssym</td><td>6.0</td><td>79.8</td></tr><tr><td rowspan=\"2\">Reddit</td><td>I-S</td><td>2.7</td><td>95.5</td></tr><tr><td>I-Ssym</td><td>2.6</td><td>95.8</td></tr></table>",
+        "bbox": [
+            532,
+            510,
+            782,
+            602
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            628,
+            305,
+            645
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have proposed Decoupled Graph Convolution (DGC), which improves significantly over previous linear GCNs through decoupling the terminal time and feature propagation steps from a continuous perspective. Experiments show that our DGC is competitive with many modern variants of non-linear GCNs while being much more computationally efficient with much fewer parameters to learn. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            729
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our findings suggest that, unfortunately, current GCN variants still have not shown significant advantages over a properly designed linear GCN. We believe that this would attract the attention of the community to reconsider the actual representation ability of current nonlinear GCNs and propose new alternatives that can truly benefit from nonlinear architectures. ",
+        "bbox": [
+            174,
+            736,
+            823,
+            791
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            330,
+            828
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yisen Wang is partially supported by the National Natural Science Foundation of China under Grant 62006153, and Project 2020BD006 supported by PKU-Baidu Fund. Jiansheng Yang is supported by the National Science Foundation of China under Grant No. 11961141007. Zhouchen Lin was supported by the NSF China (No.s 61625301 and 61731018), NSFC Tianyuan Fund for Mathematics (No. 12026606) and Project 2020BD006 supported by PKU-Baidu Fund. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] Aleksandar Bojchevski and Stephan Günnemann. Certifiable robustness to graph perturbations. NeurIPS, 2019. 9   \n[2] Jie Chen, Tengfei Ma, and Cao Xiao. FastGCN: fast learning with graph convolutional networks via importance sampling. ICLR, 2018. 8   \n[3] Ricky TQ Chen, Yulia Rubanova, Jesse Bettencourt, and David K Duvenaud. Neural ordinary differential equations. NeurIPS, 2018. 2   \n[4] Fan RK Chung and Fan Chung Graham. Spectral graph theory. American Mathematical Society, 1997. 3, 5   \n[5] Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. NeurIPS, 2017. 2, 7, 8   \n[6] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2016. 2   \n[7] Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2017. 1, 2, 5, 6, 7, 8, 9   \n[8] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. ICLR, 2019. 2, 6, 7, 8   \n[9] Guohao Li, Matthias Muller, Ali Thabet, and Bernard Ghanem. DeepGCNs: Can gcns go as deep as cnns? CVPR, 2019. 2   \n[10] Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. AAAI, 2018. 1, 2, 3   \n[11] Yiping Lu, Aoxiao Zhong, Quanzheng Li, and Bin Dong. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. ICML, 2018. 2   \n[12] Georgi S Medvedev. Stochastic stability of continuous time consensus protocols. SIAM Journal on Control and Optimization, 50(4):1859–1885, 2012. 3   \n[13] Georgi S Medvedev. The nonlinear heat equation on dense graphs and graph limits. SIAM Journal on Mathematical Analysis, 46(4):2743–2766, 2014. 3   \n[14] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. DeepWalk: Online learning of social representations. SIGKDD, 2014. 7   \n[15] Michael Poli, Stefano Massaroli, Junyoung Park, Atsushi Yamashita, Hajime Asama, and Jinkyoo Park. Graph neural ordinary differential equations. arXiv preprint arXiv:1911.07532, 2019. 2, 7, 8   \n[16] Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. DropEdge: Towards deep graph convolutional networks on node classification. ICLR, 2019. 2   \n[17] Emanuele Rossi, Fabrizio Frasca, Ben Chamberlain, Davide Eynard, Michael Bronstein, and Federico Monti. SIGN: Scalable inception graph neural networks. arXiv preprint arXiv:2004.11198, 2020. 7   \n[18] 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. 7   \n[19] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and ´ Yoshua Bengio. Graph attention networks. ICLR, 2018. 2, 7, 8   \n[20] Petar Velickovic, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. Deep graph infomax. ICLR, 2019. 7, 8   \n[21] Felix Wu, Tianyi Zhang, Amauri Holanda de Souza Jr, Christopher Fifty, Tao Yu, and Kilian Q Weinberger. Simplifying graph convolutional networks. ICML, 2019. 1, 2, 5, 6, 7, 8, 9   \n[22] Louis-Pascal Xhonneux, Meng Qu, and Jian Tang. Continuous graph neural networks. ICML, 2020. 2, 6, 7, 8   \n[23] Bingbing Xu, Huawei Shen, Qi Cao, Keting Cen, and Xueqi Cheng. Graph convolutional networks using heat kernel for semi-supervised learning. arXiv preprint arXiv:2007.16002, 2020. 7   \n[24] Bingbing Xu, Huawei Shen, Qi Cao, Yunqi Qiu, and Xueqi Cheng. Graph wavelet neural network. ICLR, 2019. 7   \n[25] Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. ICML, 2018. 2, 7, 8   \n[26] Zhilin Yang, William Cohen, and Ruslan Salakhudinov. Revisiting semi-supervised learning with graph embeddings. ICML, 2016. 2   \n[27] Lingxiao Zhao and Leman Akoglu. PairNorm: Tackling oversmoothing in gnns. ICLR, 2020. 2, 7   \n[28] Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. ICML, 2003. 7 ",
+        "bbox": [
+            171,
+            63,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            89,
+            828,
+            375
+        ],
+        "page_idx": 11
+    }
+]

parse/train/xN3XX6pKSD5/xN3XX6pKSD5.md

@@ -0,0 +1,339 @@
+# Deep Marching Tetrahedra: a Hybrid Representation for High-Resolution 3D Shape Synthesis
+
+Tianchang Shen 1,2,3 Jun Gao1,2,3 Kangxue Yin 1
+
+Ming-Yu Liu 1 Sanja Fidler1,2,3
+
+NVIDIA1 University of Toronto2 Vector Institute3
+
+{frshen, jung, kangxuey, mingyul, sfidler}@nvidia.com
+
+# Abstract
+
+We introduce DMTET, a deep 3D conditional generative model that can synthesize high-resolution 3D shapes using simple user guides such as coarse voxels. It marries the merits of implicit and explicit 3D representations by leveraging a novel hybrid 3D representation. Compared to the current implicit approaches, which are trained to regress the signed distance values, DMTET directly optimizes for the reconstructed surface, which enables us to synthesize finer geometric details with fewer artifacts. Unlike deep 3D generative models that directly generate explicit representations such as meshes, our model can synthesize shapes with arbitrary topology. The core of DMTET includes a deformable tetrahedral grid that encodes a discretized signed distance function and a differentiable marching tetrahedra layer that converts the implicit signed distance representation to the explicit surface mesh representation. This combination allows joint optimization of the surface geometry and topology as well as generation of the hierarchy of subdivisions using reconstruction and adversarial losses defined explicitly on the surface mesh. Our approach significantly outperforms existing work on conditional shape synthesis from coarse voxel inputs, trained on a dataset of complex 3D animal shapes. Project page: https://nv-tlabs.github.io/DMTet/.
+
+# 1 Introduction
+
+Fields such as simulation, architecture, gaming, and film rely on high-quality 3D content with rich geometric details and complex topology. However, creating such content requires tremendous expert human effort. It takes a significant amount of development time to create each individual 3D asset. In contrast, creating rough 3D shapes with simple building blocks like voxels has been widely adopted. For example, Minecraft has been used by hundreds of millions of users for creating 3D content. Most of them are non-experts. Developing A.I. tools that enable regular people to upscale coarse, voxelized objects into high resolution, beautiful 3D shapes would bring us one step closer to democratizing high-quality 3D content creation. Similar tools can be envisioned for turning 3D scans of objects recorded by modern phones into high-quality forms. Our work aspires to create such capabilities.
+
+A powerful 3D representation is a critical component of a learning-based 3D content creation framework. A good 3D representation for high-quality reconstruction and synthesis should capture local geometric details and represent objects with arbitrary topology while also being memory and computationally efficient for fast inference in interactive applications.
+
+Recently, neural implicit representations [8, 39, 42, 51], which use a neural network to implicitly represent a shape via a signed distance field (SDF) or an occupancy field (OF), have emerged as an effective 3D representation. Neural implicits have the benefit of representing complex geometry and topology, not limited to a predefined resolution. The success of these methods has been shown in shape compression [49, 13, 51], single-image shape generation [47, 60, 48], and point cloud reconstruction [57]. However, most of the current implicit approaches are trained by regressing to SDF or OF values and cannot utilize an explicit supervision on the target surface, which imposes useful constraints for training. To mitigate this issue, several works [45, 31] proposed to utilize iso-surfacing techniques such as the Marching Cubes (MC) algorithm to extract a surface mesh from the implicit representation, which, however, is computationally expensive.
+
+In this work, we introduce DMTET, a deep 3D conditional generative model for high-resolution 3D shape synthesis from user guides in the form of coarse voxels. In the heart of DMTET is a new differentiable shape representation that marries implicit and explicit 3D representations. In contrast to deep implicit approaches optimized for predicting sign distance (or occupancy) values, our model employs additional supervision on the surface, which empirically renders higher quality shapes with finer geometric details. Compared to methods that learn to directly generate explicit representations, such as meshes [54], by committing to a preset topology, our DMTET can produce shapes with arbitrary topology. Specifically, DMTET predicts the underlying surface parameterized by an implicit function encoded via a deformable tetrahedral grid. The underlying surface is converted into an explicit mesh with a Marching Tetrahedra (MT) algorithm, which we show is differentiable and more performant than the Marching Cubes. DMTET maintains efficiency by learning to adapt the grid resolution by deforming and selectively subdividing tetrahedra. This has the effect of spending computation only on the relevant regions in space. We achieve further gains in the overall quality of the output shape with learned surface subdivision. Our DMTET is end-to-end differentiable, allowing the network to jointly optimize the geometry and topology of the surface, as well as the hierarchy of subdivisions using a loss function defined explicitly on the surface mesh.
+
+We demonstrate our DMTET on two challenging tasks: 3D shape synthesis from coarse voxel inputs and point cloud 3D reconstruction. We outperform existing state-of-the-art methods by a significant margin while being 10 times faster than alternative implicit representation-based methods at inference time. In summary, we make the following technical contributions:
+
+1. We show that using Marching Tetrahedra (MT) as a differentiable iso-surfacing layer allows topological change for the underlying shape represented by a implicit field, in contrast to the analysis in prior works [31, 45].   
+2. We incorporate MT in a DL framework and introduce DMTET, a hybrid representation that combines implicit and explicit surface representations. We demonstrate that the additional supervision (e.g. chamfer distance, adversarial loss) defined directly on the extracted surface from implicit field improves the shape synthesis quality.   
+3. We introduce a coarse-to-fine optimization strategy that scales DMTET to high resolution during training. We thus achieves better reconstruction quality than state-of-the-art methods on challenging 3D shape synthesis tasks, while requiring a lower computation cost.
+
+# 2 Related Work
+
+We review the related work on learning-based 3D synthesis methods based on their 3D representations.
+
+Voxel-based Methods Early work [59, 10, 38] represented 3D shapes as voxels, which store the coarse occupancy (inside/outside) values on a regular grid, which makes powerful convolutional neural networks native and renders impressive results on 3D reconstruction and synthesis [12, 11, 58, 2]. For high-resolution shape synthesis, DECOR-GAN [6] transfers geometric details from a high-resolution shape represented in voxel to a low-resolution shape by utilizing a discriminator defined on 3D patches of the voxel grid. However, the computational and memory costs grow cubically as the resolution increases, prohibiting the reconstruction of fine geometric details and smooth curves. One common way to address this limitation is building hierarchical structures such as octrees [46, 52, 55, 56, 24, 52], which adapt the grid resolution locally based on the underlying shape. In this paper, we adopt a hierarchical deformable tetrahedral grid to utilize the resolution better. Unlike octree-based shape synthesis, our network learns grid deformation and subdivision jointly to better represent the surface without relying on explicit supervision from a pre-computed hierarchy.
+
+Deep Implicit Fields (DIFs) represent a 3D shape as a zero level set of a continuous function parameterized by a neural network [39, 44, 17, 40]. This formulation can represent arbitrary typology and has infinite resolution. DIF-based shape synthesis approaches have demonstrated strong performance in many applications, including single view 3D reconstruction [60, 30, 47, 48], shape manipulation, and synthesis [26, 21, 28, 14, 1, 9]. However, as these approaches are trained by minimizing the reconstruction loss of function values at a set of sampled 3D locations (a rough proxy of the surface), they tend to render artifacts when synthesizing fine details. Furthermore, if one desires a mesh to be extracted from a DIF, an expensive iso-surfacing step based on Marching Cubes [36] or Marching Tetrahedra [15] is required. Due to the computational burden, iso-surfacing is often done on a smaller resolution, hence prone to quantization errors. Lei et al. [29] proposes an analytic meshing solution to reduce the error, but is only applicable to DIFs parametrized by MLPs with ReLU activation. Our representation scales to high resolution and does not require additional modification to the backward pass for training end-to-end. DMTET can represent arbitrary typology, and is trained via direct supervision on the generated surface. Recent works [1, 9] learn to regress unsigned distance to triangle soup or point cloud. However, their iso-surfacing formulation is not differentiable in contrast to DMTET.
+
+![](images/0d5058ec53aafbd0e0995b8e5ac5432565d0802e926641001c8ac4ebef8fb2be.jpg)  
+Figure 1: DMTET reconstructs the shape implicitly in a coarse-to-fine manner by predicting the SDF defined on a deformable tetrahedral grid. It then converts the SDF to a surface mesh by a differentiable Marching Tetrahedra layer. DMTET is trained by optimizing the objective function defined on the final surface.
+
+Surface-based Methods directly predict triangular meshes and have achieved impressive results for reconstructing and synthesizing simpler shapes [54, 23, 5, 41, 7]. Typically, they predefined the topology of the shape, e.g. equivalent to a sphere [54, 5, 25], or a union of primitives [43, 53, 19] or a set of segmented parts [61, 62, 50]. As a result, they can not model a distribution of shapes with complex topology variations. Recently, DefTet [18] represents a mesh with a deformable tetrahedral grid where the grid vertex coordinates and the occupancy values are learned. However, similar to voxel-based methods, the computational costf increases cubically with the grid resolution. Furthermore, as the occupancy loss for supervising topology learning and the surface loss for supervising geometry learning do not support joint training, it tends to generate suboptimal results. In contrast, our method is able to synthesize high-resolution 3D shapes, not shown in previous work.
+
+# 3 Deep Marching Tetrahedra
+
+We now introduce our DMTET for synthesizing high-quality 3D objects. The schematic illustration is provided in Fig. 1. Our model relies on a new, hybrid 3D representation specifically designed for high-resolution reconstruction and synthesis, which we describe in Sec. 3.1. In Sec. 3.2, we describe the neural network architecture of DMTET that predicts the shape representation from inputs such as coarse voxels. We provide the training objectives in Sec. 3.3.
+
+# 3.1 3D Representation
+
+We represent a shape using a sign distance field (SDF) encoded with a deformable tetrahedral grid, adopted from DefTet [18, 20]. The grid fully tetrahedralizes a unit cube, where each cell in the volume is a tetahedron with 4 vertices and faces. The key aspect of this representation is that the grid vertices can deform to represent the geometry of the shape more efficiently. While the original DefTet encoded occupancy defined on each tetrahedron, we here encode signed distance values defined on the vertices of the grid and represent the underlying surface implicitly (Sec. 3.1.1). The use of signed distance values, instead of occupancy values, provides more flexibility in representing the underlying surface. For greater representation power while keeping memory and computation manageable, we further selectively subdivide the tetrahedra around the predicted surface (Sec. 3.1.2). We convert the signed distance-based implicit representation into a triangular mesh using a marching tetrahedra layer, which we discuss in Sec. 3.1.3. The final mesh is further converted into a parameterized surface with a differentiable surface subdivision module, described in Sec. 3.1.4.
+
+# 3.1.1 Deformable Tetrahedral Mesh as an Approximation of an Implicit Function
+
+We adopt and extend the deformable tetrahedral grid introduced in Gao et al. [18], which we denote with $( V _ { T } , T )$ , where $V _ { T }$ are the vertices in the tetrahedral grid $T$ . Following the notation in [18], each tetrahedron $T _ { k } \in T$ is represented with four vertices $\left\{ v _ { a _ { k } } , v _ { b _ { k } } , v _ { c _ { k } } , v _ { d _ { k } } \right\}$ , with $k \in \{ 1 , . . . . , K \}$ , where $K$ is the total number of tetrahedra and $v _ { i _ { k } } \in V _ { T }$ .
+
+We represent the sign distance field by interpolating SDF values defined on the vertices of the grid. Specifically, we denote the SDF value in vertex $v _ { i } \in V _ { T }$ as $s ( v _ { i } )$ . SDF values for the points that lie inside the tetrahedron follow a barycentric interpolation of the SDF values of the four vertices that encapsulates the point.
+
+# 3.1.2 Volume Subdivision
+
+We represent shape in a coarse to fine manner for efficiency. We determine the surface tetrahedra $T _ { s u r f }$ by checking whether a tetrahedron has vertices with different SDF signs – indicating that it intersects the surface encoded by the SDF. We subdivide $T _ { s u r f }$ as well as their immediate neighbors and increase resolution by adding the mid point to each edge. We compute SDF values of the new vertices by averaging the SDF values on the edge (Fig. 2).
+
+![](images/690ebadbdb5fb11a0781110c51057baf1fbf00e37c739b19a6285e80b9e34a71.jpg)  
+Figure 2: Volume Subdivision: Each surface tet.(blue) is divided into 8 tet.(red) by adding midpoints.
+
+# 3.1.3 Marching Tetrahedra for converting between an Implicit and Explicit Representation
+
+![](images/66197fc00f7d532542743103dce49d9e142b692a641aa4f468f4386db848bf60.jpg)  
+Figure 3: Three unique surface configurations in MT. Vertex color indicates the sign of signed distance value. Notice that flipping the signs of all vertices will result in the same surface configuration. Position of the vertex is linearly interpolated along the edges with sign change.
+
+We use the Marching Tetrahedra [15] algorithm to convert the encoded SDF into an explicit triangular mesh. Given the SDF values $\mathbf { \bar { \{ } }  s ( v _ { a } ) , s ( \mathbf { \bar { { v } } } _ { b } ) , s ( v _ { c } ) , s ( v _ { d } ) \}$ of the vertices of a tetrahedron, MT determines the surface typology inside the tetrahedron based on the signs of $s ( v )$ , which is illustrated in Fig. 3. The total number of configurations is $2 ^ { 4 } = { \bar { 1 } } 6$ , which falls into 3 unique cases after considering rotation symmetry. Once the surface typology inside the tetrahedron is identified, the vertex location of the iso-surface is computed at the zero crossings of the linear interpolation along the tetrahedron’s edges, as shown in Fig. 3.
+
+Prior works [45, 31] argue that the singularity in this formulation, i.e. when $s ( v _ { a } ) = s ( v _ { b } )$ , prevents the change of surface typology (sign change of $s ( v _ { a } ) )$ ) during training. However, we find that, in practise, the equation is only evaluated when $\mathrm { s i g n } ( s ( v _ { a } ) ) \neq \mathrm { s i g n } ( s ( v _ { b } ) )$ . Thus, during training, the singularity never happens and the gradient from a loss defined on the extracted iso-surface (Sec. 3.3), can be back-propagated to both vertex positions and SDF values via the chain rule. A more detailed analysis is in the Appendix.
+
+# 3.1.4 Surface Subdivision
+
+Having a surface mesh as output allows us to further increase the representation power and the visual quality of the shapes with a differentiable surface subdivision module. We follow the scheme of the Loop Subdivision method [35], but instead of using a fixed set of parameters for subdivision, we make these parameters learnable in DMTET. Specifically, learnable parameters include the positions of each mesh vertex $\boldsymbol { v } _ { i } ^ { \prime }$ , as well as $\alpha _ { i }$ which controls the generated surface via weighting the smoothness of neighbouring vertices. Note that different from Liu et al. [33], we only predict the per-vertex parameter at the beginning and carry it over to subsequent subdivision iterations to attain a lower computational cost. We provide more details in Appendix.
+
+# 3.2 DMTET: 3D Deep Conditional Generative Model
+
+Our DMTET is a neural network that utilizes our proposed 3D representation and aims to output a high resolution 3D mesh $M$ from input $x$ (a point cloud or a coarse voxelized shape). We describe the architecture (Fig. 4) of the generator for each module of our 3D representation in Sec. 3.2.1, with the architecture of the discriminator presented in Sec. 3.2.2. Further details are in Appendix.
+
+![](images/fa49995de6dd2e0e3e4ada8be106cd973661cac4b1241747a493f2249be01cff.jpg)  
+Figure 4: Our generator and discriminator architectures. The generator is composed of two parts—one utilizes MLP to generate the initial predictions for all grid vertices and the other uses GCN to refine the surface.
+
+# 3.2.1 3D Generator
+
+Input Encoder We use PVCNN [34] as an input encoder to extract a 3D feature volume $F _ { v o l } ( x )$ from a point cloud. When the input is a coarse voxelized shape, we sample points on its surface. We compute a feature vector $F _ { v o l } ( v , x )$ for a grid vertex $v \in \mathbb { R } ^ { 3 }$ via trilinear interpolation.
+
+Initial Prediction of SDF We predict the SDF value for each vertex in the initial deformable tetrahedral grid using a fully-connected network $s ( v ) = M L P ( F _ { v o l } ( v , x ) , v )$ . The fully-connected network additionally outputs a feature vector $f ( v )$ , which is used for the surface refinement in the volume subdivision stage.
+
+Surface Refinement with Volume Subdivision After obtaining the initial SDF, we iteratively refine the surface and subdivide the tetrahedral grid. We first identify surface tetrahedra $T _ { s u r f }$ based on the current $s ( v )$ value. We then build a graph $G = ( V _ { s u r f } , E _ { s u r f } )$ , where $V _ { s u r f } , E _ { s u r f }$ correspond to the vertices and edges in $T _ { s u r f }$ . We then predict the position offsets $\Delta v _ { i }$ and SDF residual values $\Delta s ( v _ { i } )$ for each vertex $i$ in $V _ { s u r f }$ using a Graph Convolutional Network [32] (GCN):
+
+$$
+\begin{array} { r c l } { f _ { v _ { i } } ^ { \prime } } & { = } & { \mathsf { c o n c a t } ( v _ { i } , s ( v _ { i } ) , F _ { v o l } ( v _ { i } , x ) , f ( v _ { i } ) ) , } \\ { ( \Delta v _ { i } , \Delta s ( v _ { i } ) , \overline { { f ( v _ { i } ) } } ) _ { i = 1 , \cdots N _ { s u r f } } } & { = } & { \mathsf { G C N } \big ( ( f _ { v _ { i } } ^ { \prime } ) _ { i = 1 , \cdots N _ { s u r f } } , G \big ) , } \end{array}
+$$
+
+where $N _ { s u r f }$ is the total number of vertices in $V _ { s u r f }$ and $\overline { { f ( v _ { i } ) } }$ is the updated per-vertex feature. The vertex position and the SDF value for vertex $v _ { i }$ are updated as $v _ { i } ^ { \prime } = v _ { i } + \Delta v _ { i }$ and $s ( v _ { i } ^ { \prime } ) =$ $s ( v _ { i } ) + \Delta s ( v _ { i } )$ . This refinement step can potentially flip the sign of the SDF values to refine the local typology, and also move the vertices thus improving the local geometry.
+
+After surface refinement, we perform the volume subdivision step followed by an additional surface refinement step. In particular, we re-identify $T _ { s u r f }$ and subdivide $T _ { s u r f }$ and their immediate neighbors. We drop the unsubdivided tetrahedra from the full tetrahedral grid in both steps, which saves memory and computation, as the size of the $T _ { s u r f }$ is proportional to the surface area of the object, and scales up quadratically rather than cubically as the grid resolution increases.
+
+Note that the SDF values and positions of the vertices are inherited from the level before subdivision, thus, the loss computed at the final surface can back-propagate to all vertices from all levels. Therefore, our DMTET automatically learns to subdivide the tetrahedra and does not need an additional loss term in the intermediate steps to supervise the learning of the octree hierarchy as in the prior work [52].
+
+Learnable Surface Subdivision After extracting the surface mesh using MT, we can further apply learnable surface subdivision. Specifically, we build a new graph on the extracted mesh, and use GCN to predict the updated position of each vertex $\boldsymbol { v } _ { i } ^ { \prime }$ , and $\alpha _ { i }$ for Loop Subvidision. This step removes the quantization errors and mitigates the approximation errors from the classic Loop Subdivision by adjusting $\alpha _ { i }$ , which are fixed in the classic method.
+
+# 3.2.2 3D Discriminator
+
+We apply a 3D discriminator $D$ on the final surface predicted from the generator. We empirically find that using a 3D CNN from DECOR-GAN [6] as the discriminator on the signed distance field that is computed from the predicted mesh is effective to capture the local details. Specifically, we first randomly select a high-curvature vertex $v$ from the target mesh and compute the ground truth signed distance field $S _ { r e a l } \in \mathbb { R } ^ { N \times N \times N }$ at a voxelized region around $v$ . Similarly, we compute the signed distance field of the predicted surface mesh $M$ at the same location to obtain $S _ { p r e d } \in \mathbb { R } ^ { N \times \tilde { N } \times N }$ . Note that $S _ { p r e d }$ is an analytical function of the mesh $M$ , and thus the gradient to $S _ { p r e d }$ can backpropagate to the vertex positions in $M$ . We feed $S _ { r e a l }$ or $S _ { p r e d }$ into the discriminator, along with the feature vector $F _ { v o l } ( v , x )$ in position $v$ . The discriminator then predicts the probability indicating whether the input comes from the real or generated shapes.
+
+# 3.3 Loss Function
+
+DMTET is end-to-end trainable. We supervise all modules to minimize the error defined on the final predicted mesh $M$ . Our loss function contains three different terms: a surface alignment loss to encourage the alignment with ground truth surface, an adversarial loss to improve realism of the generated shape, and regularizations to regularize the behavior of SDF and vertex deformations.
+
+Surface Alignment loss We sample a set of points $P _ { g t }$ from the surface of the ground truth mesh $M _ { g t }$ . Similarly, we also sample a set of points from $M _ { p r e d }$ to obtain $P _ { p r e d }$ , and minimize the L2 Chamfer Distance and the normal consistency loss between $P _ { g t }$ and $P _ { p r e d }$ :
+
+$$
+L _ { \mathrm { c d } } = \sum _ { p \in P _ { p r e d } } \operatorname* { m i n } _ { q \in P _ { g t } } | | p - q | | _ { 2 } + \sum _ { q \in P _ { g t } } \operatorname* { m i n } _ { p \in P _ { p r e d } } | | q - p | | _ { 2 } , L _ { \mathrm { n o m a l } } = \sum _ { p \in P _ { p r e d } } ( 1 - | \Vec { \mathbf { n } } _ { p } \cdot \Vec { \mathbf { n } } _ { \Vec { q } } | ) ,
+$$
+
+where $\hat { q }$ is the point that corresponds to $p$ when computing the Chamfer Distance, and $\vec { \bf n } _ { p } , \vec { \bf n } _ { \hat { q } }$ denotes the normal direction at point $p , \hat { q }$ .
+
+Adversarial Loss We use the adversarial loss proposed in LSGAN [37]:
+
+$$
+L _ { \mathrm { D } } = \frac { 1 } { 2 } [ ( D ( M _ { g t } ) - 1 ) ^ { 2 } + D ( M _ { p r e d } ) ^ { 2 } ] , L _ { \mathrm { G } } = \frac { 1 } { 2 } [ ( D ( M _ { p r e d } ) - 1 ) ^ { 2 } ] .
+$$
+
+Regularizations The above loss functions operate on the extracted surface, thus, only the vertices that are close to the iso-surface in the tetrahedral grid receive gradients, while the other vertices do not. Moreover, the surface losses do not provide information about what is inside/outside, since flipping the SDF sign of all vertices in a tetrahedron would result in the same surface being extracted by MT. This may lead to disconnected components during training. To alleviate this issue, we add a SDF loss to regularize SDF values:
+
+$$
+L _ { \mathrm { S D F } } = \sum _ { v _ { i } \in V _ { T } } | s ( v _ { i } ) - S D F ( v _ { i } , M _ { g t } ) | ^ { 2 } ,
+$$
+
+where $S D F ( v _ { i } , M _ { g t } )$ denotes the SDF value of point $v _ { i }$ to the mesh $M _ { g t }$ . In addition, we apply the $L _ { 2 }$ regularization loss on the predicted vertex deformations to avoid artifacts: $\begin{array} { r } { L _ { \mathrm { d e f } } = \sum _ { v _ { i } \in V _ { T } } | | \Delta v _ { i } | | _ { 2 } } \end{array}$ .
+
+The final loss is a weighted sum of all five loss terms:
+
+$$
+L = \lambda _ { \mathrm { c d } } L _ { \mathrm { c d } } + \lambda _ { \mathrm { n o r m a l } } L _ { \mathrm { n o r m a l } } + \lambda _ { \mathrm { G } } L _ { \mathrm { G } } + \lambda _ { \mathrm { S D F } } L _ { \mathrm { S D F } } + \lambda _ { \mathrm { d e f } } L _ { \mathrm { d e f } } ,
+$$
+
+where $\lambda _ { \mathrm { c d } } , \lambda _ { \mathrm { n o r m a l } } , \lambda _ { \mathrm { G } } , \lambda _ { \mathrm { S D F } } , \lambda _ { \mathrm { d e f } }$ are hyperparameters (provided in the Supplement).
+
+# 4 Experiments
+
+We first evaluate DMTET in the challenging application of generating high-quality animal shapes from coarse voxels. We further evaluate DMTET in reconstructing 3D shapes from noisy point clouds on ShapeNet by comparing to existing state-of-the-art methods.
+
+# 4.1 3D Shape Synthesis from Coarse Voxels
+
+Experimental Settings We collected 1562 animal models from the TurboSquid website1. These models have a wide range of diversity, ranging from cats, dogs, bears, giraffes, to rhinoceros, goats, etc. We provide visualizations in Supplement. Among 1562 shapes, we randomly select 1120 shapes for training, and the remaining 442 shapes for testing. We follow the pipeline in Kaolin [27] to convert shapes to watertight meshes. To prepare the input to the network, we first voxelize the mesh into the resolution of $1 6 ^ { \overleftarrow { 3 } }$ , and then sample 3000 points from the surface after applying marching cubes to the $1 6 ^ { 3 }$ voxel grid. Note that this preprocessing is agnostic to the representation of the input coarse shape, allowing us to evaluate on different resolution voxels, or even meshes.
+
+We compare our model with the official implementation of ConvOnet [44], which achieved SOTA performance on voxel upsampling. We also compare to DECOR-GAN [6], which obtained impressive results on transferring styles from a high-resolution voxel shape to a low-resolution voxel. Note that the original setting of DECOR-GAN is different from ours. For a fair comparison, we use all 1120 training shapes as the high-resolution style shapes during training, and retrieve the closet training shape to the test shape as the style shape during inference, which we refer as DECOR-Retv. We also compare against a randomly selected style shape as reference, denoted as DECOR-Rand.
+
+1https://www.turbosquid.com, we obtain consent via an agreement with TurboSquid, and following license at https://blog.turbosquid.com/turbosquid-3d-model-license/
+
+![](images/4b1bbd56197269ad4335baabf87fb00fe595064f3e4ec463efdf1d0b619d8092.jpg)  
+Figure 5: Qualitative results on 3D shapes Synthesis from Coarse Voxels. Comparing with all baselines, our method reconstructs shapes with much higher quality. Adding GAN further improves the realism of the generated shape. We also show the retrieved shapes from the training set in the second last column.
+
+Metrics We evaluate L2 and L1 Chamfer Distance, as well as normal consistency score to assess how well the methods reconstruct the corresponding high-resolution shape following [44]. We also report Light Field Distance [4] (LFD) which measures the visual similarity in 2D rendered views. In addition, we evaluate Cls score following [6]. Specifically, we render the predicted 3D shapes and train a patch-based image classifier to distinguish whether images are from the renderings of real or generated shapes. The mean classification accuracy of the trained classifier is reported as Cls (lower is better). More details are in the Supplement.
+
+Experimental Results We provide quantitative results in Table 1 with qualitative examples in Fig. 5. Our DMTET achieves significant improvements over all baselines in terms of all metrics. Compared to both ConvOnet [44] and DECORGAN [6], our DMTET reconstructs shapes with better quality when training without adversarial loss (5th column in Fig. 5). Further geometric details, including nails, ears, eyes, mouths, etc, are captured when trained with the adversarial loss (6th column in Fig. 5), significantly improving the realism and visual quality of the generated shape. To demonstrate the generalization ability of our
+
+![](images/51a010aed7513fe7dfaf318abbe714fe80699ba1341c5a33b907b24eb8d658e0.jpg)  
+Figure 6: Qualitative Results of synthesizing highresolution shapes from coarse voxels collected online.
+
+DMTET, we collect human-created low-resolution voxels from Turbosquid (shapes unseen in training). We provide qualitative results in Fig. 6. Despite the fact that these human-created shapes have noticeable differences with our coarse voxels used in training, e.g., different ratios of body parts compared with our training shapes (larger head, thinner legs, longer necks), our model faithfully generates high-quality 3D details conditioned on each coarse voxel – an exciting result.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>L2 Chamfer↓</td><td rowspan=1 colspan=1>L1 Chamfer↓</td><td rowspan=1 colspan=1>Norm. Cons.↑</td><td rowspan=1 colspan=1>LFD↓</td><td rowspan=1 colspan=1>Cls</td></tr><tr><td rowspan=1 colspan=1>ConvOnet [44]</td><td rowspan=1 colspan=1>0.83</td><td rowspan=1 colspan=1>2.41</td><td rowspan=1 colspan=1>0.901</td><td rowspan=1 colspan=1>3220</td><td rowspan=1 colspan=1>0.63</td></tr><tr><td rowspan=1 colspan=1>DECOR [6]-Retv.</td><td rowspan=1 colspan=1>1.32</td><td rowspan=1 colspan=1>3.81</td><td rowspan=1 colspan=1>0.876</td><td rowspan=1 colspan=1>3689</td><td rowspan=1 colspan=1>0.66</td></tr><tr><td rowspan=1 colspan=1>DECOR [6]-Rand.</td><td rowspan=1 colspan=1>2.38</td><td rowspan=1 colspan=1>6.85</td><td rowspan=1 colspan=1>0.797</td><td rowspan=1 colspan=1>5338</td><td rowspan=1 colspan=1>0.67</td></tr><tr><td rowspan=1 colspan=1>DMTET wo Adv.</td><td rowspan=1 colspan=1>0.76</td><td rowspan=1 colspan=1>2.20</td><td rowspan=1 colspan=1>0.916</td><td rowspan=1 colspan=1>2846</td><td rowspan=1 colspan=1>0.58</td></tr><tr><td rowspan=1 colspan=1>DMTET</td><td rowspan=1 colspan=1>0.75</td><td rowspan=1 colspan=1>2.19</td><td rowspan=1 colspan=1>0.918</td><td rowspan=1 colspan=1>2823</td><td rowspan=1 colspan=1>0.54</td></tr></table>
+
+Table 1: Super Resolution of Animal Shapes: DMTET significantly outperforms all baselines in all metrics.
+
+User Studies We conduct user studies via Amazon Machanical Turk (AMT) to further evaluate the performance of all methods. In particular, we present two shapes that are predicted from two different models to the AMT workers and ask them to evaluate which one is a better looking shape and which one features more realistic details. Detailed experimental settings are provided in the Supplement. We compare DMTET against ConvONet [44], DECOR [6]-Retv, as well as DMTET without adversarial loss (w.o. Adv.). Quantitative results are reported in Table 2. Human judges agree that the shapes generated from our model have better details, compared to all baselines, in a vast majority of the cases. Ablations on using adversarial loss demonstrate the effectiveness of generating higher quality geometry using a discriminator during training.
+
+Ablation Studies To evaluate the effectiveness of our volume subdivision and surface subdivision modules, we ablate by sequentially introducing them to the base model (we refer as $\mathrm { D M T E T } _ { B }$ ) which we train on 100-resolution uniform tetrahedral grid without both volume and surface subdivision modules and adversarial
+
+Table 2: User Study on 3D Shape Synthesis from Coarse voxels. In each cell, we report percentages of shapes for which the users agree are better looking (left) or have better details (right).   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>ConvONet[44]</td><td rowspan=1 colspan=1>DECOR[6]-Retv.</td><td rowspan=1 colspan=1>DMTETWoAdv</td></tr><tr><td rowspan=1 colspan=1>Baselinewins</td><td rowspan=1 colspan=1>5% 15%</td><td rowspan=1 colspan=1>26%/17%</td><td rowspan=1 colspan=1>29% /25%</td></tr><tr><td rowspan=1 colspan=1>DMTETwins</td><td rowspan=1 colspan=1>95%/95%</td><td rowspan=1 colspan=1>74% /83%</td><td rowspan=1 colspan=1>71% 175%</td></tr></table>
+
+loss. We conduct user studies to evaluate the improvement after each step using the protocol described in the above paragraph. We first reduce the initial resolution to 70 and employ volume subdivision to support higher output resolution (we refer this model as $\mathbf { D M T E T } _ { V }$ ) and compare with $\mathbf { D M T E T } _ { B }$ Predictions by $\mathrm { D M T E T } _ { V }$ wins $78 \%$ of cases over $\mathrm { D M T E T } _ { B }$ for better looking, and $61 \%$ of cases for realistic details, showing that the volume subdivision module is effective in synthesizing shape details. We then add surface subdivision on top of the $\mathbf { D M T E T } _ { V }$ and compare with it. The new model wins $62 \%$ of cases over $\mathrm { D M T E T } _ { V }$ for better looking, and $62 \%$ of cases for realistic details as well, demonstrating the effect of surface subdivision module in enhancing the shape details.
+
+# 4.2 Point Cloud 3D Reconstruction
+
+Experimental Settings We follow the setting from DefTet [18], and use all 13 categories in ShapeNet [3] core data2, which we pre-process using Kaolin [27] to watertight meshes. We sample 5000 points for each shape and add Gaussian noise with zero mean of standard deviation 0.005. For quantitative evaluation, we report the L1 Chamfer Distance in the main paper, and refer readers to the Supplement for results in other metrics (3D IoU, L2 Chamfer Distance and F1 score). We additionally report average inference time on the same Nvidia V100 GPU.
+
+We compare DMTET against state-of-the-art 3D reconstruction approaches using different representations: voxels [10], deforming a mesh with a fixed template [54], deforming a mesh generated from a volumetric representation [22], DefTet [18], and implicit functions [44]. For a fair comparison, we use the same point cloud encoder for all the methods, and adopt the decoders in the original papers to generate shapes in different representations. We also remove the adversarial loss in this application, since baselines also do not have it. We further compare with oracle performance of MC/MT where the ground truth SDF is utilized to extract iso-surface using MC/MT.
+
+Experimental Results Quantitative results are summarized in Table 3, with a few qualitative examples shown in Fig. 7. Compared to DMC [31], which also predicts the SDF values and supervises with a surface loss, DMTET achieves much better reconstruction quality since training using the marching tetrahedra layer is more efficient than calculating an expectation over all possible configurations within one grid cell as done in DMC [31]. Compared to a method that deforms a fixed template (sphere) [54], we reconstruct shapes with different topologies, achieving more faithful results compared to the ground truth shape. When compared with other explicit surface representations that also support different topology [18, 22], our method achieves higher quality results for local geometry, benefiting from the fact that the typology is jointly optimized with the geometry, whereas it is separately supervised by an occupancy loss in [18, 22]. Compared to a neural implicit method [44], we generate higher quality shapes with less artifacts, while running significantly faster at inference. Finally, compared to a voxel-based method [10] at the same resolution, our method recovers more geometric details, benefiting from the predicted vertex deformations as well as the surface loss.
+
+![](images/7bd33ba212cc763b44caca6f6748c49136fb2f72c0e054ac16d83ee028728622.jpg)  
+Figure 7: Qualitative results on 3D Reconstruction from Point Clouds: Our model reconstructs shapes with more geometric details compared to baselines.
+
+Table 3: Quantitative Results on Point Cloud Reconstruction (Chamfer L1). Note that all the networks in the baselines are not designed for this task, and thus we use the same encoder and their decoder for a fair comparison. We also ablate ourselves by operating on fixed grid (DMTET wo (Def, Vol., Surf.)), removing volume subdivision (DMTET wo Vol.), or surface subdivision (DMTET wo Surf.), or the both (DMTET wo (Vol., Surf.)).   
+
+<table><tr><td>Category</td><td>Airplane</td><td>Bench</td><td>Dresser</td><td>Car</td><td>Chair</td><td>Display</td><td>Lamp</td><td>Speaker</td><td>Rifle</td><td>Sofa</td><td>Table</td><td>Phone</td><td>Vessel</td><td>Mean↓</td><td>Time(ms)</td></tr><tr><td>3D-R2N2[10]</td><td>1.48</td><td>1.59</td><td>1.64</td><td>1.62</td><td>1.70</td><td>1.66</td><td>1.74</td><td>1.74</td><td>1.37</td><td>1.60</td><td>1.78</td><td>1.55</td><td>1.51</td><td>1.61</td><td>174</td></tr><tr><td>DMC [31]</td><td>1.57</td><td>1.47</td><td>1.29</td><td>1.67</td><td>1.44</td><td>1.25</td><td>2.15</td><td>1.49</td><td>1.45</td><td>1.19</td><td>1.33</td><td>0.88</td><td>1.70</td><td>1.45</td><td>349</td></tr><tr><td>Pixel2mesh [54]</td><td>0.98</td><td>1.28</td><td>1.44</td><td>1.19</td><td>1.91</td><td>1.25</td><td>2.07</td><td>1.61</td><td>0.91</td><td>1.15</td><td>1.82</td><td>0.83</td><td>1.12</td><td>1.35</td><td>30</td></tr><tr><td>ConvOnet [44]</td><td>0.82</td><td>0.95</td><td>0.96</td><td>1.12</td><td>1.03</td><td>0.93</td><td>1.22</td><td>1.12</td><td>0.79</td><td>0.91</td><td>0.94</td><td>0.67</td><td>0.99</td><td>0.95</td><td>866</td></tr><tr><td>MeshRCNN [22]</td><td>0.88</td><td>1.01</td><td>1.05</td><td>1.14</td><td>1.10</td><td>0.99</td><td>1.20</td><td>1.21</td><td>0.83</td><td>0.96</td><td>1.00</td><td>0.71</td><td>1.03</td><td>1.01</td><td>228</td></tr><tr><td>DEFTET[18]</td><td>0.85</td><td>0.94</td><td>0.97</td><td>1.13</td><td>1.04</td><td>0.92</td><td>1.28</td><td>1.17</td><td>0.85</td><td>0.90</td><td>0.93</td><td>0.65</td><td>0.99</td><td>0.97</td><td>61</td></tr><tr><td>DMTET wo (Def, Vol., Surf.)]</td><td>0.82</td><td>0.96</td><td>0.94</td><td>0.98</td><td>0.99</td><td>0.90</td><td>1.04</td><td>1.03</td><td>0.80</td><td>0.86</td><td>0.93</td><td>0.65</td><td>0.89</td><td>0.91</td><td></td></tr><tr><td>DMTET wo (Vol.,Surf.)</td><td>0.69</td><td>0.82</td><td>0.88</td><td>0.92</td><td>0.92</td><td>0.82</td><td>0.89</td><td>0.97</td><td>0.65</td><td>0.81</td><td>0.84</td><td>0.61</td><td>0.80</td><td>0.81</td><td>52 52</td></tr><tr><td>DMTET wo Vol.</td><td>0.65</td><td>0.78</td><td>0.84</td><td>0.89</td><td>0.89</td><td>0.79</td><td>0.86</td><td>0.95</td><td>0.61</td><td>0.78</td><td>0.79</td><td>0.60</td><td>0.78</td><td>0.79</td><td>67</td></tr><tr><td>DMTET wo Surf.</td><td>0.63</td><td>0.77</td><td>0.84</td><td>0.88</td><td>0.88</td><td>0.79</td><td>0.84</td><td>0.94</td><td>0.60</td><td>0.78</td><td>0.79</td><td>0.59</td><td>0.76</td><td>0.78</td><td>108</td></tr><tr><td>DMTET</td><td>0.62</td><td>0.76</td><td>0.83</td><td>0.87</td><td>0.88</td><td>0.78</td><td>0.84</td><td>0.94</td><td>0.59</td><td>0.77</td><td>0.78</td><td>0.57</td><td>0.76</td><td>0.77</td><td>129</td></tr></table>
+
+# 4.2.1 Analysis
+
+We investigate how each component in our representation affects the performance and reconstruction quality.
+
+Comparisons with Oracle Performance of MC/MT We first demonstrate the effect of learning on explicit surface via MT. We compare with the oracle performance of extracting the iso-surface with MT/MC from the ground truth signed distance fields on the Chair test set in ShapeNet, which contains diverse high-quality details. Specifically, for MC/MT, we first compute the discretized SDF at different grid resolutions, and compare the extracted surface to the ground truth surface.
+
+![](images/ca6df925a51dd1d96de02ca23469bf92f0ad16b5ce533ad7239d3a0faf8c0a73.jpg)  
+Figure 8: Comparing our DMTET with oracle performance of MC and MT.
+
+As shown in Fig. 8, MT consistently outperforms MC when querying the same number of points. We found the staggered grids pattern in tetrahedral grid [16, 18] better captures thin structures at a limited resolution (Fig. 9). This makes MT a better choice for efficiency reasons. The usage of tetrahedral mesh in DMTET follows this motivation. Without deforming the grid, DMTET outperforms the oracle performance of MT by a large margin when querying the same number of points, although DMTET predicts the surface from noisy point cloud. This demonstrates that directly optimizing the reconstructed surface can mitigate the discretization errors imposed by MT to a large extent.
+
+![](images/430b26fbbcba7dc56f2f3f84c2d486be08926dbae7665f553626b9f093f6b9b3.jpg)  
+Figure 9: We compare trained DMTET to oracle performance of MT and MC. Number in bracket indicates number of SDF points queried.
+
+Ablation Studies We further provide ablation studies on the entire ShapeNet test set, which is summarized in Tab. 3. We first compare the version where we only predict SDF values without learning to deform the vertices and volume/surface subdivision with the version that predicts both SDF and the deformation. Predicting deformation along with SDF is significantly more performant, since vertex movements allow for a better reconstruction of the underlying surface. This is especially true for categories with thin structures (e.g. lamp) where the grid vertices are desired to align with them. We further ablate the use of volume subdivision and surface subdivision. We show that each component provides an improvement. In particular, volume subdivision has a significant
+
+improvement for object categories with fine-grained structural details, such as airplane and lamp, which require higher grid resolutions to model the occupancy change. Surface subdivision generates shapes with a parametric surface, avoiding the quantization errors in the planar faces and produces more visually pleasing results.
+
+# 5 Conclusion
+
+In this paper, we introduced a deep 3D conditional generative model that can synthesize highresolution 3D shapes using simple user guides such as coarse voxels. Our DMTET features a novel 3D representation that marries implicit and explicit representations by leveraging the advantages of both. We experimentally show that our approach synthesizes significantly higher quality shapes with better geometric details than existing methods, confirmed by quantitative metrics and an extensive user study. By showcasing the ability to upscale coarse voxels such as Minecraft shapes, we hope that we take one step closer to democratizing 3D content creation.
+
+# 6 Broad Impact
+
+Many fields such as AR/VR, robotics, architecture, gaming and film rely on high-quality 3D content. Creating such content, however, requires human experts, i.e., experienced artists, and a significant amount of development time. In contrast, platforms like Minecraft enable millions of users around the world to carve out coarse shapes with simple blocks. Our work aims at creating A.I. tools that would enable even novice users to upscale simple, low-resolution shapes into high resolution, beautiful 3D content. Our method currently focuses on 3D animal shapes. We are not currently aware of and do not foresee nefarious use cases of our method.
+
+# 7 Disclosure of Funding
+
+This work was funded by NVIDIA. Tianchang Shen and Jun Gao acknowledge additional revenue in the form of student scholarships from University of Toronto and the Vector Institute, which are not in direct support of this work.
+
+# References
+
+[1] Matan Atzmon and Yaron Lipman. Sal: Sign agnostic learning of shapes from raw data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2565–2574, 2020.   
+[2] Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Generative and discriminative voxel modeling with convolutional neural networks. arXiv preprint arXiv:1608.04236, 2016. [3] 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.   
+[4] Ding-Yun Chen, Xiao-Pei Tian, Yu-Te Shen, and Ming Ouhyoung. On visual similarity based 3d model retrieval. In Computer graphics forum, volume 22, pages 223–232. Wiley Online Library, 2003.   
+[5] Wenzheng Chen, Jun Gao, Huan Ling, Edward Smith, Jaakko Lehtinen, Alec Jacobson, and Sanja Fidler. Learning to predict 3d objects with an interpolation-based differentiable renderer. In Advances In Neural Information Processing Systems, 2019.   
+[6] Zhiqin Chen, Vladimir G. Kim, Matthew Fisher, Noam Aigerman, Hao Zhang, and Siddhartha Chaudhuri. Decor-gan: 3d shape detailization by conditional refinement. Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[7] Zhiqin Chen, Andrea Tagliasacchi, and Hao Zhang. Bsp-net: Generating compact meshes via binary space partitioning. Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020. [8] Zhiqin Chen and Hao Zhang. Learning implicit fields for generative shape modeling. Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   
+[9] Julian Chibane, Aymen Mir, and Gerard Pons-Moll. Neural unsigned distance fields for implicit function learning. In Advances in Neural Information Processing Systems (NeurIPS), December 2020.   
+[10] Christopher B Choy, Danfei Xu, JunYoung Gwak, Kevin Chen, and Silvio Savarese. 3d-r2n2: A unified approach for single and multi-view 3d object reconstruction. In European conference on computer vision, pages 628–644. Springer, 2016.   
+[11] Angela Dai, Daniel Ritchie, Martin Bokeloh, Scott Reed, Jürgen Sturm, and Matthias Nießner. Scancomplete: Large-scale scene completion and semantic segmentation for 3d scans. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4578–4587, 2018.   
+[12] Angela Dai, Charles Ruizhongtai Qi, and Matthias Nießner. Shape completion using 3d-encoder-predictor cnns and shape synthesis. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5868–5877, 2017.   
+[13] Thomas Davies, Derek Nowrouzezahrai, and Alec Jacobson. Overfit neural networks as a compact shape representation. arXiv preprint arXiv:2009.09808, 2020.   
+[14] Yu Deng, Jiaolong Yang, and Xin Tong. Deformed implicit field: Modeling 3d shapes with learned dense correspondence. In IEEE Computer Vision and Pattern Recognition, 2021.   
+[15] Akio Doi and Akio Koide. An efficient method of triangulating equi-valued surfaces by using tetrahedral cells. IEICE TRANSACTIONS on Information and Systems, 74(1):214–224, 1991.   
+[16] Crawford Doran, Athena Chang, and Robert Bridson. Isosurface stuffing improved: acute lattices and feature matching. In ACM SIGGRAPH 2013 Talks, pages 1–1, 2013.   
+[17] Yueqi Duan, Haidong Zhu, He Wang, Li Yi, Ram Nevatia, and Leonidas J Guibas. Curriculum deepsdf. In European Conference on Computer Vision, pages 51–67. Springer, 2020.   
+[18] Jun Gao, Wenzheng Chen, Tommy Xiang, Clement Fuji Tsang, Alec Jacobson, Morgan McGuire, and Sanja Fidler. Learning deformable tetrahedral meshes for 3d reconstruction. In Advances In Neural Information Processing Systems, 2020.   
+[19] Jun Gao, Chengcheng Tang, Vignesh Ganapathi-Subramanian, Jiahui Huang, Hao Su, and Leonidas J Guibas. Deepspline: Data-driven reconstruction of parametric curves and surfaces. arXiv preprint arXiv:1901.03781, 2019.   
+[20] Jun Gao, Zian Wang, Jinchen Xuan, and Sanja Fidler. Beyond fixed grid: Learning geometric image representation with a deformable grid. In ECCV, 2020.   
+[21] Lin Gao, Jie Yang, Tong Wu, Yu-Jie Yuan, Hongbo Fu, Yu-Kun Lai, and Hao Zhang. Sdm-net: Deep generative network for structured deformable mesh. ACM Transactions on Graphics (TOG), 38(6):1–15, 2019.   
+[22] Georgia Gkioxari, Jitendra Malik, and Justin Johnson. Mesh r-cnn. In Proceedings of the IEEE International Conference on Computer Vision, pages 9785–9795, 2019.   
+[23] Thibault Groueix, Matthew Fisher, Vladimir G Kim, Bryan C Russell, and Mathieu Aubry. A papier-mâché approach to learning 3d surface generation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 216–224, 2018.   
+[24] Christian Häne, Shubham Tulsiani, and Jitendra Malik. Hierarchical surface prediction for 3d object reconstruction. In 2017 International Conference on 3D Vision (3DV), pages 412–420. IEEE, 2017.   
+[25] Rana Hanocka, Gal Metzer, Raja Giryes, and Daniel Cohen-Or. Point2mesh: A self-prior for deformable meshes. ACM Trans. Graph., 39(4), 2020.   
+[26] Zekun Hao, Hadar Averbuch-Elor, Noah Snavely, and Serge Belongie. Dualsdf: Semantic shape manipulation using a two-level representation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7631–7641, 2020.   
+[27] Krishna Murthy J., Edward Smith, Jean-Francois Lafleche, Clement Fuji Tsang, Artem Rozantsev, Wenzheng Chen, Tommy Xiang, Rev Lebaredian, and Sanja Fidler. Kaolin: A pytorch library for accelerating 3d deep learning research. arXiv:1911.05063, 2019.   
+[28] Marian Kleineberg, Matthias Fey, and Frank Weichert. Adversarial generation of continuous implicit shape representations. arXiv preprint arXiv:2002.00349, 2020.   
+[29] Jiabao Lei and Kui Jia. Analytic marching: An analytic meshing solution from deep implicit surface networks. In International Conference on Machine Learning, pages 5789–5798. PMLR, 2020.   
+[30] Manyi Li and Hao Zhang. D2im-net: Learning detail disentangled implicit fields from single images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10246– 10255, 2021.   
+[31] Yiyi Liao, Simon Donné, and Andreas Geiger. Deep marching cubes: Learning explicit surface representations. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018.   
+[32] Huan Ling, Jun Gao, Amlan Kar, Wenzheng Chen, and Sanja Fidler. Fast interactive object annotation with curve-gcn. In CVPR, 2019.   
+[33] Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson. Neural subdivision. ACM Trans. Graph., 39(4), 2020.   
+[34] Zhijian Liu, Haotian Tang, Yujun Lin, and Song Han. Point-voxel cnn for efficient 3d deep learning. In Advances in Neural Information Processing Systems, 2019.   
+[35] Charles Loop. Smooth subdivision surfaces based on triangles. January 1987.   
+[36] William E Lorensen and Harvey E Cline. Marching cubes: A high resolution 3d surface construction algorithm. ACM siggraph computer graphics, 21(4):163–169, 1987.   
+[37] Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In Proceedings of the IEEE international conference on computer vision, pages 2794–2802, 2017.   
+[38] Daniel Maturana and Sebastian Scherer. Voxnet: A 3d convolutional neural network for real-time object recognition. In 2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 922–928. IEEE, 2015.   
+[39] Lars Mescheder, Michael Oechsle, Michael Niemeyer, Sebastian Nowozin, and Andreas Geiger. Occupancy networks: Learning 3d reconstruction in function space. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4460–4470, 2019.   
+[40] Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In ECCV, 2020.   
+[41] Charlie Nash, Yaroslav Ganin, S. M. Ali Eslami, and Peter W. Battaglia. Polygen: An autoregressive generative model of 3d meshes. ICML, 2020.   
+[42] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 165–174, 2019.   
+[43] Despoina Paschalidou, Angelos Katharopoulos, Andreas Geiger, and Sanja Fidler. Neural parts: Learning expressive 3d shape abstractions with invertible neural networks. In Proceedings IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2021.
+
+[44] Songyou Peng, Michael Niemeyer, Lars Mescheder, Marc Pollefeys, and Andreas Geiger. Convolutional occupancy networks. In European Conference on Computer Vision (ECCV), 2020.
+
+[45] Edoardo Remelli, Artem Lukoianov, Stephan Richter, Benoit Guillard, Timur Bagautdinov, Pierre Baque, and Pascal Fua. Meshsdf: Differentiable iso-surface extraction. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 22468–22478. Curran Associates, Inc., 2020.
+
+[46] Gernot Riegler, Ali Osman Ulusoy, and Andreas Geiger. Octnet: Learning deep 3d representations at high resolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3577–3586, 2017.
+
+[47] Shunsuke Saito, Zeng Huang, Ryota Natsume, Shigeo Morishima, Angjoo Kanazawa, and Hao Li. Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization. In The IEEE International Conference on Computer Vision (ICCV), October 2019.
+
+[48] Shunsuke Saito, Tomas Simon, Jason Saragih, and Hanbyul Joo. Pifuhd: Multi-level pixel-aligned implicit function for high-resolution 3d human digitization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, June 2020.
+
+[49] Vincent Sitzmann, Julien N.P. Martel, Alexander W. Bergman, David B. Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. In Proc. NeurIPS, 2020.
+
+[50] Minhyuk Sung, Hao Su, Vladimir G Kim, Siddhartha Chaudhuri, and Leonidas Guibas. Complementme: Weakly-supervised component suggestions for 3d modeling. ACM Transactions on Graphics (TOG), 36(6):1–12, 2017.
+
+[51] Towaki Takikawa, Joey Litalien, Kangxue Yin, Karsten Kreis, Charles Loop, Derek Nowrouzezahrai, Alec Jacobson, Morgan McGuire, and Sanja Fidler. Neural geometric level of detail: Real-time rendering with implicit 3D shapes. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2021.
+
+[52] M. Tatarchenko, A. Dosovitskiy, and T. Brox. Octree generating networks: Efficient convolutional architectures for high-resolution 3d outputs. In IEEE International Conference on Computer Vision (ICCV), 2017.
+
+[53] Shubham Tulsiani, Hao Su, Leonidas J. Guibas, Alexei A. Efros, and Jitendra Malik. Learning shape abstractions by assembling volumetric primitives. In Computer Vision and Pattern Regognition (CVPR), 2017.
+
+[54] Nanyang Wang, Yinda Zhang, Zhuwen Li, Yanwei Fu, Wei Liu, and Yu-Gang Jiang. Pixel2mesh: Generating 3d mesh models from single rgb images. In Proceedings of the European Conference on Computer Vision (ECCV), pages 52–67, 2018.
+
+[55] Peng-Shuai Wang, Yang Liu, Yu-Xiao Guo, Chun-Yu Sun, and Xin Tong. O-CNN: Octree-based Convolutional Neural Networks for 3D Shape Analysis. ACM Transactions on Graphics (SIGGRAPH), 36(4), 2017.
+
+[56] Peng-Shuai Wang, Yang Liu, and Xin Tong. Deep octree-based cnns with output-guided skip connections for 3d shape and scene completion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 266–267, 2020.
+
+[57] Francis Williams, Matthew Trager, Joan Bruna, and Denis Zorin. Neural splines: Fitting 3d surfaces with infinitely-wide neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9949–9958, 2021.
+
+[58] Jiajun Wu, Chengkai Zhang, Tianfan Xue, William T Freeman, and Joshua B Tenenbaum. Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling. In Advances in Neural Information Processing Systems, pages 82–90, 2016.
+
+[59] Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1912–1920, 2015.
+
+[60] Qiangeng Xu, Weiyue Wang, Duygu Ceylan, Radomir Mech, and Ulrich Neumann. Disn: Deep implicit surface network for high-quality single-view 3d reconstruction. In Advances in Neural Information Processing Systems, pages 490–500, 2019.
+
+[61] Kangxue Yin, Zhiqin Chen, Siddhartha Chaudhuri, Matthew Fisher, Vladimir Kim, and Hao Zhang. Coalesce: Component assembly by learning to synthesize connections. In Proc. of 3DV, 2020.   
+[62] Chenyang Zhu, Kai Xu, Siddhartha Chaudhuri, Renjiao Yi, and Hao Zhang. SCORES: Shape composition with recursive substructure priors. ACM Transactions on Graphics, 37(6):Article 211, 2018.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] We provide extensive experiments in Sec. 4.   
+(b) Did you describe the limitations of your work? [Yes] We provide the discussion on limitations an failure cases in Supplement.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] We provide the discussion in the Board Impact section with further discussions in Supplement.   
+(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? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+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)? [No] The code is currently quite uncleaned and requires many dependencies. We are planning to release the code after cleaning.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We provide training details in both Sec. 4 in the main paper and Supplement.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] Training existing 3D models, including ours, on large-scale 3D datasets is too computation costly to repeat multiple times.   
+(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] We provide in the Supplement.
+
+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] We used ShapeNet [3] core dataset in Sec. 4.2. We also used official code to reproduce baselines with citations. In particular, ConvONet [44] and DECOR-GAN [6].   
+(b) Did you mention the license of the assets? [Yes] We provided the license of ShapeNet and Turbosquid.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No] The Turbosquid data we are using contains proprietary information.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] We discussed in the Sec. 4 and provide further details in the Supplementary Materials.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] We provide discussion on this in Supplement.
+
+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? [Yes] We provide details in the paper, with full text and screenshot in Supplement.   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [No] We did not anticipate the potential participant risks, as we only conduct human studies on generated animals.   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [Yes] We provide details in Supplement

parse/train/xN3XX6pKSD5/xN3XX6pKSD5_content_list.json

@@ -0,0 +1,1582 @@
+[
+    {
+        "type": "text",
+        "text": "Deep Marching Tetrahedra: a Hybrid Representation for High-Resolution 3D Shape Synthesis ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            122,
+            823,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tianchang Shen 1,2,3 Jun Gao1,2,3 Kangxue Yin 1 ",
+        "bbox": [
+            276,
+            223,
+            718,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Ming-Yu Liu 1 Sanja Fidler1,2,3 ",
+        "bbox": [
+            382,
+            260,
+            656,
+            276
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "NVIDIA1 University of Toronto2 Vector Institute3 ",
+        "bbox": [
+            334,
+            286,
+            656,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{frshen, jung, kangxuey, mingyul, sfidler}@nvidia.com ",
+        "bbox": [
+            339,
+            306,
+            658,
+            318
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            353,
+            535,
+            369
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce DMTET, a deep 3D conditional generative model that can synthesize high-resolution 3D shapes using simple user guides such as coarse voxels. It marries the merits of implicit and explicit 3D representations by leveraging a novel hybrid 3D representation. Compared to the current implicit approaches, which are trained to regress the signed distance values, DMTET directly optimizes for the reconstructed surface, which enables us to synthesize finer geometric details with fewer artifacts. Unlike deep 3D generative models that directly generate explicit representations such as meshes, our model can synthesize shapes with arbitrary topology. The core of DMTET includes a deformable tetrahedral grid that encodes a discretized signed distance function and a differentiable marching tetrahedra layer that converts the implicit signed distance representation to the explicit surface mesh representation. This combination allows joint optimization of the surface geometry and topology as well as generation of the hierarchy of subdivisions using reconstruction and adversarial losses defined explicitly on the surface mesh. Our approach significantly outperforms existing work on conditional shape synthesis from coarse voxel inputs, trained on a dataset of complex 3D animal shapes. Project page: https://nv-tlabs.github.io/DMTet/. ",
+        "bbox": [
+            233,
+            386,
+            766,
+            619
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            312,
+            655
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fields such as simulation, architecture, gaming, and film rely on high-quality 3D content with rich geometric details and complex topology. However, creating such content requires tremendous expert human effort. It takes a significant amount of development time to create each individual 3D asset. In contrast, creating rough 3D shapes with simple building blocks like voxels has been widely adopted. For example, Minecraft has been used by hundreds of millions of users for creating 3D content. Most of them are non-experts. Developing A.I. tools that enable regular people to upscale coarse, voxelized objects into high resolution, beautiful 3D shapes would bring us one step closer to democratizing high-quality 3D content creation. Similar tools can be envisioned for turning 3D scans of objects recorded by modern phones into high-quality forms. Our work aspires to create such capabilities. ",
+        "bbox": [
+            174,
+            665,
+            825,
+            790
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A powerful 3D representation is a critical component of a learning-based 3D content creation framework. A good 3D representation for high-quality reconstruction and synthesis should capture local geometric details and represent objects with arbitrary topology while also being memory and computationally efficient for fast inference in interactive applications. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            852
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, neural implicit representations [8, 39, 42, 51], which use a neural network to implicitly represent a shape via a signed distance field (SDF) or an occupancy field (OF), have emerged as an effective 3D representation. Neural implicits have the benefit of representing complex geometry and topology, not limited to a predefined resolution. The success of these methods has been shown in shape compression [49, 13, 51], single-image shape generation [47, 60, 48], and point cloud reconstruction [57]. However, most of the current implicit approaches are trained by regressing to SDF or OF values and cannot utilize an explicit supervision on the target surface, which imposes useful constraints for training. To mitigate this issue, several works [45, 31] proposed to utilize iso-surfacing techniques such as the Marching Cubes (MC) algorithm to extract a surface mesh from the implicit representation, which, however, is computationally expensive. ",
+        "bbox": [
+            174,
+            858,
+            823,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            189
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we introduce DMTET, a deep 3D conditional generative model for high-resolution 3D shape synthesis from user guides in the form of coarse voxels. In the heart of DMTET is a new differentiable shape representation that marries implicit and explicit 3D representations. In contrast to deep implicit approaches optimized for predicting sign distance (or occupancy) values, our model employs additional supervision on the surface, which empirically renders higher quality shapes with finer geometric details. Compared to methods that learn to directly generate explicit representations, such as meshes [54], by committing to a preset topology, our DMTET can produce shapes with arbitrary topology. Specifically, DMTET predicts the underlying surface parameterized by an implicit function encoded via a deformable tetrahedral grid. The underlying surface is converted into an explicit mesh with a Marching Tetrahedra (MT) algorithm, which we show is differentiable and more performant than the Marching Cubes. DMTET maintains efficiency by learning to adapt the grid resolution by deforming and selectively subdividing tetrahedra. This has the effect of spending computation only on the relevant regions in space. We achieve further gains in the overall quality of the output shape with learned surface subdivision. Our DMTET is end-to-end differentiable, allowing the network to jointly optimize the geometry and topology of the surface, as well as the hierarchy of subdivisions using a loss function defined explicitly on the surface mesh. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            416
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate our DMTET on two challenging tasks: 3D shape synthesis from coarse voxel inputs and point cloud 3D reconstruction. We outperform existing state-of-the-art methods by a significant margin while being 10 times faster than alternative implicit representation-based methods at inference time. In summary, we make the following technical contributions: ",
+        "bbox": [
+            176,
+            421,
+            825,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We show that using Marching Tetrahedra (MT) as a differentiable iso-surfacing layer allows topological change for the underlying shape represented by a implicit field, in contrast to the analysis in prior works [31, 45].   \n2. We incorporate MT in a DL framework and introduce DMTET, a hybrid representation that combines implicit and explicit surface representations. We demonstrate that the additional supervision (e.g. chamfer distance, adversarial loss) defined directly on the extracted surface from implicit field improves the shape synthesis quality.   \n3. We introduce a coarse-to-fine optimization strategy that scales DMTET to high resolution during training. We thus achieves better reconstruction quality than state-of-the-art methods on challenging 3D shape synthesis tasks, while requiring a lower computation cost. ",
+        "bbox": [
+            210,
+            488,
+            825,
+            636
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            651,
+            323,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We review the related work on learning-based 3D synthesis methods based on their 3D representations. ",
+        "bbox": [
+            176,
+            674,
+            823,
+            689
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Voxel-based Methods Early work [59, 10, 38] represented 3D shapes as voxels, which store the coarse occupancy (inside/outside) values on a regular grid, which makes powerful convolutional neural networks native and renders impressive results on 3D reconstruction and synthesis [12, 11, 58, 2]. For high-resolution shape synthesis, DECOR-GAN [6] transfers geometric details from a high-resolution shape represented in voxel to a low-resolution shape by utilizing a discriminator defined on 3D patches of the voxel grid. However, the computational and memory costs grow cubically as the resolution increases, prohibiting the reconstruction of fine geometric details and smooth curves. One common way to address this limitation is building hierarchical structures such as octrees [46, 52, 55, 56, 24, 52], which adapt the grid resolution locally based on the underlying shape. In this paper, we adopt a hierarchical deformable tetrahedral grid to utilize the resolution better. Unlike octree-based shape synthesis, our network learns grid deformation and subdivision jointly to better represent the surface without relying on explicit supervision from a pre-computed hierarchy. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            862
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep Implicit Fields (DIFs) represent a 3D shape as a zero level set of a continuous function parameterized by a neural network [39, 44, 17, 40]. This formulation can represent arbitrary typology and has infinite resolution. DIF-based shape synthesis approaches have demonstrated strong performance in many applications, including single view 3D reconstruction [60, 30, 47, 48], shape manipulation, and synthesis [26, 21, 28, 14, 1, 9]. However, as these approaches are trained by minimizing the reconstruction loss of function values at a set of sampled 3D locations (a rough proxy of the surface), they tend to render artifacts when synthesizing fine details. Furthermore, if one desires a mesh to be extracted from a DIF, an expensive iso-surfacing step based on Marching Cubes [36] or Marching Tetrahedra [15] is required. Due to the computational burden, iso-surfacing is often done on a smaller resolution, hence prone to quantization errors. Lei et al. [29] proposes an analytic meshing solution to reduce the error, but is only applicable to DIFs parametrized by MLPs with ReLU activation. Our representation scales to high resolution and does not require additional modification to the backward pass for training end-to-end. DMTET can represent arbitrary typology, and is trained via direct supervision on the generated surface. Recent works [1, 9] learn to regress unsigned distance to triangle soup or point cloud. However, their iso-surfacing formulation is not differentiable in contrast to DMTET. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d5058ec53aafbd0e0995b8e5ac5432565d0802e926641001c8ac4ebef8fb2be.jpg",
+        "image_caption": [
+            "Figure 1: DMTET reconstructs the shape implicitly in a coarse-to-fine manner by predicting the SDF defined on a deformable tetrahedral grid. It then converts the SDF to a surface mesh by a differentiable Marching Tetrahedra layer. DMTET is trained by optimizing the objective function defined on the final surface. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            87,
+            815,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            262,
+            825,
+            441
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Surface-based Methods directly predict triangular meshes and have achieved impressive results for reconstructing and synthesizing simpler shapes [54, 23, 5, 41, 7]. Typically, they predefined the topology of the shape, e.g. equivalent to a sphere [54, 5, 25], or a union of primitives [43, 53, 19] or a set of segmented parts [61, 62, 50]. As a result, they can not model a distribution of shapes with complex topology variations. Recently, DefTet [18] represents a mesh with a deformable tetrahedral grid where the grid vertex coordinates and the occupancy values are learned. However, similar to voxel-based methods, the computational costf increases cubically with the grid resolution. Furthermore, as the occupancy loss for supervising topology learning and the surface loss for supervising geometry learning do not support joint training, it tends to generate suboptimal results. In contrast, our method is able to synthesize high-resolution 3D shapes, not shown in previous work. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Deep Marching Tetrahedra ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            609,
+            433,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now introduce our DMTET for synthesizing high-quality 3D objects. The schematic illustration is provided in Fig. 1. Our model relies on a new, hybrid 3D representation specifically designed for high-resolution reconstruction and synthesis, which we describe in Sec. 3.1. In Sec. 3.2, we describe the neural network architecture of DMTET that predicts the shape representation from inputs such as coarse voxels. We provide the training objectives in Sec. 3.3. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            704
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 3D Representation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            720,
+            341,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We represent a shape using a sign distance field (SDF) encoded with a deformable tetrahedral grid, adopted from DefTet [18, 20]. The grid fully tetrahedralizes a unit cube, where each cell in the volume is a tetahedron with 4 vertices and faces. The key aspect of this representation is that the grid vertices can deform to represent the geometry of the shape more efficiently. While the original DefTet encoded occupancy defined on each tetrahedron, we here encode signed distance values defined on the vertices of the grid and represent the underlying surface implicitly (Sec. 3.1.1). The use of signed distance values, instead of occupancy values, provides more flexibility in representing the underlying surface. For greater representation power while keeping memory and computation manageable, we further selectively subdivide the tetrahedra around the predicted surface (Sec. 3.1.2). We convert the signed distance-based implicit representation into a triangular mesh using a marching tetrahedra layer, which we discuss in Sec. 3.1.3. The final mesh is further converted into a parameterized surface with a differentiable surface subdivision module, described in Sec. 3.1.4. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 Deformable Tetrahedral Mesh as an Approximation of an Implicit Function ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            751,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We adopt and extend the deformable tetrahedral grid introduced in Gao et al. [18], which we denote with $( V _ { T } , T )$ , where $V _ { T }$ are the vertices in the tetrahedral grid $T$ . Following the notation in [18], each tetrahedron $T _ { k } \\in T$ is represented with four vertices $\\left\\{ v _ { a _ { k } } , v _ { b _ { k } } , v _ { c _ { k } } , v _ { d _ { k } } \\right\\}$ , with $k \\in \\{ 1 , . . . . , K \\}$ , where $K$ is the total number of tetrahedra and $v _ { i _ { k } } \\in V _ { T }$ . ",
+        "bbox": [
+            174,
+            109,
+            826,
+            165
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We represent the sign distance field by interpolating SDF values defined on the vertices of the grid. Specifically, we denote the SDF value in vertex $v _ { i } \\in V _ { T }$ as $s ( v _ { i } )$ . SDF values for the points that lie inside the tetrahedron follow a barycentric interpolation of the SDF values of the four vertices that encapsulates the point. ",
+        "bbox": [
+            173,
+            171,
+            825,
+            228
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 Volume Subdivision ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            247,
+            362,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We represent shape in a coarse to fine manner for efficiency. We determine the surface tetrahedra $T _ { s u r f }$ by checking whether a tetrahedron has vertices with different SDF signs – indicating that it intersects the surface encoded by the SDF. We subdivide $T _ { s u r f }$ as well as their immediate neighbors and increase resolution by adding the mid point to each edge. We compute SDF values of the new vertices by averaging the SDF values on the edge (Fig. 2). ",
+        "bbox": [
+            174,
+            273,
+            604,
+            371
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/690ebadbdb5fb11a0781110c51057baf1fbf00e37c739b19a6285e80b9e34a71.jpg",
+        "image_caption": [
+            "Figure 2: Volume Subdivision: Each surface tet.(blue) is divided into 8 tet.(red) by adding midpoints. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            617,
+            227,
+            820,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 Marching Tetrahedra for converting between an Implicit and Explicit Representation ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            383,
+            560,
+            411
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/66197fc00f7d532542743103dce49d9e142b692a641aa4f468f4386db848bf60.jpg",
+        "image_caption": [
+            "Figure 3: Three unique surface configurations in MT. Vertex color indicates the sign of signed distance value. Notice that flipping the signs of all vertices will result in the same surface configuration. Position of the vertex is linearly interpolated along the edges with sign change. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            417,
+            464,
+            513
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use the Marching Tetrahedra [15] algorithm to convert the encoded SDF into an explicit triangular mesh. Given the SDF values $\\mathbf { \\bar { \\{ } }  s ( v _ { a } ) , s ( \\mathbf { \\bar { { v } } } _ { b } ) , s ( v _ { c } ) , s ( v _ { d } ) \\}$ of the vertices of a tetrahedron, MT determines the surface typology inside the tetrahedron based on the signs of $s ( v )$ , which is illustrated in Fig. 3. The total number of configurations is $2 ^ { 4 } = { \\bar { 1 } } 6$ , which falls into 3 unique cases after considering rotation symmetry. Once the surface typology inside the tetrahedron is identified, the vertex location of the iso-surface is computed at the zero crossings of the linear interpolation along the tetrahedron’s edges, as shown in Fig. 3. ",
+        "bbox": [
+            488,
+            416,
+            825,
+            595
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Prior works [45, 31] argue that the singularity in this formulation, i.e. when $s ( v _ { a } ) = s ( v _ { b } )$ , prevents the change of surface typology (sign change of $s ( v _ { a } ) )$ ) during training. However, we find that, in practise, the equation is only evaluated when $\\mathrm { s i g n } ( s ( v _ { a } ) ) \\neq \\mathrm { s i g n } ( s ( v _ { b } ) )$ . Thus, during training, the singularity never happens and the gradient from a loss defined on the extracted iso-surface (Sec. 3.3), can be back-propagated to both vertex positions and SDF values via the chain rule. A more detailed analysis is in the Appendix. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            685
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.4 Surface Subdivision ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            698,
+            364,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Having a surface mesh as output allows us to further increase the representation power and the visual quality of the shapes with a differentiable surface subdivision module. We follow the scheme of the Loop Subdivision method [35], but instead of using a fixed set of parameters for subdivision, we make these parameters learnable in DMTET. Specifically, learnable parameters include the positions of each mesh vertex $\\boldsymbol { v } _ { i } ^ { \\prime }$ , as well as $\\alpha _ { i }$ which controls the generated surface via weighting the smoothness of neighbouring vertices. Note that different from Liu et al. [33], we only predict the per-vertex parameter at the beginning and carry it over to subsequent subdivision iterations to attain a lower computational cost. We provide more details in Appendix. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 DMTET: 3D Deep Conditional Generative Model ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            835,
+            558,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our DMTET is a neural network that utilizes our proposed 3D representation and aims to output a high resolution 3D mesh $M$ from input $x$ (a point cloud or a coarse voxelized shape). We describe the architecture (Fig. 4) of the generator for each module of our 3D representation in Sec. 3.2.1, with the architecture of the discriminator presented in Sec. 3.2.2. Further details are in Appendix. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa49995de6dd2e0e3e4ada8be106cd973661cac4b1241747a493f2249be01cff.jpg",
+        "image_caption": [
+            "Figure 4: Our generator and discriminator architectures. The generator is composed of two parts—one utilizes MLP to generate the initial predictions for all grid vertices and the other uses GCN to refine the surface. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            61,
+            807,
+            178
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 3D Generator ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            231,
+            321,
+            246
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Input Encoder We use PVCNN [34] as an input encoder to extract a 3D feature volume $F _ { v o l } ( x )$ from a point cloud. When the input is a coarse voxelized shape, we sample points on its surface. We compute a feature vector $F _ { v o l } ( v , x )$ for a grid vertex $v \\in \\mathbb { R } ^ { 3 }$ via trilinear interpolation. ",
+        "bbox": [
+            174,
+            248,
+            825,
+            290
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Initial Prediction of SDF We predict the SDF value for each vertex in the initial deformable tetrahedral grid using a fully-connected network $s ( v ) = M L P ( F _ { v o l } ( v , x ) , v )$ . The fully-connected network additionally outputs a feature vector $f ( v )$ , which is used for the surface refinement in the volume subdivision stage. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Surface Refinement with Volume Subdivision After obtaining the initial SDF, we iteratively refine the surface and subdivide the tetrahedral grid. We first identify surface tetrahedra $T _ { s u r f }$ based on the current $s ( v )$ value. We then build a graph $G = ( V _ { s u r f } , E _ { s u r f } )$ , where $V _ { s u r f } , E _ { s u r f }$ correspond to the vertices and edges in $T _ { s u r f }$ . We then predict the position offsets $\\Delta v _ { i }$ and SDF residual values $\\Delta s ( v _ { i } )$ for each vertex $i$ in $V _ { s u r f }$ using a Graph Convolutional Network [32] (GCN): ",
+        "bbox": [
+            174,
+            359,
+            825,
+            431
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c23b00128dc037edafe2fde1487ee41eb4ff642d329832475e1941d503f3144b.jpg",
+        "text": "$$\n\\begin{array} { r c l } { f _ { v _ { i } } ^ { \\prime } } & { = } & { \\mathsf { c o n c a t } ( v _ { i } , s ( v _ { i } ) , F _ { v o l } ( v _ { i } , x ) , f ( v _ { i } ) ) , } \\\\ { ( \\Delta v _ { i } , \\Delta s ( v _ { i } ) , \\overline { { f ( v _ { i } ) } } ) _ { i = 1 , \\cdots N _ { s u r f } } } & { = } & { \\mathsf { G C N } \\big ( ( f _ { v _ { i } } ^ { \\prime } ) _ { i = 1 , \\cdots N _ { s u r f } } , G \\big ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            435,
+            743,
+            477
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $N _ { s u r f }$ is the total number of vertices in $V _ { s u r f }$ and $\\overline { { f ( v _ { i } ) } }$ is the updated per-vertex feature. The vertex position and the SDF value for vertex $v _ { i }$ are updated as $v _ { i } ^ { \\prime } = v _ { i } + \\Delta v _ { i }$ and $s ( v _ { i } ^ { \\prime } ) =$ $s ( v _ { i } ) + \\Delta s ( v _ { i } )$ . This refinement step can potentially flip the sign of the SDF values to refine the local typology, and also move the vertices thus improving the local geometry. ",
+        "bbox": [
+            174,
+            482,
+            825,
+            539
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After surface refinement, we perform the volume subdivision step followed by an additional surface refinement step. In particular, we re-identify $T _ { s u r f }$ and subdivide $T _ { s u r f }$ and their immediate neighbors. We drop the unsubdivided tetrahedra from the full tetrahedral grid in both steps, which saves memory and computation, as the size of the $T _ { s u r f }$ is proportional to the surface area of the object, and scales up quadratically rather than cubically as the grid resolution increases. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            616
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the SDF values and positions of the vertices are inherited from the level before subdivision, thus, the loss computed at the final surface can back-propagate to all vertices from all levels. Therefore, our DMTET automatically learns to subdivide the tetrahedra and does not need an additional loss term in the intermediate steps to supervise the learning of the octree hierarchy as in the prior work [52]. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learnable Surface Subdivision After extracting the surface mesh using MT, we can further apply learnable surface subdivision. Specifically, we build a new graph on the extracted mesh, and use GCN to predict the updated position of each vertex $\\boldsymbol { v } _ { i } ^ { \\prime }$ , and $\\alpha _ { i }$ for Loop Subvidision. This step removes the quantization errors and mitigates the approximation errors from the classic Loop Subdivision by adjusting $\\alpha _ { i }$ , which are fixed in the classic method. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            753
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 3D Discriminator ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            761,
+            346,
+            775
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We apply a 3D discriminator $D$ on the final surface predicted from the generator. We empirically find that using a 3D CNN from DECOR-GAN [6] as the discriminator on the signed distance field that is computed from the predicted mesh is effective to capture the local details. Specifically, we first randomly select a high-curvature vertex $v$ from the target mesh and compute the ground truth signed distance field $S _ { r e a l } \\in \\mathbb { R } ^ { N \\times N \\times N }$ at a voxelized region around $v$ . Similarly, we compute the signed distance field of the predicted surface mesh $M$ at the same location to obtain $S _ { p r e d } \\in \\mathbb { R } ^ { N \\times \\tilde { N } \\times N }$ . Note that $S _ { p r e d }$ is an analytical function of the mesh $M$ , and thus the gradient to $S _ { p r e d }$ can backpropagate to the vertex positions in $M$ . We feed $S _ { r e a l }$ or $S _ { p r e d }$ into the discriminator, along with the feature vector $F _ { v o l } ( v , x )$ in position $v$ . The discriminator then predicts the probability indicating whether the input comes from the real or generated shapes. ",
+        "bbox": [
+            173,
+            777,
+            826,
+            916
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Loss Function ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            90,
+            312,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "DMTET is end-to-end trainable. We supervise all modules to minimize the error defined on the final predicted mesh $M$ . Our loss function contains three different terms: a surface alignment loss to encourage the alignment with ground truth surface, an adversarial loss to improve realism of the generated shape, and regularizations to regularize the behavior of SDF and vertex deformations. ",
+        "bbox": [
+            174,
+            109,
+            825,
+            165
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Surface Alignment loss We sample a set of points $P _ { g t }$ from the surface of the ground truth mesh $M _ { g t }$ . Similarly, we also sample a set of points from $M _ { p r e d }$ to obtain $P _ { p r e d }$ , and minimize the L2 Chamfer Distance and the normal consistency loss between $P _ { g t }$ and $P _ { p r e d }$ : ",
+        "bbox": [
+            174,
+            171,
+            825,
+            214
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e64ab678ee6659ce63b55c98d5f2f734f874712d27e15225187c2b8e7093ea13.jpg",
+        "text": "$$\nL _ { \\mathrm { c d } } = \\sum _ { p \\in P _ { p r e d } } \\operatorname* { m i n } _ { q \\in P _ { g t } } | | p - q | | _ { 2 } + \\sum _ { q \\in P _ { g t } } \\operatorname* { m i n } _ { p \\in P _ { p r e d } } | | q - p | | _ { 2 } , L _ { \\mathrm { n o m a l } } = \\sum _ { p \\in P _ { p r e d } } ( 1 - | \\Vec { \\mathbf { n } } _ { p } \\cdot \\Vec { \\mathbf { n } } _ { \\Vec { q } } | ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            218,
+            776,
+            255
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { q }$ is the point that corresponds to $p$ when computing the Chamfer Distance, and $\\vec { \\bf n } _ { p } , \\vec { \\bf n } _ { \\hat { q } }$ denotes the normal direction at point $p , \\hat { q }$ . ",
+        "bbox": [
+            174,
+            258,
+            825,
+            287
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Adversarial Loss We use the adversarial loss proposed in LSGAN [37]: ",
+        "bbox": [
+            174,
+            292,
+            663,
+            309
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17f344150cf5ac968e7b3ff206f3a406b00d72d8b6b004e8975ea72d1606bac8.jpg",
+        "text": "$$\nL _ { \\mathrm { D } } = \\frac { 1 } { 2 } [ ( D ( M _ { g t } ) - 1 ) ^ { 2 } + D ( M _ { p r e d } ) ^ { 2 } ] , L _ { \\mathrm { G } } = \\frac { 1 } { 2 } [ ( D ( M _ { p r e d } ) - 1 ) ^ { 2 } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            310,
+            714,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Regularizations The above loss functions operate on the extracted surface, thus, only the vertices that are close to the iso-surface in the tetrahedral grid receive gradients, while the other vertices do not. Moreover, the surface losses do not provide information about what is inside/outside, since flipping the SDF sign of all vertices in a tetrahedron would result in the same surface being extracted by MT. This may lead to disconnected components during training. To alleviate this issue, we add a SDF loss to regularize SDF values: ",
+        "bbox": [
+            173,
+            352,
+            825,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/776fd095945e78462a0165ae55b342a5542feb18a1f752dc0ac69338d741825d.jpg",
+        "text": "$$\nL _ { \\mathrm { S D F } } = \\sum _ { v _ { i } \\in V _ { T } } | s ( v _ { i } ) - S D F ( v _ { i } , M _ { g t } ) | ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            438,
+            617,
+            473
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $S D F ( v _ { i } , M _ { g t } )$ denotes the SDF value of point $v _ { i }$ to the mesh $M _ { g t }$ . In addition, we apply the $L _ { 2 }$ regularization loss on the predicted vertex deformations to avoid artifacts: $\\begin{array} { r } { L _ { \\mathrm { d e f } } = \\sum _ { v _ { i } \\in V _ { T } } | | \\Delta v _ { i } | | _ { 2 } } \\end{array}$ . ",
+        "bbox": [
+            169,
+            477,
+            825,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The final loss is a weighted sum of all five loss terms: ",
+        "bbox": [
+            171,
+            511,
+            526,
+            526
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dda99802456be2f83ede0a92476294d583b92d4aa933604c884ab3838aa4b2aa.jpg",
+        "text": "$$\nL = \\lambda _ { \\mathrm { c d } } L _ { \\mathrm { c d } } + \\lambda _ { \\mathrm { n o r m a l } } L _ { \\mathrm { n o r m a l } } + \\lambda _ { \\mathrm { G } } L _ { \\mathrm { G } } + \\lambda _ { \\mathrm { S D F } } L _ { \\mathrm { S D F } } + \\lambda _ { \\mathrm { d e f } } L _ { \\mathrm { d e f } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            530,
+            684,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { \\mathrm { c d } } , \\lambda _ { \\mathrm { n o r m a l } } , \\lambda _ { \\mathrm { G } } , \\lambda _ { \\mathrm { S D F } } , \\lambda _ { \\mathrm { d e f } }$ are hyperparameters (provided in the Supplement). ",
+        "bbox": [
+            178,
+            550,
+            717,
+            565
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            577,
+            313,
+            593
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate DMTET in the challenging application of generating high-quality animal shapes from coarse voxels. We further evaluate DMTET in reconstructing 3D shapes from noisy point clouds on ShapeNet by comparing to existing state-of-the-art methods. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 3D Shape Synthesis from Coarse Voxels ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            650,
+            490,
+            665
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Experimental Settings We collected 1562 animal models from the TurboSquid website1. These models have a wide range of diversity, ranging from cats, dogs, bears, giraffes, to rhinoceros, goats, etc. We provide visualizations in Supplement. Among 1562 shapes, we randomly select 1120 shapes for training, and the remaining 442 shapes for testing. We follow the pipeline in Kaolin [27] to convert shapes to watertight meshes. To prepare the input to the network, we first voxelize the mesh into the resolution of $1 6 ^ { \\overleftarrow { 3 } }$ , and then sample 3000 points from the surface after applying marching cubes to the $1 6 ^ { 3 }$ voxel grid. Note that this preprocessing is agnostic to the representation of the input coarse shape, allowing us to evaluate on different resolution voxels, or even meshes. ",
+        "bbox": [
+            173,
+            669,
+            825,
+            780
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare our model with the official implementation of ConvOnet [44], which achieved SOTA performance on voxel upsampling. We also compare to DECOR-GAN [6], which obtained impressive results on transferring styles from a high-resolution voxel shape to a low-resolution voxel. Note that the original setting of DECOR-GAN is different from ours. For a fair comparison, we use all 1120 training shapes as the high-resolution style shapes during training, and retrieve the closet training shape to the test shape as the style shape during inference, which we refer as DECOR-Retv. We also compare against a randomly selected style shape as reference, denoted as DECOR-Rand. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "1https://www.turbosquid.com, we obtain consent via an agreement with TurboSquid, and following license at https://blog.turbosquid.com/turbosquid-3d-model-license/ ",
+        "bbox": [
+            173,
+            885,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4b1bbd56197269ad4335baabf87fb00fe595064f3e4ec463efdf1d0b619d8092.jpg",
+        "image_caption": [
+            "Figure 5: Qualitative results on 3D shapes Synthesis from Coarse Voxels. Comparing with all baselines, our method reconstructs shapes with much higher quality. Adding GAN further improves the realism of the generated shape. We also show the retrieved shapes from the training set in the second last column. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            84,
+            812,
+            501
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Metrics We evaluate L2 and L1 Chamfer Distance, as well as normal consistency score to assess how well the methods reconstruct the corresponding high-resolution shape following [44]. We also report Light Field Distance [4] (LFD) which measures the visual similarity in 2D rendered views. In addition, we evaluate Cls score following [6]. Specifically, we render the predicted 3D shapes and train a patch-based image classifier to distinguish whether images are from the renderings of real or generated shapes. The mean classification accuracy of the trained classifier is reported as Cls (lower is better). More details are in the Supplement. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            654
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experimental Results We provide quantitative results in Table 1 with qualitative examples in Fig. 5. Our DMTET achieves significant improvements over all baselines in terms of all metrics. Compared to both ConvOnet [44] and DECORGAN [6], our DMTET reconstructs shapes with better quality when training without adversarial loss (5th column in Fig. 5). Further geometric details, including nails, ears, eyes, mouths, etc, are captured when trained with the adversarial loss (6th column in Fig. 5), significantly improving the realism and visual quality of the generated shape. To demonstrate the generalization ability of our ",
+        "bbox": [
+            174,
+            662,
+            498,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/51a010aed7513fe7dfaf318abbe714fe80699ba1341c5a33b907b24eb8d658e0.jpg",
+        "image_caption": [
+            "Figure 6: Qualitative Results of synthesizing highresolution shapes from coarse voxels collected online. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            521,
+            650,
+            818,
+            810
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "DMTET, we collect human-created low-resolution voxels from Turbosquid (shapes unseen in training). We provide qualitative results in Fig. 6. Despite the fact that these human-created shapes have noticeable differences with our coarse voxels used in training, e.g., different ratios of body parts compared with our training shapes (larger head, thinner legs, longer necks), our model faithfully generates high-quality 3D details conditioned on each coarse voxel – an exciting result. ",
+        "bbox": [
+            174,
+            843,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/df1e7551c170f87070b67404a130987968feb5b96f31ec1b8553941510bf4ad7.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Super Resolution of Animal Shapes: DMTET significantly outperforms all baselines in all metrics. "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>L2 Chamfer↓</td><td rowspan=1 colspan=1>L1 Chamfer↓</td><td rowspan=1 colspan=1>Norm. Cons.↑</td><td rowspan=1 colspan=1>LFD↓</td><td rowspan=1 colspan=1>Cls</td></tr><tr><td rowspan=1 colspan=1>ConvOnet [44]</td><td rowspan=1 colspan=1>0.83</td><td rowspan=1 colspan=1>2.41</td><td rowspan=1 colspan=1>0.901</td><td rowspan=1 colspan=1>3220</td><td rowspan=1 colspan=1>0.63</td></tr><tr><td rowspan=1 colspan=1>DECOR [6]-Retv.</td><td rowspan=1 colspan=1>1.32</td><td rowspan=1 colspan=1>3.81</td><td rowspan=1 colspan=1>0.876</td><td rowspan=1 colspan=1>3689</td><td rowspan=1 colspan=1>0.66</td></tr><tr><td rowspan=1 colspan=1>DECOR [6]-Rand.</td><td rowspan=1 colspan=1>2.38</td><td rowspan=1 colspan=1>6.85</td><td rowspan=1 colspan=1>0.797</td><td rowspan=1 colspan=1>5338</td><td rowspan=1 colspan=1>0.67</td></tr><tr><td rowspan=1 colspan=1>DMTET wo Adv.</td><td rowspan=1 colspan=1>0.76</td><td rowspan=1 colspan=1>2.20</td><td rowspan=1 colspan=1>0.916</td><td rowspan=1 colspan=1>2846</td><td rowspan=1 colspan=1>0.58</td></tr><tr><td rowspan=1 colspan=1>DMTET</td><td rowspan=1 colspan=1>0.75</td><td rowspan=1 colspan=1>2.19</td><td rowspan=1 colspan=1>0.918</td><td rowspan=1 colspan=1>2823</td><td rowspan=1 colspan=1>0.54</td></tr></table>",
+        "bbox": [
+            241,
+            85,
+            754,
+            160
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "User Studies We conduct user studies via Amazon Machanical Turk (AMT) to further evaluate the performance of all methods. In particular, we present two shapes that are predicted from two different models to the AMT workers and ask them to evaluate which one is a better looking shape and which one features more realistic details. Detailed experimental settings are provided in the Supplement. We compare DMTET against ConvONet [44], DECOR [6]-Retv, as well as DMTET without adversarial loss (w.o. Adv.). Quantitative results are reported in Table 2. Human judges agree that the shapes generated from our model have better details, compared to all baselines, in a vast majority of the cases. Ablations on using adversarial loss demonstrate the effectiveness of generating higher quality geometry using a discriminator during training. ",
+        "bbox": [
+            173,
+            199,
+            825,
+            325
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ablation Studies To evaluate the effectiveness of our volume subdivision and surface subdivision modules, we ablate by sequentially introducing them to the base model (we refer as $\\mathrm { D M T E T } _ { B }$ ) which we train on 100-resolution uniform tetrahedral grid without both volume and surface subdivision modules and adversarial ",
+        "bbox": [
+            174,
+            342,
+            485,
+            438
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a97fa21e21618d409e2083e585facfbf1958aaa1268147ae1b4384ddd53a54e6.jpg",
+        "table_caption": [
+            "Table 2: User Study on 3D Shape Synthesis from Coarse voxels. In each cell, we report percentages of shapes for which the users agree are better looking (left) or have better details (right). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>ConvONet[44]</td><td rowspan=1 colspan=1>DECOR[6]-Retv.</td><td rowspan=1 colspan=1>DMTETWoAdv</td></tr><tr><td rowspan=1 colspan=1>Baselinewins</td><td rowspan=1 colspan=1>5% 15%</td><td rowspan=1 colspan=1>26%/17%</td><td rowspan=1 colspan=1>29% /25%</td></tr><tr><td rowspan=1 colspan=1>DMTETwins</td><td rowspan=1 colspan=1>95%/95%</td><td rowspan=1 colspan=1>74% /83%</td><td rowspan=1 colspan=1>71% 175%</td></tr></table>",
+        "bbox": [
+            503,
+            340,
+            818,
+            372
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "loss. We conduct user studies to evaluate the improvement after each step using the protocol described in the above paragraph. We first reduce the initial resolution to 70 and employ volume subdivision to support higher output resolution (we refer this model as $\\mathbf { D M T E T } _ { V }$ ) and compare with $\\mathbf { D M T E T } _ { B }$ Predictions by $\\mathrm { D M T E T } _ { V }$ wins $78 \\%$ of cases over $\\mathrm { D M T E T } _ { B }$ for better looking, and $61 \\%$ of cases for realistic details, showing that the volume subdivision module is effective in synthesizing shape details. We then add surface subdivision on top of the $\\mathbf { D M T E T } _ { V }$ and compare with it. The new model wins $62 \\%$ of cases over $\\mathrm { D M T E T } _ { V }$ for better looking, and $62 \\%$ of cases for realistic details as well, demonstrating the effect of surface subdivision module in enhancing the shape details. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Point Cloud 3D Reconstruction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            559,
+            429,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental Settings We follow the setting from DefTet [18], and use all 13 categories in ShapeNet [3] core data2, which we pre-process using Kaolin [27] to watertight meshes. We sample 5000 points for each shape and add Gaussian noise with zero mean of standard deviation 0.005. For quantitative evaluation, we report the L1 Chamfer Distance in the main paper, and refer readers to the Supplement for results in other metrics (3D IoU, L2 Chamfer Distance and F1 score). We additionally report average inference time on the same Nvidia V100 GPU. ",
+        "bbox": [
+            174,
+            578,
+            825,
+            661
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare DMTET against state-of-the-art 3D reconstruction approaches using different representations: voxels [10], deforming a mesh with a fixed template [54], deforming a mesh generated from a volumetric representation [22], DefTet [18], and implicit functions [44]. For a fair comparison, we use the same point cloud encoder for all the methods, and adopt the decoders in the original papers to generate shapes in different representations. We also remove the adversarial loss in this application, since baselines also do not have it. We further compare with oracle performance of MC/MT where the ground truth SDF is utilized to extract iso-surface using MC/MT. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            765
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental Results Quantitative results are summarized in Table 3, with a few qualitative examples shown in Fig. 7. Compared to DMC [31], which also predicts the SDF values and supervises with a surface loss, DMTET achieves much better reconstruction quality since training using the marching tetrahedra layer is more efficient than calculating an expectation over all possible configurations within one grid cell as done in DMC [31]. Compared to a method that deforms a fixed template (sphere) [54], we reconstruct shapes with different topologies, achieving more faithful results compared to the ground truth shape. When compared with other explicit surface representations that also support different topology [18, 22], our method achieves higher quality results for local geometry, benefiting from the fact that the typology is jointly optimized with the geometry, whereas it is separately supervised by an occupancy loss in [18, 22]. Compared to a neural implicit method [44], we generate higher quality shapes with less artifacts, while running significantly faster at inference. Finally, compared to a voxel-based method [10] at the same resolution, our method recovers more geometric details, benefiting from the predicted vertex deformations as well as the surface loss. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            885
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7bd33ba212cc763b44caca6f6748c49136fb2f72c0e054ac16d83ee028728622.jpg",
+        "image_caption": [
+            "Figure 7: Qualitative results on 3D Reconstruction from Point Clouds: Our model reconstructs shapes with more geometric details compared to baselines. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            63,
+            823,
+            404
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1585e0bf24ed2ee50f6489bda6d09d78fef7cc3f9d898b9448c222e335133ad1.jpg",
+        "table_caption": [
+            "Table 3: Quantitative Results on Point Cloud Reconstruction (Chamfer L1). Note that all the networks in the baselines are not designed for this task, and thus we use the same encoder and their decoder for a fair comparison. We also ablate ourselves by operating on fixed grid (DMTET wo (Def, Vol., Surf.)), removing volume subdivision (DMTET wo Vol.), or surface subdivision (DMTET wo Surf.), or the both (DMTET wo (Vol., Surf.)). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Category</td><td>Airplane</td><td>Bench</td><td>Dresser</td><td>Car</td><td>Chair</td><td>Display</td><td>Lamp</td><td>Speaker</td><td>Rifle</td><td>Sofa</td><td>Table</td><td>Phone</td><td>Vessel</td><td>Mean↓</td><td>Time(ms)</td></tr><tr><td>3D-R2N2[10]</td><td>1.48</td><td>1.59</td><td>1.64</td><td>1.62</td><td>1.70</td><td>1.66</td><td>1.74</td><td>1.74</td><td>1.37</td><td>1.60</td><td>1.78</td><td>1.55</td><td>1.51</td><td>1.61</td><td>174</td></tr><tr><td>DMC [31]</td><td>1.57</td><td>1.47</td><td>1.29</td><td>1.67</td><td>1.44</td><td>1.25</td><td>2.15</td><td>1.49</td><td>1.45</td><td>1.19</td><td>1.33</td><td>0.88</td><td>1.70</td><td>1.45</td><td>349</td></tr><tr><td>Pixel2mesh [54]</td><td>0.98</td><td>1.28</td><td>1.44</td><td>1.19</td><td>1.91</td><td>1.25</td><td>2.07</td><td>1.61</td><td>0.91</td><td>1.15</td><td>1.82</td><td>0.83</td><td>1.12</td><td>1.35</td><td>30</td></tr><tr><td>ConvOnet [44]</td><td>0.82</td><td>0.95</td><td>0.96</td><td>1.12</td><td>1.03</td><td>0.93</td><td>1.22</td><td>1.12</td><td>0.79</td><td>0.91</td><td>0.94</td><td>0.67</td><td>0.99</td><td>0.95</td><td>866</td></tr><tr><td>MeshRCNN [22]</td><td>0.88</td><td>1.01</td><td>1.05</td><td>1.14</td><td>1.10</td><td>0.99</td><td>1.20</td><td>1.21</td><td>0.83</td><td>0.96</td><td>1.00</td><td>0.71</td><td>1.03</td><td>1.01</td><td>228</td></tr><tr><td>DEFTET[18]</td><td>0.85</td><td>0.94</td><td>0.97</td><td>1.13</td><td>1.04</td><td>0.92</td><td>1.28</td><td>1.17</td><td>0.85</td><td>0.90</td><td>0.93</td><td>0.65</td><td>0.99</td><td>0.97</td><td>61</td></tr><tr><td>DMTET wo (Def, Vol., Surf.)]</td><td>0.82</td><td>0.96</td><td>0.94</td><td>0.98</td><td>0.99</td><td>0.90</td><td>1.04</td><td>1.03</td><td>0.80</td><td>0.86</td><td>0.93</td><td>0.65</td><td>0.89</td><td>0.91</td><td></td></tr><tr><td>DMTET wo (Vol.,Surf.)</td><td>0.69</td><td>0.82</td><td>0.88</td><td>0.92</td><td>0.92</td><td>0.82</td><td>0.89</td><td>0.97</td><td>0.65</td><td>0.81</td><td>0.84</td><td>0.61</td><td>0.80</td><td>0.81</td><td>52 52</td></tr><tr><td>DMTET wo Vol.</td><td>0.65</td><td>0.78</td><td>0.84</td><td>0.89</td><td>0.89</td><td>0.79</td><td>0.86</td><td>0.95</td><td>0.61</td><td>0.78</td><td>0.79</td><td>0.60</td><td>0.78</td><td>0.79</td><td>67</td></tr><tr><td>DMTET wo Surf.</td><td>0.63</td><td>0.77</td><td>0.84</td><td>0.88</td><td>0.88</td><td>0.79</td><td>0.84</td><td>0.94</td><td>0.60</td><td>0.78</td><td>0.79</td><td>0.59</td><td>0.76</td><td>0.78</td><td>108</td></tr><tr><td>DMTET</td><td>0.62</td><td>0.76</td><td>0.83</td><td>0.87</td><td>0.88</td><td>0.78</td><td>0.84</td><td>0.94</td><td>0.59</td><td>0.77</td><td>0.78</td><td>0.57</td><td>0.76</td><td>0.77</td><td>129</td></tr></table>",
+        "bbox": [
+            174,
+            438,
+            825,
+            544
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            625,
+            826,
+            694
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.2.1 Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            710,
+            284,
+            726
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We investigate how each component in our representation affects the performance and reconstruction quality. ",
+        "bbox": [
+            174,
+            729,
+            575,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparisons with Oracle Performance of MC/MT We first demonstrate the effect of learning on explicit surface via MT. We compare with the oracle performance of extracting the iso-surface with MT/MC from the ground truth signed distance fields on the Chair test set in ShapeNet, which contains diverse high-quality details. Specifically, for MC/MT, we first compute the discretized SDF at different grid resolutions, and compare the extracted surface to the ground truth surface. ",
+        "bbox": [
+            174,
+            766,
+            576,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca6df925a51dd1d96de02ca23469bf92f0ad16b5ce533ad7239d3a0faf8c0a73.jpg",
+        "image_caption": [
+            "Figure 8: Comparing our DMTET with oracle performance of MC and MT. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            593,
+            717,
+            821,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As shown in Fig. 8, MT consistently outperforms MC when querying the same number of points. We found the staggered grids pattern in tetrahedral grid [16, 18] better captures thin structures at a limited resolution (Fig. 9). This makes MT a better choice for efficiency reasons. The usage of tetrahedral mesh in DMTET follows this motivation. Without deforming the grid, DMTET outperforms the oracle performance of MT by a large margin when querying the same number of points, although DMTET predicts the surface from noisy point cloud. This demonstrates that directly optimizing the reconstructed surface can mitigate the discretization errors imposed by MT to a large extent. ",
+        "bbox": [
+            173,
+            883,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            161
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/430b26fbbcba7dc56f2f3f84c2d486be08926dbae7665f553626b9f093f6b9b3.jpg",
+        "image_caption": [
+            "Figure 9: We compare trained DMTET to oracle performance of MT and MC. Number in bracket indicates number of SDF points queried. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            167,
+            467,
+            347
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ablation Studies We further provide ablation studies on the entire ShapeNet test set, which is summarized in Tab. 3. We first compare the version where we only predict SDF values without learning to deform the vertices and volume/surface subdivision with the version that predicts both SDF and the deformation. Predicting deformation along with SDF is significantly more performant, since vertex movements allow for a better reconstruction of the underlying surface. This is especially true for categories with thin structures (e.g. lamp) where the grid vertices are desired to align with them. We further ablate the use of volume subdivision and surface subdivision. We show that each component provides an improvement. In particular, volume subdivision has a significant ",
+        "bbox": [
+            501,
+            171,
+            825,
+            392
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "improvement for object categories with fine-grained structural details, such as airplane and lamp, which require higher grid resolutions to model the occupancy change. Surface subdivision generates shapes with a parametric surface, avoiding the quantization errors in the planar faces and produces more visually pleasing results. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            446
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            458,
+            299,
+            474
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduced a deep 3D conditional generative model that can synthesize highresolution 3D shapes using simple user guides such as coarse voxels. Our DMTET features a novel 3D representation that marries implicit and explicit representations by leveraging the advantages of both. We experimentally show that our approach synthesizes significantly higher quality shapes with better geometric details than existing methods, confirmed by quantitative metrics and an extensive user study. By showcasing the ability to upscale coarse voxels such as Minecraft shapes, we hope that we take one step closer to democratizing 3D content creation. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Broad Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            323,
+            604
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Many fields such as AR/VR, robotics, architecture, gaming and film rely on high-quality 3D content. Creating such content, however, requires human experts, i.e., experienced artists, and a significant amount of development time. In contrast, platforms like Minecraft enable millions of users around the world to carve out coarse shapes with simple blocks. Our work aims at creating A.I. tools that would enable even novice users to upscale simple, low-resolution shapes into high resolution, beautiful 3D content. Our method currently focuses on 3D animal shapes. We are not currently aware of and do not foresee nefarious use cases of our method. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            390,
+            744
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was funded by NVIDIA. Tianchang Shen and Jun Gao acknowledge additional revenue in the form of student scholarships from University of Toronto and the Vector Institute, which are not in direct support of this work. ",
+        "bbox": [
+            174,
+            758,
+            825,
+            801
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            821,
+            267,
+            838
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Matan Atzmon and Yaron Lipman. Sal: Sign agnostic learning of shapes from raw data. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 2565–2574, 2020.   \n[2] Andrew Brock, Theodore Lim, James M Ritchie, and Nick Weston. Generative and discriminative voxel modeling with convolutional neural networks. arXiv preprint arXiv:1608.04236, 2016. [3] 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.   \n[4] Ding-Yun Chen, Xiao-Pei Tian, Yu-Te Shen, and Ming Ouhyoung. On visual similarity based 3d model retrieval. In Computer graphics forum, volume 22, pages 223–232. Wiley Online Library, 2003.   \n[5] Wenzheng Chen, Jun Gao, Huan Ling, Edward Smith, Jaakko Lehtinen, Alec Jacobson, and Sanja Fidler. Learning to predict 3d objects with an interpolation-based differentiable renderer. In Advances In Neural Information Processing Systems, 2019.   \n[6] Zhiqin Chen, Vladimir G. Kim, Matthew Fisher, Noam Aigerman, Hao Zhang, and Siddhartha Chaudhuri. Decor-gan: 3d shape detailization by conditional refinement. Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[7] Zhiqin Chen, Andrea Tagliasacchi, and Hao Zhang. Bsp-net: Generating compact meshes via binary space partitioning. Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020. [8] Zhiqin Chen and Hao Zhang. Learning implicit fields for generative shape modeling. Proceedings of IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   \n[9] Julian Chibane, Aymen Mir, and Gerard Pons-Moll. Neural unsigned distance fields for implicit function learning. In Advances in Neural Information Processing Systems (NeurIPS), December 2020.   \n[10] Christopher B Choy, Danfei Xu, JunYoung Gwak, Kevin Chen, and Silvio Savarese. 3d-r2n2: A unified approach for single and multi-view 3d object reconstruction. In European conference on computer vision, pages 628–644. Springer, 2016.   \n[11] Angela Dai, Daniel Ritchie, Martin Bokeloh, Scott Reed, Jürgen Sturm, and Matthias Nießner. Scancomplete: Large-scale scene completion and semantic segmentation for 3d scans. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4578–4587, 2018.   \n[12] Angela Dai, Charles Ruizhongtai Qi, and Matthias Nießner. Shape completion using 3d-encoder-predictor cnns and shape synthesis. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5868–5877, 2017.   \n[13] Thomas Davies, Derek Nowrouzezahrai, and Alec Jacobson. Overfit neural networks as a compact shape representation. arXiv preprint arXiv:2009.09808, 2020.   \n[14] Yu Deng, Jiaolong Yang, and Xin Tong. Deformed implicit field: Modeling 3d shapes with learned dense correspondence. In IEEE Computer Vision and Pattern Recognition, 2021.   \n[15] Akio Doi and Akio Koide. An efficient method of triangulating equi-valued surfaces by using tetrahedral cells. IEICE TRANSACTIONS on Information and Systems, 74(1):214–224, 1991.   \n[16] Crawford Doran, Athena Chang, and Robert Bridson. Isosurface stuffing improved: acute lattices and feature matching. In ACM SIGGRAPH 2013 Talks, pages 1–1, 2013.   \n[17] Yueqi Duan, Haidong Zhu, He Wang, Li Yi, Ram Nevatia, and Leonidas J Guibas. Curriculum deepsdf. In European Conference on Computer Vision, pages 51–67. Springer, 2020.   \n[18] Jun Gao, Wenzheng Chen, Tommy Xiang, Clement Fuji Tsang, Alec Jacobson, Morgan McGuire, and Sanja Fidler. Learning deformable tetrahedral meshes for 3d reconstruction. In Advances In Neural Information Processing Systems, 2020.   \n[19] Jun Gao, Chengcheng Tang, Vignesh Ganapathi-Subramanian, Jiahui Huang, Hao Su, and Leonidas J Guibas. Deepspline: Data-driven reconstruction of parametric curves and surfaces. arXiv preprint arXiv:1901.03781, 2019.   \n[20] Jun Gao, Zian Wang, Jinchen Xuan, and Sanja Fidler. Beyond fixed grid: Learning geometric image representation with a deformable grid. In ECCV, 2020.   \n[21] Lin Gao, Jie Yang, Tong Wu, Yu-Jie Yuan, Hongbo Fu, Yu-Kun Lai, and Hao Zhang. Sdm-net: Deep generative network for structured deformable mesh. ACM Transactions on Graphics (TOG), 38(6):1–15, 2019.   \n[22] Georgia Gkioxari, Jitendra Malik, and Justin Johnson. Mesh r-cnn. In Proceedings of the IEEE International Conference on Computer Vision, pages 9785–9795, 2019.   \n[23] Thibault Groueix, Matthew Fisher, Vladimir G Kim, Bryan C Russell, and Mathieu Aubry. A papier-mâché approach to learning 3d surface generation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 216–224, 2018.   \n[24] Christian Häne, Shubham Tulsiani, and Jitendra Malik. Hierarchical surface prediction for 3d object reconstruction. In 2017 International Conference on 3D Vision (3DV), pages 412–420. IEEE, 2017.   \n[25] Rana Hanocka, Gal Metzer, Raja Giryes, and Daniel Cohen-Or. Point2mesh: A self-prior for deformable meshes. ACM Trans. Graph., 39(4), 2020.   \n[26] Zekun Hao, Hadar Averbuch-Elor, Noah Snavely, and Serge Belongie. Dualsdf: Semantic shape manipulation using a two-level representation. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 7631–7641, 2020.   \n[27] Krishna Murthy J., Edward Smith, Jean-Francois Lafleche, Clement Fuji Tsang, Artem Rozantsev, Wenzheng Chen, Tommy Xiang, Rev Lebaredian, and Sanja Fidler. Kaolin: A pytorch library for accelerating 3d deep learning research. arXiv:1911.05063, 2019.   \n[28] Marian Kleineberg, Matthias Fey, and Frank Weichert. Adversarial generation of continuous implicit shape representations. arXiv preprint arXiv:2002.00349, 2020.   \n[29] Jiabao Lei and Kui Jia. Analytic marching: An analytic meshing solution from deep implicit surface networks. In International Conference on Machine Learning, pages 5789–5798. PMLR, 2020.   \n[30] Manyi Li and Hao Zhang. D2im-net: Learning detail disentangled implicit fields from single images. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 10246– 10255, 2021.   \n[31] Yiyi Liao, Simon Donné, and Andreas Geiger. Deep marching cubes: Learning explicit surface representations. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018.   \n[32] Huan Ling, Jun Gao, Amlan Kar, Wenzheng Chen, and Sanja Fidler. Fast interactive object annotation with curve-gcn. In CVPR, 2019.   \n[33] Hsueh-Ti Derek Liu, Vladimir G. Kim, Siddhartha Chaudhuri, Noam Aigerman, and Alec Jacobson. Neural subdivision. ACM Trans. Graph., 39(4), 2020.   \n[34] Zhijian Liu, Haotian Tang, Yujun Lin, and Song Han. Point-voxel cnn for efficient 3d deep learning. In Advances in Neural Information Processing Systems, 2019.   \n[35] Charles Loop. Smooth subdivision surfaces based on triangles. January 1987.   \n[36] William E Lorensen and Harvey E Cline. Marching cubes: A high resolution 3d surface construction algorithm. ACM siggraph computer graphics, 21(4):163–169, 1987.   \n[37] Xudong Mao, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, and Stephen Paul Smolley. Least squares generative adversarial networks. In Proceedings of the IEEE international conference on computer vision, pages 2794–2802, 2017.   \n[38] Daniel Maturana and Sebastian Scherer. Voxnet: A 3d convolutional neural network for real-time object recognition. In 2015 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), pages 922–928. IEEE, 2015.   \n[39] Lars Mescheder, Michael Oechsle, Michael Niemeyer, Sebastian Nowozin, and Andreas Geiger. Occupancy networks: Learning 3d reconstruction in function space. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4460–4470, 2019.   \n[40] Ben Mildenhall, Pratul P. Srinivasan, Matthew Tancik, Jonathan T. Barron, Ravi Ramamoorthi, and Ren Ng. Nerf: Representing scenes as neural radiance fields for view synthesis. In ECCV, 2020.   \n[41] Charlie Nash, Yaroslav Ganin, S. M. Ali Eslami, and Peter W. Battaglia. Polygen: An autoregressive generative model of 3d meshes. ICML, 2020.   \n[42] Jeong Joon Park, Peter Florence, Julian Straub, Richard Newcombe, and Steven Lovegrove. Deepsdf: Learning continuous signed distance functions for shape representation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 165–174, 2019.   \n[43] Despoina Paschalidou, Angelos Katharopoulos, Andreas Geiger, and Sanja Fidler. Neural parts: Learning expressive 3d shape abstractions with invertible neural networks. In Proceedings IEEE Conf. on Computer Vision and Pattern Recognition (CVPR), 2021. ",
+        "bbox": [
+            178,
+            847,
+            826,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            83,
+            828,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            58,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "[44] Songyou Peng, Michael Niemeyer, Lars Mescheder, Marc Pollefeys, and Andreas Geiger. Convolutional occupancy networks. In European Conference on Computer Vision (ECCV), 2020. ",
+        "bbox": [
+            169,
+            92,
+            823,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[45] Edoardo Remelli, Artem Lukoianov, Stephan Richter, Benoit Guillard, Timur Bagautdinov, Pierre Baque, and Pascal Fua. Meshsdf: Differentiable iso-surface extraction. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin, editors, Advances in Neural Information Processing Systems, volume 33, pages 22468–22478. Curran Associates, Inc., 2020. ",
+        "bbox": [
+            176,
+            127,
+            820,
+            179
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[46] Gernot Riegler, Ali Osman Ulusoy, and Andreas Geiger. Octnet: Learning deep 3d representations at high resolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3577–3586, 2017. ",
+        "bbox": [
+            173,
+            189,
+            821,
+            228
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[47] Shunsuke Saito, Zeng Huang, Ryota Natsume, Shigeo Morishima, Angjoo Kanazawa, and Hao Li. Pifu: Pixel-aligned implicit function for high-resolution clothed human digitization. In The IEEE International Conference on Computer Vision (ICCV), October 2019. ",
+        "bbox": [
+            171,
+            238,
+            823,
+            277
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[48] Shunsuke Saito, Tomas Simon, Jason Saragih, and Hanbyul Joo. Pifuhd: Multi-level pixel-aligned implicit function for high-resolution 3d human digitization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, June 2020. ",
+        "bbox": [
+            171,
+            286,
+            823,
+            325
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[49] Vincent Sitzmann, Julien N.P. Martel, Alexander W. Bergman, David B. Lindell, and Gordon Wetzstein. Implicit neural representations with periodic activation functions. In Proc. NeurIPS, 2020. ",
+        "bbox": [
+            171,
+            335,
+            823,
+            363
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[50] Minhyuk Sung, Hao Su, Vladimir G Kim, Siddhartha Chaudhuri, and Leonidas Guibas. Complementme: Weakly-supervised component suggestions for 3d modeling. ACM Transactions on Graphics (TOG), 36(6):1–12, 2017. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            411
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[51] Towaki Takikawa, Joey Litalien, Kangxue Yin, Karsten Kreis, Charles Loop, Derek Nowrouzezahrai, Alec Jacobson, Morgan McGuire, and Sanja Fidler. Neural geometric level of detail: Real-time rendering with implicit 3D shapes. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2021. ",
+        "bbox": [
+            173,
+            420,
+            825,
+            472
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[52] M. Tatarchenko, A. Dosovitskiy, and T. Brox. Octree generating networks: Efficient convolutional architectures for high-resolution 3d outputs. In IEEE International Conference on Computer Vision (ICCV), 2017. ",
+        "bbox": [
+            173,
+            482,
+            823,
+            521
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[53] Shubham Tulsiani, Hao Su, Leonidas J. Guibas, Alexei A. Efros, and Jitendra Malik. Learning shape abstractions by assembling volumetric primitives. In Computer Vision and Pattern Regognition (CVPR), 2017. ",
+        "bbox": [
+            173,
+            530,
+            823,
+            570
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[54] Nanyang Wang, Yinda Zhang, Zhuwen Li, Yanwei Fu, Wei Liu, and Yu-Gang Jiang. Pixel2mesh: Generating 3d mesh models from single rgb images. In Proceedings of the European Conference on Computer Vision (ECCV), pages 52–67, 2018. ",
+        "bbox": [
+            173,
+            579,
+            823,
+            619
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[55] Peng-Shuai Wang, Yang Liu, Yu-Xiao Guo, Chun-Yu Sun, and Xin Tong. O-CNN: Octree-based Convolutional Neural Networks for 3D Shape Analysis. ACM Transactions on Graphics (SIGGRAPH), 36(4), 2017. ",
+        "bbox": [
+            173,
+            627,
+            823,
+            666
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[56] Peng-Shuai Wang, Yang Liu, and Xin Tong. Deep octree-based cnns with output-guided skip connections for 3d shape and scene completion. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 266–267, 2020. ",
+        "bbox": [
+            173,
+            676,
+            823,
+            717
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[57] Francis Williams, Matthew Trager, Joan Bruna, and Denis Zorin. Neural splines: Fitting 3d surfaces with infinitely-wide neural networks. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pages 9949–9958, 2021. ",
+        "bbox": [
+            171,
+            726,
+            825,
+            765
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[58] Jiajun Wu, Chengkai Zhang, Tianfan Xue, William T Freeman, and Joshua B Tenenbaum. Learning a probabilistic latent space of object shapes via 3d generative-adversarial modeling. In Advances in Neural Information Processing Systems, pages 82–90, 2016. ",
+        "bbox": [
+            171,
+            775,
+            823,
+            814
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[59] Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 1912–1920, 2015. ",
+        "bbox": [
+            171,
+            823,
+            823,
+            863
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[60] Qiangeng Xu, Weiyue Wang, Duygu Ceylan, Radomir Mech, and Ulrich Neumann. Disn: Deep implicit surface network for high-quality single-view 3d reconstruction. In Advances in Neural Information Processing Systems, pages 490–500, 2019. ",
+        "bbox": [
+            173,
+            872,
+            826,
+            911
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "[61] Kangxue Yin, Zhiqin Chen, Siddhartha Chaudhuri, Matthew Fisher, Vladimir Kim, and Hao Zhang. Coalesce: Component assembly by learning to synthesize connections. In Proc. of 3DV, 2020.   \n[62] Chenyang Zhu, Kai Xu, Siddhartha Chaudhuri, Renjiao Yi, and Hao Zhang. SCORES: Shape composition with recursive substructure priors. ACM Transactions on Graphics, 37(6):Article 211, 2018. ",
+        "bbox": [
+            171,
+            92,
+            826,
+            154
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes] We provide extensive experiments in Sec. 4.   \n(b) Did you describe the limitations of your work? [Yes] We provide the discussion on limitations an failure cases in Supplement.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] We provide the discussion in the Board Impact section with further discussions in Supplement.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            253
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            257,
+            493,
+            272
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            236,
+            276,
+            736,
+            308
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            311,
+            393,
+            325
+        ],
+        "page_idx": 14
+    },
+    {
+        "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)? [No] The code is currently quite uncleaned and requires many dependencies. We are planning to release the code after cleaning.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] We provide training details in both Sec. 4 in the main paper and Supplement.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] Training existing 3D models, including ours, on large-scale 3D datasets is too computation costly to repeat multiple times.   \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] We provide in the Supplement. ",
+        "bbox": [
+            238,
+            332,
+            825,
+            503
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            508,
+            823,
+            523
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We used ShapeNet [3] core dataset in Sec. 4.2. We also used official code to reproduce baselines with citations. In particular, ConvONet [44] and DECOR-GAN [6].   \n(b) Did you mention the license of the assets? [Yes] We provided the license of ShapeNet and Turbosquid.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No] The Turbosquid data we are using contains proprietary information.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] We discussed in the Sec. 4 and provide further details in the Supplementary Materials.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [Yes] We provide discussion on this in Supplement. ",
+        "bbox": [
+            238,
+            527,
+            825,
+            703
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            708,
+            705,
+            722
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [Yes] We provide details in the paper, with full text and screenshot in Supplement.   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [No] We did not anticipate the potential participant risks, as we only conduct human studies on generated animals.   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [Yes] We provide details in Supplement ",
+        "bbox": [
+            238,
+            727,
+            825,
+            843
+        ],
+        "page_idx": 14
+    }
+]

parse/train/z-l1kpDXs88/z-l1kpDXs88.md

@@ -0,0 +1,253 @@
+# TokenLearner: Adaptive Space-Time Tokenization for Videos
+
+Michael S. Ryoo1,2, AJ Piergiovanni1, Anurag Arnab1, Mostafa Dehghani1, Anelia Angelova1
+
+1Google Research 2Stony Brook University {mryoo,ajpiergi,aarnab,dehghani,anelia}@google.com
+
+# Abstract
+
+In this paper, we introduce a novel visual representation learning which relies on a handful of adaptively learned tokens, and which is applicable to both image and video understanding tasks. Instead of relying on hand-designed splitting strategies to obtain visual tokens and processing a large number of densely sampled patches for attention, our approach learns to mine important tokens in visual data. This results in efficiently and effectively finding a few important visual tokens and enables modeling of pairwise attention between such tokens, over a longer temporal horizon for videos, or the spatial content in image frames. Our experiments demonstrate strong performance on several challenging benchmarks for video recognition tasks. Importantly, due to our tokens being adaptive, we accomplish competitive results at significantly reduced computational cost. We establish new state-of-the-arts on multiple video datasets, including Kinetics-400, Kinetics-600, Charades, and AViD.
+
+The code will be available at: https://github.com/google-research/ scenic/tree/main/scenic/projects/token_learner
+
+# 1 Introduction
+
+Videos provide an abundance of visual information. Video understanding particularly requires employing effective spatial-temporal processing of frames to capture long-range interactions [5, 37, 21, 17, 24, 12, 34, 20, 25, 1]. An important aspect of this understanding is how to quickly learn which parts of the input video stream are important, both spatially and temporally, and to focus computational resources on them. But what basic processing mechanism are able to do so successfully?
+
+Recent advancements in Transformers demonstrate improved accuracy on vision classification tasks. For example, departing from standard convolutional approaches, the Vision Transformer (ViT) [9] treats the image as a sequence of patches, utilizing the Transformer architecture [39] similar to text understanding. Standard approaches for video recognition take videos as stacked images (i.e., a spacetime volume) and tend to extend 2D neural architectures to 3D (e.g., 3D-ResNets [17, 5, 38, 11]). Motivated by ViT, recent approaches [2, 3] also extend Transformers for videos by creating 3D ‘tubelet’ video tokens with regular 3D-grids, which often result in computationally heavy models. There are often too many tokens to process, especially for longer videos.
+
+The main question addressed in this work is how to adaptively learn the representation from visual inputs to most effectively capture the spatial information for image frames and spatio-temporal interactions for videos. Here are our main ideas:
+
+The first key observation is we are able to learn to represent visual data by learning to ‘tokenize’ the representations. This is in contrast to previous approaches which used densely sampled tokens e.g., 16x16 or $3 2 \mathrm { x } 3 2$ over a series of attention layers [9, 3].
+
+![](images/228c46745c64ff5abc69a08c68e281e1f5c3dbfcf19f5f3daa36b7c3016f39d3.jpg)  
+Figure 1: Visual illustration of the TokenLearner module, applied to a single image frame. TokenLearner learns to spatially attend over a subset of tensor pixels (i.e., from intermediate spatial representations), and generates a set of token vectors adaptive to the input.
+
+Specifically, we can learn to compute important regions in the input image/video, making the tokens adapt to the input data. We compute multiple spatial weight maps per frame with a spatial attention mechanism, and use it for the tokenization. The goal of these maps is to learn which areas are of importance. Here, each spatial weight map is multiplied with the input to form a ‘token’, to be processed by the subsequent learning modules.
+
+Furthermore, we find that very few tokens may be sufficient for a visual understanding task. More specifically, we show that one can significantly reduce the computational budget of video Transformers, by utilizing 8-16 tokens as an intermediate frame representation (instead of keeping $2 0 0 { \sim } 5 0 0 $ ). Our TokenLearner is able to reduce the number of total FLOPS by half, while maintaining or even increasing the classification accuracy.
+
+The approach is simple, efficient, and, as shown by the results, outperforms methods including both convolutional methods and previous space-time Transformer ones from prior art. In video understanding tasks, we establish new state-of-the-art numbers on Kinetics-400, Kinetics-600, Charades, and AViD datasets by outperforming prior models.
+
+# 2 TokenLearner Modules for Adaptive Tokenization
+
+In visual Transformer architectures such as ViT [9], an input image is first tokenized by splitting it into small (e.g., 16x16) spatial patches, which are used as input to the model. Similarly, in recent video Transformer architectures, such as ViViT [2] and TimeSformer [3], the video is tokenized by cutting the video into 2d spatial or 3d spatio-temporal cubes on a regular grid.
+
+Instead of processing fixed, tokenized inputs, our attention module learns the tokens that are to be used for the recognition task. We gain several important properties by doing so: (1) We enable the adaptive tokenization so that the tokens can be dynamically selected conditioned on the input. (2) This also effectively reduces the total number of tokens for the transformer, which is particularly beneficial considering that there are many tokens in videos (e.g., $1 4 \times 1 4 \times 6 4 \times$ and the computation is quadratic to the number of tokens. (3) Finally, we provide an ability for each subsequent layer to learn to rely on different space-time tokenizations, potentially allowing different layers to capture different aspects of the video. These dynamically and adaptively generated tokens can be used in standard transformer architectures such as ViT for images and ViViT for videos.
+
+# 2.1 TokenLearner
+
+Let $X$ be an input tensor with a space-time shape: $X \in \mathbb { R } ^ { T \times H \times W \times C }$ where $H \times W$ corresponds to the spatial dimension of the input, $T$ is the temporal dimension (i.e., number of frames), and $C$ is the number of channels. Let $X _ { t }$ be a temporal slice of it, corresponding to the frame $t$ : $X _ { t } \in \mathbb { R } ^ { H \times W \times C }$
+
+In the case of an image input, $T = 1$ and $X = X _ { t }$ . Note that $X$ could also be an intermediate representation within a network, and $X _ { t }$ will be its slice in such case.
+
+For every time frame $t$ , we learn to generate a series of $S$ tokens, $Z _ { t } = [ z _ { i } ] _ { i = 1 } ^ { S }$ , from the input frame $X _ { t }$ . Specifically, we formulate a tokenizer function, $z _ { i } = A _ { i } ( X _ { t } )$ , which maps the input frame $X _ { t }$ to a token vector $z _ { i }$ : $\mathbb { R } ^ { H \times W \times C } \mapsto \mathbb { R } ^ { C }$ . The idea is to learn our tokenizer function $A _ { i }$ to adaptively select an informative combination of pixels (or spatial locations) in $X _ { t }$ , and we have $S$ number of such functions. This way, our tokens will not be fixed splits of the input tensor, but a set of adaptively changing spatial selections. Different tokens will be mined per frame, allowing us to model their space-time relations/interactions in case of videos. We also set $S$ to be smaller than $H \times W$ (e.g., $S = 8$ and $H \times W = 1 4 \times 1 4$ ), enabling the model to significantly reduce the computations needed for the layers following this module.
+
+Here, our tokenizer $z _ { i } = A _ { i } ( X _ { t } )$ is implemented with a spatial attention mechanism: i.e., the model learns to compute a weight map (of size $H \times W$ ) conditioned on the input $X _ { t }$ , and is multiplied with $X _ { t }$ itself. More specifically, let $\alpha _ { i } ( X _ { t } )$ be a function generating the spatial $H \times W \times 1$ weight map. Each token $z _ { i }$ is generated by
+
+$$
+z _ { i } = A _ { i } ( X _ { t } ) = \rho ( X _ { t } \odot A _ { i w } ) = \rho ( X _ { t } \odot \gamma ( \alpha _ { i } ( X _ { t } ) ) ) ,
+$$
+
+where $\odot$ is the Hadamard product (i.e., element-wise multiplication) and $A _ { i w } \in \mathbb { R } ^ { H \times W \times C }$ is an intermediate weight tensor computed with the function $\alpha _ { i } ( X _ { t } )$ and the broadcasting function $\gamma ( \cdot )$ . Finally, spatial global average pooling $\rho ( \cdot )$ is applied on top of them to reduce the dimensionality to $\mathbb { R } ^ { C }$ . The resulting tokens are gathered to form the output tensor: $Z _ { t } = [ z _ { i } ] _ { i = 1 } ^ { S } \in \mathbb { R } ^ { S \times C }$ .
+
+The overall process has a form of an element-wise spatial self-attention. In our version, $\{ \alpha _ { i } ( \cdot ) \} _ { i = 1 } ^ { S }$ are implemented together as a single or a series of convolutional layers (with the channel size $S$ ) followed by a sigmoid function, although this could be extended with other implementations. In case of an image, $Z = Z _ { t }$ . In the case of a video, the tokens $Z _ { t }$ from all the frames are collected to form the final output token tensor Z ∈ RST ×C .
+
+We specifically name our token learning module as “TokenLeaner”. Figure 1 visually summarizes the TokenLearner module.
+
+Compute reduction in Transformers: The learned tokens (i.e., the outputs of the TokenLearner $Z$ ) are provided to the subsequent layers for the visual representation learning, such as multi-head selfattention (MHSA) used in Vision Transformer and ViViT. With the TokenLearner, these subsequent layers only need to process a small number of tokens (e.g., 8 instead of 1024 per frame) and this significantly reduces the computations, as they are quadratic to the number of tokens. Figure 4 (a) shows a basic architecture inserting the TokenLearner module within ViViT. It could be added at any location within the network, and the relative compute of the Transformer layers after the TokenLearner become almost negligible due to the huge difference in the number of tokens.
+
+# 2.2 TokenFuser
+
+After the TokenLearner generates tokens and its subsequent Transformer layer (e.g., MHSA) processes them, the “TokenFuser” could be used to further (1) fuse information across the tokens and (2) remap the representation back to its original spatial resolution. This enables the model to capture spatial (or spatio-temporal) ‘patterns’ formulated by the tokens, and recover the original input tensor shape when necessary.
+
+![](images/ac8430698282f52e4aa03e60ff76c1a2866d14cb82a800e20d5180d1d597a1f8.jpg)  
+Figure 2: Visual illustration of the TokenFuser module, applied to each image frame individually.
+
+![](images/0d89d52af2aa2f516a081322abb74143e016370abc5593222950ee987bcd153f.jpg)  
+Figure 3: TokenLearner, Transformer, and TokenFuser combined for video representation learning. TokenLearner first learns to generate a set of token vectors, Transformer (e.g., MHSA) models their space-time relations, and TokenFuser combines them. $S$ is the number of tokens we learn per frame, and $T$ is the number of frames. Note that this combination can serve as a ‘module’ itself, and one may stack such module multiple times within the network. TokenFuser could be dropped.
+
+First, given the token tensor $Y \in \mathbb { R } ^ { S T \times C }$ from a Transformer layer, we apply a linear layer (i.e., a fully connected MLP layer) over the tokens, not channels. That is, we learn a linear function of $\mathbb { R } ^ { S T } \overset { \cdot } { \mapsto } \mathbb { R } ^ { S T }$ where $S$ is the number of our tokens mined per frame and $T$ is temporal size of the input tensor, and apply it to every channel independently. That is, we update $\boldsymbol { Y } = \bar { ( } \boldsymbol { Y } ^ { T } \boldsymbol { M } ) ^ { T }$ where $M$ is a learnable weight matrix with size $S T \times S T$ . The result of such operation maintains the tensor size of $S T \times C$ . We believe this also has a connection to the observations from the concurrent work, MLPMixer [36], that token-wise linear layers are beneficial.
+
+Next, the TokenFuser processes each temporal slice $Y _ { t } \in \mathbb { R } ^ { S \times C }$ individually, and remaps the token tensor of size $S \times C$ back to $H \times W \times C$ , by learning to combine the tokens for each spatial location in $H \times W$ differently.
+
+$$
+X _ { t } ^ { j + 1 } = B ( Y _ { t } , X _ { t } ^ { j } ) = B _ { w } Y _ { t } + X _ { t } ^ { j } = \beta _ { i } ( X _ { t } ^ { j } ) Y _ { t } + X _ { t } ^ { j }
+$$
+
+where $X _ { t } ^ { j }$ is the residual input to the previous TokenLearner module, $Y _ { t }$ is the processed tokens in the TokenFuser module, and $X _ { t } ^ { j + 1 }$ is the output. $B _ { w } \in \mathbb { R } ^ { H W \times S }$ is an intermediate weight tensor computed with the function $\beta _ { i } ( X _ { t } )$ . The function $\beta _ { i } ( X _ { t } )$ is implemented with a simple linear layer followed by a sigmoid function.
+
+Figure 2 illustrates the overall process of the TokenFuser (the token-wise linear layer is omitted).
+
+# 2.3 Video architecture overview
+
+Here, we provide an overview of video representation architecture with TokenLearner. The TokenLearner and TokenFuser modules introduced in Section 2 are directly applicable for video representation learning. TokenLearner generates multiple $Z _ { t }$ for frames in videos and they are stacked to form $Z$ . Once $Z$ is generated, any standard Transformer layers could be used to parse them jointly.
+
+Figure 3 provides an overview of the combined architecture for video representation, which is to be repeated over multiple layers. TokenLearner first extracts $S$ number of tokens per frame, resulting in a total of $S T$ tokens where $T$ is the number of frames. Once TokenLearner generates these adaptively learned tokens, they are provided to the subsequent Transformer layer to capture the global space-time patterns. Finally (and optionally depending on the architecture), TokenFuser applies a linear layer over the token axis and remaps the tensor shape back, as discussed in Subsection 2.2. Following Eq. 2, TokenFuser is applied for per-frame representation $Y _ { t }$ . This results in a lightweight approach, which brings forth an efficient video representation by capturing long-range visual patterns.
+
+# 3 Experiments: TokenLearner with Video Vision Transformer
+
+# 3.1 Network architecture implementation
+
+In this experiment, we use the Video Vision Transformer (ViViT) architecture [2], following its detailed settings and implementation [7]. ViViT is a direct extension of ViT [9] for videos, which uses spatiotemporal tubelets from videos as its tokens. The size of the space-time tubelets are typically 16x16x2, which are given to the Transformer layers.
+
+We use ViViT-L/16 as our backbone, while also applying the TokenLearner to backbones with more initial tokens such as L/14 and L/10. ViViT-L models have 24 transformer layers. Following the setting of [2], we used the input resolution of $2 2 4 \mathbf { x } 2 2 4$ , extracting tubelets, and attaching positional encodings.
+
+Figure 4 (a) and (b) show two different architectures incorporating TokenLearner. (a) is formed by inserting TokenLearner in the middle of the network such as after the 12th layer among 24, while (b) uses both TokenLearner and TokenFuser. In particular, our model (b) is formed by replacing conventional Transformer layers with a series of TokenLearnerTransformer-TokenFuser. Similar to (a), such replacement is done only for the layers after a certain point. For instance, we keep twelve of the standard Transformer MHSA layers in the beginning, and replaces the remaining twelve layers with our TokenLearner-Transformer-TokenFuser modules repeated twelve times. We also modified L/14 and L/10 models to have more transformer layers (e.g., 35 instead of 24). Note that the computation increase caused by the transformer layers added after TokenLearner module is relatively very small, as the number of tokens are few: 8 or 16 per frame.
+
+![](images/a669c790966a4654e2404f648c2401bdfa7a9b7ed4e0f4d5687ff0e5ea6e5638.jpg)  
+Figure 4: Our models following the ViViT architecture. (a) with TokenLearner and (b) with both TokenLearner and TokenFuser.
+
+We tried various number of tokens including $S = 8 , 1 6 , 3 2$ , and use $S = 8$ and 16 as our default settings. That is, the TokenLearner is learning to abstract an image frame into 8 (or 16) tokens. The spatial attention function $( \alpha )$ in TokenLearner is implemented with four 3x3 conv. layers (with gelu in between), whose channel size is identical to the number of tokens (e.g., $S = 8$ ).
+
+# 3.2 Datasets and training
+
+We use the Kinetics datasets, which are video classification datasets with relatively short video clips ${ \sim } 1 0$ seconds). We train and evaluate on both Kinetics-400 and Kinetics-600 datasets, which have about $2 4 0 \mathrm { k }$ and 390k training samples. We follow the standard settings used in previous papers and report accuracy on the validation set [5, 12].
+
+Following ViViT [2], we first pretrain models on JFT [35] to obtain initial weights. The weights of the initial convolutional layers to handle image patches (e.g., 16x16) are processed to handle 16x16x2 video patches by following ViViT’s 3D initialization strategy, and the weights of the Transformer and the TokenLearner layers are directly inherited.
+
+# 3.3 Results
+
+We evaluate various versions of the ViT-L models incorporating the TokenLearner module. As mentioned above, all of the models are pre-trained on JFT and finetuned on Kinetics. We use the standard L/16 models $^ +$ TokenLearner, as well as L/14 and $\mathrm { L } / 1 0 . \mathrm { L } / 1 4$ and $\mathrm { L } / 1 0$ use 11 additional layers compared to the standard ViT L/16, but as also described in the above subsections, the computation increase caused by them are minimal due to the number of tokens being much smaller, 8 or 16 per frame, in the added layers. We report both their classification accuracies and FLOPS.
+
+Table 1 compares the accuracies of the base ViViT models against our ViViT $^ +$ TokenLearner models on Kinetics-400. These models are directly comparable as they follow the exact same setting and the pre-train dataset. “TokenLearner 16at12” means that we have the TokenLearner layer learning 16 tokens, after the 12th Transformer layer. We are able to observe that the use of TokenLearner enables better classification while also reducing the compute. In particular, inserting TokenLearner in the middle of the network (at 12) achieves better accuracy than the base mode, while cutting the computation by (almost) half. In addition, having the TokenLearner at the later layer (at 18) achieves even superior accuracy while still performing faster, thanks to its adaptiveness.
+
+Table 1: Comparison of ViViT models with and without TokenLearner on Kinetics-400. GLOPS are per view. The difference in the number of parameters between the TokenLearner models comes from the different number of layers used after the TokenLearner module.   
+
+<table><tr><td>Method</td><td>Top-1 accuracy</td><td>Top-5 accuracy</td><td># params.</td><td>GFLOPS</td></tr><tr><td>ViViT-L/16 [2]</td><td>82.8</td><td>95.5</td><td>308M</td><td>1446</td></tr><tr><td>ViViT-L/16 320 [2]</td><td>83.5</td><td>95.5</td><td>308M</td><td>3992</td></tr><tr><td>ViViT-H/14 [2]</td><td>84.8</td><td>95.8</td><td>654M</td><td>3981</td></tr><tr><td>ViViT-L/16 (our run)</td><td>83.4</td><td>95.6</td><td>308M</td><td>1446</td></tr><tr><td>TokenLearner 16at12 + L/16</td><td>83.5</td><td>95.6</td><td>308M</td><td>766</td></tr><tr><td>TokenLearner 8at18 +L/16</td><td>84.5</td><td>96.1</td><td>383M</td><td>1105</td></tr><tr><td>TokenLearner 16at18+ L/14</td><td>84.7</td><td>96.1</td><td>447M</td><td>1621</td></tr><tr><td>TokenLearner 16at18+ L/10</td><td>85.4</td><td>96.3</td><td>450M</td><td>4076</td></tr></table>
+
+Table 2: ViViT $^ +$ TokenLearner on Kinetics-400, compared to the state-of-the-art models. Different approaches rely on different pre-training datasets, such as ImageNet-21K (for TimeSformer and Swin) and JFT (for ViViT and TokenLearner). The multiplication in GFLOPS correponds to the number of views used for the inference, such as $4 \mathbf { X } 3 = 1 2$ .   
+
+<table><tr><td>Method</td><td>Top-1 accuracy</td><td>Total GFLOPS</td></tr><tr><td>R(2+1)D [38]</td><td>73.9</td><td>304 × 115</td></tr><tr><td>SlowFast 16x8,R101+NL [12]</td><td>79.8</td><td>234×30</td></tr><tr><td>TimeSformer-L [3]</td><td>80.7</td><td>2380 ×3</td></tr><tr><td>ViViT-L/16 [2]</td><td>82.8</td><td>1446 × 12</td></tr><tr><td>ViViT-H/14 [2]</td><td>84.8</td><td>3981 × 12</td></tr><tr><td>Swin-L [23]</td><td>83.1</td><td>604 ×12</td></tr><tr><td>Swin-L (384) [23]</td><td>84.6</td><td>2107×12</td></tr><tr><td>Swin-L (384) [23]</td><td>84.9</td><td>2107 × 50</td></tr><tr><td>TokenLearner 16at12 (L/16)</td><td>82.1</td><td>766×6</td></tr><tr><td>TokenLearner 8at18 (L/16)</td><td>83.2</td><td>1105 × 6</td></tr><tr><td>TokenLearner 16at12 (L/16)</td><td>83.5</td><td>766 × 12</td></tr><tr><td>TokenLearner 8at18 (L/16)</td><td>84.5</td><td>1105 × 12</td></tr><tr><td>TokenLearner 16at18 (L/14)</td><td>84.7</td><td></td></tr><tr><td>TokenLearner 16at18 (L/10)</td><td>85.4</td><td>1621 × 12 4076 × 12</td></tr></table>
+
+Table 2 compares the TokenLearner accuracy against the state-of-the-arts models. Note that these approaches follow slightly different settings and pretrain datasets (e.g., the use of ImageNet-21K instead of JFT like ours). We believe the accuracy of 85.4 is the highest that has been reported so far, and we believe it is meaningful. Table 3 compares the results on Kinetics-600. Similar to our results on Kinetics-400, we are able to observe that our proposed approach extends the state-of-the-arts while also being computationally efficient.
+
+# 4 Experiments: TokenLearner with Bottleneck Transformer
+
+# 4.1 Network architecture implementation
+
+In this experiment, we follow the Bottleneck Transformer [33] network style, while taking advantage of X3D [11] as the backbone. This is motivated by the successful usage of X3D on Charades.
+
+Table 3: ViViT $^ +$ TokenLearner on Kinetics-600. The multiplication in GFLOPS correponds to the number of views used for the inference, such as $4 \mathbf { X } 3 = 1 2$ .   
+
+<table><tr><td>Method</td><td>Top-1</td><td>Total GFLOPS</td></tr><tr><td>SlowFast 16x8,R101+NL [12]</td><td>81.8</td><td>234× 30</td></tr><tr><td>X3D-XL [11]</td><td>81.9</td><td>48×30</td></tr><tr><td>TimeSformer-HR [3]</td><td>82.4</td><td>1703×3</td></tr><tr><td>ViViT-L/16 [2]</td><td>84.3</td><td>1446 × 12</td></tr><tr><td>ViViT-H/14 [2]</td><td>85.8</td><td>3981 × 12</td></tr><tr><td>Swin-B [23]</td><td>84.0</td><td>282×12</td></tr><tr><td>Swin-L (384) [23]</td><td>85.9</td><td>2107 × 12</td></tr><tr><td>Swin-L (384) [23]</td><td>86.1</td><td>2107 × 50</td></tr><tr><td>TokenLearner 16at12 (L/16)</td><td>84.4</td><td>766×12</td></tr><tr><td>TokenLearner 8at18 (L/16)</td><td>86.0</td><td>1105×12</td></tr><tr><td>TokenLearner 16at18 (L/10)</td><td>86.1</td><td>4076 ×12</td></tr><tr><td>TokenLearner 16at18 w. Fuser (L/10)</td><td>86.3</td><td>4100 ×12</td></tr></table>
+
+Specifically, we modified X3D to be more computationally efficient by (1) replacing its 3D XYT convolutional layers with a pair of 2D conv. layer and 1D conv. layer, and (2) removing Squeeze-and-Excitation layers [18] and swish activations. Our backbone could be viewed as ${ \mathrm { X } } ( 2 { + } 1 ) { \mathrm { D } }$ . We use the channel sizes and the number of layers identical to X3D-M, which is an efficient model.
+
+Based on such ${ \mathrm { X } } ( 2 { + } 1 ) { \mathrm { D } }$ architecture, and following the Bottleneck Transformer concept, we replace the space-time convolution layers in the last block with our transformers. Figure 5 illustrates the residual module architecture, which is repeated multiple times in the block. TokenLearner, Transformer, TokenFuser are applied in a sequence, with an optional 2D $3 \times 3$ convolution layer before them. The spatial attention function (i.e., $\alpha ( \cdot ) )$ in TokenLearner is implemented with a single conv2d layer.
+
+Here, we used a Vector Transformer instead of MHSA as our Transformer layer, which could be also viewed as the MHSA with the number of heads being identical to the number of channels. We provide more details in Appendix.
+
+We use $2 2 4 \times 2 2 4 \times 6 4$ videos for training and $2 5 6 \times 2 5 6 \times 6 4$ videos for testing. After the 3rd residual block, the input tensor has the shape of $8 \times 8 \times 6 4$ , and this becomes the input to the TokenLearner. For an efficient implementation the intermediate channel size of TokenLearner was set identical to the output channel size, $d = 4 3 2$ . Notice that 64 frames were used to best capture longer-term temporal information. $S = 8$ number of tokens were used.
+
+![](images/bc76334af69b3eaf600a690da6f88e90a0141729d2f6db341b835e9b5949d29a.jpg)  
+Figure 5: Our network module following the bottleneck transformer, with ${ \mathrm { X } } ( 2 { + } 1 ) { \mathrm { D } }$ backbone. It is an inverted bottleneck.
+
+# 4.1.1 Datasets
+
+Charades dataset: The Charades dataset [31] is a dataset collected by assigning activity tasks which people in various environments are acting out, by performing a sequence of actions which involve interaction with objects. For example, sitting on the couch and reading a book, closing the book, standing up and speaking on the phone. It comprises 8000 training and 1686 validation videos with an average duration of 30 seconds. It has 157 activity classes. This dataset is very challenging as it is a multi-class, multi-label video dataset, that is, more than one activity can occur at the same time, and it includes fine grained motions or interactions with small objects in real-world environments. We follow the standard evaluation protocols, reporting the mean Average Precision (mAP) $\%$ (v1 classification setting of the dataset). We used the frame rate of 6 fps and 12 fps to obtain the training/testing videos. The dataset has a Non-Commercial Use license.
+
+Table 4: Performance on the Charades multi-label classification task. 12 fps setting. Performance is measured using the Mean Average Precision (mAP) since more than one ground truth action is possible. Methods with RGB and optical flow input modalities are listed.   
+
+<table><tr><td>Method</td><td>Input</td><td>Pre-train</td><td>mAP</td></tr><tr><td>I3D [5]</td><td>RGB</td><td>Kinetics</td><td>32.9</td></tr><tr><td>I3D from [40]</td><td>RGB</td><td>Kinetics</td><td>35.5</td></tr><tr><td>I3D + Non-local [40]</td><td>RGB</td><td>Kinetics</td><td>37.5</td></tr><tr><td>EvaNet [26]</td><td>RGB</td><td>Kinetics</td><td>38.1</td></tr><tr><td>STRG [41]</td><td>RGB</td><td>Kinetics</td><td>39.7</td></tr><tr><td>LFB-101 [43]</td><td>RGB</td><td>Kinetics</td><td>42.5</td></tr><tr><td>SGFB-101[19]</td><td>RGB</td><td>Kinetics</td><td>44.3</td></tr><tr><td>SlowFast-101[12]</td><td>RGB+RGB</td><td>Kinetics</td><td>45.2</td></tr><tr><td>AssembleNet-50 [30]</td><td>RGB+Flow</td><td>None</td><td>47.0</td></tr><tr><td>Multiscale ViT[10]</td><td>RGB</td><td>Kinetics</td><td>47.7</td></tr><tr><td>AssembleNet-101 [30]</td><td>RGB+Flow</td><td>Kinetics</td><td>58.6</td></tr><tr><td>AssembleNet++ [29](w/o object)</td><td>RGB+Flow</td><td>None</td><td>55.0</td></tr><tr><td>MoViNets [22]</td><td>RGB</td><td>None</td><td>63.2</td></tr><tr><td>Backbone (X(2+1)D-M)</td><td>RGB</td><td>None</td><td>62.7</td></tr><tr><td>Ours</td><td>RGB</td><td>None</td><td>66.3</td></tr></table>
+
+Table 5: Performance on the Anonymized Videos from Diverse countries (AViD) dataset. Performance in terms of mean accuracy is shown in $\%$ averaged over 887 classes. Previous approaches results are reported from [27], all based on training from scratch with RGB-only inputs.   
+
+<table><tr><td>Method</td><td>Accuracy</td><td>total GFLOPS</td></tr><tr><td>I3D [5]</td><td>46.5</td><td>108× N/A</td></tr><tr><td>(2+1)D ResNet-50</td><td>46.7</td><td>152 × 115</td></tr><tr><td>3D ResNet-50</td><td>47.9</td><td>N/A</td></tr><tr><td>SlowFast-50 8x8 [12]</td><td>50.2</td><td>65.7 × 30</td></tr><tr><td>SlowFast-101 16x4[12]</td><td>50.8</td><td>213×30</td></tr><tr><td rowspan="2">Backbone (X(2+1)D-M) X(2+1)D-M w/ disjoint space+time Transformer (like [3])</td><td>48.6</td><td>532×1</td></tr><tr><td>50.6</td><td>493×1</td></tr><tr><td>Ours</td><td>53.8</td><td>487×1</td></tr></table>
+
+AViD dataset: The Anonymized Videos from Diverse countries (AViD) dataset [27] is a unique dataset which is representative of the world’s population video content generation. It is collected from videos uploaded from multiple countries across six continents and demonstrates higher diversity compared to other video datasets such as Kinetics in its concepts, actions and visual representations. For example a ‘greeting’ in certain countries involves a handshake, in some a kiss, but in others a slight bow. The dataset is explicitly designed to contain less bias, encourage diversity, while respecting privacy and licenses. The AViD dataset contains 887 classes and 450k videos (410k training $4 0 \mathrm { k }$ testing) and is of comparable size to Kinetics-400 and Kinetics-600 datasets with 400 and 600 classes respectively, also containing variable duration videos $3 - 1 5 s$ . We report classification accuracy over the 887 classes. All the videos in this dataset have the Creative Commons License.
+
+# 4.2 Results
+
+Charades dataset results: In Table 4 we compare the proposed TokenLearner to the state-of-the-art methods. Our approach outperforms these, including several recent works. The mAP of $6 6 . 3 \%$ on Charades classification establishes the new state-of-the-art.
+
+AViD results: Table 5 shows the results on the AViD dataset. As seen, our approach outperforms prior work on this challenging dataset too. We also compared ours to the reimplementation of TimeSformer module [3] applied to the same backbone as ours. This uses disjoint spatial and temporal transformer modules, which was also tested in [2]. We are able to observe that we establish the new state-of-the-arts on this dataset, while also being more computationally efficient.
+
+Table 6: Comparison between TokenLearner and the joint space-time transformer modules similar to [2], applied to our backbone. They use the ${ \mathrm { X } } ( 2 { + } 1 ) { \mathrm { D } }$ backbone, tested on Charades with the 6 fps setting, Charades 12 fps setting, and AViD dataset. GFLOPs and $\#$ params are of each module (with 64 frame inputs), not the entire network.   
+
+<table><tr><td>Module</td><td>Char-6fps</td><td>Char-12fps</td><td>AViD</td><td>GFLOPs</td><td># params</td></tr><tr><td>Joint space-time MHSA</td><td>57.9</td><td>64.0</td><td>53.3</td><td>22.0</td><td>0.30M</td></tr><tr><td>Conv2D + Joint space-time MHSA</td><td>58.6</td><td>62.5</td><td>52.5</td><td>35.8</td><td>1.98M</td></tr><tr><td>Ours (TokenLearner)</td><td>58.8</td><td>63.4</td><td>53.8</td><td>3.4</td><td>0.81M</td></tr><tr><td>Ours (Conv2D + TokenLearner)</td><td>59.6</td><td>66.3</td><td>53.7</td><td>17.2</td><td>2.49M</td></tr></table>
+
+# 4.3 Ablations
+
+Comparison against different tokenizations: Here, we compare the model with TokenLearner against space-time transformer modules with the standard tokenization. More specifically, we compare the use of TokenLearner $^ +$ Vector Transformer $^ +$ TokenFuser against the full joint space-time transformer module (advocated in [2] and also mentioned in [3]), without token learning. The full joint space-time transformer module is a transformer layer on space-time tokens similar to ours, but it relies only on the hand-designed tokenization. Compared to TokenLearner which generates $S \times T$ number of tokens, the full joint space-time transformer uses $H \times W \times T$ number of tokens. In our bottleneck implementation, it uses ${ \sim } 8$ times more tokens (i.e., $8 ^ { * } 6 4$ vs. $8 ^ { * } 8 ^ { * } 6 4$ ). For the joint space-time transformer modules, the standard multi-head self-attention (MHSA) with 8 heads is used.
+
+Table 6 shows the results. Interestingly, despite the heavier computation of the full joint spacetime transformer, it performed slightly worse to the TokenLearner modules. We believe this shows the advantage of the ‘adaptiveness’ of the tokens in the TokenLearner and shows that the standard transformers might be suffering from the tokens irrelevant to the actions serving as noise or distractors.
+
+We also report the amount of computation and the number of parameters of each module in these models. This depends on the input size and the hyper parameter setting, and our measurement is based on the input size (i.e., $T \times H \times W \times C )$ of $8 \times 8 \times 6 4 \times 4 9 2$ . Note that this is the measurement of modules, not the entire network.
+
+Comparison between multiple space-time layer combinations. As also suggested in previous literature, it is a common strategy for video representations to pair a layer focusing on spatial information with a layer focusing on temporal information (e.g., $\mathrm { R } ( 2 { + } 1 ) \mathrm { D }$ [38] and TimeSformer [3]). Table 7 shows the results of this ablation. For spatial and temporal transformer implementations, the standard multi-head self-attention was used, as was done in [2, 3]. The result shows that the proposed TokenLearner is more accurate than other popular combinations. The modules based on TokenLearner also effectively only uses a fraction of the Tokens per frame (i.e., 8) as opposed to other methods which use $1 6 \times 1 6$ or $3 2 \times 3 2$ tokens.
+
+One of the main benefits of the TokenLearner (in addition to the adaptive tokenization of the input and that we explicitly fuse the tokens to capture their spatio-temporal patterns) is that, unlike the disjoint space/time transformers used in this ablation study, it is a joint space-time transformer. Simultaneously, it still manages its computation to be much more tractable (as shown in Tables 6 and 7): A naive full version of the space-time transformer would require consideration of $8 { \times } 8 { \times } 6 4 = 4 0 9 6$ tokens in our case, building and multiply the attention tensor of size $4 0 9 6 \times 4 0 9 6$ . On the other hand, the TokenLearner learns to consider $8 \times 6 4 = 5 1 2$ tokens jointly.
+
+More TokenLearner alternatives. We also compared our spatial attention-based token learning with alternative approaches: (1) using a fixed grid to split each frame into the same number of tokens (i.e., 8 tokens), (2) the approach of directly generating tokens using a fully connected layer, and (3) the approach of spatially average pooling the entire frame pixels and using fully connected layers to generate multiple tokens per frame. In the second approach, we directly model $z _ { i } = A _ { i } ( x )$ as a dense layer, producing $T \times S \times C$ tensor based on the $T \times H \times W \times C$ input. The third approach is similar, except that we apply spatial global average pooling per frame and then use MLP to generate tokens.
+
+Table 7: Comparison between different space-time transformer modules. They were all applied to the same backbone architecture (i.e., the Bottleneck Transformer-style with $\mathbf { X } ( 2 { + } 1 ) \mathbf { D } )$ . The Charades-6fps is used in this experiment. FLOPS are estimated with 64-frame settings, per module.   
+
+<table><tr><td>Module</td><td>Charades-6fps (%)</td><td>GFLOPs</td><td># params</td></tr><tr><td>Conv2D + Conv1D</td><td>56.6</td><td>18.3</td><td>2.24M</td></tr><tr><td>Conv2D+MLPMixer [36]</td><td>57.0</td><td>13.8</td><td>2.06M</td></tr><tr><td>Conv2D + Temporal transformer</td><td>58.4</td><td>16.5</td><td>1.98M</td></tr><tr><td>Spatial + Temporal transformer</td><td>58.8</td><td>5.5</td><td>0.59M</td></tr><tr><td>Conv2D + Spatial + Temporal transformer</td><td>58.0</td><td>19.2</td><td>2.27M</td></tr><tr><td>Ours (TokenLearner)</td><td>58.8</td><td>3.4</td><td>0.81M</td></tr><tr><td>Ours (SpatialT + TokenLearner)</td><td>58.9</td><td>6.2</td><td>1.11M</td></tr><tr><td>Ours (Conv2D + TokenLearner)</td><td>59.6</td><td>17.2</td><td>2.49M</td></tr></table>
+
+The fixed split tokenization method (1) provided us the accuracy of 58.8 on Charades, as opposed to 59.6 of ours. The direct token generation method (2) provided the accuracy of 56.6 on Charades, failing to obtain better tokens. Pooling and generation method (3) gave us the accuracy of 58.6. These results suggest the importance of spatial attention for the token learning, our TokenLearner. The same vector transformer and TokenFuser (from Section 2) were used for this ablation.
+
+# 5 Related work
+
+Video understanding relies on both the spatial and the temporal information in the video. In order to adequately capture both motion and appearance information in videos, full 3D space-time convolutional layers as well as $( 2 + 1 ) \mathrm { D }$ convolutional layers have been used [37, 5, 38, 44]. More advanced network designs have also been extremely popular in video CNNs particularly two-stream ones [32, 13, 14, 15, 8, 12] and, recently, architecture searched ones [11, 30, 26].
+
+Attention-based architectures, e.g., the Transformer [39] have shown remarkable success in both Natural Language processing (NLP) and computer vision. Most adaptations of the Transformer architectures to computer vision, have been slow, although some optimizations, have been successful e.g., for image classification, [4, 45, 6, 28] and for video generation [42].
+
+Applying attention-based architectures to video presents a definite challenge as the model needs to learn dependencies across both the spatial and temporal domains. The Vision Transformer [9] demonstrated how the NLP-specific Transformer architecture can elegantly work for images, by subdividing the input image into non-overlapping patches on a regular grid and feeding them as token embeddings to the Trasnformer, where $O ( \bar { N } ^ { 2 } )$ tokens are used or order of 256 or 1024. [16] relied on the region proposal network to use the detected human and object candidates as tokens, showing that it could be combined with CNNs.
+
+A couple of recent work [2, 3], in the spirit of the Vision Transformer, subdivided the video into token in a 3D grid to capture the video input. This leads to $O ( N ^ { 3 } )$ increase in the number of tokens required for learning (typically $\sim 2 5 \mathrm { k }$ tokens for 96-frame model). Our work, in contrast, learns the tokens from data which results in a significantly fewer tokens, and more efficient approach. We see that even ${ } ^ { 8 \mathrm { { X } } }$ times fewer tokens (e.g., 512 vs 4096), when learned, are able to capture successfully the information needed for video representation learning.
+
+# 6 Conclusions
+
+We have presented TokenLearner, a novel approach for visual representation learning, which adaptively tokenizes the representations. The goal is to learn to extract important tokens in image frames and videos for the recognition tasks at hand. Our approach is more efficient, than contemporary work, by finding few important space-time tokens which can model visual representations of images and videos. We observe improved accuracies across challenging video understanding tasks, and outperformed prior approaches in many datasets. One of the remaining challenges is in learning full spatio-temporal tokens. The current TokenLearner focuses on finding spatial tokens over a sequence of frames, and it could be extended to directly mine tokens over space-time volumes.
+
+# Acknowledgement
+
+We thank Dmitry Kalashnikov, Andy Zeng, and Robotics at Google NYC team members for valuable discussions on attention mechanisms.
+
+# References
+
+[1] J.-B. Alayrac, A. Recasens, R. Schneider, R. Arandjelovic, J. Ramapuram, J. D. Fauw, L. Smaira, S. Diele- ´ man, and A. Zisserman. Self-supervised multimodal versatile networks. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   
+[2] A. Arnab, M. Dehghani, G. Heigold, C. Sun, M. Luciˇ c, and C. Schmid. ViViT: A video vision transformer. ´ In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2021.   
+[3] G. Bertasius, H. Wang, and L. Torresani. Is space-time attention all you need for video understanding? In International Conference on Machine Learning (ICML), 2021. [4] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko. End-to-end object detection with transformers. In Proceedings of European Conference on Computer Vision (ECCV), 2020.   
+[5] J. Carreira and A. Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.   
+[6] J. Cordonnier, A. Loukas, and M. Jaggi. On the relationship between self-attention and convolutional layers. In International Conference on Learning Representations (ICLR), 2020.   
+[7] M. Dehghani, A. Gritsenko, A. Arnab, M. Minderer, and Y. Tay. Scenic: A JAX library for computer vision research and beyond. arXiv preprint arXiv:2110.11403, 2021.   
+[8] A. Diba, M. Fayyaz, V. Sharma, M. Paluri, J. Gall, , R. Stiefelhagen, and L. V. Gool. Holistic large scale video understanding. arXiv preprint arXiv:1904.114511, 2019.   
+[9] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   
+[10] H. Fan, B. Xiong, K. Mangalam, Y. Li, Z. Yan, J. Malik, and C. Feichtenhofer. Multiscale vision transformers. arXiv preprint arXiv:2104.11227, 2021.   
+[11] C. Feichtenhofer. X3D: expanding architectures for efficient video recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[12] C. Feichtenhofer, H. Fan, J. Malik, and K. He. Slowfast networks for video recognition. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2019.   
+[13] C. Feichtenhofer, A. Pinz, and R. Wildes. Spatiotemporal residual networks for video action recognition. In Advances in Neural Information Processing Systems (NeurIPS), pages 3468–3476, 2016.   
+[14] C. Feichtenhofer, A. Pinz, and R. P. Wildes. Spatiotemporal multiplier networks for video action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 4768– 4777, 2017.   
+[15] C. Feichtenhofer, A. Pinz, and A. Zisserman. Convolutional two-stream network fusion for video action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1933–1941, 2016.   
+[16] R. Girdhar, J. Carreira, C. Doersch, and A. Zisserman. Video action transformer network. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   
+[17] K. Hara, H. Kataoka, and Y. Satoh. Learning spatio-temporal features with 3d residual networks for action recognition. In Proceedings of the ICCV Workshop on Action, Gesture, and Emotion Recognition, 2017.   
+[18] J. Hu, L. Shen, S. Albanie, G. Sun, and E. Wu. Squeeze-and-excitation networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.   
+[19] J. Ji, R. Krishna, L. Fei-Fei, and J. C. Niebles. Action genome: Actions as composition of spatio-temporal scene graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[20] S. Ji, W. Xu, M. Yang, and K. Yu. 3d convolutional neural networks for human action recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(1):221–231, 2013.   
+[21] W. Kay, J. Carreira, K. Simonyan, B. Zhang, C. Hillier, S. Vijayanarasimhan, F. Viola, T. Green, T. Back, P. Natsev, et al. The kinetics human action video dataset. arXiv preprint arXiv:1705.06950, 2017.   
+[22] D. Kondratyuk, L. Yuan, Y. Li, L. Zhang, M. Tan, M. Brown, and B. Gong. Movinets: Mobile video networks for efficient video recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   
+[23] Z. Liu, J. Ning, Y. Cao, Y. Wei, Z. Zhang, S. Lin, and H. Hu. Video swin transformer. arXiv preprint arXiv:2106.13230, 2021.   
+[24] M. Monfort, A. Andonian, B. Zhou, K. Ramakrishnan, S. A. Bargal, T. Yan, L. Brown, Q. Fan, D. Gutfruend, C. Vondrick, et al. Moments in time dataset: one million videos for event understanding. arXiv preprint arXiv:1801.03150, 2018.   
+[25] A. Piergiovanni, A. Angelova, and M. S. Ryoo. Evolving losses for unsupervised video representation learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[26] A. Piergiovanni, A. Angelova, A. Toshev, and M. S. Ryoo. Evolving space-time neural architectures for videos. Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2019.   
+[27] A. Piergiovanni and M. S. Ryoo. AViD dataset: Anonymized videos from diverse countries. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   
+[28] P. Ramachandran, N. Parmar, A. Vaswani, I. Bello, A. Levskaya, and J. Shlens. Stand-alone self-attention in vision models. In Advances in Neural Information Processing Systems (NeurIPS), 2019.   
+[29] M. S. Ryoo, A. Piergiovanni, J. Kangaspunta, and A. Angelova. AssembleNet++: Assembling modality representations via attention connections. In Proceedings of European Conference on Computer Vision (ECCV), 2020.   
+[30] M. S. Ryoo, A. Piergiovanni, M. Tan, and A. Angelova. AssembleNet: Searching for multi-stream neural connectivity in video architectures. In International Conference on Learning Representations (ICLR), 2020.   
+[31] G. A. Sigurdsson, G. Varol, X. Wang, A. Farhadi, I. Laptev, and A. Gupta. Hollywood in homes: Crowdsourcing data collection for activity understanding. In Proceedings of European Conference on Computer Vision (ECCV), 2016.   
+[32] K. Simonyan and A. Zisserman. Two-stream convolutional networks for action recognition in videos. In Advances in Neural Information Processing Systems (NeurIPS), pages 568–576, 2014.   
+[33] A. Srinivas, T. Lin, N. Parmar, J. Shlens, P. Abbeel, and A. Vaswani. Bottleneck transformers for visual recognition. arXiv preprint arXiv:2101.11605, 2021.   
+[34] J. C. Stroud, D. A. Ross, C. Sun, J. Deng, and R. Sukthankar. D3D: Distilled 3d networks for video action recognition. arXiv preprint arXiv:1812.08249, 2018.   
+[35] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2017.   
+[36] I. Tolstikhin, N. Houlsby, A. Kolesnikov, L. Beyer, X. Zhai, T. Unterthiner, J. Yung, A. Steiner, D. Keysers, J. Uszkoreit, M. Lucic, and A. Dosovitskiy. Mlp-mixer: An all-mlp architecture for vision. arXiv preprint arXiv:2105.01601, 2021.   
+[37] D. Tran, L. D. Bourdev, R. Fergus, L. Torresani, and M. Paluri. C3d: generic features for video analysis. CoRR, abs/1412.0767, 2(7):8, 2014.   
+[38] D. Tran, H. Wang, L. Torresani, J. Ray, Y. LeCun, and M. Paluri. A closer look at spatiotemporal convolutions for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 6450–6459, 2018.   
+[39] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   
+[40] X. Wang, R. Girshick, A. Gupta, and K. He. Non-local neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 7794–7803, 2018.   
+[41] X. Wang and A. Gupta. Videos as space-time region graphs. In Proceedings of European Conference on Computer Vision (ECCV), pages 399–417, 2018.   
+[42] D. Weissenborn, O. Täckström, and J. Uszkoreit. Scaling autoregressive video models. In International Conference on Learning Representations (ICLR), 2020.   
+[43] C.-Y. Wu, C. Feichtenhofer, H. Fan, K. He, P. Krähenbühl, and R. Girshick. Long-term feature banks for detailed video understanding. arXiv preprint arXiv:1812.05038, 2018.   
+[44] S. Xie, C. Sun, J. Huang, Z. Tu, and K. Murphy. Rethinking spatiotemporal feature learning: Speedaccuracy trade-offs in video classification. In Proceedings of European Conference on Computer Vision (ECCV), pages 305–321, 2018.   
+[45] H. Zhao, J. Jia, and V. Koltun. Exploring self-attention for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.

parse/train/z-l1kpDXs88/z-l1kpDXs88_content_list.json

@@ -0,0 +1,1148 @@
+[
+    {
+        "type": "text",
+        "text": "TokenLearner: Adaptive Space-Time Tokenization for Videos ",
+        "text_level": 1,
+        "bbox": [
+            192,
+            122,
+            808,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Michael S. Ryoo1,2, AJ Piergiovanni1, Anurag Arnab1, Mostafa Dehghani1, Anelia Angelova1 ",
+        "bbox": [
+            181,
+            220,
+            831,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Google Research 2Stony Brook University {mryoo,ajpiergi,aarnab,dehghani,anelia}@google.com ",
+        "bbox": [
+            295,
+            237,
+            723,
+            279
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            314,
+            535,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce a novel visual representation learning which relies on a handful of adaptively learned tokens, and which is applicable to both image and video understanding tasks. Instead of relying on hand-designed splitting strategies to obtain visual tokens and processing a large number of densely sampled patches for attention, our approach learns to mine important tokens in visual data. This results in efficiently and effectively finding a few important visual tokens and enables modeling of pairwise attention between such tokens, over a longer temporal horizon for videos, or the spatial content in image frames. Our experiments demonstrate strong performance on several challenging benchmarks for video recognition tasks. Importantly, due to our tokens being adaptive, we accomplish competitive results at significantly reduced computational cost. We establish new state-of-the-arts on multiple video datasets, including Kinetics-400, Kinetics-600, Charades, and AViD. ",
+        "bbox": [
+            233,
+            345,
+            766,
+            522
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The code will be available at: https://github.com/google-research/ scenic/tree/main/scenic/projects/token_learner ",
+        "bbox": [
+            232,
+            525,
+            764,
+            553
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            579,
+            310,
+            595
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Videos provide an abundance of visual information. Video understanding particularly requires employing effective spatial-temporal processing of frames to capture long-range interactions [5, 37, 21, 17, 24, 12, 34, 20, 25, 1]. An important aspect of this understanding is how to quickly learn which parts of the input video stream are important, both spatially and temporally, and to focus computational resources on them. But what basic processing mechanism are able to do so successfully? ",
+        "bbox": [
+            174,
+            609,
+            825,
+            693
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent advancements in Transformers demonstrate improved accuracy on vision classification tasks. For example, departing from standard convolutional approaches, the Vision Transformer (ViT) [9] treats the image as a sequence of patches, utilizing the Transformer architecture [39] similar to text understanding. Standard approaches for video recognition take videos as stacked images (i.e., a spacetime volume) and tend to extend 2D neural architectures to 3D (e.g., 3D-ResNets [17, 5, 38, 11]). Motivated by ViT, recent approaches [2, 3] also extend Transformers for videos by creating 3D ‘tubelet’ video tokens with regular 3D-grids, which often result in computationally heavy models. There are often too many tokens to process, especially for longer videos. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            809
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The main question addressed in this work is how to adaptively learn the representation from visual inputs to most effectively capture the spatial information for image frames and spatio-temporal interactions for videos. Here are our main ideas: ",
+        "bbox": [
+            176,
+            814,
+            821,
+            856
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The first key observation is we are able to learn to represent visual data by learning to ‘tokenize’ the representations. This is in contrast to previous approaches which used densely sampled tokens e.g., 16x16 or $3 2 \\mathrm { x } 3 2$ over a series of attention layers [9, 3]. ",
+        "bbox": [
+            176,
+            862,
+            825,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/228c46745c64ff5abc69a08c68e281e1f5c3dbfcf19f5f3daa36b7c3016f39d3.jpg",
+        "image_caption": [
+            "Figure 1: Visual illustration of the TokenLearner module, applied to a single image frame. TokenLearner learns to spatially attend over a subset of tensor pixels (i.e., from intermediate spatial representations), and generates a set of token vectors adaptive to the input. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            308,
+            90,
+            692,
+            290
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we can learn to compute important regions in the input image/video, making the tokens adapt to the input data. We compute multiple spatial weight maps per frame with a spatial attention mechanism, and use it for the tokenization. The goal of these maps is to learn which areas are of importance. Here, each spatial weight map is multiplied with the input to form a ‘token’, to be processed by the subsequent learning modules. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            440
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we find that very few tokens may be sufficient for a visual understanding task. More specifically, we show that one can significantly reduce the computational budget of video Transformers, by utilizing 8-16 tokens as an intermediate frame representation (instead of keeping $2 0 0 { \\sim } 5 0 0 $ ). Our TokenLearner is able to reduce the number of total FLOPS by half, while maintaining or even increasing the classification accuracy. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            515
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The approach is simple, efficient, and, as shown by the results, outperforms methods including both convolutional methods and previous space-time Transformer ones from prior art. In video understanding tasks, we establish new state-of-the-art numbers on Kinetics-400, Kinetics-600, Charades, and AViD datasets by outperforming prior models. ",
+        "bbox": [
+            174,
+            521,
+            826,
+            577
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 TokenLearner Modules for Adaptive Tokenization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            601,
+            624,
+            618
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In visual Transformer architectures such as ViT [9], an input image is first tokenized by splitting it into small (e.g., 16x16) spatial patches, which are used as input to the model. Similarly, in recent video Transformer architectures, such as ViViT [2] and TimeSformer [3], the video is tokenized by cutting the video into 2d spatial or 3d spatio-temporal cubes on a regular grid. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Instead of processing fixed, tokenized inputs, our attention module learns the tokens that are to be used for the recognition task. We gain several important properties by doing so: (1) We enable the adaptive tokenization so that the tokens can be dynamically selected conditioned on the input. (2) This also effectively reduces the total number of tokens for the transformer, which is particularly beneficial considering that there are many tokens in videos (e.g., $1 4 \\times 1 4 \\times 6 4 \\times$ and the computation is quadratic to the number of tokens. (3) Finally, we provide an ability for each subsequent layer to learn to rely on different space-time tokenizations, potentially allowing different layers to capture different aspects of the video. These dynamically and adaptively generated tokens can be used in standard transformer architectures such as ViT for images and ViViT for videos. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            820
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 TokenLearner ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            842,
+            312,
+            857
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $X$ be an input tensor with a space-time shape: $X \\in \\mathbb { R } ^ { T \\times H \\times W \\times C }$ where $H \\times W$ corresponds to the spatial dimension of the input, $T$ is the temporal dimension (i.e., number of frames), and $C$ is the number of channels. Let $X _ { t }$ be a temporal slice of it, corresponding to the frame $t$ : $X _ { t } \\in \\mathbb { R } ^ { H \\times W \\times C }$ ",
+        "bbox": [
+            174,
+            868,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the case of an image input, $T = 1$ and $X = X _ { t }$ . Note that $X$ could also be an intermediate representation within a network, and $X _ { t }$ will be its slice in such case. ",
+        "bbox": [
+            173,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For every time frame $t$ , we learn to generate a series of $S$ tokens, $Z _ { t } = [ z _ { i } ] _ { i = 1 } ^ { S }$ , from the input frame $X _ { t }$ . Specifically, we formulate a tokenizer function, $z _ { i } = A _ { i } ( X _ { t } )$ , which maps the input frame $X _ { t }$ to a token vector $z _ { i }$ : $\\mathbb { R } ^ { H \\times W \\times C } \\mapsto \\mathbb { R } ^ { C }$ . The idea is to learn our tokenizer function $A _ { i }$ to adaptively select an informative combination of pixels (or spatial locations) in $X _ { t }$ , and we have $S$ number of such functions. This way, our tokens will not be fixed splits of the input tensor, but a set of adaptively changing spatial selections. Different tokens will be mined per frame, allowing us to model their space-time relations/interactions in case of videos. We also set $S$ to be smaller than $H \\times W$ (e.g., $S = 8$ and $H \\times W = 1 4 \\times 1 4$ ), enabling the model to significantly reduce the computations needed for the layers following this module. ",
+        "bbox": [
+            173,
+            125,
+            825,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, our tokenizer $z _ { i } = A _ { i } ( X _ { t } )$ is implemented with a spatial attention mechanism: i.e., the model learns to compute a weight map (of size $H \\times W$ ) conditioned on the input $X _ { t }$ , and is multiplied with $X _ { t }$ itself. More specifically, let $\\alpha _ { i } ( X _ { t } )$ be a function generating the spatial $H \\times W \\times 1$ weight map. Each token $z _ { i }$ is generated by ",
+        "bbox": [
+            174,
+            256,
+            825,
+            313
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0edb681876faacec088a26c4981eec84b77b720f28e6b8eabeefe514724d9f21.jpg",
+        "text": "$$\nz _ { i } = A _ { i } ( X _ { t } ) = \\rho ( X _ { t } \\odot A _ { i w } ) = \\rho ( X _ { t } \\odot \\gamma ( \\alpha _ { i } ( X _ { t } ) ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            319,
+            673,
+            337
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ is the Hadamard product (i.e., element-wise multiplication) and $A _ { i w } \\in \\mathbb { R } ^ { H \\times W \\times C }$ is an intermediate weight tensor computed with the function $\\alpha _ { i } ( X _ { t } )$ and the broadcasting function $\\gamma ( \\cdot )$ . Finally, spatial global average pooling $\\rho ( \\cdot )$ is applied on top of them to reduce the dimensionality to $\\mathbb { R } ^ { C }$ . The resulting tokens are gathered to form the output tensor: $Z _ { t } = [ z _ { i } ] _ { i = 1 } ^ { S } \\in \\mathbb { R } ^ { S \\times C }$ . ",
+        "bbox": [
+            173,
+            345,
+            825,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The overall process has a form of an element-wise spatial self-attention. In our version, $\\{ \\alpha _ { i } ( \\cdot ) \\} _ { i = 1 } ^ { S }$ are implemented together as a single or a series of convolutional layers (with the channel size $S$ ) followed by a sigmoid function, although this could be extended with other implementations. In case of an image, $Z = Z _ { t }$ . In the case of a video, the tokens $Z _ { t }$ from all the frames are collected to form the final output token tensor Z ∈ RST ×C . ",
+        "bbox": [
+            173,
+            410,
+            825,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We specifically name our token learning module as “TokenLeaner”. Figure 1 visually summarizes the TokenLearner module. ",
+        "bbox": [
+            174,
+            484,
+            823,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Compute reduction in Transformers: The learned tokens (i.e., the outputs of the TokenLearner $Z$ ) are provided to the subsequent layers for the visual representation learning, such as multi-head selfattention (MHSA) used in Vision Transformer and ViViT. With the TokenLearner, these subsequent layers only need to process a small number of tokens (e.g., 8 instead of 1024 per frame) and this significantly reduces the computations, as they are quadratic to the number of tokens. Figure 4 (a) shows a basic architecture inserting the TokenLearner module within ViViT. It could be added at any location within the network, and the relative compute of the Transformer layers after the TokenLearner become almost negligible due to the huge difference in the number of tokens. ",
+        "bbox": [
+            173,
+            529,
+            825,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 TokenFuser ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            656,
+            295,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After the TokenLearner generates tokens and its subsequent Transformer layer (e.g., MHSA) processes them, the “TokenFuser” could be used to further (1) fuse information across the tokens and (2) remap the representation back to its original spatial resolution. This enables the model to capture spatial (or spatio-temporal) ‘patterns’ formulated by the tokens, and recover the original input tensor shape when necessary. ",
+        "bbox": [
+            173,
+            681,
+            825,
+            752
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/ac8430698282f52e4aa03e60ff76c1a2866d14cb82a800e20d5180d1d597a1f8.jpg",
+        "image_caption": [
+            "Figure 2: Visual illustration of the TokenFuser module, applied to each image frame individually. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            307,
+            775,
+            692,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d89d52af2aa2f516a081322abb74143e016370abc5593222950ee987bcd153f.jpg",
+        "image_caption": [
+            "Figure 3: TokenLearner, Transformer, and TokenFuser combined for video representation learning. TokenLearner first learns to generate a set of token vectors, Transformer (e.g., MHSA) models their space-time relations, and TokenFuser combines them. $S$ is the number of tokens we learn per frame, and $T$ is the number of frames. Note that this combination can serve as a ‘module’ itself, and one may stack such module multiple times within the network. TokenFuser could be dropped. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            90,
+            800,
+            327
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "First, given the token tensor $Y \\in \\mathbb { R } ^ { S T \\times C }$ from a Transformer layer, we apply a linear layer (i.e., a fully connected MLP layer) over the tokens, not channels. That is, we learn a linear function of $\\mathbb { R } ^ { S T } \\overset { \\cdot } { \\mapsto } \\mathbb { R } ^ { S T }$ where $S$ is the number of our tokens mined per frame and $T$ is temporal size of the input tensor, and apply it to every channel independently. That is, we update $\\boldsymbol { Y } = \\bar { ( } \\boldsymbol { Y } ^ { T } \\boldsymbol { M } ) ^ { T }$ where $M$ is a learnable weight matrix with size $S T \\times S T$ . The result of such operation maintains the tensor size of $S T \\times C$ . We believe this also has a connection to the observations from the concurrent work, MLPMixer [36], that token-wise linear layers are beneficial. ",
+        "bbox": [
+            173,
+            425,
+            825,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Next, the TokenFuser processes each temporal slice $Y _ { t } \\in \\mathbb { R } ^ { S \\times C }$ individually, and remaps the token tensor of size $S \\times C$ back to $H \\times W \\times C$ , by learning to combine the tokens for each spatial location in $H \\times W$ differently. ",
+        "bbox": [
+            176,
+            529,
+            823,
+            571
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/075fd5f5b997e36fdafc645765a5b41f161f61471875e1f01f5f85b7cf64b510.jpg",
+        "text": "$$\nX _ { t } ^ { j + 1 } = B ( Y _ { t } , X _ { t } ^ { j } ) = B _ { w } Y _ { t } + X _ { t } ^ { j } = \\beta _ { i } ( X _ { t } ^ { j } ) Y _ { t } + X _ { t } ^ { j }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            578,
+            679,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $X _ { t } ^ { j }$ is the residual input to the previous TokenLearner module, $Y _ { t }$ is the processed tokens in the TokenFuser module, and $X _ { t } ^ { j + 1 }$ is the output. $B _ { w } \\in \\mathbb { R } ^ { H W \\times S }$ is an intermediate weight tensor computed with the function $\\beta _ { i } ( X _ { t } )$ . The function $\\beta _ { i } ( X _ { t } )$ is implemented with a simple linear layer followed by a sigmoid function. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 illustrates the overall process of the TokenFuser (the token-wise linear layer is omitted). ",
+        "bbox": [
+            171,
+            670,
+            805,
+            685
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Video architecture overview ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            700,
+            406,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, we provide an overview of video representation architecture with TokenLearner. The TokenLearner and TokenFuser modules introduced in Section 2 are directly applicable for video representation learning. TokenLearner generates multiple $Z _ { t }$ for frames in videos and they are stacked to form $Z$ . Once $Z$ is generated, any standard Transformer layers could be used to parse them jointly. ",
+        "bbox": [
+            173,
+            726,
+            825,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 provides an overview of the combined architecture for video representation, which is to be repeated over multiple layers. TokenLearner first extracts $S$ number of tokens per frame, resulting in a total of $S T$ tokens where $T$ is the number of frames. Once TokenLearner generates these adaptively learned tokens, they are provided to the subsequent Transformer layer to capture the global space-time patterns. Finally (and optionally depending on the architecture), TokenFuser applies a linear layer over the token axis and remaps the tensor shape back, as discussed in Subsection 2.2. Following Eq. 2, TokenFuser is applied for per-frame representation $Y _ { t }$ . This results in a lightweight approach, which brings forth an efficient video representation by capturing long-range visual patterns. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Experiments: TokenLearner with Video Vision Transformer ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            707,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 Network architecture implementation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            121,
+            475,
+            136
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we use the Video Vision Transformer (ViViT) architecture [2], following its detailed settings and implementation [7]. ViViT is a direct extension of ViT [9] for videos, which uses spatiotemporal tubelets from videos as its tokens. The size of the space-time tubelets are typically 16x16x2, which are given to the Transformer layers. ",
+        "bbox": [
+            174,
+            147,
+            517,
+            243
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use ViViT-L/16 as our backbone, while also applying the TokenLearner to backbones with more initial tokens such as L/14 and L/10. ViViT-L models have 24 transformer layers. Following the setting of [2], we used the input resolution of $2 2 4 \\mathbf { x } 2 2 4$ , extracting tubelets, and attaching positional encodings. ",
+        "bbox": [
+            174,
+            250,
+            517,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 (a) and (b) show two different architectures incorporating TokenLearner. (a) is formed by inserting TokenLearner in the middle of the network such as after the 12th layer among 24, while (b) uses both TokenLearner and TokenFuser. In particular, our model (b) is formed by replacing conventional Transformer layers with a series of TokenLearnerTransformer-TokenFuser. Similar to (a), such replacement is done only for the layers after a certain point. For instance, we keep twelve of the standard Transformer MHSA layers in the beginning, and replaces the remaining twelve layers with our TokenLearner-Transformer-TokenFuser modules repeated twelve times. We also modified L/14 and L/10 models to have more transformer layers (e.g., 35 instead of 24). Note that the computation increase caused by the transformer layers added after TokenLearner module is relatively very small, as the number of tokens are few: 8 or 16 per frame. ",
+        "bbox": [
+            174,
+            338,
+            517,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a669c790966a4654e2404f648c2401bdfa7a9b7ed4e0f4d5687ff0e5ea6e5638.jpg",
+        "image_caption": [
+            "Figure 4: Our models following the ViViT architecture. (a) with TokenLearner and (b) with both TokenLearner and TokenFuser. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            547,
+            138,
+            810,
+            385
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            448,
+            825,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We tried various number of tokens including $S = 8 , 1 6 , 3 2$ , and use $S = 8$ and 16 as our default settings. That is, the TokenLearner is learning to abstract an image frame into 8 (or 16) tokens. The spatial attention function $( \\alpha )$ in TokenLearner is implemented with four 3x3 conv. layers (with gelu in between), whose channel size is identical to the number of tokens (e.g., $S = 8$ ). ",
+        "bbox": [
+            176,
+            535,
+            825,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Datasets and training ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            608,
+            362,
+            623
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use the Kinetics datasets, which are video classification datasets with relatively short video clips ${ \\sim } 1 0$ seconds). We train and evaluate on both Kinetics-400 and Kinetics-600 datasets, which have about $2 4 0 \\mathrm { k }$ and 390k training samples. We follow the standard settings used in previous papers and report accuracy on the validation set [5, 12]. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following ViViT [2], we first pretrain models on JFT [35] to obtain initial weights. The weights of the initial convolutional layers to handle image patches (e.g., 16x16) are processed to handle 16x16x2 video patches by following ViViT’s 3D initialization strategy, and the weights of the Transformer and the TokenLearner layers are directly inherited. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            263,
+            782
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We evaluate various versions of the ViT-L models incorporating the TokenLearner module. As mentioned above, all of the models are pre-trained on JFT and finetuned on Kinetics. We use the standard L/16 models $^ +$ TokenLearner, as well as L/14 and $\\mathrm { L } / 1 0 . \\mathrm { L } / 1 4$ and $\\mathrm { L } / 1 0$ use 11 additional layers compared to the standard ViT L/16, but as also described in the above subsections, the computation increase caused by them are minimal due to the number of tokens being much smaller, 8 or 16 per frame, in the added layers. We report both their classification accuracies and FLOPS. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Table 1 compares the accuracies of the base ViViT models against our ViViT $^ +$ TokenLearner models on Kinetics-400. These models are directly comparable as they follow the exact same setting and the pre-train dataset. “TokenLearner 16at12” means that we have the TokenLearner layer learning 16 tokens, after the 12th Transformer layer. We are able to observe that the use of TokenLearner enables better classification while also reducing the compute. In particular, inserting TokenLearner in the middle of the network (at 12) achieves better accuracy than the base mode, while cutting the computation by (almost) half. In addition, having the TokenLearner at the later layer (at 18) achieves even superior accuracy while still performing faster, thanks to its adaptiveness. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/5746d37338cbaf5fc661534a2206d07e646d763ac0592c2914330df0a9d4093e.jpg",
+        "table_caption": [
+            "Table 1: Comparison of ViViT models with and without TokenLearner on Kinetics-400. GLOPS are per view. The difference in the number of parameters between the TokenLearner models comes from the different number of layers used after the TokenLearner module. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Top-1 accuracy</td><td>Top-5 accuracy</td><td># params.</td><td>GFLOPS</td></tr><tr><td>ViViT-L/16 [2]</td><td>82.8</td><td>95.5</td><td>308M</td><td>1446</td></tr><tr><td>ViViT-L/16 320 [2]</td><td>83.5</td><td>95.5</td><td>308M</td><td>3992</td></tr><tr><td>ViViT-H/14 [2]</td><td>84.8</td><td>95.8</td><td>654M</td><td>3981</td></tr><tr><td>ViViT-L/16 (our run)</td><td>83.4</td><td>95.6</td><td>308M</td><td>1446</td></tr><tr><td>TokenLearner 16at12 + L/16</td><td>83.5</td><td>95.6</td><td>308M</td><td>766</td></tr><tr><td>TokenLearner 8at18 +L/16</td><td>84.5</td><td>96.1</td><td>383M</td><td>1105</td></tr><tr><td>TokenLearner 16at18+ L/14</td><td>84.7</td><td>96.1</td><td>447M</td><td>1621</td></tr><tr><td>TokenLearner 16at18+ L/10</td><td>85.4</td><td>96.3</td><td>450M</td><td>4076</td></tr></table>",
+        "bbox": [
+            191,
+            138,
+            805,
+            290
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/073c1096d978b8662313c5b43665d10022dc3061f2f9db8a3de7aa68f29cab74.jpg",
+        "table_caption": [
+            "Table 2: ViViT $^ +$ TokenLearner on Kinetics-400, compared to the state-of-the-art models. Different approaches rely on different pre-training datasets, such as ImageNet-21K (for TimeSformer and Swin) and JFT (for ViViT and TokenLearner). The multiplication in GFLOPS correponds to the number of views used for the inference, such as $4 \\mathbf { X } 3 = 1 2$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Top-1 accuracy</td><td>Total GFLOPS</td></tr><tr><td>R(2+1)D [38]</td><td>73.9</td><td>304 × 115</td></tr><tr><td>SlowFast 16x8,R101+NL [12]</td><td>79.8</td><td>234×30</td></tr><tr><td>TimeSformer-L [3]</td><td>80.7</td><td>2380 ×3</td></tr><tr><td>ViViT-L/16 [2]</td><td>82.8</td><td>1446 × 12</td></tr><tr><td>ViViT-H/14 [2]</td><td>84.8</td><td>3981 × 12</td></tr><tr><td>Swin-L [23]</td><td>83.1</td><td>604 ×12</td></tr><tr><td>Swin-L (384) [23]</td><td>84.6</td><td>2107×12</td></tr><tr><td>Swin-L (384) [23]</td><td>84.9</td><td>2107 × 50</td></tr><tr><td>TokenLearner 16at12 (L/16)</td><td>82.1</td><td>766×6</td></tr><tr><td>TokenLearner 8at18 (L/16)</td><td>83.2</td><td>1105 × 6</td></tr><tr><td>TokenLearner 16at12 (L/16)</td><td>83.5</td><td>766 × 12</td></tr><tr><td>TokenLearner 8at18 (L/16)</td><td>84.5</td><td>1105 × 12</td></tr><tr><td>TokenLearner 16at18 (L/14)</td><td>84.7</td><td></td></tr><tr><td>TokenLearner 16at18 (L/10)</td><td>85.4</td><td>1621 × 12 4076 × 12</td></tr></table>",
+        "bbox": [
+            266,
+            361,
+            730,
+            599
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            625,
+            825,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 compares the TokenLearner accuracy against the state-of-the-arts models. Note that these approaches follow slightly different settings and pretrain datasets (e.g., the use of ImageNet-21K instead of JFT like ours). We believe the accuracy of 85.4 is the highest that has been reported so far, and we believe it is meaningful. Table 3 compares the results on Kinetics-600. Similar to our results on Kinetics-400, we are able to observe that our proposed approach extends the state-of-the-arts while also being computationally efficient. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments: TokenLearner with Bottleneck Transformer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            819,
+            691,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Network architecture implementation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            853,
+            475,
+            868
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this experiment, we follow the Bottleneck Transformer [33] network style, while taking advantage of X3D [11] as the backbone. This is motivated by the successful usage of X3D on Charades. ",
+        "bbox": [
+            173,
+            881,
+            823,
+            909
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5415888c9f1dba4dd16dba3198e59ac3bbcfe91f64a0e8d85658c8d6f9c67d34.jpg",
+        "table_caption": [
+            "Table 3: ViViT $^ +$ TokenLearner on Kinetics-600. The multiplication in GFLOPS correponds to the number of views used for the inference, such as $4 \\mathbf { X } 3 = 1 2$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Top-1</td><td>Total GFLOPS</td></tr><tr><td>SlowFast 16x8,R101+NL [12]</td><td>81.8</td><td>234× 30</td></tr><tr><td>X3D-XL [11]</td><td>81.9</td><td>48×30</td></tr><tr><td>TimeSformer-HR [3]</td><td>82.4</td><td>1703×3</td></tr><tr><td>ViViT-L/16 [2]</td><td>84.3</td><td>1446 × 12</td></tr><tr><td>ViViT-H/14 [2]</td><td>85.8</td><td>3981 × 12</td></tr><tr><td>Swin-B [23]</td><td>84.0</td><td>282×12</td></tr><tr><td>Swin-L (384) [23]</td><td>85.9</td><td>2107 × 12</td></tr><tr><td>Swin-L (384) [23]</td><td>86.1</td><td>2107 × 50</td></tr><tr><td>TokenLearner 16at12 (L/16)</td><td>84.4</td><td>766×12</td></tr><tr><td>TokenLearner 8at18 (L/16)</td><td>86.0</td><td>1105×12</td></tr><tr><td>TokenLearner 16at18 (L/10)</td><td>86.1</td><td>4076 ×12</td></tr><tr><td>TokenLearner 16at18 w. Fuser (L/10)</td><td>86.3</td><td>4100 ×12</td></tr></table>",
+        "bbox": [
+            276,
+            125,
+            720,
+            337
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Specifically, we modified X3D to be more computationally efficient by (1) replacing its 3D XYT convolutional layers with a pair of 2D conv. layer and 1D conv. layer, and (2) removing Squeeze-and-Excitation layers [18] and swish activations. Our backbone could be viewed as ${ \\mathrm { X } } ( 2 { + } 1 ) { \\mathrm { D } }$ . We use the channel sizes and the number of layers identical to X3D-M, which is an efficient model. ",
+        "bbox": [
+            174,
+            369,
+            647,
+            452
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Based on such ${ \\mathrm { X } } ( 2 { + } 1 ) { \\mathrm { D } }$ architecture, and following the Bottleneck Transformer concept, we replace the space-time convolution layers in the last block with our transformers. Figure 5 illustrates the residual module architecture, which is repeated multiple times in the block. TokenLearner, Transformer, TokenFuser are applied in a sequence, with an optional 2D $3 \\times 3$ convolution layer before them. The spatial attention function (i.e., $\\alpha ( \\cdot ) )$ in TokenLearner is implemented with a single conv2d layer. ",
+        "bbox": [
+            174,
+            458,
+            647,
+            555
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Here, we used a Vector Transformer instead of MHSA as our Transformer layer, which could be also viewed as the MHSA with the number of heads being identical to the number of channels. We provide more details in Appendix. ",
+        "bbox": [
+            173,
+            561,
+            645,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use $2 2 4 \\times 2 2 4 \\times 6 4$ videos for training and $2 5 6 \\times 2 5 6 \\times 6 4$ videos for testing. After the 3rd residual block, the input tensor has the shape of $8 \\times 8 \\times 6 4$ , and this becomes the input to the TokenLearner. For an efficient implementation the intermediate channel size of TokenLearner was set identical to the output channel size, $d = 4 3 2$ . Notice that 64 frames were used to best capture longer-term temporal information. $S = 8$ number of tokens were used. ",
+        "bbox": [
+            174,
+            622,
+            647,
+            719
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/bc76334af69b3eaf600a690da6f88e90a0141729d2f6db341b835e9b5949d29a.jpg",
+        "image_caption": [
+            "Figure 5: Our network module following the bottleneck transformer, with ${ \\mathrm { X } } ( 2 { + } 1 ) { \\mathrm { D } }$ backbone. It is an inverted bottleneck. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            669,
+            363,
+            813,
+            671
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1.1 Datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            746,
+            284,
+            761
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Charades dataset: The Charades dataset [31] is a dataset collected by assigning activity tasks which people in various environments are acting out, by performing a sequence of actions which involve interaction with objects. For example, sitting on the couch and reading a book, closing the book, standing up and speaking on the phone. It comprises 8000 training and 1686 validation videos with an average duration of 30 seconds. It has 157 activity classes. This dataset is very challenging as it is a multi-class, multi-label video dataset, that is, more than one activity can occur at the same time, and it includes fine grained motions or interactions with small objects in real-world environments. We follow the standard evaluation protocols, reporting the mean Average Precision (mAP) $\\%$ (v1 classification setting of the dataset). We used the frame rate of 6 fps and 12 fps to obtain the training/testing videos. The dataset has a Non-Commercial Use license. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e042c4fe740786b6a4b3ded4e76412d5d1f4bd8f4a798a7cb12cb856cb4c3c91.jpg",
+        "table_caption": [
+            "Table 4: Performance on the Charades multi-label classification task. 12 fps setting. Performance is measured using the Mean Average Precision (mAP) since more than one ground truth action is possible. Methods with RGB and optical flow input modalities are listed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Input</td><td>Pre-train</td><td>mAP</td></tr><tr><td>I3D [5]</td><td>RGB</td><td>Kinetics</td><td>32.9</td></tr><tr><td>I3D from [40]</td><td>RGB</td><td>Kinetics</td><td>35.5</td></tr><tr><td>I3D + Non-local [40]</td><td>RGB</td><td>Kinetics</td><td>37.5</td></tr><tr><td>EvaNet [26]</td><td>RGB</td><td>Kinetics</td><td>38.1</td></tr><tr><td>STRG [41]</td><td>RGB</td><td>Kinetics</td><td>39.7</td></tr><tr><td>LFB-101 [43]</td><td>RGB</td><td>Kinetics</td><td>42.5</td></tr><tr><td>SGFB-101[19]</td><td>RGB</td><td>Kinetics</td><td>44.3</td></tr><tr><td>SlowFast-101[12]</td><td>RGB+RGB</td><td>Kinetics</td><td>45.2</td></tr><tr><td>AssembleNet-50 [30]</td><td>RGB+Flow</td><td>None</td><td>47.0</td></tr><tr><td>Multiscale ViT[10]</td><td>RGB</td><td>Kinetics</td><td>47.7</td></tr><tr><td>AssembleNet-101 [30]</td><td>RGB+Flow</td><td>Kinetics</td><td>58.6</td></tr><tr><td>AssembleNet++ [29](w/o object)</td><td>RGB+Flow</td><td>None</td><td>55.0</td></tr><tr><td>MoViNets [22]</td><td>RGB</td><td>None</td><td>63.2</td></tr><tr><td>Backbone (X(2+1)D-M)</td><td>RGB</td><td>None</td><td>62.7</td></tr><tr><td>Ours</td><td>RGB</td><td>None</td><td>66.3</td></tr></table>",
+        "bbox": [
+            251,
+            138,
+            745,
+            378
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/a2ebb903bdcc8af00419310b107aeb861ff76e2eb0f985f40fc8ffbb82697d94.jpg",
+        "table_caption": [
+            "Table 5: Performance on the Anonymized Videos from Diverse countries (AViD) dataset. Performance in terms of mean accuracy is shown in $\\%$ averaged over 887 classes. Previous approaches results are reported from [27], all based on training from scratch with RGB-only inputs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Accuracy</td><td>total GFLOPS</td></tr><tr><td>I3D [5]</td><td>46.5</td><td>108× N/A</td></tr><tr><td>(2+1)D ResNet-50</td><td>46.7</td><td>152 × 115</td></tr><tr><td>3D ResNet-50</td><td>47.9</td><td>N/A</td></tr><tr><td>SlowFast-50 8x8 [12]</td><td>50.2</td><td>65.7 × 30</td></tr><tr><td>SlowFast-101 16x4[12]</td><td>50.8</td><td>213×30</td></tr><tr><td rowspan=\"2\">Backbone (X(2+1)D-M) X(2+1)D-M w/ disjoint space+time Transformer (like [3])</td><td>48.6</td><td>532×1</td></tr><tr><td>50.6</td><td>493×1</td></tr><tr><td>Ours</td><td>53.8</td><td>487×1</td></tr></table>",
+        "bbox": [
+            199,
+            436,
+            797,
+            582
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "AViD dataset: The Anonymized Videos from Diverse countries (AViD) dataset [27] is a unique dataset which is representative of the world’s population video content generation. It is collected from videos uploaded from multiple countries across six continents and demonstrates higher diversity compared to other video datasets such as Kinetics in its concepts, actions and visual representations. For example a ‘greeting’ in certain countries involves a handshake, in some a kiss, but in others a slight bow. The dataset is explicitly designed to contain less bias, encourage diversity, while respecting privacy and licenses. The AViD dataset contains 887 classes and 450k videos (410k training $4 0 \\mathrm { k }$ testing) and is of comparable size to Kinetics-400 and Kinetics-600 datasets with 400 and 600 classes respectively, also containing variable duration videos $3 - 1 5 s$ . We report classification accuracy over the 887 classes. All the videos in this dataset have the Creative Commons License. ",
+        "bbox": [
+            174,
+            608,
+            825,
+            746
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            767,
+            263,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Charades dataset results: In Table 4 we compare the proposed TokenLearner to the state-of-the-art methods. Our approach outperforms these, including several recent works. The mAP of $6 6 . 3 \\%$ on Charades classification establishes the new state-of-the-art. ",
+        "bbox": [
+            176,
+            795,
+            823,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "AViD results: Table 5 shows the results on the AViD dataset. As seen, our approach outperforms prior work on this challenging dataset too. We also compared ours to the reimplementation of TimeSformer module [3] applied to the same backbone as ours. This uses disjoint spatial and temporal transformer modules, which was also tested in [2]. We are able to observe that we establish the new state-of-the-arts on this dataset, while also being more computationally efficient. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/0cd5efea6e01763576bca7de283dba89f41146ad0b4275d136218f34c0a173bf.jpg",
+        "table_caption": [
+            "Table 6: Comparison between TokenLearner and the joint space-time transformer modules similar to [2], applied to our backbone. They use the ${ \\mathrm { X } } ( 2 { + } 1 ) { \\mathrm { D } }$ backbone, tested on Charades with the 6 fps setting, Charades 12 fps setting, and AViD dataset. GFLOPs and $\\#$ params are of each module (with 64 frame inputs), not the entire network. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Module</td><td>Char-6fps</td><td>Char-12fps</td><td>AViD</td><td>GFLOPs</td><td># params</td></tr><tr><td>Joint space-time MHSA</td><td>57.9</td><td>64.0</td><td>53.3</td><td>22.0</td><td>0.30M</td></tr><tr><td>Conv2D + Joint space-time MHSA</td><td>58.6</td><td>62.5</td><td>52.5</td><td>35.8</td><td>1.98M</td></tr><tr><td>Ours (TokenLearner)</td><td>58.8</td><td>63.4</td><td>53.8</td><td>3.4</td><td>0.81M</td></tr><tr><td>Ours (Conv2D + TokenLearner)</td><td>59.6</td><td>66.3</td><td>53.7</td><td>17.2</td><td>2.49M</td></tr></table>",
+        "bbox": [
+            173,
+            152,
+            828,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            266,
+            281,
+            280
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison against different tokenizations: Here, we compare the model with TokenLearner against space-time transformer modules with the standard tokenization. More specifically, we compare the use of TokenLearner $^ +$ Vector Transformer $^ +$ TokenFuser against the full joint space-time transformer module (advocated in [2] and also mentioned in [3]), without token learning. The full joint space-time transformer module is a transformer layer on space-time tokens similar to ours, but it relies only on the hand-designed tokenization. Compared to TokenLearner which generates $S \\times T$ number of tokens, the full joint space-time transformer uses $H \\times W \\times T$ number of tokens. In our bottleneck implementation, it uses ${ \\sim } 8$ times more tokens (i.e., $8 ^ { * } 6 4$ vs. $8 ^ { * } 8 ^ { * } 6 4$ ). For the joint space-time transformer modules, the standard multi-head self-attention (MHSA) with 8 heads is used. ",
+        "bbox": [
+            174,
+            295,
+            826,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 6 shows the results. Interestingly, despite the heavier computation of the full joint spacetime transformer, it performed slightly worse to the TokenLearner modules. We believe this shows the advantage of the ‘adaptiveness’ of the tokens in the TokenLearner and shows that the standard transformers might be suffering from the tokens irrelevant to the actions serving as noise or distractors. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We also report the amount of computation and the number of parameters of each module in these models. This depends on the input size and the hyper parameter setting, and our measurement is based on the input size (i.e., $T \\times H \\times W \\times C )$ of $8 \\times 8 \\times 6 4 \\times 4 9 2$ . Note that this is the measurement of modules, not the entire network. ",
+        "bbox": [
+            174,
+            486,
+            825,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison between multiple space-time layer combinations. As also suggested in previous literature, it is a common strategy for video representations to pair a layer focusing on spatial information with a layer focusing on temporal information (e.g., $\\mathrm { R } ( 2 { + } 1 ) \\mathrm { D }$ [38] and TimeSformer [3]). Table 7 shows the results of this ablation. For spatial and temporal transformer implementations, the standard multi-head self-attention was used, as was done in [2, 3]. The result shows that the proposed TokenLearner is more accurate than other popular combinations. The modules based on TokenLearner also effectively only uses a fraction of the Tokens per frame (i.e., 8) as opposed to other methods which use $1 6 \\times 1 6$ or $3 2 \\times 3 2$ tokens. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            675
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One of the main benefits of the TokenLearner (in addition to the adaptive tokenization of the input and that we explicitly fuse the tokens to capture their spatio-temporal patterns) is that, unlike the disjoint space/time transformers used in this ablation study, it is a joint space-time transformer. Simultaneously, it still manages its computation to be much more tractable (as shown in Tables 6 and 7): A naive full version of the space-time transformer would require consideration of $8 { \\times } 8 { \\times } 6 4 = 4 0 9 6$ tokens in our case, building and multiply the attention tensor of size $4 0 9 6 \\times 4 0 9 6$ . On the other hand, the TokenLearner learns to consider $8 \\times 6 4 = 5 1 2$ tokens jointly. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            777
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "More TokenLearner alternatives. We also compared our spatial attention-based token learning with alternative approaches: (1) using a fixed grid to split each frame into the same number of tokens (i.e., 8 tokens), (2) the approach of directly generating tokens using a fully connected layer, and (3) the approach of spatially average pooling the entire frame pixels and using fully connected layers to generate multiple tokens per frame. In the second approach, we directly model $z _ { i } = A _ { i } ( x )$ as a dense layer, producing $T \\times S \\times C$ tensor based on the $T \\times H \\times W \\times C$ input. The third approach is similar, except that we apply spatial global average pooling per frame and then use MLP to generate tokens. ",
+        "bbox": [
+            173,
+            801,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/082d1a8b5f3ed87f189ec66bda323ed266b7f536efdf9ac964f70789932c2826.jpg",
+        "table_caption": [
+            "Table 7: Comparison between different space-time transformer modules. They were all applied to the same backbone architecture (i.e., the Bottleneck Transformer-style with $\\mathbf { X } ( 2 { + } 1 ) \\mathbf { D } )$ . The Charades-6fps is used in this experiment. FLOPS are estimated with 64-frame settings, per module. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Module</td><td>Charades-6fps (%)</td><td>GFLOPs</td><td># params</td></tr><tr><td>Conv2D + Conv1D</td><td>56.6</td><td>18.3</td><td>2.24M</td></tr><tr><td>Conv2D+MLPMixer [36]</td><td>57.0</td><td>13.8</td><td>2.06M</td></tr><tr><td>Conv2D + Temporal transformer</td><td>58.4</td><td>16.5</td><td>1.98M</td></tr><tr><td>Spatial + Temporal transformer</td><td>58.8</td><td>5.5</td><td>0.59M</td></tr><tr><td>Conv2D + Spatial + Temporal transformer</td><td>58.0</td><td>19.2</td><td>2.27M</td></tr><tr><td>Ours (TokenLearner)</td><td>58.8</td><td>3.4</td><td>0.81M</td></tr><tr><td>Ours (SpatialT + TokenLearner)</td><td>58.9</td><td>6.2</td><td>1.11M</td></tr><tr><td>Ours (Conv2D + TokenLearner)</td><td>59.6</td><td>17.2</td><td>2.49M</td></tr></table>",
+        "bbox": [
+            199,
+            138,
+            797,
+            277
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The fixed split tokenization method (1) provided us the accuracy of 58.8 on Charades, as opposed to 59.6 of ours. The direct token generation method (2) provided the accuracy of 56.6 on Charades, failing to obtain better tokens. Pooling and generation method (3) gave us the accuracy of 58.6. These results suggest the importance of spatial attention for the token learning, our TokenLearner. The same vector transformer and TokenFuser (from Section 2) were used for this ablation. ",
+        "bbox": [
+            173,
+            301,
+            825,
+            371
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            392,
+            316,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Video understanding relies on both the spatial and the temporal information in the video. In order to adequately capture both motion and appearance information in videos, full 3D space-time convolutional layers as well as $( 2 + 1 ) \\mathrm { D }$ convolutional layers have been used [37, 5, 38, 44]. More advanced network designs have also been extremely popular in video CNNs particularly two-stream ones [32, 13, 14, 15, 8, 12] and, recently, architecture searched ones [11, 30, 26]. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Attention-based architectures, e.g., the Transformer [39] have shown remarkable success in both Natural Language processing (NLP) and computer vision. Most adaptations of the Transformer architectures to computer vision, have been slow, although some optimizations, have been successful e.g., for image classification, [4, 45, 6, 28] and for video generation [42]. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            556
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Applying attention-based architectures to video presents a definite challenge as the model needs to learn dependencies across both the spatial and temporal domains. The Vision Transformer [9] demonstrated how the NLP-specific Transformer architecture can elegantly work for images, by subdividing the input image into non-overlapping patches on a regular grid and feeding them as token embeddings to the Trasnformer, where $O ( \\bar { N } ^ { 2 } )$ tokens are used or order of 256 or 1024. [16] relied on the region proposal network to use the detected human and object candidates as tokens, showing that it could be combined with CNNs. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            657
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A couple of recent work [2, 3], in the spirit of the Vision Transformer, subdivided the video into token in a 3D grid to capture the video input. This leads to $O ( N ^ { 3 } )$ increase in the number of tokens required for learning (typically $\\sim 2 5 \\mathrm { k }$ tokens for 96-frame model). Our work, in contrast, learns the tokens from data which results in a significantly fewer tokens, and more efficient approach. We see that even ${ } ^ { 8 \\mathrm { { X } } }$ times fewer tokens (e.g., 512 vs 4096), when learned, are able to capture successfully the information needed for video representation learning. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            747
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            307,
+            786
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have presented TokenLearner, a novel approach for visual representation learning, which adaptively tokenizes the representations. The goal is to learn to extract important tokens in image frames and videos for the recognition tasks at hand. Our approach is more efficient, than contemporary work, by finding few important space-time tokens which can model visual representations of images and videos. We observe improved accuracies across challenging video understanding tasks, and outperformed prior approaches in many datasets. One of the remaining challenges is in learning full spatio-temporal tokens. The current TokenLearner focuses on finding spatial tokens over a sequence of frames, and it could be extended to directly mine tokens over space-time volumes. ",
+        "bbox": [
+            174,
+            801,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            89,
+            330,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We thank Dmitry Kalashnikov, Andy Zeng, and Robotics at Google NYC team members for valuable discussions on attention mechanisms. ",
+        "bbox": [
+            174,
+            121,
+            823,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            178,
+            266,
+            193
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] J.-B. Alayrac, A. Recasens, R. Schneider, R. Arandjelovic, J. Ramapuram, J. D. Fauw, L. Smaira, S. Diele- ´ man, and A. Zisserman. Self-supervised multimodal versatile networks. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   \n[2] A. Arnab, M. Dehghani, G. Heigold, C. Sun, M. Luciˇ c, and C. Schmid. ViViT: A video vision transformer. ´ In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2021.   \n[3] G. Bertasius, H. Wang, and L. Torresani. Is space-time attention all you need for video understanding? In International Conference on Machine Learning (ICML), 2021. [4] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko. End-to-end object detection with transformers. In Proceedings of European Conference on Computer Vision (ECCV), 2020.   \n[5] J. Carreira and A. Zisserman. Quo vadis, action recognition? a new model and the kinetics dataset. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2017.   \n[6] J. Cordonnier, A. Loukas, and M. Jaggi. On the relationship between self-attention and convolutional layers. In International Conference on Learning Representations (ICLR), 2020.   \n[7] M. Dehghani, A. Gritsenko, A. Arnab, M. Minderer, and Y. Tay. Scenic: A JAX library for computer vision research and beyond. arXiv preprint arXiv:2110.11403, 2021.   \n[8] A. Diba, M. Fayyaz, V. Sharma, M. Paluri, J. Gall, , R. Stiefelhagen, and L. V. Gool. Holistic large scale video understanding. arXiv preprint arXiv:1904.114511, 2019.   \n[9] A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   \n[10] H. Fan, B. Xiong, K. Mangalam, Y. Li, Z. Yan, J. Malik, and C. Feichtenhofer. Multiscale vision transformers. arXiv preprint arXiv:2104.11227, 2021.   \n[11] C. Feichtenhofer. X3D: expanding architectures for efficient video recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[12] C. Feichtenhofer, H. Fan, J. Malik, and K. He. Slowfast networks for video recognition. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2019.   \n[13] C. Feichtenhofer, A. Pinz, and R. Wildes. Spatiotemporal residual networks for video action recognition. In Advances in Neural Information Processing Systems (NeurIPS), pages 3468–3476, 2016.   \n[14] C. Feichtenhofer, A. Pinz, and R. P. Wildes. Spatiotemporal multiplier networks for video action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 4768– 4777, 2017.   \n[15] C. Feichtenhofer, A. Pinz, and A. Zisserman. Convolutional two-stream network fusion for video action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1933–1941, 2016.   \n[16] R. Girdhar, J. Carreira, C. Doersch, and A. Zisserman. Video action transformer network. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   \n[17] K. Hara, H. Kataoka, and Y. Satoh. Learning spatio-temporal features with 3d residual networks for action recognition. In Proceedings of the ICCV Workshop on Action, Gesture, and Emotion Recognition, 2017.   \n[18] J. Hu, L. Shen, S. Albanie, G. Sun, and E. Wu. Squeeze-and-excitation networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2018.   \n[19] J. Ji, R. Krishna, L. Fei-Fei, and J. C. Niebles. Action genome: Actions as composition of spatio-temporal scene graphs. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[20] S. Ji, W. Xu, M. Yang, and K. Yu. 3d convolutional neural networks for human action recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(1):221–231, 2013.   \n[21] W. Kay, J. Carreira, K. Simonyan, B. Zhang, C. Hillier, S. Vijayanarasimhan, F. Viola, T. Green, T. Back, P. Natsev, et al. The kinetics human action video dataset. arXiv preprint arXiv:1705.06950, 2017.   \n[22] D. Kondratyuk, L. Yuan, Y. Li, L. Zhang, M. Tan, M. Brown, and B. Gong. Movinets: Mobile video networks for efficient video recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2021.   \n[23] Z. Liu, J. Ning, Y. Cao, Y. Wei, Z. Zhang, S. Lin, and H. Hu. Video swin transformer. arXiv preprint arXiv:2106.13230, 2021.   \n[24] M. Monfort, A. Andonian, B. Zhou, K. Ramakrishnan, S. A. Bargal, T. Yan, L. Brown, Q. Fan, D. Gutfruend, C. Vondrick, et al. Moments in time dataset: one million videos for event understanding. arXiv preprint arXiv:1801.03150, 2018.   \n[25] A. Piergiovanni, A. Angelova, and M. S. Ryoo. Evolving losses for unsupervised video representation learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[26] A. Piergiovanni, A. Angelova, A. Toshev, and M. S. Ryoo. Evolving space-time neural architectures for videos. Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2019.   \n[27] A. Piergiovanni and M. S. Ryoo. AViD dataset: Anonymized videos from diverse countries. In Advances in Neural Information Processing Systems (NeurIPS), 2020.   \n[28] P. Ramachandran, N. Parmar, A. Vaswani, I. Bello, A. Levskaya, and J. Shlens. Stand-alone self-attention in vision models. In Advances in Neural Information Processing Systems (NeurIPS), 2019.   \n[29] M. S. Ryoo, A. Piergiovanni, J. Kangaspunta, and A. Angelova. AssembleNet++: Assembling modality representations via attention connections. In Proceedings of European Conference on Computer Vision (ECCV), 2020.   \n[30] M. S. Ryoo, A. Piergiovanni, M. Tan, and A. Angelova. AssembleNet: Searching for multi-stream neural connectivity in video architectures. In International Conference on Learning Representations (ICLR), 2020.   \n[31] G. A. Sigurdsson, G. Varol, X. Wang, A. Farhadi, I. Laptev, and A. Gupta. Hollywood in homes: Crowdsourcing data collection for activity understanding. In Proceedings of European Conference on Computer Vision (ECCV), 2016.   \n[32] K. Simonyan and A. Zisserman. Two-stream convolutional networks for action recognition in videos. In Advances in Neural Information Processing Systems (NeurIPS), pages 568–576, 2014.   \n[33] A. Srinivas, T. Lin, N. Parmar, J. Shlens, P. Abbeel, and A. Vaswani. Bottleneck transformers for visual recognition. arXiv preprint arXiv:2101.11605, 2021.   \n[34] J. C. Stroud, D. A. Ross, C. Sun, J. Deng, and R. Sukthankar. D3D: Distilled 3d networks for video action recognition. arXiv preprint arXiv:1812.08249, 2018.   \n[35] C. Sun, A. Shrivastava, S. Singh, and A. Gupta. Revisiting unreasonable effectiveness of data in deep learning era. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2017.   \n[36] I. Tolstikhin, N. Houlsby, A. Kolesnikov, L. Beyer, X. Zhai, T. Unterthiner, J. Yung, A. Steiner, D. Keysers, J. Uszkoreit, M. Lucic, and A. Dosovitskiy. Mlp-mixer: An all-mlp architecture for vision. arXiv preprint arXiv:2105.01601, 2021.   \n[37] D. Tran, L. D. Bourdev, R. Fergus, L. Torresani, and M. Paluri. C3d: generic features for video analysis. CoRR, abs/1412.0767, 2(7):8, 2014.   \n[38] D. Tran, H. Wang, L. Torresani, J. Ray, Y. LeCun, and M. Paluri. A closer look at spatiotemporal convolutions for action recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 6450–6459, 2018.   \n[39] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, L. Kaiser, and I. Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems (NeurIPS), 2017.   \n[40] X. Wang, R. Girshick, A. Gupta, and K. He. Non-local neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 7794–7803, 2018.   \n[41] X. Wang and A. Gupta. Videos as space-time region graphs. In Proceedings of European Conference on Computer Vision (ECCV), pages 399–417, 2018.   \n[42] D. Weissenborn, O. Täckström, and J. Uszkoreit. Scaling autoregressive video models. In International Conference on Learning Representations (ICLR), 2020.   \n[43] C.-Y. Wu, C. Feichtenhofer, H. Fan, K. He, P. Krähenbühl, and R. Girshick. Long-term feature banks for detailed video understanding. arXiv preprint arXiv:1812.05038, 2018.   \n[44] S. Xie, C. Sun, J. Huang, Z. Tu, and K. Murphy. Rethinking spatiotemporal feature learning: Speedaccuracy trade-offs in video classification. In Proceedings of European Conference on Computer Vision (ECCV), pages 305–321, 2018.   \n[45] H. Zhao, J. Jia, and V. Koltun. Exploring self-attention for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020. ",
+        "bbox": [
+            173,
+            208,
+            828,
+            917
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            85,
+            830,
+            911
+        ],
+        "page_idx": 11
+    }
+]