Add files using upload-large-folder tool

parse/train/Jnspzp-oIZE/Jnspzp-oIZE.md

@@ -0,0 +1,276 @@
+# GAUGE EQUIVARIANT MESH CNNS ANISOTROPIC CONVOLUTIONS ON GEOMETRIC GRAPHS
+
+Pim de Haan∗ Qualcomm AI Research† University of Amsterdam
+
+Taco Cohen Qualcomm AI Research
+
+Maurice Weiler∗ QUVA Lab University of Amsterdam
+
+Max Welling Qualcomm AI Research University of Amsterdam
+
+# ABSTRACT
+
+A common approach to define convolutions on meshes is to interpret them as a graph and apply graph convolutional networks (GCNs). Such GCNs utilize isotropic kernels and are therefore insensitive to the relative orientation of vertices and thus to the geometry of the mesh as a whole. We propose Gauge Equivariant Mesh CNNs which generalize GCNs to apply anisotropic gauge equivariant kernels. Since the resulting features carry orientation information, we introduce a geometric message passing scheme defined by parallel transporting features over mesh edges. Our experiments validate the significantly improved expressivity of the proposed model over conventional GCNs and other methods.
+
+# 1 INTRODUCTION
+
+Convolutional neural networks (CNNs) have been established as the default method for many machine learning tasks like speech recognition or planar and volumetric image classification and segmentation. Most CNNs are restricted to flat or spherical geometries, where convolutions are easily defined and optimized implementations are available. The empirical success of CNNs on such spaces has generated interest to generalize convolutions to more general spaces like graphs or Riemannian manifolds, creating a field now known as geometric deep learning (Bronstein et al., 2017).
+
+A case of specific interest is convolution on meshes, the discrete analog of 2-dimensional embedded Riemannian manifolds. Mesh CNNs can be applied to tasks such as detecting shapes, registering different poses of the same shape and shape segmentation. If we forget the positions of vertices, and which vertices form faces, a mesh $M$ can be represented by a graph $\mathcal { G }$ . This allows for the application of graph convolutional networks (GCNs) to processing signals on meshes.
+
+Figure 1: Two local neighbourhoods around vertices $p$ and their representations in the tangent planes $T _ { p } M$ . The distinct geometry of the neighbourhoods is reflected in the different angles $\theta _ { p q _ { i } }$ of incident edges from neighbours $q _ { i }$ . Graph convolutional networks apply isotropic kernels and can therefore not distinguish both neighbourhoods. Gauge Equivariant Mesh CNNs apply anisotropic kernels and are therefore sensitive to orientations. The arbitrariness of reference orientations, determined by a choice of neighbour $q _ { 0 }$ , is accounted for by the gauge equivariance of the model.
+
+However, when representing a mesh by a graph, we lose important geometrical information. In particular, in a graph there is no notion of angle between or ordering of two of a node’s incident edges (see figure 1). Hence, a GCNs output at a node $p$ is designed to be independent of relative angles and invariant to any permutation of its neighbours $q _ { i } \in \bar { \mathcal { N } } ( p )$ . A graph convolution on a mesh graph therefore corresponds to applying an isotropic convolution kernel. Isotropic filters are insensitive to the orientation of input patterns, so their features are strictly less expressive than those of orientation aware anisotropic filters.
+
+To address this limitation of graph networks we propose Gauge Equivariant Mesh CNNs (GEM-CNN), which minimally modify GCNs such that they are able to use anisotropic filters while sharing weights across different positions and respecting the local geometry. One obstacle in sharing anisotropic kernels, which are functions of the angle $\theta _ { p q }$ of neighbour $q$ with respect to vertex $p$ , over multiple vertices of a mesh is that there is no unique way of selecting a reference neighbour $q _ { 0 }$ , which has the direction $\theta _ { p q _ { 0 } } = 0$ . The reference neighbour, and hence the orientation of the neighbours, needs to be chosen arbitrarily. In order to guarantee the equivalence of the features resulting from different choices of orientations, we adapt Gauge Equivariant CNNs (Cohen et al., 2019b) to general meshes. The kernels of our model are thus designed to be equivariant under gauge transformations, that is, to guarantee that the responses for different kernel orientations are related by a prespecified transformation law. Such features are identified as geometric objects like scalars, vectors, tensors, etc., depending on the specific choice of transformation law. In order to compare such geometric features at neighbouring vertices, they need to be parallel transported along the connecting edge.
+
+In our implementation we first specify the transformation laws of the feature spaces and compute a space of gauge equivariant kernels. Then we pick arbitrary reference orientations at each node, relative to which we compute neighbour orientations and compute the corresponding edge transporters. Given these quantities, we define the forward pass as a message passing step via edge transporters followed by a contraction with the equivariant kernels evaluated at the neighbour orientations. Algorithmically, Gauge Equivariant Mesh CNNs are therefore just GCNs with anisotropic, gauge equivariant kernels and message passing via parallel transporters. Conventional GCNs are covered in this framework for the specific choice of isotropic kernels and trivial edge transporters, given by identity maps.
+
+In Sec. 2, we will give an outline of our method, deferring details to Secs. 3 and 4. In Sec. 3.2, we describe how to compute general geometric quantities, not specific to our method, used for the computation of the convolution. In our experiments in Sec. 6.1, we find that the enhanced expressiveness of Gauge Equivariant Mesh CNNs enables them to outperform conventional GCNs and other prior work in a shape correspondence task.
+
+# 2 CONVOLUTIONS ON GRAPHS WITH GEOMETRY
+
+We consider the problem of processing signals on discrete 2-dimensional manifolds, or meshes $M$ . Such meshes are described by a set $\nu$ of vertices in $\mathbb { R } ^ { 3 }$ together with a set $\mathcal { F }$ of tuples, each consisting of the vertices at the corners of a face. For a mesh to describe a proper manifold, each edge needs to be connected to two faces, and the neighbourhood of each vertex needs to be homeomorphic to a disk. Mesh $M$ induces a graph $\mathcal { G }$ by forgetting the coordinates of the vertices while preserving the edges.
+
+A conventional graph convolution between kernel $K$ and signal $f$ , evaluated at a vertex $p$ , can be defined by
+
+$$
+( K \star f ) _ { p } = K _ { \mathrm { s e l f } } f _ { p } + \sum _ { q \in { \mathcal N } _ { p } } K _ { \mathrm { n e i g h } } f _ { q } ,
+$$
+
+where $\mathcal { N } _ { p }$ is the set of neighbours of $p$ in $\mathcal { G }$ , and $K _ { \mathrm { s e l f } } \in \mathbb { R } ^ { C _ { \mathrm { i n } } \times C _ { \mathrm { o u t } } }$ and $K _ { \mathrm { n e i g h } } \in \mathbb { R } ^ { C _ { \mathrm { i n } } \times C _ { \mathrm { o u t } } }$ are two linear maps which model a self interaction and the neighbour contribution, respectively. Importantly, graph convolution does not distinguish different neighbours, because each feature vector $f _ { q }$ is multiplied by the same matrix $K _ { \mathrm { n e i g h } }$ and then summed. For this reason we say the kernel is isotropic.
+
+Consider the example in figure 1, where on the left and right, the neighbourhood of one vertex $p$ containing neighbours $q \in \mathcal { N } _ { p }$ , is visualized. An isotropic kernel would propagate the signal from the neighbours to $p$ in exactly the same way in both neighbourhoods, even though the neighbourhoods are geometrically distinct. For this reason, our method uses direction sensitive (anisotropic) kernels instead of isotropic kernels. Anisotropic kernels are inherently more expressive than isotropic ones which is why they are used universally in conventional planar CNNs.
+
+# Algorithm 1 Gauge Equivariant Mesh CNN layer
+
+<table><tr><td>Input: mesh M,input/output feature types pin, pout,reference neighbours (q ∈ Np)p∈M.</td><td> Sec.3</td></tr><tr><td>Compute basis kernels K&#x27;ef, Kneigh (0) Initialise weights wself and wneigh·</td><td></td></tr><tr><td>For each neighbour pair,p ∈ M,q ∈Np:</td><td> App. A.</td></tr><tr><td>compute neighbor angles θpq relative to reference neighbor</td><td></td></tr><tr><td>compute parallel transporters gq→p</td><td></td></tr><tr><td>Forward(input features (fp)p∈M, weights wself,wneigh):</td><td></td></tr><tr><td>f←∑iwselfKselffp+∑i,q∈NpwneighKneigh(0pq)Pin(gq→p)fq</td><td></td></tr></table>
+
+We propose the Gauge Equivariant Mesh Convolution, a minimal modification of graph convolution that allows for anisotropic kernels $K ( \theta )$ whose value depends on an orientation $\theta \in [ 0 , 2 \pi )$ . 1 To define the orientations $\theta _ { p q }$ of neighbouring vertices $q \in \mathcal { N } _ { p }$ of $p$ , we first map them to the tangent plane $T _ { p } M$ at $p$ , as visualized in figure 1. We then pick an arbitrary reference neighbour $q _ { 0 } ^ { \bar { p } }$ to determine a reference orientation2 $\theta _ { p q _ { 0 } ^ { p } } : = 0$ , marked orange in figure 1. This induces a basis on the tangent plane, which, when expressed in polar coordinates, defines the angles $\theta _ { p q }$ of the other neighbours.
+
+As we will motivate in the next section, features in a Gauge Equivariant CNN are coefficients of geometric quantities. For example, a tangent vector at vertex $p$ can be described either geometrically by a 3 dimensional vector orthogonal to the normal at $p$ or by two coefficients in the basis on the tangent plane. In order to perform convolution, geometric features at different vertices need to be linearly combined, for which it is required to first “parallel transport” the features to the same vertex. This is done by applying a matrix $\rho ( \mathsf { \bar { g } } _ { q \to p } ) \in \mathbb { R } ^ { C _ { \mathrm { i n } } \times C _ { \mathrm { i n } } }$ to the coefficients of the feature at $q$ , in order to obtain the coefficients of the feature vector transported to $p$ , which can be used for the convolution at $p$ . The transporter depends on the geometric type (group representation) of the feature, denoted by $\rho$ and described in more detail below. Details of how the tangent space is defined, how to compute the map to the tangent space, angles $\theta _ { p q }$ , and the parallel transporter are given in Appendix A.
+
+In combination, this leads to the GEM-CNN convolution
+
+$$
+( K \star f ) _ { p } ~ = ~ K _ { \mathrm { s e l f } } f _ { p } + \sum _ { q \in { \cal N } _ { p } } K _ { \mathrm { n e i g h } } ( \theta _ { p q } ) \rho ( g _ { q \to p } ) f _ { q }
+$$
+
+which differs from the conventional graph convolution, defined in Eq. 1 only by the use of an anisotropic kernel and the parallel transport message passing.
+
+We require the outcome of the convolution to be equivalent for any choice of reference orientation. This is not the case for any anisotropic kernel but only for those which are equivariant under changes of reference orientations (gauge transformations). Equivariance imposes a linear constraint on the kernels. We therefore solve for complete sets of “basis-kernels” $\dot { K } _ { \mathrm { s e l f } } ^ { i }$ and $K _ { \mathrm { n e i g h } } ^ { i }$ satisfying this constraint and linearly combine them with parameters $w _ { \mathrm { s e l f } } ^ { i }$ and $w _ { \mathrm { n e i g h } } ^ { i }$ such that $\begin{array} { r } { K _ { \mathrm { s e l f } } = \sum _ { i } w _ { \mathrm { s e l f } } ^ { i } K _ { \mathrm { s e l f } } ^ { i } } \end{array}$ and $\begin{array} { r } { K _ { \mathrm { n e i g h } } = \sum _ { i } w _ { \mathrm { n e i g h } } ^ { i } K _ { \mathrm { n e i g h } } ^ { i } } \end{array}$ . Details on the computation of basis kernels are given in section 3. The full algorithm for initialisation and forward pass, which is of time and space complexity linear in the number of vertices, for a GEM-CNN layer are listed in algorithm 1. Gradients can be computed by automatic differentiation.
+
+The GEM-CNN is gauge equivariant, but furthermore satisfies two important properties. Firstly, it depends only on the intrinsic shape of the 2D mesh, not on the embedding of the mesh in $\mathbb { R } ^ { \bar { 3 } }$ . Secondly, whenever a map from the mesh to itself exists that preserves distances and orientation, the convolution is equivariant to moving the signal along such transformations. These properties are proven in Appendix D and empirically shown in Appendix F.2.
+
+![](images/6ac0a3a2320acbde203ad94a79a9d22005edf891fd847ae6eb2d500d0f720c4e.jpg)  
+Figure 2: Visualization of the Gauge Equivariant Mesh Convolution in two configurations, scalar to scalar and scalar to vector. The convolution operates in a gauge, so that vectors are expressed in coefficients in a basis and neighbours have polar coordinates, but can also be seen as a geometric convolution, a gauge-independent map from an input signal on the mesh to a output signal on the mesh. The convolution is equivariant if this geometric convolution does not depend on the intermediate chosen gauge, so if the diagram commutes.
+
+# 3 GAUGE EQUIVARIANCE & GEOMETRIC FEATURES
+
+On a general mesh, the choice of the reference neighbour, or gauge, which defines the orientation of the kernel, can only be made arbitrarily. However, this choice should not arbitrarily affect the outcome of the convolution, as this would impede the generalization between different locations and different meshes. Instead, Gauge Equivariant Mesh CNNs have the property that their output transforms according to a known rule as the gauge changes.
+
+Consider the left hand side of figure 2(a). Given a neighbourhood of vertex $p$ , we want to express each neighbour $q$ in terms of its polar coordinates $( r _ { q } , \theta _ { q } )$ on the tangent plane, so that the kernel value at that neighbour $K _ { \mathrm { n e i g h } } ( \bar { \theta _ { q } } )$ is well defined. This requires choosing a basis on the tangent plane, determined by picking a neighbour as reference neighbour (denoted $q _ { 0 . }$ ), which has the zero angle $\theta _ { q _ { 0 } } = 0$ . In the top path, we pick $q _ { A }$ as reference neighbour. Let us call this gauge A, in which neighbours have angles $\theta _ { q } ^ { A }$ . In the bottom path, we instead pick neighbour $q _ { B }$ as reference point and are in gauge B. We get a different basis for the tangent plane and different angles $\underset { . } { \theta _ { q } ^ { B } }$ for each neighbour. Comparing the two gauges, we see that they are related by a rotation, so that $\theta _ { q } ^ { B } = \theta _ { q } ^ { A } - \mathsf { \bar { \theta } } _ { q B } ^ { A }$ . This change of gauge is called a gauge transformation of angle $g : = \theta _ { q _ { B } } ^ { A }$ .
+
+In figure 2(a), we illustrate a gauge equivariant convolution that takes input and output features such as gray scale image values on the mesh, which are called scalar features. The top path represents the convolution in gauge A, the bottom path in gauge B. In either case, the convolution can be interpreted as consisting of three steps. First, for each vertex $p$ , the value of the scalar features on the mesh at each neighbouring vertex $q$ , represented by colors, is mapped to the tangent plane at $p$ at angle $\theta _ { q }$ defined by the gauge. Subsequently, the convolutional kernel sums for each neighbour $q$ , the product of the feature at $q$ and kernel $K ( \theta _ { q } )$ . Finally the output is mapped back to the mesh. These three steps can be composed into a single step, which we could call a geometric convolution, mapping from input features on the mesh to output features on the mesh. The convolution is gauge equivariant if this geometric convolution does not depend on the gauge we pick in the interim, so in figure 2(a), if the convolution in the top path in gauge A has same result the convolution in the bottom path in gauge B, making the diagram commute. In this case, however, we see that the convolution output needs to be the same in both gauges, for the convolution to be equivariant. Hence, we must have that $K ( \theta _ { q } ) = K ( \theta _ { q } - g )$ , as the orientations of the neighbours differ by some angle $g$ , and the kernel must be isotropic.
+
+As we aim to design an anisotropic convolution, the output feature of the convolution at $p$ can, instead of a scalar, be two numbers $v \in \mathbb { R } ^ { 2 }$ , which can be interpreted as coefficients of a tangent feature vector in the tangent space at $p$ , visualized in figure 2(b). As shown on the right hand side, different gauges induce a different basis of the tangent plane, so that the same tangent vector (shown on the middle right on the mesh), is represented by different coefficients in the gauge (shown on the top and bottom on the right). This gauge equivariant convolution must be anisotropic: going from the top row to the bottom row, if we change orientations of the neighbours by $- g$ , the coefficients of the output vector $v \in \mathbb { R } ^ { 2 }$ of the kernel must be also rotated by $- g$ . This is written as $R ( - g ) v$ , where $R ( - g ) \in \mathbb { R } ^ { 2 \times 2 }$ is the matrix that rotates by angle $- g$ .
+
+Vectors and scalars are not the only type of geometric features that can be inputs and outputs of a GEM-CNN layer. In general, the coefficients of a geometric feature of $C$ dimensions changes by an invertible linear transformation $\rho ( - g ) \in \mathbb { R } ^ { C \times C }$ if the gauge is rotated by angle $g$ . The map $\begin{array} { r } { \dot { \rho ^ { \smash { \sum } } } : [ 0 , 2 \pi ) \to \mathbb { R } ^ { C \times C } } \end{array}$ is called the type of the geometric quantity and is formally known as a group representation of the planar rotation group SO(2). Group representations have the property that $\bar { \rho ( g + h ) } = \rho ( g ) \rho ( h )$ (they are group homomorphisms), which implies in particular that $\dot { \rho } ( 0 ) = \mathbb { 1 }$ and $\rho ( - g ) = \rho ( g ) ^ { - 1 }$ . For more background on group representation theory, we refer the reader to (Serre, 1977) and, specifically in the context of equivariant deep learning, to (Lang & Weiler, 2020). From the theory of group representations, we know that any feature type can be composed from “irreducible representations” (irreps). For SO(2), these are the one dimensional invariant scalar representation $\rho _ { 0 }$ and for all $n \in  { \mathbb { N } } _ { > 0 }$ , a two dimensional representation $\rho _ { n }$ ,
+
+$$
+\rho _ { 0 } ( g ) = 1 , \quad \rho _ { n } ( g ) = \binom { \cos n g } { \sin n g } \quad \sp { - \sin n g } \nonumber \cos n g \biggr ) .
+$$
+
+where we write, for example, $\rho = \rho _ { 0 } \oplus \rho _ { 1 } \oplus \rho _ { 1 }$ to denote that representation $\rho ( g )$ is the direct sum (i.e. block-diagonal stacking) of the matrices $\dot { \rho } _ { 0 } ( g ) , \rho _ { 1 } ( g ) , \rho _ { 1 } ( g )$ . Scalars and tangent vector features correspond to $\rho _ { 0 }$ and $\rho _ { 1 }$ respectively and we have $R ( g ) = \rho _ { 1 } ( g )$ .
+
+The type of the feature at each layer in the network can thus be fully specified (up to a change of basis) by the number of copies of each irrep. Similar to the dimensionality in a conventional CNN, the choice of type is a hyperparameter that can be freely chosen to optimize performance.
+
+# 3.1 KERNEL CONSTRAINT
+
+Given an input type $\rho _ { \mathrm { i n } }$ and output type $\rho _ { \mathrm { o u t } }$ of dimensions $C _ { \mathrm { i n } }$ and $C _ { \mathrm { { o u t } } }$ , the kernels are $K _ { \mathrm { s e l f } } ~ \in$ $\mathbb { R } ^ { C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } }$ and $K _ { \mathrm { n e i g h } } : [ 0 , 2 \pi )  ] \mathbb { R } ^ { C _ { \mathrm { o u t } } \times C _ { \mathrm { i n } } }$ . However, not all such kernels are equivariant. Consider again examples figure 2(a) and figure 2(b). If we map from a scalar to a scalar, we get that $K _ { \mathrm { n e i g h } } ( \theta -$ $\bar { g ) } = K _ { \mathrm { n e i g h } } \bar { ( \theta ) }$ for all angles $\theta , g$ and the convolution is isotropic. If we map from a scalar to a vector, we get that rotating the angles $\theta _ { q }$ results in the same tangent vector as rotating the output vector coefficients, so that $K _ { \mathrm { n e i g h } } ( \theta - g ) { \dot { = } } R ( - g ) K _ { \mathrm { n e i g h } } ( \theta )$ .
+
+In general, as derived by Cohen et al. (2019b) and in appendix B, the kernels must satisfy for any gauge transformation $g \in [ 0 , 2 \pi )$ and angle $\theta \in [ 0 , 2 \pi )$ , that
+
+$$
+\begin{array} { r } { K _ { \mathrm { n e i g h } } ( \theta - g ) = \rho _ { \mathrm { o u t } } ( - g ) K _ { \mathrm { n e i g h } } ( \theta ) \rho _ { \mathrm { i n } } ( g ) , } \\ { K _ { \mathrm { s e l f } } = \rho _ { \mathrm { o u t } } ( - g ) \ K _ { \mathrm { s e l f } } \ \rho _ { \mathrm { i n } } ( g ) . \qquad } \end{array}
+$$
+
+The kernel can be seen as consisting of multiple blocks, where each block takes as input one irrep and outputs one irrep. For example if $\rho _ { \mathrm { i n } }$ would be of type $\rho _ { 0 } \oplus \rho _ { 1 } \oplus \rho _ { 1 }$ and $\rho _ { \mathrm { o u t } }$ of type $\rho _ { 1 } \oplus \rho _ { 3 }$ , we have $4 \times 5$ matrix
+
+$$
+K _ { \mathrm { n e i g h } } ( \theta ) = { \binom { K _ { 1 0 } ( \theta ) } { K _ { 3 0 } ( \theta ) } } K _ { 1 1 } ( \theta ) K _ { 1 1 } ( \theta ) \Big )
+$$
+
+Table 1: Solutions to the angular kernel constraint for kernels that map from $\rho _ { n }$ to $\rho _ { m }$ . We denote $c _ { \pm } = \cos ( ( m \pm n ) \theta )$ and $s _ { \pm } = \sin ( ( m \pm n ) \theta )$ .   
+
+<table><tr><td>pin→pout</td><td>linearly independent solutions for Kneigh (0)</td></tr><tr><td>p→po</td><td>(1)</td></tr><tr><td>pn→po</td><td>(cos nθ sin nθ),(sin nθ -cos n0)</td></tr><tr><td>po→pm</td><td>(cos mθ) sin m) (sinmθ) ， (-cosm0)</td></tr><tr><td>pn→pm</td><td>(c- -s_ S_ C_ (C+ S+ -S+ C+ s_ c_ -c S- S+ -C+） ， c+s+)</td></tr><tr><td>pin→pout</td><td>linearly independent solutions for Kself</td></tr><tr><td>p→po</td><td>(1)</td></tr><tr><td>pn→pn</td><td>(61). (-1)</td></tr></table>
+
+where e.g. $K _ { 3 1 } ( \theta ) \in \mathbb { R } ^ { 2 \times 2 }$ is a kernel that takes as input irrep $\rho _ { 1 }$ and as output irrep $\rho _ { 3 }$ and needs to satisfy Eq. 3. As derived by Weiler & Cesa (2019) and in Appendix C, the kernels $K _ { \mathrm { n e i g h } } ( \theta )$ and $K _ { \mathrm { s e l f } }$ mapping from irrep $\rho _ { n }$ to irrep $\rho _ { m }$ can be written as a linear combination of the basis kernels listed in Table 1. The table shows that equivariance requires the self-interaction to only map from one irrep to the same irrep. Hence, we have $K _ { \mathrm { s e l f } } = \left( \begin{array} { c c c } { 0 } & { K _ { 1 1 } } & { K _ { 1 1 } } \\ { 0 } & { 0 } & { 0 } \end{array} \right) \in \mathbb { R } ^ { 4 \times 3 } .$
+
+All basis-kernels of all pairs of input irreps and output irreps can be linearly combined to form an arbitrary equivariant kernel from feature of type $\rho _ { \mathrm { i n } }$ to $\rho _ { \mathrm { o u t } }$ . In the above example, we have $2 \times 2 + 4 \times 4 = 2 0$ basis kernels for $K _ { \mathrm { n e i g h } }$ and 4 basis kernels for $K _ { \mathrm { s e l f } }$ . The layer thus has 24 parameters. As proven in (Weiler & Cesa, 2019) and (Lang & Weiler, 2020), this parameterization of the equivariant kernel space is complete, that is, more general equivariant kernels do not exist.
+
+# 3.2 GEOMETRY AND PARALLEL TRANSPORT
+
+In order to implement gauge equivariant mesh CNNs, we need to make the abstract notion of tangent spaces, gauges and transporters concrete.
+
+As the mesh is embedded in $\mathbb { R } ^ { 3 }$ , a natural definition of the tangent spaces $T _ { p } M$ is as two dimensional subspaces that are orthogonal to the normal vector at $p$ . We follow the common definition of normal vectors at mesh vertices as the area weighted average of the adjacent faces’ normals. The Riemannian logarithm map $\log _ { p } : \mathcal { N } _ { p } \to T _ { p } M$ represents the one-ring neighborhood of each point $p$ on their tangent spaces as visualized in figure 1. Specifically, neighbors $q \in \mathcal { N } _ { p }$ are mapped to $\bar { \log _ { p } ( q ) } \in T _ { p } \bar { M }$ by first projecting them to $T _ { p } M$ and then rescaling the projection such that the norm is preserved, i.e. $| \log _ { p } ( q ) | = | q - p |$ ; see Eq. 6. A choice of reference neighbor $q _ { p } \in \mathcal { N }$ uniquely determines a right handed, orthonormal reference frame $( e _ { p , 1 } , e _ { p , 2 } )$ of $T _ { p } M$ by setting $e _ { p , 1 } : = \log _ { p } ( q _ { 0 } ) / | \log _ { p } ( q _ { 0 } ) |$ and $e _ { p , 2 } : = n \times e _ { p , 1 }$ . The polar angle $\theta _ { p q }$ of any neighbor $q \in \mathcal N$ relative to the first frame axis is then given by $\theta _ { p q } : = \mathrm { a t a n 2 } \left( e _ { p , 2 } ^ { \top } \log _ { p } ( q ) , e _ { p , 1 } ^ { \top } \log _ { p } ( q ) \right) )$ .
+
+Given the reference frame $( e _ { p , 1 } , e _ { p , 2 } )$ , a 2-tuple of coefficients $( v _ { 1 } , v _ { 2 } ) \in \mathbb { R } ^ { 2 }$ specifies an (embedded) tangent vector $v _ { 1 } e _ { p , 1 } + v _ { 2 } e _ { p , 2 } \in T _ { p } M \subset \mathbb { R } ^ { 3 }$ . This assignment is formally given by the gauge map $E _ { p } : \mathbb { R } ^ { 2 } \to T _ { p } M \overset { \cdot } { \subset } \mathbb { R } ^ { 3 }$ which is a vector space isomorphism. In our case, it can be identified with the matrix
+
+$$
+\begin{array} { r } { \boldsymbol { E _ { p } } = \left[ \begin{array} { c c } { \boldsymbol { \vert } } & { \boldsymbol { \vert } } \\ { \boldsymbol { e _ { p , 1 } } } & { \boldsymbol { e _ { p , 2 } } } \\ { \boldsymbol { \vert } } & { \boldsymbol { \vert } } \end{array} \right] \in \mathbb { R } ^ { 3 \times 2 } . } \end{array}
+$$
+
+Feature vectors $f _ { p }$ and $f _ { q }$ at neighboring (or any other) vertices $p \in M$ and $q \in \mathcal { N } _ { p } \subseteq M$ live in different vector spaces and are expressed relative to independent gauges, which makes it invalid to sum them directly. Instead, they have to be parallel transported along the mesh edge that connects the two vertices. As explained above, this transport is given by group elements $\mathsf { \bar { g } } _ { q \to p } \in [ 0 , 2 \pi )$ , which determine the transformation of tangent vector coefficients as $v _ { q } \mapsto R ( g _ { q  p } ) v _ { q } \in \mathbb { R } ^ { 2 }$ and, analogously, for feature vector coefficients as $f _ { q } \mapsto \rho ( g _ { q  p } ) f _ { q }$ . Figure 4 in the appendix visualizes the definition of edge transporters for flat spaces and meshes. On a flat space, tangent vectors are transported by keeping them parallel in the usual sense on Euclidean spaces. However, if the source and target frame orientations disagree, the vector coefficients relative to the source frame need to be transformed to the target frame. This coordinate transformation from polar angles $\varphi _ { q }$ of $v$ to $\varphi _ { p }$ of $R ( g _ { q  p } ) v$ defines the transporter $g _ { q  p } = \varphi _ { p } - \varphi _ { q }$ . On meshes, the source and target tangent spaces $T _ { q } M$ and $T _ { p } M$ are not longer parallel. It is therefore additionally necessary to rotate the source tangent space and its vectors parallel to the target space, before transforming between the frames. Since transporters effectively make up for differences in the source and target frames, the parallel transporters transform under gauge transformations $g _ { p }$ and $g _ { q }$ according to $g _ { q \to p } \mapsto g _ { p } + g _ { q \to p } - g _ { q }$ . Note that this transformation law cancels with the transformation law of the coefficients at $q$ and lets the transported coefficients transform according to gauge transformations at $p$ . It is therefore valid to sum vectors and features that are parallel transported into the same gauge at $p$ .
+
+A more detailed discussion of the concepts presented in this section can be found in Appendix A.
+
+# 4 NON-LINEARITY
+
+Besides convolutional layers, the GEM-CNN contains non-linear layers, which also need to be gauge equivariant, for the entire network to be gauge equivariant. The coefficients of features built out of irreducible representaions, as described in section 3, do not commute with point-wise nonlinearities (Worrall et al., 2017; Thomas et al., 2018; Weiler et al., 2018a; Kondor et al., 2018). Norm non-linearities and gated non-linearities (Weiler & Cesa, 2019) can be used with such features, but generally perform worse in practice compared to point-wise non-linearities (Weiler & Cesa,
+
+2019). Hence, we propose the RegularNonlinearity, which uses point-wise non-linearities and is approximately gauge equivariant.
+
+This non-linearity is built on Fourier transformations. Consider a continuous periodic signal, on which we perform a band-limited Fourier transform with band limit $b$ , obtaining $2 b + 1$ Fourier coefficients. If this continuous signal is shifted by an arbitrary angle $g$ , then the corresponding Fourier components transform with linear transformation $\rho _ { 0 : b } ( - g )$ , for $2 b + 1$ dimensional representation $\rho _ { 0 : b } : = \rho _ { 0 } \oplus \rho _ { 1 } \oplus \ldots \oplus \rho _ { b }$ .
+
+It would be exactly equivariant to take a feature of type $\rho _ { 0 : b }$ , take a continuous inverse Fourier transform to a continuous periodic signal, then apply a point-wise non-linearity to that signal, and take the continuous Fourier transform, to recover a feature of type $\rho _ { 0 : b }$ . However, for implementation, we use $N$ intermediate samples and the discrete Fourier transform. This is exactly gauge equivariant for gauge transformation of angles multiple of $2 \pi / N$ , but only approximately equivariant for other angles. In App. G we prove that as $N \to \infty$ , the non-linearity is exactly gauge equivariant.
+
+The run-time cost per vertex of the (inverse) Fourier transform implemented as a simple linear transformation is $\mathcal { O } ( b N )$ , which is what we use in our experiments. The pointwise non-linearity scales linearly with $N$ , so the complexity of the RegularNonLineariy is also $\mathcal { O } ( b N )$ . However, one can also use a fast Fourier transform, achieving a complexity of $\mathcal { O } ( N \log N )$ . Concrete memory and run-time cost of varying $N$ are shown in appendix F.1.
+
+# 5 RELATED WORK
+
+The irregular structure of meshes leads to a variety of approaches to define convolutions. Closely related to our method are graph based methods which are often based on variations of graph convolutional networks (Kipf & Welling, 2017; Defferrard et al., 2016). GCNs have been applied on spherical meshes (Perraudin et al., 2019) and cortical surfaces (Cucurull et al., 2018; Zhao et al., 2019a). Verma et al. (2018) augment GCNs with anisotropic kernels which are dynamically computed via an attention mechanism over graph neighbours.
+
+Instead of operating on the graph underlying a mesh, several approaches leverage its geometry by treating it as a discrete manifold. Convolution kernels can then be defined in geodesic polar coordinates which corresponds to a projection of kernels from the tangent space to the mesh via the exponential map. This allows for kernels that are larger than the immediate graph neighbourhood and message passing over faces but does not resolve the issue of ambiguous kernel orientation. Masci et al. (2015); Monti et al. (2016) and Sun et al. (2018) address this issue by restricting the network to orientation invariant features which are computed by applying anisotropic kernels in several orientations and pooling over the resulting responses. The models proposed in (Boscaini et al., 2016) and (Schonsheck et al., 2018) are explicitly gauge dependent with preferred orientations chosen via the principal curvature direction and the parallel transport of kernels, respectively. Poulenard & Ovsjanikov (2018) proposed a non-trivially gauge equivariant network based on geodesic convolutions, however, the model parallel transports only partial information of the feature vectors, corresponding to certain kernel orientations. In concurrent work, Wiersma et al. (2020) also define convolutions on surfaces equivariantly to the orientation of the kernel, but differ in that they use norm non-linearities instead of regular ones and that they apply the convolution along longer geodesics, which adds complexity to the geometric pre-computation - as partial differential equations need to be solved, but may result in less susceptibility to the particular discretisation of the manifold.
+
+Another class of approaches defines spectral convolutions on meshes. However, as argued in (Bronstein et al., 2017), the Fourier spectrum of a mesh depends heavily on its geometry, which makes such methods instable under deformations and impedes the generalization between different meshes. Spectral convolutions further correspond to isotropic kernels. Kostrikov et al. (2018) overcomes isotropy of the Laplacian by decomposing it into two applications of the first-order Dirac operator.
+
+A construction based on toric covering maps of topologically spherical meshes was presented in (Maron et al., 2017). An entirely different approach to mesh convolutions is to apply a linear map to a spiral of neighbours (Bouritsas et al., 2019; Gong et al., 2019), which works well only for meshes with a similar graph structure.
+
+The above-mentioned methods operate on the intrinsic, 2-dimensional geometry of the mesh. A popular alternative for embedded meshes is to define convolutions in the embedding space $\mathbb { R } ^ { 3 }$ . This can for instance be done by voxelizing space and representing the mesh in terms of an occupancy grid (Wu et al., 2015; Tchapmi et al., 2017; Hanocka et al., 2018). A downside of this approach are the high memory and compute requirements of voxel representations. If the grid occupancy is low, this can partly be addressed by resorting to an inhomogeneous grid density (Riegler et al., 2017). Instead of voxelizing space, one may interpret the set of mesh vertices as a point cloud and run a convolution on those (Qi et al., 2017a;b). Point cloud based methods can be made equivariant w.r.t. the isometries of $\mathbb { R } ^ { 3 }$ (Zhao et al., 2019b; Thomas et al., 2018), which implies in particular the isometry equivariance on the embedded mesh. In general, geodesic distances within the manifold differ usually substantially from the distances in the embedding space. Which approach is more suitable depends on the particular application.
+
+On flat Euclidean spaces our method corresponds to Steerable CNNs (Cohen & Welling, 2017; Weiler et al., 2018a; Weiler & Cesa, 2019; Cohen et al., 2019a; Lang & Weiler, 2020). As our model, these networks process geometric feature fields of types $\rho$ and are equivariant under gauge transformations, however, due to the flat geometry, the parallel transporters become trivial. Regular nonlinearities are on flat spaces used in group convolutional networks (Cohen & Welling, 2016; Weiler et al., 2018b; Hoogeboom et al., 2018; Bekkers et al., 2018; Winkels & Cohen, 2018; Worrall & Brostow, 2018; Worrall & Welling, 2019; Sosnovik et al., 2020).
+
+# 6 EXPERIMENTS
+
+# 6.1 EMBEDDED MNIST
+
+We first investigate how Gauge Equivariant Mesh CNNs perform on, and generalize between, different mesh geometries. For this purpose we conduct simple MNIST digit classification experiments on embedded rectangular meshes of $2 8 \times 2 8$ vertices. As a baseline geometry we consider a flat mesh as visualized in figure 5(a). A second type of geometry is defined as different isometric embeddings of the flat mesh, see figure 5(b). Note that this implies that the intrinsic geometry of these isometrically embedded meshes is indistinguishable from that of the flat mesh. To generate geometries which are intrinsically curved, we add random normal displacements to the flat mesh. We control the amount of curvature by smoothing the resulting displacement fields with Gaussian kernels of different widths $\sigma$ and define the roughness of the resulting mesh as $3 - \sigma$ . Figures 5(c)-5(h) show the results for roughnesses of 0.5, 1, 1.5, 2, 2.25 and 2.5. For each of the considered settings we generate 32 different train and 32 test geometries.
+
+To test the performance on, and generalization between, different geometries, we train equivalent GEM-CNN models on a flat mesh and meshes with a roughness of 1, 1.5, 2, 2.25 and 2.5. Each model is tested individually on each of the considered test geometries, which are the flat mesh, isometric embeddings and curved embeddings with a roughness of 0.5, 1, 1.25, 1.5, 1.75, 2, 2.25 and 2.5. Figure 3 shows the test errors of the GEM-CNNs on the different train geometries (different curves) for all test geometries (shown on the x-axis). Since our model is purely defined in terms of the intrinsic geometry of a mesh, it is expected to be insensitive to isometric changes in the embeddings. This is empirically confirmed by the fact that the test performances on flat and isometric embeddings are exactly equal. As expected, the test error increases for most models with the surface roughness. Models trained on more rough surfaces are hereby more robust to deformations. The models generalize well from a rough training to smooth test geometry up to a training roughness of 1.5. Beyond that point, the test performances on smooth meshes degrades up to the point of random guessing at a training roughness of 2.5.
+
+As a baseline, we build an isotropic graph CNN with the same network topology and number of parameters $( \approx 1 6 3 k )$ ). This model is insensitive to the mesh geometry and therefore performs exactly equal on all surfaces. While this enhances its robustness on very rough meshes, its test error of $1 9 . 8 0 \pm 3 . 4 3 \%$ is an extremely bad result on MNIST. In contrast, the use of anisotropic filters of GEM-CNN allows it to reach a test error of only $0 . 6 0 \pm 0 . 0 5 \%$ on the flat geometry. It is therefore competitive with conventional CNNs on pixel grids, which apply anisotropic kernels as well. More details on the datasets, models and further experimental setup are given in appendix E.1.
+
+![](images/b14045eeb68ab7cd2fd302585eb95df9b21376a3b7cd1e3e6c26805b57a4eb45.jpg)  
+Figure 3: Test errors for MNIST digit classification on embedded meshes. Different lines denote train geometries, $\mathbf { X }$ -axis shows test geometries. Regions are standard errors of the means over 6 runs.
+
+<table><tr><td>Model</td><td>Features</td><td>Accuracy (%)</td></tr><tr><td>ACNN (Boscaini et al.,2016)</td><td>SHOT</td><td>62.4</td></tr><tr><td>Geodesic CNN (Masci et al.,2015)</td><td>SHOT</td><td>65.4</td></tr><tr><td>MoNet (Monti et al.,2016)</td><td>SHOT</td><td>73.8</td></tr><tr><td>FeaStNet (Verma et al.,2018)</td><td>XYZ</td><td>98.7</td></tr><tr><td>ZerNet (Sun et al.,2018)</td><td>XYZ</td><td>96.9</td></tr><tr><td>SpiralNet++ (Gong et al.,2019)</td><td>XYZ</td><td>99.8</td></tr><tr><td>Graph CNN</td><td>XYZ</td><td>1.40±0.5</td></tr><tr><td>Graph CNN</td><td>SHOT</td><td>23.80±8</td></tr><tr><td>Non-equiv. CNN (SHOT frames)</td><td>XYZ</td><td>73.00±4.0</td></tr><tr><td>Non-equiv. CNN (SHOT frames)</td><td>SHOT</td><td>75.11±2.4</td></tr><tr><td>GEM-CNN</td><td>XYZ</td><td>99.73±0.04</td></tr><tr><td>GEM-CNN (broken symmetry)</td><td>XYZ</td><td>99.89±0.02</td></tr></table>
+
+Table 2: Results of FAUST shape correspondence. Statistics are means and standard errors of the mean of over three runs. All cited results are from their respective papers.
+
+# 6.2 SHAPE CORRESPONDENCE
+
+As a second experiment, we perform non-rigid shape correspondence on the FAUST dataset (Bogo et al., 2014), following Masci et al. (2015) 3 . The data consists of 100 meshes of human bodies in various positions, split into 80 train and 20 test meshes. The vertices are registered, such that vertices on the same position on the body, such as the tip of the left thumb, have the same identifier on all meshes. All meshes have 6890 vertices, making this a 6890-class segmentation problem.
+
+The architecture transforms the vertices’ $X Y Z$ coordinates (of type $3 \rho _ { 0 }$ ), via 6 convolutional layers to features $6 4 \rho _ { 0 }$ , with intermediate features $1 6 ( \rho _ { 0 } \oplus \rho _ { 1 } \oplus \rho _ { 2 } )$ , with residual connections and the RegularNonlinearity with $N = 5$ samples. Afterwards, we use two $1 \times 1$ convolutions with ReLU to map first to 256 and then 6980 channels, after which a softmax predicts the registration probabilities. The $1 \times 1$ convolutions use a dropout of $50 \%$ and 1E-4 weight decay. The network is trained with a cross entropy loss with an initial learning rate of 0.01, which is halved when training loss reaches a plateau.
+
+As all meshes in the FAUST dataset share the same topology, breaking the gauge equivariance in higher layers can actually be beneficial. As shown in (Weiler & Cesa, 2019), symmetry can be broken by treating non-invariant features as invariant features as input to the final $1 \times 1$ convolution.
+
+As baselines, we compare to various models, some of which use more complicated pipelines, such as (1) the computation of geodesics over the mesh, which requires solving partial differential equations, (2) pooling, which requires finding a uniform sub-selection of vertices, (3) the pre-computation of SHOT features which locally describe the geometry (Tombari et al., 2010), or (4) post-processing refinement of the predictions. The GEM-CNN requires none of these additional steps. In addition, we compare to SpiralNet $^ { - + }$ (Gong et al., 2019), which requires all inputs to be similarly meshed. Finally, we compare to an isotropic version of the GEM-CNN, which reduces to a conventional graph CNN, as well as a non-gauge-equivariant CNN based on SHOT frames. The results in table 2 show that the GEM-CNN outperforms prior works and a non-gauge-equivariant CNN, that isotropic graph CNNs are unable to solve the task and that for this data set breaking gauge symmetry in the final layers of the network is beneficial. More experimental details are given in appendix E.2.
+
+# 7 CONCLUSIONS
+
+Convolutions on meshes are commonly performed as a convolution on their underlying graph, by forgetting geometry, such as orientation of neighbouring vertices. In this paper we propose Gauge Equivariant Mesh CNNs, which endow Graph Convolutional Networks on meshes with anisotropic kernels and parallel transport. Hence, they are sensitive to the mesh geometry, and result in equivalent outputs regardless of the arbitrary choice of kernel orientation.
+
+We demonstrate that the inference of GEM-CNNs is invariant under isometric deformations of meshes and generalizes well over a range of non-isometric deformations. On the FAUST shape correspondence task, we show that Gauge equivariance, combined with symmetry breaking in the final layer, leads to state of the art performance.
+
+# REFERENCES
+
+Bekkers, E. J., Lafarge, M. W., Veta, M., Eppenhof, K. A., Pluim, J. P., and Duits, R. Roto-translation covariant convolutional networks for medical image analysis. In International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI), 2018.
+
+Bogo, F., Romero, J., Loper, M., and Black, M. J. Faust: Dataset and evaluation for 3d mesh registration. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3794–3801, 2014.
+
+Boscaini, D., Masci, J., Rodola, E., and Bronstein, M. M. Learning shape correspondence with \` anisotropic convolutional neural networks. In NIPS, 2016.
+
+Bouritsas, G., Bokhnyak, S., Ploumpis, S., Bronstein, M., and Zafeiriou, S. Neural 3d morphable models: Spiral convolutional networks for 3d shape representation learning and generation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 7213–7222, 2019.
+
+Bronstein, M. M., Bruna, J., LeCun, Y., Szlam, A., and Vandergheynst, P. Geometric deep learning: Going beyond Euclidean data. IEEE Signal Processing Magazine, 2017.
+
+Cohen, T. and Welling, M. Group equivariant convolutional networks. In ICML, 2016.
+
+Cohen, T. S. and Welling, M. Steerable CNNs. In ICLR, 2017.
+
+Cohen, T. S., Geiger, M., and Weiler, M. A general theory of equivariant CNNs on homogeneous spaces. In Conference on Neural Information Processing Systems (NeurIPS), 2019a.
+
+Cohen, T. S., Weiler, M., Kicanaoglu, B., and Welling, M. Gauge equivariant convolutional networks and the Icosahedral CNN. 2019b.
+
+Crane, K., Desbrun, M., and Schroder, P. Trivial connections on discrete surfaces. ¨ Computer Graphics Forum (SGP), 29(5):1525–1533, 2010.
+
+Crane, K., de Goes, F., Desbrun, M., and Schroder, P. Digital geometry processing with discrete ¨ exterior calculus. In ACM SIGGRAPH 2013 courses, SIGGRAPH ’13, New York, NY, USA, 2013. ACM.
+
+Cucurull, G., Wagstyl, K., Casanova, A., Velickovi ˇ c, P., Jakobsen, E., Drozdzal, M., Romero, A., ´ Evans, A., and Bengio, Y. Convolutional neural networks for mesh-based parcellation of the cerebral cortex. 2018.
+
+Defferrard, M., Bresson, X., and Vandergheynst, P. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in neural information processing systems, pp. 3844–3852, 2016.
+
+Gallier, J. and Quaintance, J. Differential Geometry and Lie Groups: A Computational Perspective, volume 12. Springer Nature, 2020.
+
+Gong, S., Chen, L., Bronstein, M., and Zafeiriou, S. Spiralnet++: A fast and highly efficient mesh convolution operator. In Proceedings of the IEEE International Conference on Computer Vision Workshops, pp. 0–0, 2019.
+
+Hanocka, R., Fish, N., Wang, Z., Giryes, R., Fleishman, S., and Cohen-Or, D. Alignet: Partial-shape agnostic alignment via unsupervised learning. ACM Transactions on Graphics (TOG), 38(1):1–14, 2018.
+
+Hoogeboom, E., Peters, J. W. T., Cohen, T. S., and Welling, M. HexaConv. In International Conference on Learning Representations (ICLR), 2018.
+
+Kipf, T. N. and Welling, M. Semi-Supervised Classification with Graph Convolutional Networks. In ICLR, 2017.
+
+Kondor, R., Lin, Z., and Trivedi, S. Clebsch-gordan nets: a fully fourier space spherical convolutional neural network. In NIPS, 2018.
+
+Kostrikov, I., Jiang, Z., Panozzo, D., Zorin, D., and Bruna, J. Surface networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2540–2548, 2018.
+
+Lai, Y.-K., Jin, M., Xie, X., He, Y., Palacios, J., Zhang, E., Hu, S.-M., and Gu, X. Metric-driven rosy field design and remeshing. IEEE Transactions on Visualization and Computer Graphics, 16(1): 95–108, 2009.
+
+Lang, L. and Weiler, M. A Wigner-Eckart Theorem for Group Equivariant Convolution Kernels. arXiv preprint arXiv:2010.10952, 2020.
+
+Maron, H., Galun, M., Aigerman, N., Trope, M., Dym, N., Yumer, E., Kim, V. G., and Lipman, Y. Convolutional neural networks on surfaces via seamless toric covers. ACM Trans. Graph., 36(4): 71–1, 2017.
+
+Masci, J., Boscaini, D., Bronstein, M. M., and Vandergheynst, P. Geodesic convolutional neural networks on riemannian manifolds. ICCVW, 2015.
+
+Monti, F., Boscaini, D., Masci, J., Rodola, E., Svoboda, J., and Bronstein, M. M. Geometric deep \` learning on graphs and manifolds using mixture model cnns. CoRR, abs/1611.08402, 2016. URL http://arxiv.org/abs/1611.08402.
+
+Perraudin, N., Defferrard, M., Kacprzak, T., and Sgier, R. Deepsphere: Efficient spherical convolutional neural network with healpix sampling for cosmological applications. Astronomy and Computing, 27:130–146, 2019.
+
+Poulenard, A. and Ovsjanikov, M. Multi-directional geodesic neural networks via equivariant convolution. ACM Transactions on Graphics, 2018.
+
+Qi, C. R., Su, H., Mo, K., and Guibas, L. J. Pointnet: Deep learning on point sets for 3d classification and segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 652–660, 2017a.
+
+Qi, C. R., Yi, L., Su, H., and Guibas, L. J. Pointne $^ { + + }$ : Deep hierarchical feature learning on point sets in a metric space. In Advances in neural information processing systems, pp. 5099–5108, 2017b.
+
+Riegler, G., Osman Ulusoy, A., and Geiger, A. Octnet: Learning deep 3d representations at high resolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3577–3586, 2017.
+
+Schonsheck, S. C., Dong, B., and Lai, R. Parallel Transport Convolution: A New Tool for Convolutional Neural Networks on Manifolds. arXiv:1805.07857 [cs, math, stat], May 2018.
+
+Serre, J.-P. Linear representations of finite groups. 1977.
+
+Sosnovik, I., Szmaja, M., and Smeulders, A. Scale-equivariant steerable networks. In International Conference on Learning Representations (ICLR), 2020.
+
+Sun, Z., Rooke, E., Charton, J., He, Y., Lu, J., and Baek, S. Zernet: Convolutional neural networks on arbitrary surfaces via zernike local tangent space estimation. arXiv preprint arXiv:1812.01082, 2018.
+
+Tchapmi, L., Choy, C., Armeni, I., Gwak, J., and Savarese, S. Segcloud: Semantic segmentation of 3d point clouds. In 2017 international conference on 3D vision (3DV), pp. 537–547. IEEE, 2017.
+
+Thomas, N., Smidt, T., Kearnes, S., Yang, L., Li, L., Kohlhoff, K., and Riley, P. Tensor Field Networks: Rotation- and Translation-Equivariant Neural Networks for 3D Point Clouds. 2018.
+
+Tombari, F., Salti, S., and Di Stefano, L. Unique signatures of histograms for local surface description. In European conference on computer vision, pp. 356–369. Springer, 2010.
+
+Tu, L. W. Differential geometry: connections, curvature, and characteristic classes, volume 275. Springer, 2017.
+
+Verma, N., Boyer, E., and Verbeek, J. Feastnet: Feature-steered graph convolutions for 3d shape analysis. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2598–2606, 2018.   
+Weiler, M. and Cesa, G. General E(2)-equivariant steerable CNNs. In Conference on Neural Information Processing Systems (NeurIPS), 2019. URL https://arxiv.org/abs/1911. 08251.   
+Weiler, M., Geiger, M., Welling, M., Boomsma, W., and Cohen, T. 3D Steerable CNNs: Learning Rotationally Equivariant Features in Volumetric Data. In NeurIPS, 2018a.   
+Weiler, M., Hamprecht, F. A., and Storath, M. Learning steerable filters for rotation equivariant CNNs. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018b.   
+Wiersma, R., Eisemann, E., and Hildebrandt, K. CNNs on Surfaces using Rotation-Equivariant Features. Transactions on Graphics, 39(4), July 2020. doi: 10.1145/3386569.3392437.   
+Winkels, M. and Cohen, T. S. 3D G-CNNs for pulmonary nodule detection. In Conference on Medical Imaging with Deep Learning (MIDL), 2018.   
+Worrall, D. and Welling, M. Deep scale-spaces: Equivariance over scale. In Conference on Neural Information Processing Systems (NeurIPS), 2019.   
+Worrall, D. E. and Brostow, G. J. Cubenet: Equivariance to 3D rotation and translation. In European Conference on Computer Vision (ECCV), 2018.   
+Worrall, D. E., Garbin, S. J., Turmukhambetov, D., and Brostow, G. J. Harmonic Networks: Deep Translation and Rotation Equivariance. In CVPR, 2017.   
+Wu, Z., Song, S., Khosla, A., Yu, F., Zhang, L., Tang, X., and Xiao, J. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1912–1920, 2015.   
+Zhao, F., Xia, S., Wu, Z., Duan, D., Wang, L., Lin, W., Gilmore, J. H., Shen, D., and Li, G. Spherical u-net on cortical surfaces: Methods and applications. CoRR, abs/1904.00906, 2019a. URL http://arxiv.org/abs/1904.00906.   
+Zhao, Y., Birdal, T., Lenssen, J. E., Menegatti, E., Guibas, L., and Tombari, F. Quaternion equivariant capsule networks for 3d point clouds. arXiv preprint arXiv:1912.12098, 2019b.

parse/train/Jnspzp-oIZE/Jnspzp-oIZE_content_list.json

@@ -0,0 +1,1432 @@
+[
+    {
+        "type": "text",
+        "text": "GAUGE EQUIVARIANT MESH CNNS ANISOTROPIC CONVOLUTIONS ON GEOMETRIC GRAPHS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            838,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pim de Haan∗ Qualcomm AI Research† University of Amsterdam ",
+        "bbox": [
+            183,
+            170,
+            352,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Taco Cohen Qualcomm AI Research ",
+        "bbox": [
+            653,
+            170,
+            813,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Maurice Weiler∗ QUVA Lab University of Amsterdam ",
+        "bbox": [
+            418,
+            170,
+            588,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Max Welling Qualcomm AI Research University of Amsterdam ",
+        "bbox": [
+            183,
+            234,
+            352,
+            276
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            313,
+            544,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A common approach to define convolutions on meshes is to interpret them as a graph and apply graph convolutional networks (GCNs). Such GCNs utilize isotropic kernels and are therefore insensitive to the relative orientation of vertices and thus to the geometry of the mesh as a whole. We propose Gauge Equivariant Mesh CNNs which generalize GCNs to apply anisotropic gauge equivariant kernels. Since the resulting features carry orientation information, we introduce a geometric message passing scheme defined by parallel transporting features over mesh edges. Our experiments validate the significantly improved expressivity of the proposed model over conventional GCNs and other methods. ",
+        "bbox": [
+            233,
+            347,
+            766,
+            472
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            501,
+            336,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Convolutional neural networks (CNNs) have been established as the default method for many machine learning tasks like speech recognition or planar and volumetric image classification and segmentation. Most CNNs are restricted to flat or spherical geometries, where convolutions are easily defined and optimized implementations are available. The empirical success of CNNs on such spaces has generated interest to generalize convolutions to more general spaces like graphs or Riemannian manifolds, creating a field now known as geometric deep learning (Bronstein et al., 2017). ",
+        "bbox": [
+            174,
+            535,
+            825,
+            618
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A case of specific interest is convolution on meshes, the discrete analog of 2-dimensional embedded Riemannian manifolds. Mesh CNNs can be applied to tasks such as detecting shapes, registering different poses of the same shape and shape segmentation. If we forget the positions of vertices, and which vertices form faces, a mesh $M$ can be represented by a graph $\\mathcal { G }$ . This allows for the application of graph convolutional networks (GCNs) to processing signals on meshes. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            695
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "",
+        "image_caption": [
+            "Figure 1: Two local neighbourhoods around vertices $p$ and their representations in the tangent planes $T _ { p } M$ . The distinct geometry of the neighbourhoods is reflected in the different angles $\\theta _ { p q _ { i } }$ of incident edges from neighbours $q _ { i }$ . Graph convolutional networks apply isotropic kernels and can therefore not distinguish both neighbourhoods. Gauge Equivariant Mesh CNNs apply anisotropic kernels and are therefore sensitive to orientations. The arbitrariness of reference orientations, determined by a choice of neighbour $q _ { 0 }$ , is accounted for by the gauge equivariance of the model. "
+        ],
+        "image_footnote": [],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, when representing a mesh by a graph, we lose important geometrical information. In particular, in a graph there is no notion of angle between or ordering of two of a node’s incident edges (see figure 1). Hence, a GCNs output at a node $p$ is designed to be independent of relative angles and invariant to any permutation of its neighbours $q _ { i } \\in \\bar { \\mathcal { N } } ( p )$ . A graph convolution on a mesh graph therefore corresponds to applying an isotropic convolution kernel. Isotropic filters are insensitive to the orientation of input patterns, so their features are strictly less expressive than those of orientation aware anisotropic filters. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address this limitation of graph networks we propose Gauge Equivariant Mesh CNNs (GEM-CNN), which minimally modify GCNs such that they are able to use anisotropic filters while sharing weights across different positions and respecting the local geometry. One obstacle in sharing anisotropic kernels, which are functions of the angle $\\theta _ { p q }$ of neighbour $q$ with respect to vertex $p$ , over multiple vertices of a mesh is that there is no unique way of selecting a reference neighbour $q _ { 0 }$ , which has the direction $\\theta _ { p q _ { 0 } } = 0$ . The reference neighbour, and hence the orientation of the neighbours, needs to be chosen arbitrarily. In order to guarantee the equivalence of the features resulting from different choices of orientations, we adapt Gauge Equivariant CNNs (Cohen et al., 2019b) to general meshes. The kernels of our model are thus designed to be equivariant under gauge transformations, that is, to guarantee that the responses for different kernel orientations are related by a prespecified transformation law. Such features are identified as geometric objects like scalars, vectors, tensors, etc., depending on the specific choice of transformation law. In order to compare such geometric features at neighbouring vertices, they need to be parallel transported along the connecting edge. ",
+        "bbox": [
+            174,
+            208,
+            825,
+            388
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In our implementation we first specify the transformation laws of the feature spaces and compute a space of gauge equivariant kernels. Then we pick arbitrary reference orientations at each node, relative to which we compute neighbour orientations and compute the corresponding edge transporters. Given these quantities, we define the forward pass as a message passing step via edge transporters followed by a contraction with the equivariant kernels evaluated at the neighbour orientations. Algorithmically, Gauge Equivariant Mesh CNNs are therefore just GCNs with anisotropic, gauge equivariant kernels and message passing via parallel transporters. Conventional GCNs are covered in this framework for the specific choice of isotropic kernels and trivial edge transporters, given by identity maps. ",
+        "bbox": [
+            174,
+            395,
+            825,
+            507
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Sec. 2, we will give an outline of our method, deferring details to Secs. 3 and 4. In Sec. 3.2, we describe how to compute general geometric quantities, not specific to our method, used for the computation of the convolution. In our experiments in Sec. 6.1, we find that the enhanced expressiveness of Gauge Equivariant Mesh CNNs enables them to outperform conventional GCNs and other prior work in a shape correspondence task. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 CONVOLUTIONS ON GRAPHS WITH GEOMETRY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            596,
+            619
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider the problem of processing signals on discrete 2-dimensional manifolds, or meshes $M$ . Such meshes are described by a set $\\nu$ of vertices in $\\mathbb { R } ^ { 3 }$ together with a set $\\mathcal { F }$ of tuples, each consisting of the vertices at the corners of a face. For a mesh to describe a proper manifold, each edge needs to be connected to two faces, and the neighbourhood of each vertex needs to be homeomorphic to a disk. Mesh $M$ induces a graph $\\mathcal { G }$ by forgetting the coordinates of the vertices while preserving the edges. ",
+        "bbox": [
+            173,
+            633,
+            825,
+            705
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A conventional graph convolution between kernel $K$ and signal $f$ , evaluated at a vertex $p$ , can be defined by ",
+        "bbox": [
+            176,
+            710,
+            823,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f7dc7346638ffdd597ded37e5b12f075a1233c4aa09a66d5c8203757360421fd.jpg",
+        "text": "$$\n( K \\star f ) _ { p } = K _ { \\mathrm { s e l f } } f _ { p } + \\sum _ { q \\in { \\mathcal N } _ { p } } K _ { \\mathrm { n e i g h } } f _ { q } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            743,
+            635,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { N } _ { p }$ is the set of neighbours of $p$ in $\\mathcal { G }$ , and $K _ { \\mathrm { s e l f } } \\in \\mathbb { R } ^ { C _ { \\mathrm { i n } } \\times C _ { \\mathrm { o u t } } }$ and $K _ { \\mathrm { n e i g h } } \\in \\mathbb { R } ^ { C _ { \\mathrm { i n } } \\times C _ { \\mathrm { o u t } } }$ are two linear maps which model a self interaction and the neighbour contribution, respectively. Importantly, graph convolution does not distinguish different neighbours, because each feature vector $f _ { q }$ is multiplied by the same matrix $K _ { \\mathrm { n e i g h } }$ and then summed. For this reason we say the kernel is isotropic. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            834
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Consider the example in figure 1, where on the left and right, the neighbourhood of one vertex $p$ containing neighbours $q \\in \\mathcal { N } _ { p }$ , is visualized. An isotropic kernel would propagate the signal from the neighbours to $p$ in exactly the same way in both neighbourhoods, even though the neighbourhoods are geometrically distinct. For this reason, our method uses direction sensitive (anisotropic) kernels instead of isotropic kernels. Anisotropic kernels are inherently more expressive than isotropic ones which is why they are used universally in conventional planar CNNs. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Gauge Equivariant Mesh CNN layer ",
+        "text_level": 1,
+        "bbox": [
+            179,
+            104,
+            472,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/0964f893a1533421235ae6a44ce853f32c081b20aa6c2a68cbe2e09b96b9866a.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Input: mesh M,input/output feature types pin, pout,reference neighbours (q ∈ Np)p∈M.</td><td> Sec.3</td></tr><tr><td>Compute basis kernels K&#x27;ef, Kneigh (0) Initialise weights wself and wneigh·</td><td></td></tr><tr><td>For each neighbour pair,p ∈ M,q ∈Np:</td><td> App. A.</td></tr><tr><td>compute neighbor angles θpq relative to reference neighbor</td><td></td></tr><tr><td>compute parallel transporters gq→p</td><td></td></tr><tr><td>Forward(input features (fp)p∈M, weights wself,wneigh):</td><td></td></tr><tr><td>f←∑iwselfKselffp+∑i,q∈NpwneighKneigh(0pq)Pin(gq→p)fq</td><td></td></tr></table>",
+        "bbox": [
+            184,
+            121,
+            823,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose the Gauge Equivariant Mesh Convolution, a minimal modification of graph convolution that allows for anisotropic kernels $K ( \\theta )$ whose value depends on an orientation $\\theta \\in [ 0 , 2 \\pi )$ . 1 To define the orientations $\\theta _ { p q }$ of neighbouring vertices $q \\in \\mathcal { N } _ { p }$ of $p$ , we first map them to the tangent plane $T _ { p } M$ at $p$ , as visualized in figure 1. We then pick an arbitrary reference neighbour $q _ { 0 } ^ { \\bar { p } }$ to determine a reference orientation2 $\\theta _ { p q _ { 0 } ^ { p } } : = 0$ , marked orange in figure 1. This induces a basis on the tangent plane, which, when expressed in polar coordinates, defines the angles $\\theta _ { p q }$ of the other neighbours. ",
+        "bbox": [
+            173,
+            276,
+            825,
+            378
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As we will motivate in the next section, features in a Gauge Equivariant CNN are coefficients of geometric quantities. For example, a tangent vector at vertex $p$ can be described either geometrically by a 3 dimensional vector orthogonal to the normal at $p$ or by two coefficients in the basis on the tangent plane. In order to perform convolution, geometric features at different vertices need to be linearly combined, for which it is required to first “parallel transport” the features to the same vertex. This is done by applying a matrix $\\rho ( \\mathsf { \\bar { g } } _ { q \\to p } ) \\in \\mathbb { R } ^ { C _ { \\mathrm { i n } } \\times C _ { \\mathrm { i n } } }$ to the coefficients of the feature at $q$ , in order to obtain the coefficients of the feature vector transported to $p$ , which can be used for the convolution at $p$ . The transporter depends on the geometric type (group representation) of the feature, denoted by $\\rho$ and described in more detail below. Details of how the tangent space is defined, how to compute the map to the tangent space, angles $\\theta _ { p q }$ , and the parallel transporter are given in Appendix A. ",
+        "bbox": [
+            173,
+            385,
+            826,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In combination, this leads to the GEM-CNN convolution ",
+        "bbox": [
+            174,
+            530,
+            547,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/302d8166143564dabd695dacee11c43bf5872a6a1275aace591824eb21cdf787.jpg",
+        "text": "$$\n( K \\star f ) _ { p } ~ = ~ K _ { \\mathrm { s e l f } } f _ { p } + \\sum _ { q \\in { \\cal N } _ { p } } K _ { \\mathrm { n e i g h } } ( \\theta _ { p q } ) \\rho ( g _ { q \\to p } ) f _ { q }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            315,
+            559,
+            681,
+            587
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "which differs from the conventional graph convolution, defined in Eq. 1 only by the use of an anisotropic kernel and the parallel transport message passing. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We require the outcome of the convolution to be equivalent for any choice of reference orientation. This is not the case for any anisotropic kernel but only for those which are equivariant under changes of reference orientations (gauge transformations). Equivariance imposes a linear constraint on the kernels. We therefore solve for complete sets of “basis-kernels” $\\dot { K } _ { \\mathrm { s e l f } } ^ { i }$ and $K _ { \\mathrm { n e i g h } } ^ { i }$ satisfying this constraint and linearly combine them with parameters $w _ { \\mathrm { s e l f } } ^ { i }$ and $w _ { \\mathrm { n e i g h } } ^ { i }$ such that $\\begin{array} { r } { K _ { \\mathrm { s e l f } } = \\sum _ { i } w _ { \\mathrm { s e l f } } ^ { i } K _ { \\mathrm { s e l f } } ^ { i } } \\end{array}$ and $\\begin{array} { r } { K _ { \\mathrm { n e i g h } } = \\sum _ { i } w _ { \\mathrm { n e i g h } } ^ { i } K _ { \\mathrm { n e i g h } } ^ { i } } \\end{array}$ . Details on the computation of basis kernels are given in section 3. The full algorithm for initialisation and forward pass, which is of time and space complexity linear in the number of vertices, for a GEM-CNN layer are listed in algorithm 1. Gradients can be computed by automatic differentiation. ",
+        "bbox": [
+            173,
+            635,
+            826,
+            768
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The GEM-CNN is gauge equivariant, but furthermore satisfies two important properties. Firstly, it depends only on the intrinsic shape of the 2D mesh, not on the embedding of the mesh in $\\mathbb { R } ^ { \\bar { 3 } }$ . Secondly, whenever a map from the mesh to itself exists that preserves distances and orientation, the convolution is equivariant to moving the signal along such transformations. These properties are proven in Appendix D and empirically shown in Appendix F.2. ",
+        "bbox": [
+            173,
+            775,
+            826,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/6ac0a3a2320acbde203ad94a79a9d22005edf891fd847ae6eb2d500d0f720c4e.jpg",
+        "image_caption": [
+            "Figure 2: Visualization of the Gauge Equivariant Mesh Convolution in two configurations, scalar to scalar and scalar to vector. The convolution operates in a gauge, so that vectors are expressed in coefficients in a basis and neighbours have polar coordinates, but can also be seen as a geometric convolution, a gauge-independent map from an input signal on the mesh to a output signal on the mesh. The convolution is equivariant if this geometric convolution does not depend on the intermediate chosen gauge, so if the diagram commutes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            92,
+            789,
+            340
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 GAUGE EQUIVARIANCE & GEOMETRIC FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            622,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On a general mesh, the choice of the reference neighbour, or gauge, which defines the orientation of the kernel, can only be made arbitrarily. However, this choice should not arbitrarily affect the outcome of the convolution, as this would impede the generalization between different locations and different meshes. Instead, Gauge Equivariant Mesh CNNs have the property that their output transforms according to a known rule as the gauge changes. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            536
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Consider the left hand side of figure 2(a). Given a neighbourhood of vertex $p$ , we want to express each neighbour $q$ in terms of its polar coordinates $( r _ { q } , \\theta _ { q } )$ on the tangent plane, so that the kernel value at that neighbour $K _ { \\mathrm { n e i g h } } ( \\bar { \\theta _ { q } } )$ is well defined. This requires choosing a basis on the tangent plane, determined by picking a neighbour as reference neighbour (denoted $q _ { 0 . }$ ), which has the zero angle $\\theta _ { q _ { 0 } } = 0$ . In the top path, we pick $q _ { A }$ as reference neighbour. Let us call this gauge A, in which neighbours have angles $\\theta _ { q } ^ { A }$ . In the bottom path, we instead pick neighbour $q _ { B }$ as reference point and are in gauge B. We get a different basis for the tangent plane and different angles $\\underset { . } { \\theta _ { q } ^ { B } }$ for each neighbour. Comparing the two gauges, we see that they are related by a rotation, so that $\\theta _ { q } ^ { B } = \\theta _ { q } ^ { A } - \\mathsf { \\bar { \\theta } } _ { q B } ^ { A }$ . This change of gauge is called a gauge transformation of angle $g : = \\theta _ { q _ { B } } ^ { A }$ . ",
+        "bbox": [
+            173,
+            542,
+            825,
+            675
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In figure 2(a), we illustrate a gauge equivariant convolution that takes input and output features such as gray scale image values on the mesh, which are called scalar features. The top path represents the convolution in gauge A, the bottom path in gauge B. In either case, the convolution can be interpreted as consisting of three steps. First, for each vertex $p$ , the value of the scalar features on the mesh at each neighbouring vertex $q$ , represented by colors, is mapped to the tangent plane at $p$ at angle $\\theta _ { q }$ defined by the gauge. Subsequently, the convolutional kernel sums for each neighbour $q$ , the product of the feature at $q$ and kernel $K ( \\theta _ { q } )$ . Finally the output is mapped back to the mesh. These three steps can be composed into a single step, which we could call a geometric convolution, mapping from input features on the mesh to output features on the mesh. The convolution is gauge equivariant if this geometric convolution does not depend on the gauge we pick in the interim, so in figure 2(a), if the convolution in the top path in gauge A has same result the convolution in the bottom path in gauge B, making the diagram commute. In this case, however, we see that the convolution output needs to be the same in both gauges, for the convolution to be equivariant. Hence, we must have that $K ( \\theta _ { q } ) = K ( \\theta _ { q } - g )$ , as the orientations of the neighbours differ by some angle $g$ , and the kernel must be isotropic. ",
+        "bbox": [
+            173,
+            681,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As we aim to design an anisotropic convolution, the output feature of the convolution at $p$ can, instead of a scalar, be two numbers $v \\in \\mathbb { R } ^ { 2 }$ , which can be interpreted as coefficients of a tangent feature vector in the tangent space at $p$ , visualized in figure 2(b). As shown on the right hand side, different gauges induce a different basis of the tangent plane, so that the same tangent vector (shown on the middle right on the mesh), is represented by different coefficients in the gauge (shown on the top and bottom on the right). This gauge equivariant convolution must be anisotropic: going from the top row to the bottom row, if we change orientations of the neighbours by $- g$ , the coefficients of the output vector $v \\in \\mathbb { R } ^ { 2 }$ of the kernel must be also rotated by $- g$ . This is written as $R ( - g ) v$ , where $R ( - g ) \\in \\mathbb { R } ^ { 2 \\times 2 }$ is the matrix that rotates by angle $- g$ . ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Vectors and scalars are not the only type of geometric features that can be inputs and outputs of a GEM-CNN layer. In general, the coefficients of a geometric feature of $C$ dimensions changes by an invertible linear transformation $\\rho ( - g ) \\in \\mathbb { R } ^ { C \\times C }$ if the gauge is rotated by angle $g$ . The map $\\begin{array} { r } { \\dot { \\rho ^ { \\smash { \\sum } } } : [ 0 , 2 \\pi ) \\to \\mathbb { R } ^ { C \\times C } } \\end{array}$ is called the type of the geometric quantity and is formally known as a group representation of the planar rotation group SO(2). Group representations have the property that $\\bar { \\rho ( g + h ) } = \\rho ( g ) \\rho ( h )$ (they are group homomorphisms), which implies in particular that $\\dot { \\rho } ( 0 ) = \\mathbb { 1 }$ and $\\rho ( - g ) = \\rho ( g ) ^ { - 1 }$ . For more background on group representation theory, we refer the reader to (Serre, 1977) and, specifically in the context of equivariant deep learning, to (Lang & Weiler, 2020). From the theory of group representations, we know that any feature type can be composed from “irreducible representations” (irreps). For SO(2), these are the one dimensional invariant scalar representation $\\rho _ { 0 }$ and for all $n \\in  { \\mathbb { N } } _ { > 0 }$ , a two dimensional representation $\\rho _ { n }$ , ",
+        "bbox": [
+            173,
+            208,
+            825,
+            361
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2265104b9cbc645b9b769ce1afe82e52e1f5a6d74e46342b309221ed79df66cd.jpg",
+        "text": "$$\n\\rho _ { 0 } ( g ) = 1 , \\quad \\rho _ { n } ( g ) = \\binom { \\cos n g } { \\sin n g } \\quad \\sp { - \\sin n g } \\nonumber \\cos n g \\biggr ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            349,
+            364,
+            647,
+            400
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we write, for example, $\\rho = \\rho _ { 0 } \\oplus \\rho _ { 1 } \\oplus \\rho _ { 1 }$ to denote that representation $\\rho ( g )$ is the direct sum (i.e. block-diagonal stacking) of the matrices $\\dot { \\rho } _ { 0 } ( g ) , \\rho _ { 1 } ( g ) , \\rho _ { 1 } ( g )$ . Scalars and tangent vector features correspond to $\\rho _ { 0 }$ and $\\rho _ { 1 }$ respectively and we have $R ( g ) = \\rho _ { 1 } ( g )$ . ",
+        "bbox": [
+            173,
+            404,
+            823,
+            448
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The type of the feature at each layer in the network can thus be fully specified (up to a change of basis) by the number of copies of each irrep. Similar to the dimensionality in a conventional CNN, the choice of type is a hyperparameter that can be freely chosen to optimize performance. ",
+        "bbox": [
+            174,
+            453,
+            825,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 KERNEL CONSTRAINT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            370,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given an input type $\\rho _ { \\mathrm { i n } }$ and output type $\\rho _ { \\mathrm { o u t } }$ of dimensions $C _ { \\mathrm { i n } }$ and $C _ { \\mathrm { { o u t } } }$ , the kernels are $K _ { \\mathrm { s e l f } } ~ \\in$ $\\mathbb { R } ^ { C _ { \\mathrm { o u t } } \\times C _ { \\mathrm { i n } } }$ and $K _ { \\mathrm { n e i g h } } : [ 0 , 2 \\pi )  ] \\mathbb { R } ^ { C _ { \\mathrm { o u t } } \\times C _ { \\mathrm { i n } } }$ . However, not all such kernels are equivariant. Consider again examples figure 2(a) and figure 2(b). If we map from a scalar to a scalar, we get that $K _ { \\mathrm { n e i g h } } ( \\theta -$ $\\bar { g ) } = K _ { \\mathrm { n e i g h } } \\bar { ( \\theta ) }$ for all angles $\\theta , g$ and the convolution is isotropic. If we map from a scalar to a vector, we get that rotating the angles $\\theta _ { q }$ results in the same tangent vector as rotating the output vector coefficients, so that $K _ { \\mathrm { n e i g h } } ( \\theta - g ) { \\dot { = } } R ( - g ) K _ { \\mathrm { n e i g h } } ( \\theta )$ . ",
+        "bbox": [
+            173,
+            537,
+            825,
+            622
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In general, as derived by Cohen et al. (2019b) and in appendix B, the kernels must satisfy for any gauge transformation $g \\in [ 0 , 2 \\pi )$ and angle $\\theta \\in [ 0 , 2 \\pi )$ , that ",
+        "bbox": [
+            173,
+            627,
+            483,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fbc75e930baf3cb9bad530c82dda353813ad8e002856b34fce4691a7a382a086.jpg",
+        "text": "$$\n\\begin{array} { r } { K _ { \\mathrm { n e i g h } } ( \\theta - g ) = \\rho _ { \\mathrm { o u t } } ( - g ) K _ { \\mathrm { n e i g h } } ( \\theta ) \\rho _ { \\mathrm { i n } } ( g ) , } \\\\ { K _ { \\mathrm { s e l f } } = \\rho _ { \\mathrm { o u t } } ( - g ) \\ K _ { \\mathrm { s e l f } } \\ \\rho _ { \\mathrm { i n } } ( g ) . \\qquad } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            178,
+            688,
+            454,
+            726
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The kernel can be seen as consisting of multiple blocks, where each block takes as input one irrep and outputs one irrep. For example if $\\rho _ { \\mathrm { i n } }$ would be of type $\\rho _ { 0 } \\oplus \\rho _ { 1 } \\oplus \\rho _ { 1 }$ and $\\rho _ { \\mathrm { o u t } }$ of type $\\rho _ { 1 } \\oplus \\rho _ { 3 }$ , we have $4 \\times 5$ matrix ",
+        "bbox": [
+            173,
+            728,
+            485,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2569c412e3aebe133e776b95db271b43767b03c0e8557d0f49d9a6c28063c646.jpg",
+        "text": "$$\nK _ { \\mathrm { n e i g h } } ( \\theta ) = { \\binom { K _ { 1 0 } ( \\theta ) } { K _ { 3 0 } ( \\theta ) } } K _ { 1 1 } ( \\theta ) K _ { 1 1 } ( \\theta ) \\Big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            184,
+            800,
+            475,
+            834
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/9b1db510bcf3c43ffb972cd878e32ddda9d4e7acf540fb3f090e3d40f4ae2d9c.jpg",
+        "table_caption": [
+            "Table 1: Solutions to the angular kernel constraint for kernels that map from $\\rho _ { n }$ to $\\rho _ { m }$ . We denote $c _ { \\pm } = \\cos ( ( m \\pm n ) \\theta )$ and $s _ { \\pm } = \\sin ( ( m \\pm n ) \\theta )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>pin→pout</td><td>linearly independent solutions for Kneigh (0)</td></tr><tr><td>p→po</td><td>(1)</td></tr><tr><td>pn→po</td><td>(cos nθ sin nθ),(sin nθ -cos n0)</td></tr><tr><td>po→pm</td><td>(cos mθ) sin m) (sinmθ) ， (-cosm0)</td></tr><tr><td>pn→pm</td><td>(c- -s_ S_ C_ (C+ S+ -S+ C+ s_ c_ -c S- S+ -C+） ， c+s+)</td></tr><tr><td>pin→pout</td><td>linearly independent solutions for Kself</td></tr><tr><td>p→po</td><td>(1)</td></tr><tr><td>pn→pn</td><td>(61). (-1)</td></tr></table>",
+        "bbox": [
+            498,
+            645,
+            820,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where e.g. $K _ { 3 1 } ( \\theta ) \\in \\mathbb { R } ^ { 2 \\times 2 }$ is a kernel that takes as input irrep $\\rho _ { 1 }$ and as output irrep $\\rho _ { 3 }$ and needs to satisfy Eq. 3. As derived by Weiler & Cesa (2019) and in Appendix C, the kernels $K _ { \\mathrm { n e i g h } } ( \\theta )$ and $K _ { \\mathrm { s e l f } }$ mapping from irrep $\\rho _ { n }$ to irrep $\\rho _ { m }$ can be written as a linear combination of the basis kernels listed in Table 1. The table shows that equivariance requires the self-interaction to only map from one irrep to the same irrep. Hence, we have $K _ { \\mathrm { s e l f } } = \\left( \\begin{array} { c c c } { 0 } & { K _ { 1 1 } } & { K _ { 1 1 } } \\\\ { 0 } & { 0 } & { 0 } \\end{array} \\right) \\in \\mathbb { R } ^ { 4 \\times 3 } .$ ",
+        "bbox": [
+            173,
+            839,
+            825,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All basis-kernels of all pairs of input irreps and output irreps can be linearly combined to form an arbitrary equivariant kernel from feature of type $\\rho _ { \\mathrm { i n } }$ to $\\rho _ { \\mathrm { o u t } }$ . In the above example, we have $2 \\times 2 + 4 \\times 4 = 2 0$ basis kernels for $K _ { \\mathrm { n e i g h } }$ and 4 basis kernels for $K _ { \\mathrm { s e l f } }$ . The layer thus has 24 parameters. As proven in (Weiler & Cesa, 2019) and (Lang & Weiler, 2020), this parameterization of the equivariant kernel space is complete, that is, more general equivariant kernels do not exist. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 GEOMETRY AND PARALLEL TRANSPORT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            190,
+            495,
+            204
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In order to implement gauge equivariant mesh CNNs, we need to make the abstract notion of tangent spaces, gauges and transporters concrete. ",
+        "bbox": [
+            174,
+            215,
+            823,
+            244
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As the mesh is embedded in $\\mathbb { R } ^ { 3 }$ , a natural definition of the tangent spaces $T _ { p } M$ is as two dimensional subspaces that are orthogonal to the normal vector at $p$ . We follow the common definition of normal vectors at mesh vertices as the area weighted average of the adjacent faces’ normals. The Riemannian logarithm map $\\log _ { p } : \\mathcal { N } _ { p } \\to T _ { p } M$ represents the one-ring neighborhood of each point $p$ on their tangent spaces as visualized in figure 1. Specifically, neighbors $q \\in \\mathcal { N } _ { p }$ are mapped to $\\bar { \\log _ { p } ( q ) } \\in T _ { p } \\bar { M }$ by first projecting them to $T _ { p } M$ and then rescaling the projection such that the norm is preserved, i.e. $| \\log _ { p } ( q ) | = | q - p |$ ; see Eq. 6. A choice of reference neighbor $q _ { p } \\in \\mathcal { N }$ uniquely determines a right handed, orthonormal reference frame $( e _ { p , 1 } , e _ { p , 2 } )$ of $T _ { p } M$ by setting $e _ { p , 1 } : = \\log _ { p } ( q _ { 0 } ) / | \\log _ { p } ( q _ { 0 } ) |$ and $e _ { p , 2 } : = n \\times e _ { p , 1 }$ . The polar angle $\\theta _ { p q }$ of any neighbor $q \\in \\mathcal N$ relative to the first frame axis is then given by $\\theta _ { p q } : = \\mathrm { a t a n 2 } \\left( e _ { p , 2 } ^ { \\top } \\log _ { p } ( q ) , e _ { p , 1 } ^ { \\top } \\log _ { p } ( q ) \\right) )$ . ",
+        "bbox": [
+            173,
+            251,
+            825,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given the reference frame $( e _ { p , 1 } , e _ { p , 2 } )$ , a 2-tuple of coefficients $( v _ { 1 } , v _ { 2 } ) \\in \\mathbb { R } ^ { 2 }$ specifies an (embedded) tangent vector $v _ { 1 } e _ { p , 1 } + v _ { 2 } e _ { p , 2 } \\in T _ { p } M \\subset \\mathbb { R } ^ { 3 }$ . This assignment is formally given by the gauge map $E _ { p } : \\mathbb { R } ^ { 2 } \\to T _ { p } M \\overset { \\cdot } { \\subset } \\mathbb { R } ^ { 3 }$ which is a vector space isomorphism. In our case, it can be identified with the matrix ",
+        "bbox": [
+            174,
+            405,
+            825,
+            463
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1af838a9ec21d8ddaad65a26f8b728761dacd73ae62d0fa7ec56bd6dee146450.jpg",
+        "text": "$$\n\\begin{array} { r } { \\boldsymbol { E _ { p } } = \\left[ \\begin{array} { c c } { \\boldsymbol { \\vert } } & { \\boldsymbol { \\vert } } \\\\ { \\boldsymbol { e _ { p , 1 } } } & { \\boldsymbol { e _ { p , 2 } } } \\\\ { \\boldsymbol { \\vert } } & { \\boldsymbol { \\vert } } \\end{array} \\right] \\in \\mathbb { R } ^ { 3 \\times 2 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            459,
+            604,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Feature vectors $f _ { p }$ and $f _ { q }$ at neighboring (or any other) vertices $p \\in M$ and $q \\in \\mathcal { N } _ { p } \\subseteq M$ live in different vector spaces and are expressed relative to independent gauges, which makes it invalid to sum them directly. Instead, they have to be parallel transported along the mesh edge that connects the two vertices. As explained above, this transport is given by group elements $\\mathsf { \\bar { g } } _ { q \\to p } \\in [ 0 , 2 \\pi )$ , which determine the transformation of tangent vector coefficients as $v _ { q } \\mapsto R ( g _ { q  p } ) v _ { q } \\in \\mathbb { R } ^ { 2 }$ and, analogously, for feature vector coefficients as $f _ { q } \\mapsto \\rho ( g _ { q  p } ) f _ { q }$ . Figure 4 in the appendix visualizes the definition of edge transporters for flat spaces and meshes. On a flat space, tangent vectors are transported by keeping them parallel in the usual sense on Euclidean spaces. However, if the source and target frame orientations disagree, the vector coefficients relative to the source frame need to be transformed to the target frame. This coordinate transformation from polar angles $\\varphi _ { q }$ of $v$ to $\\varphi _ { p }$ of $R ( g _ { q  p } ) v$ defines the transporter $g _ { q  p } = \\varphi _ { p } - \\varphi _ { q }$ . On meshes, the source and target tangent spaces $T _ { q } M$ and $T _ { p } M$ are not longer parallel. It is therefore additionally necessary to rotate the source tangent space and its vectors parallel to the target space, before transforming between the frames. Since transporters effectively make up for differences in the source and target frames, the parallel transporters transform under gauge transformations $g _ { p }$ and $g _ { q }$ according to $g _ { q \\to p } \\mapsto g _ { p } + g _ { q \\to p } - g _ { q }$ . Note that this transformation law cancels with the transformation law of the coefficients at $q$ and lets the transported coefficients transform according to gauge transformations at $p$ . It is therefore valid to sum vectors and features that are parallel transported into the same gauge at $p$ . ",
+        "bbox": [
+            173,
+            515,
+            826,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A more detailed discussion of the concepts presented in this section can be found in Appendix A. ",
+        "bbox": [
+            173,
+            773,
+            807,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 NON-LINEARITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            809,
+            343,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Besides convolutional layers, the GEM-CNN contains non-linear layers, which also need to be gauge equivariant, for the entire network to be gauge equivariant. The coefficients of features built out of irreducible representaions, as described in section 3, do not commute with point-wise nonlinearities (Worrall et al., 2017; Thomas et al., 2018; Weiler et al., 2018a; Kondor et al., 2018). Norm non-linearities and gated non-linearities (Weiler & Cesa, 2019) can be used with such features, but generally perform worse in practice compared to point-wise non-linearities (Weiler & Cesa, ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2019). Hence, we propose the RegularNonlinearity, which uses point-wise non-linearities and is approximately gauge equivariant. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This non-linearity is built on Fourier transformations. Consider a continuous periodic signal, on which we perform a band-limited Fourier transform with band limit $b$ , obtaining $2 b + 1$ Fourier coefficients. If this continuous signal is shifted by an arbitrary angle $g$ , then the corresponding Fourier components transform with linear transformation $\\rho _ { 0 : b } ( - g )$ , for $2 b + 1$ dimensional representation $\\rho _ { 0 : b } : = \\rho _ { 0 } \\oplus \\rho _ { 1 } \\oplus \\ldots \\oplus \\rho _ { b }$ . ",
+        "bbox": [
+            174,
+            138,
+            825,
+            209
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "It would be exactly equivariant to take a feature of type $\\rho _ { 0 : b }$ , take a continuous inverse Fourier transform to a continuous periodic signal, then apply a point-wise non-linearity to that signal, and take the continuous Fourier transform, to recover a feature of type $\\rho _ { 0 : b }$ . However, for implementation, we use $N$ intermediate samples and the discrete Fourier transform. This is exactly gauge equivariant for gauge transformation of angles multiple of $2 \\pi / N$ , but only approximately equivariant for other angles. In App. G we prove that as $N \\to \\infty$ , the non-linearity is exactly gauge equivariant. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The run-time cost per vertex of the (inverse) Fourier transform implemented as a simple linear transformation is $\\mathcal { O } ( b N )$ , which is what we use in our experiments. The pointwise non-linearity scales linearly with $N$ , so the complexity of the RegularNonLineariy is also $\\mathcal { O } ( b N )$ . However, one can also use a fast Fourier transform, achieving a complexity of $\\mathcal { O } ( N \\log N )$ . Concrete memory and run-time cost of varying $N$ are shown in appendix F.1. ",
+        "bbox": [
+            174,
+            306,
+            825,
+            376
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            406,
+            343,
+            422
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The irregular structure of meshes leads to a variety of approaches to define convolutions. Closely related to our method are graph based methods which are often based on variations of graph convolutional networks (Kipf & Welling, 2017; Defferrard et al., 2016). GCNs have been applied on spherical meshes (Perraudin et al., 2019) and cortical surfaces (Cucurull et al., 2018; Zhao et al., 2019a). Verma et al. (2018) augment GCNs with anisotropic kernels which are dynamically computed via an attention mechanism over graph neighbours. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            527
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Instead of operating on the graph underlying a mesh, several approaches leverage its geometry by treating it as a discrete manifold. Convolution kernels can then be defined in geodesic polar coordinates which corresponds to a projection of kernels from the tangent space to the mesh via the exponential map. This allows for kernels that are larger than the immediate graph neighbourhood and message passing over faces but does not resolve the issue of ambiguous kernel orientation. Masci et al. (2015); Monti et al. (2016) and Sun et al. (2018) address this issue by restricting the network to orientation invariant features which are computed by applying anisotropic kernels in several orientations and pooling over the resulting responses. The models proposed in (Boscaini et al., 2016) and (Schonsheck et al., 2018) are explicitly gauge dependent with preferred orientations chosen via the principal curvature direction and the parallel transport of kernels, respectively. Poulenard & Ovsjanikov (2018) proposed a non-trivially gauge equivariant network based on geodesic convolutions, however, the model parallel transports only partial information of the feature vectors, corresponding to certain kernel orientations. In concurrent work, Wiersma et al. (2020) also define convolutions on surfaces equivariantly to the orientation of the kernel, but differ in that they use norm non-linearities instead of regular ones and that they apply the convolution along longer geodesics, which adds complexity to the geometric pre-computation - as partial differential equations need to be solved, but may result in less susceptibility to the particular discretisation of the manifold. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another class of approaches defines spectral convolutions on meshes. However, as argued in (Bronstein et al., 2017), the Fourier spectrum of a mesh depends heavily on its geometry, which makes such methods instable under deformations and impedes the generalization between different meshes. Spectral convolutions further correspond to isotropic kernels. Kostrikov et al. (2018) overcomes isotropy of the Laplacian by decomposing it into two applications of the first-order Dirac operator. ",
+        "bbox": [
+            174,
+            777,
+            825,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A construction based on toric covering maps of topologically spherical meshes was presented in (Maron et al., 2017). An entirely different approach to mesh convolutions is to apply a linear map to a spiral of neighbours (Bouritsas et al., 2019; Gong et al., 2019), which works well only for meshes with a similar graph structure. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The above-mentioned methods operate on the intrinsic, 2-dimensional geometry of the mesh. A popular alternative for embedded meshes is to define convolutions in the embedding space $\\mathbb { R } ^ { 3 }$ . This can for instance be done by voxelizing space and representing the mesh in terms of an occupancy grid (Wu et al., 2015; Tchapmi et al., 2017; Hanocka et al., 2018). A downside of this approach are the high memory and compute requirements of voxel representations. If the grid occupancy is low, this can partly be addressed by resorting to an inhomogeneous grid density (Riegler et al., 2017). Instead of voxelizing space, one may interpret the set of mesh vertices as a point cloud and run a convolution on those (Qi et al., 2017a;b). Point cloud based methods can be made equivariant w.r.t. the isometries of $\\mathbb { R } ^ { 3 }$ (Zhao et al., 2019b; Thomas et al., 2018), which implies in particular the isometry equivariance on the embedded mesh. In general, geodesic distances within the manifold differ usually substantially from the distances in the embedding space. Which approach is more suitable depends on the particular application. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "On flat Euclidean spaces our method corresponds to Steerable CNNs (Cohen & Welling, 2017; Weiler et al., 2018a; Weiler & Cesa, 2019; Cohen et al., 2019a; Lang & Weiler, 2020). As our model, these networks process geometric feature fields of types $\\rho$ and are equivariant under gauge transformations, however, due to the flat geometry, the parallel transporters become trivial. Regular nonlinearities are on flat spaces used in group convolutional networks (Cohen & Welling, 2016; Weiler et al., 2018b; Hoogeboom et al., 2018; Bekkers et al., 2018; Winkels & Cohen, 2018; Worrall & Brostow, 2018; Worrall & Welling, 2019; Sosnovik et al., 2020). ",
+        "bbox": [
+            174,
+            277,
+            825,
+            375
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            406,
+            326,
+            422
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.1 EMBEDDED MNIST ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            445,
+            354,
+            459
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first investigate how Gauge Equivariant Mesh CNNs perform on, and generalize between, different mesh geometries. For this purpose we conduct simple MNIST digit classification experiments on embedded rectangular meshes of $2 8 \\times 2 8$ vertices. As a baseline geometry we consider a flat mesh as visualized in figure 5(a). A second type of geometry is defined as different isometric embeddings of the flat mesh, see figure 5(b). Note that this implies that the intrinsic geometry of these isometrically embedded meshes is indistinguishable from that of the flat mesh. To generate geometries which are intrinsically curved, we add random normal displacements to the flat mesh. We control the amount of curvature by smoothing the resulting displacement fields with Gaussian kernels of different widths $\\sigma$ and define the roughness of the resulting mesh as $3 - \\sigma$ . Figures 5(c)-5(h) show the results for roughnesses of 0.5, 1, 1.5, 2, 2.25 and 2.5. For each of the considered settings we generate 32 different train and 32 test geometries. ",
+        "bbox": [
+            174,
+            476,
+            825,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To test the performance on, and generalization between, different geometries, we train equivalent GEM-CNN models on a flat mesh and meshes with a roughness of 1, 1.5, 2, 2.25 and 2.5. Each model is tested individually on each of the considered test geometries, which are the flat mesh, isometric embeddings and curved embeddings with a roughness of 0.5, 1, 1.25, 1.5, 1.75, 2, 2.25 and 2.5. Figure 3 shows the test errors of the GEM-CNNs on the different train geometries (different curves) for all test geometries (shown on the x-axis). Since our model is purely defined in terms of the intrinsic geometry of a mesh, it is expected to be insensitive to isometric changes in the embeddings. This is empirically confirmed by the fact that the test performances on flat and isometric embeddings are exactly equal. As expected, the test error increases for most models with the surface roughness. Models trained on more rough surfaces are hereby more robust to deformations. The models generalize well from a rough training to smooth test geometry up to a training roughness of 1.5. Beyond that point, the test performances on smooth meshes degrades up to the point of random guessing at a training roughness of 2.5. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            816
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As a baseline, we build an isotropic graph CNN with the same network topology and number of parameters $( \\approx 1 6 3 k )$ ). This model is insensitive to the mesh geometry and therefore performs exactly equal on all surfaces. While this enhances its robustness on very rough meshes, its test error of $1 9 . 8 0 \\pm 3 . 4 3 \\%$ is an extremely bad result on MNIST. In contrast, the use of anisotropic filters of GEM-CNN allows it to reach a test error of only $0 . 6 0 \\pm 0 . 0 5 \\%$ on the flat geometry. It is therefore competitive with conventional CNNs on pixel grids, which apply anisotropic kernels as well. More details on the datasets, models and further experimental setup are given in appendix E.1. ",
+        "bbox": [
+            174,
+            824,
+            825,
+            921
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/b14045eeb68ab7cd2fd302585eb95df9b21376a3b7cd1e3e6c26805b57a4eb45.jpg",
+        "image_caption": [
+            "Figure 3: Test errors for MNIST digit classification on embedded meshes. Different lines denote train geometries, $\\mathbf { X }$ -axis shows test geometries. Regions are standard errors of the means over 6 runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            112,
+            465,
+            238
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/346ea1e1e69741c1fe501348bf391c31c5565764484f6ee558dea2e138524ca9.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Features</td><td>Accuracy (%)</td></tr><tr><td>ACNN (Boscaini et al.,2016)</td><td>SHOT</td><td>62.4</td></tr><tr><td>Geodesic CNN (Masci et al.,2015)</td><td>SHOT</td><td>65.4</td></tr><tr><td>MoNet (Monti et al.,2016)</td><td>SHOT</td><td>73.8</td></tr><tr><td>FeaStNet (Verma et al.,2018)</td><td>XYZ</td><td>98.7</td></tr><tr><td>ZerNet (Sun et al.,2018)</td><td>XYZ</td><td>96.9</td></tr><tr><td>SpiralNet++ (Gong et al.,2019)</td><td>XYZ</td><td>99.8</td></tr><tr><td>Graph CNN</td><td>XYZ</td><td>1.40±0.5</td></tr><tr><td>Graph CNN</td><td>SHOT</td><td>23.80±8</td></tr><tr><td>Non-equiv. CNN (SHOT frames)</td><td>XYZ</td><td>73.00±4.0</td></tr><tr><td>Non-equiv. CNN (SHOT frames)</td><td>SHOT</td><td>75.11±2.4</td></tr><tr><td>GEM-CNN</td><td>XYZ</td><td>99.73±0.04</td></tr><tr><td>GEM-CNN (broken symmetry)</td><td>XYZ</td><td>99.89±0.02</td></tr></table>",
+        "bbox": [
+            480,
+            69,
+            816,
+            237
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Results of FAUST shape correspondence. Statistics are means and standard errors of the mean of over three runs. All cited results are from their respective papers. ",
+        "bbox": [
+            480,
+            248,
+            820,
+            299
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 SHAPE CORRESPONDENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            319,
+            398,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As a second experiment, we perform non-rigid shape correspondence on the FAUST dataset (Bogo et al., 2014), following Masci et al. (2015) 3 . The data consists of 100 meshes of human bodies in various positions, split into 80 train and 20 test meshes. The vertices are registered, such that vertices on the same position on the body, such as the tip of the left thumb, have the same identifier on all meshes. All meshes have 6890 vertices, making this a 6890-class segmentation problem. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            414
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The architecture transforms the vertices’ $X Y Z$ coordinates (of type $3 \\rho _ { 0 }$ ), via 6 convolutional layers to features $6 4 \\rho _ { 0 }$ , with intermediate features $1 6 ( \\rho _ { 0 } \\oplus \\rho _ { 1 } \\oplus \\rho _ { 2 } )$ , with residual connections and the RegularNonlinearity with $N = 5$ samples. Afterwards, we use two $1 \\times 1$ convolutions with ReLU to map first to 256 and then 6980 channels, after which a softmax predicts the registration probabilities. The $1 \\times 1$ convolutions use a dropout of $50 \\%$ and 1E-4 weight decay. The network is trained with a cross entropy loss with an initial learning rate of 0.01, which is halved when training loss reaches a plateau. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            518
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As all meshes in the FAUST dataset share the same topology, breaking the gauge equivariance in higher layers can actually be beneficial. As shown in (Weiler & Cesa, 2019), symmetry can be broken by treating non-invariant features as invariant features as input to the final $1 \\times 1$ convolution. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As baselines, we compare to various models, some of which use more complicated pipelines, such as (1) the computation of geodesics over the mesh, which requires solving partial differential equations, (2) pooling, which requires finding a uniform sub-selection of vertices, (3) the pre-computation of SHOT features which locally describe the geometry (Tombari et al., 2010), or (4) post-processing refinement of the predictions. The GEM-CNN requires none of these additional steps. In addition, we compare to SpiralNet $^ { - + }$ (Gong et al., 2019), which requires all inputs to be similarly meshed. Finally, we compare to an isotropic version of the GEM-CNN, which reduces to a conventional graph CNN, as well as a non-gauge-equivariant CNN based on SHOT frames. The results in table 2 show that the GEM-CNN outperforms prior works and a non-gauge-equivariant CNN, that isotropic graph CNNs are unable to solve the task and that for this data set breaking gauge symmetry in the final layers of the network is beneficial. More experimental details are given in appendix E.2. ",
+        "bbox": [
+            173,
+            574,
+            826,
+            728
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            742,
+            328,
+            757
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Convolutions on meshes are commonly performed as a convolution on their underlying graph, by forgetting geometry, such as orientation of neighbouring vertices. In this paper we propose Gauge Equivariant Mesh CNNs, which endow Graph Convolutional Networks on meshes with anisotropic kernels and parallel transport. Hence, they are sensitive to the mesh geometry, and result in equivalent outputs regardless of the arbitrary choice of kernel orientation. ",
+        "bbox": [
+            174,
+            767,
+            825,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We demonstrate that the inference of GEM-CNNs is invariant under isometric deformations of meshes and generalizes well over a range of non-isometric deformations. On the FAUST shape correspondence task, we show that Gauge equivariance, combined with symmetry breaking in the final layer, leads to state of the art performance. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            900
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bekkers, E. J., Lafarge, M. W., Veta, M., Eppenhof, K. A., Pluim, J. P., and Duits, R. Roto-translation covariant convolutional networks for medical image analysis. In International Conference on Medical Image Computing and Computer-Assisted Intervention (MICCAI), 2018. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bogo, F., Romero, J., Loper, M., and Black, M. J. Faust: Dataset and evaluation for 3d mesh registration. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3794–3801, 2014. ",
+        "bbox": [
+            174,
+            178,
+            823,
+            220
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Boscaini, D., Masci, J., Rodola, E., and Bronstein, M. M. Learning shape correspondence with \\` anisotropic convolutional neural networks. In NIPS, 2016. ",
+        "bbox": [
+            171,
+            229,
+            825,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bouritsas, G., Bokhnyak, S., Ploumpis, S., Bronstein, M., and Zafeiriou, S. Neural 3d morphable models: Spiral convolutional networks for 3d shape representation learning and generation. In Proceedings of the IEEE International Conference on Computer Vision, pp. 7213–7222, 2019. ",
+        "bbox": [
+            176,
+            267,
+            823,
+            311
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bronstein, M. M., Bruna, J., LeCun, Y., Szlam, A., and Vandergheynst, P. Geometric deep learning: Going beyond Euclidean data. IEEE Signal Processing Magazine, 2017. ",
+        "bbox": [
+            174,
+            319,
+            823,
+            349
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cohen, T. and Welling, M. Group equivariant convolutional networks. In ICML, 2016. ",
+        "bbox": [
+            174,
+            358,
+            741,
+            373
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cohen, T. S. and Welling, M. Steerable CNNs. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            382,
+            586,
+            397
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cohen, T. S., Geiger, M., and Weiler, M. A general theory of equivariant CNNs on homogeneous spaces. In Conference on Neural Information Processing Systems (NeurIPS), 2019a. ",
+        "bbox": [
+            176,
+            406,
+            823,
+            436
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cohen, T. S., Weiler, M., Kicanaoglu, B., and Welling, M. Gauge equivariant convolutional networks and the Icosahedral CNN. 2019b. ",
+        "bbox": [
+            173,
+            444,
+            823,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Crane, K., Desbrun, M., and Schroder, P. Trivial connections on discrete surfaces. ¨ Computer Graphics Forum (SGP), 29(5):1525–1533, 2010. ",
+        "bbox": [
+            173,
+            482,
+            823,
+            512
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Crane, K., de Goes, F., Desbrun, M., and Schroder, P. Digital geometry processing with discrete ¨ exterior calculus. In ACM SIGGRAPH 2013 courses, SIGGRAPH ’13, New York, NY, USA, 2013. ACM. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            564
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Cucurull, G., Wagstyl, K., Casanova, A., Velickovi ˇ c, P., Jakobsen, E., Drozdzal, M., Romero, A., ´ Evans, A., and Bengio, Y. Convolutional neural networks for mesh-based parcellation of the cerebral cortex. 2018. ",
+        "bbox": [
+            173,
+            571,
+            823,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Defferrard, M., Bresson, X., and Vandergheynst, P. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in neural information processing systems, pp. 3844–3852, 2016. ",
+        "bbox": [
+            173,
+            625,
+            823,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gallier, J. and Quaintance, J. Differential Geometry and Lie Groups: A Computational Perspective, volume 12. Springer Nature, 2020. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gong, S., Chen, L., Bronstein, M., and Zafeiriou, S. Spiralnet++: A fast and highly efficient mesh convolution operator. In Proceedings of the IEEE International Conference on Computer Vision Workshops, pp. 0–0, 2019. ",
+        "bbox": [
+            173,
+            714,
+            826,
+            757
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hanocka, R., Fish, N., Wang, Z., Giryes, R., Fleishman, S., and Cohen-Or, D. Alignet: Partial-shape agnostic alignment via unsupervised learning. ACM Transactions on Graphics (TOG), 38(1):1–14, 2018. ",
+        "bbox": [
+            174,
+            766,
+            823,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hoogeboom, E., Peters, J. W. T., Cohen, T. S., and Welling, M. HexaConv. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kipf, T. N. and Welling, M. Semi-Supervised Classification with Graph Convolutional Networks. In ICLR, 2017. ",
+        "bbox": [
+            174,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kondor, R., Lin, Z., and Trivedi, S. Clebsch-gordan nets: a fully fourier space spherical convolutional neural network. In NIPS, 2018. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kostrikov, I., Jiang, Z., Panozzo, D., Zorin, D., and Bruna, J. Surface networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2540–2548, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lai, Y.-K., Jin, M., Xie, X., He, Y., Palacios, J., Zhang, E., Hu, S.-M., and Gu, X. Metric-driven rosy field design and remeshing. IEEE Transactions on Visualization and Computer Graphics, 16(1): 95–108, 2009. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Lang, L. and Weiler, M. A Wigner-Eckart Theorem for Group Equivariant Convolution Kernels. arXiv preprint arXiv:2010.10952, 2020. ",
+        "bbox": [
+            169,
+            193,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Maron, H., Galun, M., Aigerman, N., Trope, M., Dym, N., Yumer, E., Kim, V. G., and Lipman, Y. Convolutional neural networks on surfaces via seamless toric covers. ACM Trans. Graph., 36(4): 71–1, 2017. ",
+        "bbox": [
+            173,
+            232,
+            825,
+            276
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Masci, J., Boscaini, D., Bronstein, M. M., and Vandergheynst, P. Geodesic convolutional neural networks on riemannian manifolds. ICCVW, 2015. ",
+        "bbox": [
+            171,
+            285,
+            825,
+            315
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Monti, F., Boscaini, D., Masci, J., Rodola, E., Svoboda, J., and Bronstein, M. M. Geometric deep \\` learning on graphs and manifolds using mixture model cnns. CoRR, abs/1611.08402, 2016. URL http://arxiv.org/abs/1611.08402. ",
+        "bbox": [
+            173,
+            324,
+            823,
+            367
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Perraudin, N., Defferrard, M., Kacprzak, T., and Sgier, R. Deepsphere: Efficient spherical convolutional neural network with healpix sampling for cosmological applications. Astronomy and Computing, 27:130–146, 2019. ",
+        "bbox": [
+            174,
+            376,
+            825,
+            420
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Poulenard, A. and Ovsjanikov, M. Multi-directional geodesic neural networks via equivariant convolution. ACM Transactions on Graphics, 2018. ",
+        "bbox": [
+            169,
+            428,
+            825,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qi, C. R., Su, H., Mo, K., and Guibas, L. J. Pointnet: Deep learning on point sets for 3d classification and segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 652–660, 2017a. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Qi, C. R., Yi, L., Su, H., and Guibas, L. J. Pointne $^ { + + }$ : Deep hierarchical feature learning on point sets in a metric space. In Advances in neural information processing systems, pp. 5099–5108, 2017b. ",
+        "bbox": [
+            173,
+            520,
+            825,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Riegler, G., Osman Ulusoy, A., and Geiger, A. Octnet: Learning deep 3d representations at high resolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 3577–3586, 2017. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            614
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Schonsheck, S. C., Dong, B., and Lai, R. Parallel Transport Convolution: A New Tool for Convolutional Neural Networks on Manifolds. arXiv:1805.07857 [cs, math, stat], May 2018. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            655
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Serre, J.-P. Linear representations of finite groups. 1977. ",
+        "bbox": [
+            173,
+            662,
+            547,
+            679
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sosnovik, I., Szmaja, M., and Smeulders, A. Scale-equivariant steerable networks. In International Conference on Learning Representations (ICLR), 2020. ",
+        "bbox": [
+            173,
+            688,
+            825,
+            718
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sun, Z., Rooke, E., Charton, J., He, Y., Lu, J., and Baek, S. Zernet: Convolutional neural networks on arbitrary surfaces via zernike local tangent space estimation. arXiv preprint arXiv:1812.01082, 2018. ",
+        "bbox": [
+            176,
+            727,
+            825,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tchapmi, L., Choy, C., Armeni, I., Gwak, J., and Savarese, S. Segcloud: Semantic segmentation of 3d point clouds. In 2017 international conference on 3D vision (3DV), pp. 537–547. IEEE, 2017. ",
+        "bbox": [
+            169,
+            779,
+            825,
+            809
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas, N., Smidt, T., Kearnes, S., Yang, L., Li, L., Kohlhoff, K., and Riley, P. Tensor Field Networks: Rotation- and Translation-Equivariant Neural Networks for 3D Point Clouds. 2018. ",
+        "bbox": [
+            173,
+            818,
+            825,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tombari, F., Salti, S., and Di Stefano, L. Unique signatures of histograms for local surface description. In European conference on computer vision, pp. 356–369. Springer, 2010. ",
+        "bbox": [
+            174,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tu, L. W. Differential geometry: connections, curvature, and characteristic classes, volume 275. Springer, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Verma, N., Boyer, E., and Verbeek, J. Feastnet: Feature-steered graph convolutions for 3d shape analysis. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2598–2606, 2018.   \nWeiler, M. and Cesa, G. General E(2)-equivariant steerable CNNs. In Conference on Neural Information Processing Systems (NeurIPS), 2019. URL https://arxiv.org/abs/1911. 08251.   \nWeiler, M., Geiger, M., Welling, M., Boomsma, W., and Cohen, T. 3D Steerable CNNs: Learning Rotationally Equivariant Features in Volumetric Data. In NeurIPS, 2018a.   \nWeiler, M., Hamprecht, F. A., and Storath, M. Learning steerable filters for rotation equivariant CNNs. In Conference on Computer Vision and Pattern Recognition (CVPR), 2018b.   \nWiersma, R., Eisemann, E., and Hildebrandt, K. CNNs on Surfaces using Rotation-Equivariant Features. Transactions on Graphics, 39(4), July 2020. doi: 10.1145/3386569.3392437.   \nWinkels, M. and Cohen, T. S. 3D G-CNNs for pulmonary nodule detection. In Conference on Medical Imaging with Deep Learning (MIDL), 2018.   \nWorrall, D. and Welling, M. Deep scale-spaces: Equivariance over scale. In Conference on Neural Information Processing Systems (NeurIPS), 2019.   \nWorrall, D. E. and Brostow, G. J. Cubenet: Equivariance to 3D rotation and translation. In European Conference on Computer Vision (ECCV), 2018.   \nWorrall, D. E., Garbin, S. J., Turmukhambetov, D., and Brostow, G. J. Harmonic Networks: Deep Translation and Rotation Equivariance. In CVPR, 2017.   \nWu, Z., Song, S., Khosla, A., Yu, F., Zhang, L., Tang, X., and Xiao, J. 3d shapenets: A deep representation for volumetric shapes. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 1912–1920, 2015.   \nZhao, F., Xia, S., Wu, Z., Duan, D., Wang, L., Lin, W., Gilmore, J. H., Shen, D., and Li, G. Spherical u-net on cortical surfaces: Methods and applications. CoRR, abs/1904.00906, 2019a. URL http://arxiv.org/abs/1904.00906.   \nZhao, Y., Birdal, T., Lenssen, J. E., Menegatti, E., Guibas, L., and Tombari, F. Quaternion equivariant capsule networks for 3d point clouds. arXiv preprint arXiv:1912.12098, 2019b. ",
+        "bbox": [
+            171,
+            93,
+            828,
+            604
+        ],
+        "page_idx": 11
+    }
+]

parse/train/K6y77KRUowQ/K6y77KRUowQ.md

@@ -0,0 +1,288 @@
+# Towards Multi-Grained Explainability for Graph Neural Networks
+
+Xiang Wang§†‡, Ying-Xin Wu§, An Zhang†, Xiangnan $\mathbf { H e } ^ { \ S } ;$ ∗, Tat-Seng Chua†
+
+‡Sea-NExT Joint Lab †National University of Singapore §University of Science and Technology of China xiangwang@u.nus.edu, wuyxin@mail.ustc.edu.cn, an_zhang@nus.edu.sg xiangnanhe@gmail.com, dcscts@nus.edu.sg
+
+# Abstract
+
+When a graph neural network (GNN) made a prediction, one raises question about explainability: “Which fraction of the input graph is most influential to the model’s decision?” Producing an answer requires understanding the model’s inner workings in general and emphasizing the insights on the decision for the instance at hand. Nonetheless, most of current approaches focus only on one aspect: (1) local explainability, which explains each instance independently, thus hardly exhibits the class-wise patterns; and (2) global explainability, which systematizes the globally important patterns, but might be trivial in the local context. This dichotomy limits the flexibility and effectiveness of explainers greatly. A performant paradigm towards multi-grained explainability is until-now lacking and thus a focus of our work. In this work, we exploit the pre-training and fine-tuning idea to develop our explainer and generate multi-grained explanations. Specifically, the pre-training phase accounts for the contrastivity among different classes, so as to highlight the class-wise characteristics from a global view; afterwards, the fine-tuning phase adapts the explanations in the local context. Experiments on both synthetic and real-world datasets show the superiority of our explainer, in terms of AUC on explaining graph classification over the leading baselines. Our codes and datasets are available at https://github.com/Wuyxin/ReFine.
+
+# 1 Introduction
+
+While graph neural networks (GNNs) [1, 2] have achieved great success in a variety of applications, they usually come as black-box models. The general problem about GNN explainability [3] is to answer “What knowledge does the model use to arrive at the conclusions in general and the specific decision at hand?”. Thoroughly answering this question requires the global understanding of the model’s inner workings and the local insights on a specific instance. Take a GNN model for molecular property prediction as an example. The global understanding exhibits the knowledge encoded in the model, such as the distribution of the chemical groups; meanwhile, the local insight identifies certain chemical groups responsible for a given molecule’s property. Such multi-grained explainability flexibly and reliably inspects the decision-making process of the GNN [4, 5], which is critical to the applications on safety, fairness, and privacy [6, 7].
+
+In the field of GNN explainability [8], explainer models broadly attribute model prediction to the input graph, then sample a salient subgraph as the explanation for the model prediction. However, most of current explainers focus on either on local [9, 10, 6, 11, 12] or global explainability [13, 7], thereby suffer from inherent limitations correspondingly:
+
+![](images/02a09bd0ed0a22a1739882174903150d6e2fca645f0e80d594763f96870881bd.jpg)  
+Figure 1: Explanations on Visual Genome dataset generated from ReFine, including the pre-training and fine-tuning phases. Right indicates the changes before and after the fine-tuning.
+
+• Local explainability aims to customize the explanatory subgraph for each instance individually. However, such local explanations fall short in systematizing the prototypical patterns shared within a class or group of instances. Thus, they lack the global understanding of the model’s workings [7, 13], which is vital to generalize to other instances being explained. • Global explainability targets at the globally important patterns across multiple instances, which could violate the local fidelity [14] — the globally important substructure may not be important or even appear in the local context, thus might fail to explain a specific instance reliably.
+
+Briefly put, these approaches overlook the multi-granularity nature of explainability, while we argue that the local and global explainability should be exhibited simultaneously to obtain faithful explanations. Taking Figure 1 as an example, the global explainability differentiates the explanations for various classes, such as livestock-background subgraphs for the farm class, human-sports subgraphs for the stadium class. When zooming in a specific scene graph, the local explainability refines on the farm-wise patterns and specifies (sheep, on, meadow) as the final explanation. A paradigm towards such multi-grained explainability is until-now lacking, to the best of our knowledge.
+
+Towards multi-grained explainability, we propose a novel explainer, ReFine, with pre-training and fine-tuning [15, 16] techniques for explaining GNN models. Specifically, pre-training aims to answer “What class-wise knowledge does the GNN leverage to make predictions in general?”. We combine the contrastive learning [17, 18] into class-wise generative probabilistic models [7], thereby approach coarser-grained explanations (i.e. saliency maps of all edges). Going beyond the global view, fine-tuning is to answer “Why the GNN model made the certain prediction for the instance at hand?”, where we upgrade the coarser-grained explanations to the finer-grained explanations (i.e. explanatory subgraphs of salient edges). Through this way, ReFine can faithfully generate multigrained explanations, and we empirically show its effectiveness as compared to some state-of-the-art explainers [9, 6, 7, 19]. It is also worth mentioning that, although the general understanding of GNN predictions has been considered in a recent work PGExplainer [7], it is only exploited to train a generative probabilistic model shared across all the explained instances, rather than dissecting and modeling the class-wise knowledge explicitly. Overall, our contributions are summarized as:
+
+• We investigate the local explainability and global explainability for explaining GNNs and put forward the concept of multi-grained explainability. • We propose a pre-training and fine-tuning framework to generate multi-grained explanations, which has both global understanding of model workings and local insights on specific instances. • We achieve state-of-the-art performance on various datasets w.r.t. predictive accuracy on explaining GNNs. Quantitative and qualitative results verify multi-granularity explainability of ReFine.
+
+# 2 Background & Task Formulation
+
+In this section, we begin with the backgrounds on GNNs and frame the task of generating multigrained explainability for GNN models.
+
+![](images/b65a07bdea6282bc06afa60e008f186a18124de65faa901d9e96c15a6cb5298b.jpg)  
+Figure 2: Model construction of proposed ReFine. Left represents the pre-training phase for a graph example, which is labeled and predicted as “Cycle”, from the BA-3motif dataset. Right demonstrates the fine-tuning process where the saliency map is fine-tuned on the instance to achieve local fidelity.
+
+Graph Neural Networks. We denote the graph data as $\mathcal { G } = ( \nu , \mathcal { E } )$ with the node set $\nu$ and the edge set $\mathcal { E }$ . The structural feature of a graph can be represented by an adjacency matrix $\mathbf { A } \in \{ 0 , 1 \} ^ { | \mathcal { V } | \times | \mathcal { V } | }$ where $A _ { i j } = 1$ indicates an edge starting from node $i$ to node $j$ , and $A _ { i j } = 0$ otherwise. The node feature matrix is represented as $\mathbf { X } \in \mathbb { R } ^ { | \nu | \times d }$ .
+
+Graph neural networks (GNNs) [1, 2] aim to generate powerful representation on graphs in an end-to-end fashion. Such representation facilitates the downstream tasks, such as node classification [20, 21], link prediction [22, 23, 24, 25], and graph classification [26]. Without loss of generality, we consider a graph classifier $f : \mathbb { G } \to \mathbb { R } ^ { \bar { C } }$ , which classifies an input graph $\mathcal { G } \in \mathbb { G }$ in $C$ categories and outputs prediction by $c = \arg \operatorname* { m a x } _ { i } f ( \mathcal { G } ) _ { i }$ . Typically, $f$ consists of three components: (1) learning of node representations, which distills vectorized information from neighboring nodes and updates node representations recursively; (2) learning of graph representation, which aggregates the node representations to establish the representation for the holistic graph; (3) graph classification, which maps the graph representation into the probability distribution of different categories.
+
+Explaining Graph Neural Networks. The explainer model (aka. the explanation method) usually performs two consecutive operations: (1) feature attribution [27, 28], which associates each feature of an input $\mathcal { G } \in \mathbb { G }$ with the relevance score for the classifier’s prediction; (2) feature selection [29, 6], which extracts salient features based on the relevance scores to construct an explanatory subgraph. The subgraph is regarded as the evidence for the GNN to make the prediction.
+
+We follow previous works [6, 7, 10, 19] and focus on the contributions of the structural features (i.e. edges). Our explainer consists of two components: an attribution module $\tau$ for edge attribution and a selection module $\mathcal { H }$ for edge selection. Specifically, $\tau$ assigns the adjacency matrix $\mathbf { A }$ with a saliency map, i.e.
+
+$$
+\mathbf { M } = { \mathcal { T } } ( { \mathcal { G } } , f , c ) ,
+$$
+
+where $\mathbf { M } \in \mathbb { R } ^ { | \mathcal { V } | \times | \mathcal { V } | }$ , each element of which is the importance score of the edge to the prediction class $c$ . Such saliency map can further result in an attentive graph $\mathcal { G } _ { a t t } = \mathbf { A } \odot \mathbf { M }$ . Then, the selection module $\mathcal { H }$ identifies the edges of explanatory subgraph based on the attentive graph:
+
+$$
+\mathbf { S } = \mathcal { H } ( \mathcal { G } _ { a t t } , f , c , \rho ) ,
+$$
+
+where $\mathbf { S } \in \mathbb { R } ^ { | \mathcal { V } | \times | \mathcal { V } | }$ constructs the explanatory subgraph $\mathcal { G } _ { e x p } = \mathbf { A } \odot \mathbf { S }$ , and $\rho$ is the explanation budget [27] that equals to the number of nonzero elements in $\mathbf { s }$ .
+
+# 3 Methodology
+
+Here we present our explainer that purses multi-grained explainability by pre-training and fine-tuning, as Figure 2 shows. In the pre-training phase, the attribution module distills the class-wise knowledge, which contrasts the salient structures based on the prediction, answering the question “Why did the GNN model assign a group of graphs with the same prediction?”. In the next phase, the selection module goes beyond the class-wise knowledge and fine-tunes the saliency maps on a specific instance for answering “Why the GNN model made the certain prediction for the specific graph?”.
+
+# 3.1 Pre-training Towards Global Explainability
+
+Class-aware Attribution Module. Towards the global explainability of GNN, it is important to specify the class-wise knowledge across the instances with the same prediction. Inspired by the success of generative models [7, 30, 31] in capturing the succinct structures from the graphs, we hire multiple generative probabilistic models [7] as our attribution models (short for attributor), i.e. $\mathcal { T } _ { \theta } = \{ \mathcal { T } ^ { ( c ) } | c = 1 , \cdots , C \}$ which is parameterized by $\theta$ . The attributor $\mathcal { T } ^ { \left( c \right) }$ is responsible for uncovering the hidden patterns from some graph instances $O ^ { ( c ) } = \{ \mathcal { G } | c = \arg \operatorname* { m a x } _ { i } f ( \mathcal { G } ) _ { i } \}$ with the same prediction class $c$ .
+
+Formally, each attributor $\mathcal { T } ^ { \left( c \right) }$ is composed of a GNN encoder $\mathrm { G N N } ^ { ( c ) }$ and a MLP decoder $\mathbf { M L P } ^ { ( c ) }$ , whose parameters are shared when explaining graphs in $\mathcal { O } ^ { ( c ) }$ , so as to systematize the class-wise patterns. Next we introduce the construction of each class-wise attributor, while we omit the superscript for conciseness. Specifically, the encoder GNN embeds each node $i$ in $\mathcal { G }$ with representation $\mathbf { z } _ { i }$ and summarize the representations of all nodes as:
+
+$$
+\mathbf { Z } = \mathbf { G N N } ( { \mathcal { G } } , \mathbf { X } ) ,
+$$
+
+where $\mathbf { Z } \in \mathbb { R } ^ { | \nu | \times d ^ { \prime } }$ encodes the structural feature $\mathbf { A }$ and node feature $\mathbf { X }$ . On the top of the node representations, we model the graph structure as edge distributions and frame the generation of explanatory subgraphs by sampling from the edge distributions:
+
+$$
+P ( \mathbf { M } | \mathbf { Z } ) = \prod _ { ( i , j ) \in \mathcal { E } } P ( M _ { i j } | \mathbf { z } _ { i } , \mathbf { z } _ { j } ) ,
+$$
+
+where $M _ { i j }$ indicates the importance of edge $( i , j )$ . Then the MLP encoder takes the concatenation of node representations $\mathbf { z } _ { i }$ and $\mathbf { z } _ { j }$ as the inputs and outputs the importance score. To approximate the importance score to the discrete distribution and optimize the generator via gradient propagation, we adopt the reparameterization trick [7], where an independent random variable $\epsilon \sim \mathrm { U n i f o r m } ( 0 , 1 )$ is introduced. As such, the edge probability is formulated as:
+
+$$
+P ( M _ { i j } | \mathbf { z } _ { i } , \mathbf { z } _ { j } ) = \sigma ( ( \log \frac { \epsilon } { 1 - \epsilon } + \alpha _ { i j } ) / \beta ) , \quad \mathrm { w i t h } \quad \alpha _ { i j } = \mathbf { M L P } ( [ \mathbf { z } _ { i } , \mathbf { z } _ { j } ] ) ,
+$$
+
+where $\sigma$ is the sigmoid function, and $\beta$ denotes the temperature hyperparameter. It is worth emphasizing that our attributors is different from PGExplainer [7], where only one generative probabilistic model is involved. Thus, their attribution results are limited in differentiating the patterns of different classes and systematizing the class-wise knowledge.
+
+Pre-training Class-wise Attribution Module. We devise the following objective function for training the class-wise attributors.
+
+$$
+\operatorname* { m i n } _ { \theta } \mathcal { L } _ { 1 } + \gamma \mathcal { L } _ { c t s } ,
+$$
+
+where $\gamma$ is the trade-off hyperparameter. We start from maximizing the mutual information between the attentive graphs and the target prediction of the graph, which is a widely-used learning paradigm in the literature [32, 6, 7]. It guides us to find the prediction-relevant explanatory subgraph, which equals to minimizing the following loss:
+
+$$
+\mathcal { L } _ { 1 } = - \mathbb { E } _ { \mathcal { G } } \mathbb { E } _ { \epsilon } \mathbb { E } _ { c ^ { \prime } } [ P ( Y = c ^ { \prime } | G = \mathcal { G } ) \log P ( Y = c ^ { \prime } | G = \mathcal { G } _ { a t t } ^ { ( c ) } ) ] ,
+$$
+
+where $G$ and $Y$ are the graph and prediction variables, respectively; $\mathcal { G }$ is the full graph instance to explain; by sampling $\epsilon \in { \mathrm { U n i f o r m } } ( 0 , 1 )$ and $c ^ { \prime } \in \{ 1 , \cdots , C \}$ , the class-wise saliency map $\mathbf { M } ^ { ( c ) }$ can be generated from Equation (4); $P ( Y = c ^ { \prime } | G = \mathcal { G } ) = f ( \mathcal { G } ) _ { c ^ { \prime } }$ is the output probabilities of the prediction being $c ^ { \prime }$ when feeding $\mathcal { G }$ to the GNN model $f$ ; analogously, $P ( Y = c ^ { \prime } | G = \mathcal { G } _ { a t t } ^ { ( c ) } ) =$ $f ( \mathcal { G } _ { a t t } ^ { ( c ) } ) _ { c ^ { \prime } }$ audits the output probability when feeding $\mathcal { G } _ { a t t } ^ { ( c ) } = \mathbf { A } \odot \mathbf { M } ^ { ( c ) }$ .
+
+Moreover, we introduce a contrastive learning [33, 34, 18, 35, 36, 37] loss to emphasize differences among the class-wise patterns — the substructure of the full graph that is distant to that of the graphs with a different prediction but close to that of the graphs with the same prediction. It makes each attributor focus on the unique and discriminative information within the class. Specifically, for the saliency maps $\mathcal { G } _ { a t t 1 } ^ { ( c _ { 1 } ) }$ of $\mathcal { G } _ { 1 }$ and $\mathcal { G } _ { a t t 2 } ^ { ( c _ { 2 } ) }$ of $\mathcal { G } _ { 2 }$ , it encourages the agreements between $\mathcal { G } _ { a t t 1 } ^ { ( c _ { 1 } ) }$ and $\mathcal { G } _ { a t t 2 } ^ { ( c _ { 2 } ) }$ when , compared to that when $c _ { 1 } \neq c _ { 2 }$ :
+
+$$
+\mathcal { L } _ { c t s } = \mathbb { E } _ { \mathcal { G } , \mathcal { G } ^ { \prime } } \mathbb { E } _ { \epsilon , \epsilon ^ { \prime } } [ ( - 1 ) ^ { \mathbb { I } ( c _ { 1 } = c _ { 2 } ) } \times \mu ( \ell ( \mathcal { G } _ { a t t 1 } ^ { ( c _ { 1 } ) } , \mathcal { G } _ { a t t 2 } ^ { ( c _ { 2 } ) } ) ) ] ,
+$$
+
+where as the $\mu$ is the softplus function [3presentation similarity — $\ell$ arity bewhere een two subgraphs, which is setis the graph representations by $\ell ( \mathcal { G } _ { a t t 1 } ^ { ( c _ { 1 } ) } , \mathcal { G } _ { a t t 2 } ^ { ( c _ { 2 } ) } ) = \mathbf { h } _ { 1 } ^ { \top } \mathbf { h } _ { 2 }$ $\mathbf { h } _ { 1 }$   
+feeding G(c1)att1 into the encoder $\mathrm { G N N } ^ { ( c _ { 1 } ) }$ and aggregating the node representations. Similar for $\mathbf { h } _ { 2 }$ . In addition, following [6], we adopt the element-wise entropy and $L _ { 1 }$ norm on the edge probability. By jointly optimizing these two losses in Equation (6), the class-wise attribution module learns to stratify the discriminative information for different classes and generate the saliency maps with a global view of the target GNN. Taking an information-theoretical look at Equation (8), minimizing contrastive learning loss is maximizing a lower bound of the mutual information between the latent graph representations of two graphs within the same class.
+
+# 3.2 Fine-tuning Towards Local Explainability
+
+Having established the saliency map that exhibits the importance of each edge, the standard way is to rank all edges based on their importance scores and simply select the top edges as the explanatory subgraphs. However, we argue that such a coarser-grained selection fails to consider the dependencies of these selected edges explicitly. Within a high-quality explanatory subgraph, edges are supposed to cooperate with each other, form the coalition, and approach the target prediction better than individuals [38, 39]. Without considering such coalition effect, the quality of the explanatory subgraph is greatly limited.For example, when explaining why the molecule graph is classified as mutagenic [13], two connected nitrogen-oxygen (N-O) bonds form a chemical group $\mathrm { N O _ { 2 } }$ and present more discriminative information about the mutagenic property [13]; whereas, two salient but disconnected N-O bonds from different chemical groups are less informative to interpret the mutagenic property.
+
+Clearly, the coarser-grained saliency maps are insufficient to exhibit the coalition effect of edges, thus might be redundant and suboptimal explanations. Hence, we move forward to learn a finer-grained explanatory subgraph. Technically, on the top of the well-trained class-wise attribution module, we add the selection module:
+
+$$
+\mathbf { S } ^ { ( c ) } = \mathcal { H } ( \mathcal { G } _ { a t t } ^ { ( c ) } , f , c , \rho ) ,
+$$
+
+where $\rho$ is the number of edges selected in the explanatory subgraph; $\mathcal { H }$ is a sampling (selection) function; $\mathbf { S } ^ { ( c ) }$ preserves the elements selected by the selection function and sets the other elements as 0. Instead of the hard selection that picks up the edges with the highest probability, $\mathcal { H }$ samples edges according to their probabilities. Allowing edges with low probabilities to be sampled can prevent the explainer from collapsing to suboptimal solutions with limited coalition effect.
+
+With the new stochastic adjacency matrix $\mathbf { S } ^ { ( c ) }$ , we are able to extract the subgraph $\mathcal { G } _ { e x p } ^ { ( c ) }$ . To fine-tune the attribution and selection modules, we resort to maximize the mutual information between the explanation candidate $\mathcal { G } _ { e x p } ^ { ( c ) }$ and the target prediction of the full graph:
+
+$$
+\mathcal { L } _ { 2 } = - \mathbb { E } _ { \mathcal { G } } \mathbb { E } _ { \epsilon } \mathbb { E } _ { c ^ { \prime } } [ P ( Y = c ^ { \prime } | G = \mathcal { G } ) \log P ( Y = c ^ { \prime } | G = \mathcal { G } _ { e x p } ^ { ( c ) } ) ] .
+$$
+
+By optimizing the loss above, the selection module accounts for the edge coalition within $\mathbf { S } ^ { ( c ) }$ , so as to achieve higher local fidelity. Moreover, as the selection module discards some elements in the stochastic adjacency matrix, it blocks parts of gradient backpropagation and possibly acts as a dropout function to avoid the overfitting on the instance-level explanations.
+
+# 4 Experiments
+
+We mainly aim to investigate the following questions:
+
+• RQ1: How effective is the pre-training phase of ReFine, as compared to that of existing methods? • RQ2: How effective is the fine-tuning phase of ReFine, as compared to that of the pre-training phase?
+
+# 4.1 Experimental Settings
+
+Datasets and Target GNNs. We consider four datasets with various target GNNs:
+
+• Molecule graph classification. We use the Mutagenicity dataset [40, 41], where 4, 337 molecule graphs are classified into two classes based on their mutagenic effect on a bacterium. The welltrained Graph Isomorphism Network (GIN) [26, 42] has achieved a $100 \%$ testing accuracy.
+
+• Scene graph classification. Following the previous work [10], we select 4, 443 (images, scene graphs) pairs from Visual Genome [43] to construct the VG-5 dataset. Wherein, the graphs are labeled with five classes: stadium, street, farm, surfing, forest. Each graph contains regions of the objects as the nodes, while edges indicates the relationships between object nodes. The target GNN is an APPNP [44] which achieves $6 4 . 3 \%$ testing accuracy.
+
+• Handwriting graph classification. We use the MNIST superpixel dataset [45], which converts 70,000 images into the graphs of superpixel adjacency. Every graph is labeled as one of ten digit classes. We trained a Spline-based GNN [46] which gains $9 7 . 9 \%$ accuracy in the testing dataset.
+
+• Motif graph classification. We follow prior studies [6, 7] to create a synthetic dataset, BA-3motif, which contains 3,000 graphs. Specifically, we adopt the Barabasi-Albert (BA) graphs as the base, and attach each base with one of three motifs: house, cycle, grid. The trained GNN model, ASAP [47], classifies them according to the type of attached motifs and achieved $100 \%$ testing accuracy.
+
+Baselines. We compare our ReFine with the state-of-the-art explanation methods:
+
+• SA [9] directly uses the gradients of the model prediction w.r.t. the adjacency matrix of the input graph as the importance of edges.   
+• GNNExplainer [6] applies the soft masks on the messages carried by edges, where each mask indicates an edge’s importance. Note that the masks of graph instances are trained individually.   
+• PGExplainer [7] hires a neural network to learn to generate the masks for the input edges. The generative model is trained over multiple explained instances.   
+• PGM-Explainer [19] collects the prediction change on the random node perturbations, and then learns a Bayesian network from these perturbation-prediction observations, so as to capture the dependencies among the nodes and the prediction. Here we transfer it to model the edge importance.
+
+Optimization. For the parametric explanation methods (GNNExplainer, PGExplainer, PGMExplainer), we apply a grid search to tune their own hyperparameters. For our ReFine framework, we use the Adam optimizer and set the learning rate of pre-training and fine-tuning as 1e-3 and 1e-4, respectively. All experiments are done on a single Tesla V100 SXM2 GPU (32 GB).
+
+Evaluation Metrics. It is challenging to quantitatively evaluate the quality of explanations, since the ground-truth explanations are usually unavailable. In the literature, there are three widely-used evaluation metrics:
+
+• Predictive Accuracy $( \mathbf { A C C } @ \rho )$ [32, 48, 27]. It measures the fidelity of the explanatory subgraphs by feeding it solely into the target model and auditing how well it recovers the target prediction. We report the average $\operatorname { A C C } @ \rho$ over all graphs in the testing sets, and further denote ACC-AUC as the area under the ACC curve over different selection ratios $\rho \in \{ 0 . 1 , 0 . 2 , \cdot \cdot \cdot , 0 . 9 , 1 . 0 \}$ . $\operatorname { A C C } @ \rho$ and ACC-AUC are suitable for all the datasets.
+
+• Recall $@ N$ . As suggested in prior studies [6, 7, 32], we can create the “ground-truth explanations” for the synthetic dataset. Specifically, for BA-3motif, the motif of each graph can be viewed as the discriminative information coherent in the model knowledge. As such, we can frame the evaluation problem as the task of top edge ranking. To be more specific, for an explanatory subgraph, the edges within the motif are positive, while the others are negative. To this end, recall can be adopted as the evaluation protocols. More formally, Recall $\ @ N = \mathbb { E } _ { \boldsymbol { \mathcal { G } } } [ | \mathcal { G } _ { s } \cap \mathcal { G } _ { s } ^ { * } | / | \mathcal { G } _ { s } ^ { * } | ]$ where $\mathcal { G } _ { s }$ is composed of the top- $N$ edges and $\mathcal { G } _ { s } ^ { * }$ is the ground-truth explanatory subgraph.
+
+# 4.2 Quantitative Evaluations
+
+Influence of Pre-training (RQ1). To investigate the effectiveness of pre-training, we first compare the performance of the attribution module with the state-of-the-art explainers. We denote this variant by ReFine-FT, which disables the fine-tuning phase and simply constructs the explanatory subgraphs based on the saliency scores. Moreover, we build another variant ReFine-CT, which removes the contrastive loss (Equation (8)) from the pre-training phase, to study the effect of the contrastive loss on the class-wise knowledge modeling. To be more clear, we present the difference of PGExplainer [7], ReFine and its ablation models in Table 4.2. Table 2 presents the performance comparisons, from which we have several findings:
+
+Table 1: Structure/Training Difference of PGExplainer, ReFine and its ablation models.   
+
+<table><tr><td rowspan="2"></td><td colspan="2">Pre-training</td><td rowspan="2">Fine-tuning</td></tr><tr><td>Class-wise Attributors</td><td>Contrastive Learning</td></tr><tr><td>PG-Explainer</td><td></td><td></td><td></td></tr><tr><td>Refine-CT</td><td></td><td></td><td></td></tr><tr><td>Refine-FT</td><td></td><td></td><td></td></tr><tr><td>Refine</td><td></td><td></td><td></td></tr></table>
+
+Table 2: Comparison of our ReFine and other baseline explainers   
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Mutagenicity ACC-AUC</td><td rowspan="2">VG-5 ACC-AUC</td><td rowspan="2">MNIST ACC-AUC</td><td colspan="2">BA-3motif</td></tr><tr><td>ACC-AUC</td><td>Recall@5</td></tr><tr><td>SA</td><td>0.769</td><td>0.769</td><td>0.559</td><td>0.518</td><td>0.243</td></tr><tr><td>GNNExplainer</td><td>0.895±0.010</td><td>0.895±0.003</td><td>0.535±0.013</td><td>0.528±0.005</td><td>0.157±0.002</td></tr><tr><td>PG-Explainer</td><td>0.631±0.008</td><td>0.790±0.004</td><td>0.504±0.010</td><td>0.586±0.004</td><td>0.293±0.001</td></tr><tr><td>PGM-Explainer</td><td>0.714±0.007</td><td>0.792±0.001</td><td>0.615±0.003</td><td>0.575±0.002</td><td>0.250±0.000</td></tr><tr><td>ReFine-CT</td><td>0.888±0.008</td><td>0.891±0.002</td><td>0.526±0.007</td><td>0.610±0.004</td><td>0.248±0.001</td></tr><tr><td>ReFine-FT</td><td>0.945±0.011</td><td>0.906±0.002</td><td>0.587±0.008</td><td>0.616±0.003</td><td>0.299±0.002</td></tr><tr><td>ReFine</td><td>0.955±0.005</td><td>0.914±0.001</td><td>0.636±0.003</td><td>0.630±0.006</td><td>0.304±0.000</td></tr><tr><td>Relative Impro.</td><td>6.7%</td><td>2.1%</td><td>3.4%</td><td>7.5%</td><td>3.8%</td></tr></table>
+
+• ReFine-FT outperforms the baseline explainers in most cases. To be more specific, it achieves significant relative improvements over the strongest baselines w.r.t. ACC-AUC by $5 . 6 \%$ and $5 . 1 \%$ in Mutagenicity and BA-3motif, respectively. This demonstrates the rationality and effectiveness of the attribution module. We attribute these improvements to the class-wise knowledge modeling: (1) By specifying the attributor models for each class, ReFine-FT is able to capture the underlying patterns shared across the instances within the same class; and (2) Conducting the contrastive learning between different class-aware attributors makes ReFine-FT better stratify the discriminative information for different classes. The class-wise knowledge endows ReFine-FT with the global view of the target model’s workings.   
+• Although PGExplainer is also equipped with the global view of the target model, its performance is worse than that of ReFine-FT. We ascribe this to the limitations of PGExplainer’s global view, which is founded upon all the explained instances, but fails to differentiate the class-wise patterns. This again verifies the rationality and effectiveness of our attribution module.   
+• ReFine-FT outperforms ReFine-CT by a large margin, indicating that the contrastive learning plays a critical role in exhibiting the class-wise knowledge. Specifically, it summarizes the patterns across similar instances and focuses on the information pertinent to specific classes, while filtering the irrelevant and redundant information out.   
+• Interestingly, in MNIST, the result of ReFine-FT is worse than that of PGM-Explainer. One possible reason is that the random perturbations in PGM-Explainer create a collection of broken graphs and offer a more comprehensive observation of the graphs. We leave the exploration of subgraph-prediction relations as future work.
+
+Influence of Fine-tuning (RQ2). To justify the effectiveness of the fine-tuning phase, we report the performance of ReFine with our selection module in Tables 2 and 3, as compared to the performance before fine-tuning. We have the following observations:
+
+Table 3: Performance under different selection ratios before and after fine-tuning.   
+
+<table><tr><td rowspan="2">ACC@p</td><td colspan="2">Mutagenicity</td><td colspan="2">VG-5</td><td colspan="2">MNIST</td><td colspan="2">BA-3motif</td></tr><tr><td>0.4</td><td>0.6</td><td>0.4</td><td>0.6</td><td>0.4</td><td>0.6</td><td>0.4</td><td>0.6</td></tr><tr><td>ReFine-FT</td><td>96.8%</td><td>94.0%</td><td>91.3%</td><td>91.4%</td><td>41.4%</td><td>61.4%</td><td>36.0%</td><td>65.7%</td></tr><tr><td>ReFine</td><td>97.8%</td><td>96.2%</td><td>92.2%</td><td>93.4%</td><td>71.4%</td><td>82.0%</td><td>39.0%</td><td>72.8%</td></tr><tr><td>Improvement</td><td>+1.0%</td><td>+2.2%</td><td>+0.9%</td><td>+2.0%</td><td>+30.0%</td><td>+20.6%</td><td>+3.0%</td><td>+7.1%</td></tr></table>
+
+![](images/958274b79d85bbe255779c56ef47bf505530dc4c10daaa10196febf0acb858d1.jpg)  
+Figure 3: Qualitative Results in MNIST Superpixels dataset. Handwriting graphs are in black, which respectively represent number $\mathbf { \bar { \theta } } ^ { 6 6 } 0 ^ { 9 }$ , $^ { \cdot 6 } 2 ^ { \cdot }$ , “8” within each block from left to right. Explanatory graphs are in red, where the top $10 \%$ edges are highlighted.
+
+• Fine-tuning with the selection module can improves the explanation performance sustainably, which indicates the effectiveness of our pre-training and fine-tuning paradigm. Specifically, in MNIST, the predictive accuracy of the explanations after fine-tuning improves from $4 1 . 4 \%$ to $7 1 . 4 \%$ when the selection rato is 0.4. We attribute these improvements to the local insights on specific instances: (1) Benefiting from the saliency map obtained in the pre-training phase, the selection module is able to filter noisy edges out and narrow down to where the target model looks to make decisions; (2) Fine-tuning the explanatory subgraphs considers the coalition effect of edges, thus approaches more information to recover the target prediction.
+
+• Jointly analyzing Tables 2 and 3, ReFine consistently outperforms all baselines across the four datasets. Advantageous to the local or global explanations, our multi-grained explanations not only have the global understanding of model workings (i.e. the class-wise knowledge), but also account for the local insights on specific instances (i.e. the coalition effect of edges in the local context). It illustrates the superiority of our ReFine paradigm.
+
+Overall, the empirical supports justify the significance of fine-tuning well. The contributions of fine-tuning w.r.t. the overall improvements over PG-Explainer are $3 7 . 1 \%$ and $3 1 . 8 \%$ in MNIST and BA-3motif datasets, respectively. One possible reason that fine-tuning contributes only $3 . 1 \%$ and $6 . 4 \%$ portion of overall improvements in Mutagenicity and VG-5 as compared to PG-Explainer is the existance of rich node features in these two datasets. With the assistance of node features, the global patterns might be well-captured durining pre-training, thus leaving little space for the local patterns to improve.
+
+# 4.3 Qualitative Analysis
+
+We present the qualitative results on MNIST superpixel in Figure 3, where the pre-trained and fine-tuned explanations are the explanatory subgraphs before fine-tuning (i.e. extracted based on the saliency map) and after fine-tuning (i.e. derived from the selection module), respectively.
+
+Influence of Pre-training (RQ1). The pre-trained results (first row) well demonstrate the global patterns, where the explanatory subgraphs for interpreting the digit $\mathbf { \bar { \theta } } ^ { 6 } 0 ^ { 9 }$ focus more on the edges between hollows in the middle and the fringe of the number. While interpreting the prediction $\mathbf { \Delta } ^ { 6 6 } 5 ^ { 9 }$ , the explanations identify the edges spread on the bend of the number as the most important features. Also, we observe an interesting pattern in the results for explaining the prediction $\mathbf { \vec { \nu } } ^ { 6 } \mathbf { \vec { 8 } } ^ { 5 }$ , where the background edges draw more attention, rather than edges relevant to the digits, revealing the evidence for the target GNN to classify. It also shows the supporting evidence of the difference between the model explanation and the human explanation which focuses more on the digit graphs other than the background graphs. Through the pre-trained examples, the global patterns offer vital model understanding and inspections for the model’s decision-making process.
+
+![](images/8c34ecf09b54fdf74ebfd5cd63461ec1c88fb307e8163089a1d2617a59c7f5bb.jpg)  
+Figure 4: Qualitative Results in Mutagenicity dataset. The prediction of the molecule in the first row is mutagenic, while the molecule in the second row is predicted as non-mutagenic. The selection ratios range from $10 \%$ to $50 \%$ . Note that some opposite edges are visually coincident.
+
+Table 4: Time costs (in second) of GNNExplainer, PG-Explainer and the fine-tuning phase of Refine.   
+
+<table><tr><td></td><td>Mutagenicity</td><td>VG-5</td><td>MNIST</td><td>BA-3motif</td></tr><tr><td>GNNExplainer</td><td>2.03</td><td>1.88</td><td>0.637</td><td>1.11</td></tr><tr><td>PG-Explainer</td><td>0.030</td><td>0.035</td><td>0.040</td><td>0.032</td></tr><tr><td>Refine(Fine-tuning)</td><td>0.821</td><td>0.583</td><td>0.535</td><td>0.423</td></tr></table>
+
+Influence of Fine-tuning (RQ2). We now compare the pre-trained and fine-tuned explanations. Clearly, the fine-tuned explanatory graphs make clearer boundaries on the instances. The explanation adapted with the user-defined ratio pays greater attention to details that are only applicable to the specific instances. For example, one can take a closer look at the explanations in the 4-th column. Without the fine-tuning phase, the explanation may distracted by the edges across the digit and the background, such that these transition edges might be deemed as the most important features while achieve suboptimal predictive accuracies. In contrast, the fine-tuned explanation dispels such misunderstanding, with a higher local accuracy. Similar patterns can be found in other examples.
+
+The qualitative results on Mutagenicity are presented in Figure 4, where each explanation has been fine-tuned on the corresponding ratio. We can see the flexibility on ReFine, which enables the fine-tuning on a specific user-defined ratio. With the selection ratio increases, the class probability output by the target GNN is generally stable or further improved. Moreover, the fine-tuning phase focuses more on the combination of features, with the constraint of selection ratio, to purse the higher accuracy rather than intercepting on a ranking based on the static edge importance, which is only valid under the addictive feature assumption [32].
+
+# 4.4 Discussions
+
+Efficiency for Generating Explanations. The inference time [7] to explain a new instance by the pre-trained ReFine is the same as PGExplainer under the same attributor construction. Different from GNNExplainer which has to retrain the model for each graph, ReFine only needs a few finetuning steps on the pre-trained model (20 steps on average). Thus, ReFine can gain a boosting performance for explaining graphs while remaining efficient in terms of time complexity. Specifically, we summarize the time costs in the Table 4. Clearly, our ReFine is more efficient than GNNExplainer and is computationally comparable to PG-Explainer.
+
+Limitations. Although ReFine can well-encode the class-wise knowledge by learning the parameters of multiple attributors, it can hardly map such knowledge to the structure representation as XGNN [13]. This limits the human understanding on the core of input data via a conciseness substructure.
+
+# 5 Related Work
+
+We consider two classes of related work for GNNs explainability: studies on local explainability, which independently explain for each input graph without referring to other knowledge, e.g., training data; studies on global explainability, which provide explanations for multiple instances with the guide of the model-level or class-level knowledge. See [49, 8, 50] for more overviews.
+
+• Local Explainability. In general, there are two research lines. (1) Non-parametric explanation methods [10, 9, 11] use some heuristics as the feature contributions of a specific instance, without involving additional trainable models. Gradient-like scores [10, 9, 11] are wisely-used heuristics, which is obtained by backpropagating the model prediction or loss to the input features, such as adjacency matrix [10], along with the model architecture. (2) Parametric explanation methods [6, 19, 51, 52] additionally train a parametrized explainer model to generate the saliency maps or explanatory subgraphs for individual instances. The explainer model is typically optimized towards local fidelity [32, 48, 27], which uses the explanations to recover the target predictions. For example, GNNExplainer [6] learns soft masks for an instance and applies them on the adjacency matrix. PGM-Explainer [19] trains an Bayesian network upon the pairs of graph perturbations and prediction changes. However, these methods fall short in capturing the prototypical patterns shared within the same groups or classes.
+
+• Global Explainability. This direction is less explored compared to the local explainability of GNNs [8]. To provide a global understanding of the model prediction, PGExplainer [7] formulates the generation of multiple explanations based on its collective and inductive property, and designs the attributor as a deep neural network whose parameters are shared across the explained instances. XGNN [13] explains GNNs by training a graph generator, which outputs class-wise graph patterns to explain this class. As it is designed to explain the holistic class, making it hardly applicable on an specific instance, e.g., the graph patterns may not even exit on the instance.
+
+# 6 Conclusion and Future Work
+
+Multi-grained explainability promises to offer a flexible and all-round inspection of deep models’ decision-making, which has been less explored in the literature. Motivated by this, we proposed a novel generative probabilistic model, ReFine, to approach the multi-granularity explainability via pre-training and fine-tuning. To exhibit global explanations with the prototypical patterns, the pre-training phase is founded upon the class-aware attribution modules and distills the class-level knowledge by contrastive learning. When given a specific instance, the fine-tuning phase further adapts the global explanations in the local context with high fidelity. In the fashion of pre-training and fine-tuning, we can generate explanations with both global patterns and local features. Extensive results in four datasets show that our method indeed improves the quality of explanatory subgraphs.
+
+As future direction, we consider the extension of ReFine to fulfill the counterfactual explanation [53], which answers ‘Why the target GNN model made a certain prediction, rather than another prediction?”, to enrich the multi-granularity explainability. Further, multi-grained explainability can be exhibited to explore the model robustness and heuristically guide the model construction.
+
+# Acknowledgments and Disclosure of Funding
+
+Funding in direct support of this work: the Sea-NExT Joint Lab, Singapore MOE AcRF T2; the National Natural Science Foundation of China (U19A2079, 62121002); the National Key Research and Development Program of China (2020YFB1406703).
+
+# References
+
+[1] Vijay Prakash Dwivedi, Chaitanya K. Joshi, Thomas Laurent, Yoshua Bengio, and Xavier Bresson. Benchmarking graph neural networks. CoRR, abs/2003.00982, 2020.
+
+[2] Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and Philip S. Yu. A comprehensive survey on graph neural networks. TNNLS, 32(1):4–24, 2021.   
+[3] Shruthi Chari, Daniel M. Gruen, Oshani Seneviratne, and Deborah L. McGuinness. Directions for explainable knowledge-enabled systems. In Knowledge Graphs for eXplainable Artificial Intelligence: Foundations, Applications and Challenges, pages 245–261. 2020.   
+[4] Christopher J. Anders, Plamen Pasliev, Ann-Kathrin Dombrowski, Klaus-Robert Müller, and Pan Kessel. Fairwashing explanations with off-manifold detergent. In ICML, pages 314–323, 2020.   
+[5] Sebastian Lapuschkin, Stephan Wäldchen, Alexander Binder, Grégoire Montavon, Wojciech Samek, and Klaus-Robert Müller. Unmasking clever hans predictors and assessing what machines really learn. Nature communications, 10(1):1–8, 2019.   
+[6] Zhitao Ying, Dylan Bourgeois, Jiaxuan You, Marinka Zitnik, and Jure Leskovec. Gnnexplainer: Generating explanations for graph neural networks. In NeurIPS, pages 9240–9251, 2019.   
+[7] Dongsheng Luo, Wei Cheng, Dongkuan Xu, Wenchao Yu, Bo Zong, Haifeng Chen, and Xiang Zhang. Parameterized explainer for graph neural network. In NeurIPS, 2020.   
+[8] Hao Yuan, Haiyang Yu, Shurui Gui, and Shuiwang Ji. Explainability in graph neural networks: A taxonomic survey. CoRR, abs/2012.15445, 2020.   
+[9] Federico Baldassarre and Hossein Azizpour. Explainability techniques for graph convolutional networks. CoRR, abs/1905.13686, 2019.   
+[10] Phillip E. Pope, Soheil Kolouri, Mohammad Rostami, Charles E. Martin, and Heiko Hoffmann. Explainability methods for graph convolutional neural networks. In CVPR, pages 10772–10781, 2019.   
+[11] Thomas Schnake, Oliver Eberle, Jonas Lederer, Shinichi Nakajima, K. T. Schutt, Klaus-Robert Muller, and Grégoire Montavon. Higher-order explanations of graph neural networks via relevant walks. arXiv, 2020.   
+[12] Michael Sejr Schlichtkrull, Nicola De Cao, and Ivan Titov. Interpreting graph neural networks for NLP with differentiable edge masking. CoRR, abs/2010.00577, 2020.   
+[13] Hao Yuan, Jiliang Tang, Xia Hu, and Shuiwang Ji. XGNN: towards model-level explanations of graph neural networks. In Rajesh Gupta, Yan Liu, Jiliang Tang, and B. Aditya Prakash, editors, KDD, pages 430–438, 2020.   
+[14] Marco Túlio Ribeiro, Sameer Singh, and Carlos Guestrin. "why should I trust you?": Explaining the predictions of any classifier. In KDD, pages 1135–1144, 2016.   
+[15] Jeremy Howard and Sebastian Ruder. Universal language model fine-tuning for text classification. In ACL, pages 328–339, 2018.   
+[16] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   
+[17] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey E. Hinton. A simple framework for contrastive learning of visual representations. In ICML, volume 119, pages 1597–1607, 2020.   
+[18] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross B. Girshick. Momentum contrast for unsupervised visual representation learning. In CVPR, pages 9726–9735, 2020.   
+[19] Minh N. Vu and My T. Thai. Pgm-explainer: Probabilistic graphical model explanations for graph neural networks. In NeurIPS, 2020.   
+[20] Hongyang Gao and Shuiwang Ji. Graph u-nets. In ICML, volume 97, pages 2083–2092, 2019.
+
+[21] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´ Bengio. Graph attention networks. ICLR, 2018.   
+[22] William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NeurIPS, pages 1024–1034, 2017.   
+[23] Xiang Wang, Xiangnan He, Meng Wang, Fuli Feng, and Tat-Seng Chua. Neural graph collaborative filtering. In SIGIR, pages 165–174, 2019.   
+[24] Xiang Wang, Xiangnan He, Yixin Cao, Meng Liu, and Tat-Seng Chua. KGAT: knowledge graph attention network for recommendation. In KDD, pages 950–958, 2019.   
+[25] Xiangnan He, Kuan Deng, Xiang Wang, Yan Li, Yong-Dong Zhang, and Meng Wang. Lightgcn: Simplifying and powering graph convolution network for recommendation. In SIGIR, pages 639–648, 2020.   
+[26] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In ICLR, 2019.   
+[27] Ian Covert, Scott Lundberg, and Su-In Lee. Feature removal is a unifying principle for model explanation methods. In NeurIPS, 2020.   
+[28] Marco Ancona, Enea Ceolini, Cengiz Öztireli, and Markus Gross. Towards better understanding of gradient-based attribution methods for deep neural networks. In ICLR, 2018.   
+[29] Constantin F Aliferis, Alexander Statnikov, Ioannis Tsamardinos, Subramani Mani, and Xenofon D Koutsoukos. Local causal and markov blanket induction for causal discovery and feature selection for classification part i: Algorithms and empirical evaluation. JMLR, 11(1), 2010.   
+[30] Peter D Hoff, Adrian E Raftery, and Mark S Handcock. Latent space approaches to social network analysis. Journal of the american Statistical association, 97(460):1090–1098, 2002.   
+[31] Max Welling Thomas N. Kipf. Variational graph auto-encoders. In NeurIPS Workshops, 2016.   
+[32] Jianbo Chen, Le Song, Martin J. Wainwright, and Michael I. Jordan. Learning to explain: An information-theoretic perspective on model interpretation. In ICML, pages 882–891, 2018.   
+[33] Lukas Faber, Amin K Moghaddam, and Roger Wattenhofer. Contrastive graph neural network explanation. 2021.   
+[34] R. Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Philip Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019.   
+[35] Fan-Yun Sun, Jordan Hoffmann, Vikas Verma, and Jian Tang. Infograph: Unsupervised and semi-supervised graph-level representation learning via mutual information maximization. In ICLR, 2020.   
+[36] Yuning You, Tianlong Chen, Yongduo Sui, Ting Chen, Zhangyang Wang, and Yang Shen. Graph contrastive learning with augmentations. In NeurIPS, 2020.   
+[37] Jiancan Wu, Xiang Wang, Fuli Feng, Xiangnan He, Liang Chen, Jianxun Lian, and Xing Xie. Self-supervised graph learning for recommendation. In SIGIR, pages 726–735, 2021.   
+[38] Christopher Frye, Damien de Mijolla, Laurence Cowton, Megan Stanley, and Ilya Feige. Shapley-based explainability on the data manifold. In ICLR, 2021.   
+[39] H. W. Kuhn and A. W. Tucker. Contributions to the theory of games, volume 2. Princeton University Press, 1953.   
+[40] Jeroen Kazius, Ross McGuire, and Roberta Bursi. Derivation and validation of toxicophores for mutagenicity prediction. Journal of medicinal chemistry, 48(1):312–320, 2005.   
+[41] Kaspar Riesen and Horst Bunke. Iam graph database repository for graph based pattern recognition and machine learning. In SPR and SSPR, pages 287–297, 2008.   
+[42] Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay S. Pande, and Jure Leskovec. Strategies for pre-training graph neural networks. In ICLR, 2020.   
+[43] Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A. Shamma, Michael S. Bernstein, and Li Fei-Fei. Visual genome: Connecting language and vision using crowdsourced dense image annotations. IJCV, 123(1):32–73, 2017.   
+[44] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In ICLR, 2019.   
+[45] Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodolà, Jan Svoboda, and Michael M. Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In CVPR, pages 5425–5434, 2017.   
+[46] Matthias Fey, Jan Eric Lenssen, Frank Weichert, and Heinrich Müller. Splinecnn: Fast geometric deep learning with continuous b-spline kernels. In CVPR, pages 869–877, 2018.   
+[47] Ekagra Ranjan, Soumya Sanyal, and Partha P. Talukdar. ASAP: adaptive structure aware pooling for learning hierarchical graph representations. In AAAI, pages 5470–5477, 2020.   
+[48] Jian Liang, Bing Bai, Yuren Cao, Kun Bai, and Fei Wang. Adversarial infidelity learning for model interpretation. In KDD, pages 286–296, 2020.   
+[49] Hao Yuan, Haiyang Yu, Shurui Gui, and Shuiwang Ji. Explainability in graph neural networks: A taxonomic survey. CoRR, 2020.   
+[50] Thomas Schnake, Oliver Eberle, Jonas Lederer, Shinichi Nakajima, Kristof T. Schütt, KlausRobert Müller, and Grégoire Montavon. XAI for graphs: Explaining graph neural network predictions by identifying relevant walks. CoRR, abs/2006.03589, 2020.   
+[51] Hao Yuan, Haiyang Yu, Jie Wang, Kang Li, and Shuiwang Ji. On explainability of graph neural networks via subgraph explorations. ArXiv, 2021.   
+[52] Patrick Schwab and Walter Karlen. Cxplain: Causal explanations for model interpretation under uncertainty. In NeurIPS, pages 10220–10230, 2019.   
+[53] Raha Moraffah, Mansooreh Karami, Ruocheng Guo, Adrienne Raglin, and Huan Liu. Causal interpretability for machine learning-problems, methods and evaluation. SIGKDD Explorations, 22(1):18–33, 2020.

parse/train/K6y77KRUowQ/K6y77KRUowQ_content_list.json

@@ -0,0 +1,1229 @@
+[
+    {
+        "type": "text",
+        "text": "Towards Multi-Grained Explainability for Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            200,
+            122,
+            797,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xiang Wang§†‡, Ying-Xin Wu§, An Zhang†, Xiangnan $\\mathbf { H e } ^ { \\ S } ;$ ∗, Tat-Seng Chua† ",
+        "bbox": [
+            228,
+            220,
+            769,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "‡Sea-NExT Joint Lab †National University of Singapore §University of Science and Technology of China xiangwang@u.nus.edu, wuyxin@mail.ustc.edu.cn, an_zhang@nus.edu.sg xiangnanhe@gmail.com, dcscts@nus.edu.sg ",
+        "bbox": [
+            228,
+            238,
+            769,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            344,
+            535,
+            361
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "When a graph neural network (GNN) made a prediction, one raises question about explainability: “Which fraction of the input graph is most influential to the model’s decision?” Producing an answer requires understanding the model’s inner workings in general and emphasizing the insights on the decision for the instance at hand. Nonetheless, most of current approaches focus only on one aspect: (1) local explainability, which explains each instance independently, thus hardly exhibits the class-wise patterns; and (2) global explainability, which systematizes the globally important patterns, but might be trivial in the local context. This dichotomy limits the flexibility and effectiveness of explainers greatly. A performant paradigm towards multi-grained explainability is until-now lacking and thus a focus of our work. In this work, we exploit the pre-training and fine-tuning idea to develop our explainer and generate multi-grained explanations. Specifically, the pre-training phase accounts for the contrastivity among different classes, so as to highlight the class-wise characteristics from a global view; afterwards, the fine-tuning phase adapts the explanations in the local context. Experiments on both synthetic and real-world datasets show the superiority of our explainer, in terms of AUC on explaining graph classification over the leading baselines. Our codes and datasets are available at https://github.com/Wuyxin/ReFine. ",
+        "bbox": [
+            233,
+            375,
+            764,
+            623
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            647,
+            310,
+            665
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "While graph neural networks (GNNs) [1, 2] have achieved great success in a variety of applications, they usually come as black-box models. The general problem about GNN explainability [3] is to answer “What knowledge does the model use to arrive at the conclusions in general and the specific decision at hand?”. Thoroughly answering this question requires the global understanding of the model’s inner workings and the local insights on a specific instance. Take a GNN model for molecular property prediction as an example. The global understanding exhibits the knowledge encoded in the model, such as the distribution of the chemical groups; meanwhile, the local insight identifies certain chemical groups responsible for a given molecule’s property. Such multi-grained explainability flexibly and reliably inspects the decision-making process of the GNN [4, 5], which is critical to the applications on safety, fairness, and privacy [6, 7]. ",
+        "bbox": [
+            174,
+            679,
+            825,
+            818
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In the field of GNN explainability [8], explainer models broadly attribute model prediction to the input graph, then sample a salient subgraph as the explanation for the model prediction. However, most of current explainers focus on either on local [9, 10, 6, 11, 12] or global explainability [13, 7], thereby suffer from inherent limitations correspondingly: ",
+        "bbox": [
+            174,
+            824,
+            825,
+            880
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/02a09bd0ed0a22a1739882174903150d6e2fca645f0e80d594763f96870881bd.jpg",
+        "image_caption": [
+            "Figure 1: Explanations on Visual Genome dataset generated from ReFine, including the pre-training and fine-tuning phases. Right indicates the changes before and after the fine-tuning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            89,
+            820,
+            252
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Local explainability aims to customize the explanatory subgraph for each instance individually. However, such local explanations fall short in systematizing the prototypical patterns shared within a class or group of instances. Thus, they lack the global understanding of the model’s workings [7, 13], which is vital to generalize to other instances being explained. • Global explainability targets at the globally important patterns across multiple instances, which could violate the local fidelity [14] — the globally important substructure may not be important or even appear in the local context, thus might fail to explain a specific instance reliably. ",
+        "bbox": [
+            173,
+            316,
+            826,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Briefly put, these approaches overlook the multi-granularity nature of explainability, while we argue that the local and global explainability should be exhibited simultaneously to obtain faithful explanations. Taking Figure 1 as an example, the global explainability differentiates the explanations for various classes, such as livestock-background subgraphs for the farm class, human-sports subgraphs for the stadium class. When zooming in a specific scene graph, the local explainability refines on the farm-wise patterns and specifies (sheep, on, meadow) as the final explanation. A paradigm towards such multi-grained explainability is until-now lacking, to the best of our knowledge. ",
+        "bbox": [
+            173,
+            434,
+            825,
+            531
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Towards multi-grained explainability, we propose a novel explainer, ReFine, with pre-training and fine-tuning [15, 16] techniques for explaining GNN models. Specifically, pre-training aims to answer “What class-wise knowledge does the GNN leverage to make predictions in general?”. We combine the contrastive learning [17, 18] into class-wise generative probabilistic models [7], thereby approach coarser-grained explanations (i.e. saliency maps of all edges). Going beyond the global view, fine-tuning is to answer “Why the GNN model made the certain prediction for the instance at hand?”, where we upgrade the coarser-grained explanations to the finer-grained explanations (i.e. explanatory subgraphs of salient edges). Through this way, ReFine can faithfully generate multigrained explanations, and we empirically show its effectiveness as compared to some state-of-the-art explainers [9, 6, 7, 19]. It is also worth mentioning that, although the general understanding of GNN predictions has been considered in a recent work PGExplainer [7], it is only exploited to train a generative probabilistic model shared across all the explained instances, rather than dissecting and modeling the class-wise knowledge explicitly. Overall, our contributions are summarized as: ",
+        "bbox": [
+            173,
+            537,
+            825,
+            717
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We investigate the local explainability and global explainability for explaining GNNs and put forward the concept of multi-grained explainability. • We propose a pre-training and fine-tuning framework to generate multi-grained explanations, which has both global understanding of model workings and local insights on specific instances. • We achieve state-of-the-art performance on various datasets w.r.t. predictive accuracy on explaining GNNs. Quantitative and qualitative results verify multi-granularity explainability of ReFine. ",
+        "bbox": [
+            171,
+            729,
+            826,
+            829
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Background & Task Formulation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            483,
+            867
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we begin with the backgrounds on GNNs and frame the task of generating multigrained explainability for GNN models. ",
+        "bbox": [
+            173,
+            882,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/b65a07bdea6282bc06afa60e008f186a18124de65faa901d9e96c15a6cb5298b.jpg",
+        "image_caption": [
+            "Figure 2: Model construction of proposed ReFine. Left represents the pre-training phase for a graph example, which is labeled and predicted as “Cycle”, from the BA-3motif dataset. Right demonstrates the fine-tuning process where the saliency map is fine-tuned on the instance to achieve local fidelity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            89,
+            823,
+            193
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks. We denote the graph data as $\\mathcal { G } = ( \\nu , \\mathcal { E } )$ with the node set $\\nu$ and the edge set $\\mathcal { E }$ . The structural feature of a graph can be represented by an adjacency matrix $\\mathbf { A } \\in \\{ 0 , 1 \\} ^ { | \\mathcal { V } | \\times | \\mathcal { V } | }$ where $A _ { i j } = 1$ indicates an edge starting from node $i$ to node $j$ , and $A _ { i j } = 0$ otherwise. The node feature matrix is represented as $\\mathbf { X } \\in \\mathbb { R } ^ { | \\nu | \\times d }$ . ",
+        "bbox": [
+            173,
+            271,
+            825,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Graph neural networks (GNNs) [1, 2] aim to generate powerful representation on graphs in an end-to-end fashion. Such representation facilitates the downstream tasks, such as node classification [20, 21], link prediction [22, 23, 24, 25], and graph classification [26]. Without loss of generality, we consider a graph classifier $f : \\mathbb { G } \\to \\mathbb { R } ^ { \\bar { C } }$ , which classifies an input graph $\\mathcal { G } \\in \\mathbb { G }$ in $C$ categories and outputs prediction by $c = \\arg \\operatorname* { m a x } _ { i } f ( \\mathcal { G } ) _ { i }$ . Typically, $f$ consists of three components: (1) learning of node representations, which distills vectorized information from neighboring nodes and updates node representations recursively; (2) learning of graph representation, which aggregates the node representations to establish the representation for the holistic graph; (3) graph classification, which maps the graph representation into the probability distribution of different categories. ",
+        "bbox": [
+            173,
+            337,
+            825,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Explaining Graph Neural Networks. The explainer model (aka. the explanation method) usually performs two consecutive operations: (1) feature attribution [27, 28], which associates each feature of an input $\\mathcal { G } \\in \\mathbb { G }$ with the relevance score for the classifier’s prediction; (2) feature selection [29, 6], which extracts salient features based on the relevance scores to construct an explanatory subgraph. The subgraph is regarded as the evidence for the GNN to make the prediction. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We follow previous works [6, 7, 10, 19] and focus on the contributions of the structural features (i.e. edges). Our explainer consists of two components: an attribution module $\\tau$ for edge attribution and a selection module $\\mathcal { H }$ for edge selection. Specifically, $\\tau$ assigns the adjacency matrix $\\mathbf { A }$ with a saliency map, i.e. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            607
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d09c0afee350ea5fca06045b6fc3e21e3cfd1bbbbcbf169126c196d260d45ca7.jpg",
+        "text": "$$\n\\mathbf { M } = { \\mathcal { T } } ( { \\mathcal { G } } , f , c ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            619,
+            553,
+            637
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { M } \\in \\mathbb { R } ^ { | \\mathcal { V } | \\times | \\mathcal { V } | }$ , each element of which is the importance score of the edge to the prediction class $c$ . Such saliency map can further result in an attentive graph $\\mathcal { G } _ { a t t } = \\mathbf { A } \\odot \\mathbf { M }$ . Then, the selection module $\\mathcal { H }$ identifies the edges of explanatory subgraph based on the attentive graph: ",
+        "bbox": [
+            173,
+            650,
+            825,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/efe39b908e86ccb5a0e9723f7e3b51522495546498c375c2cfc5fc317a8a4688.jpg",
+        "text": "$$\n\\mathbf { S } = \\mathcal { H } ( \\mathcal { G } _ { a t t } , f , c , \\rho ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            707,
+            568,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { S } \\in \\mathbb { R } ^ { | \\mathcal { V } | \\times | \\mathcal { V } | }$ constructs the explanatory subgraph $\\mathcal { G } _ { e x p } = \\mathbf { A } \\odot \\mathbf { S }$ , and $\\rho$ is the explanation budget [27] that equals to the number of nonzero elements in $\\mathbf { s }$ . ",
+        "bbox": [
+            173,
+            737,
+            825,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Methodology ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            313,
+            810
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here we present our explainer that purses multi-grained explainability by pre-training and fine-tuning, as Figure 2 shows. In the pre-training phase, the attribution module distills the class-wise knowledge, which contrasts the salient structures based on the prediction, answering the question “Why did the GNN model assign a group of graphs with the same prediction?”. In the next phase, the selection module goes beyond the class-wise knowledge and fine-tunes the saliency maps on a specific instance for answering “Why the GNN model made the certain prediction for the specific graph?”. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Pre-training Towards Global Explainability ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            90,
+            514,
+            106
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Class-aware Attribution Module. Towards the global explainability of GNN, it is important to specify the class-wise knowledge across the instances with the same prediction. Inspired by the success of generative models [7, 30, 31] in capturing the succinct structures from the graphs, we hire multiple generative probabilistic models [7] as our attribution models (short for attributor), i.e. $\\mathcal { T } _ { \\theta } = \\{ \\mathcal { T } ^ { ( c ) } | c = 1 , \\cdots , C \\}$ which is parameterized by $\\theta$ . The attributor $\\mathcal { T } ^ { \\left( c \\right) }$ is responsible for uncovering the hidden patterns from some graph instances $O ^ { ( c ) } = \\{ \\mathcal { G } | c = \\arg \\operatorname* { m a x } _ { i } f ( \\mathcal { G } ) _ { i } \\}$ with the same prediction class $c$ . ",
+        "bbox": [
+            173,
+            116,
+            826,
+            218
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, each attributor $\\mathcal { T } ^ { \\left( c \\right) }$ is composed of a GNN encoder $\\mathrm { G N N } ^ { ( c ) }$ and a MLP decoder $\\mathbf { M L P } ^ { ( c ) }$ , whose parameters are shared when explaining graphs in $\\mathcal { O } ^ { ( c ) }$ , so as to systematize the class-wise patterns. Next we introduce the construction of each class-wise attributor, while we omit the superscript for conciseness. Specifically, the encoder GNN embeds each node $i$ in $\\mathcal { G }$ with representation $\\mathbf { z } _ { i }$ and summarize the representations of all nodes as: ",
+        "bbox": [
+            173,
+            223,
+            826,
+            296
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9bc120f64f56efe32b3e7dd6d5524e642c7fc0c4cb806e898cb65847d69d5f9d.jpg",
+        "text": "$$\n\\mathbf { Z } = \\mathbf { G N N } ( { \\mathcal { G } } , \\mathbf { X } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            437,
+            305,
+            558,
+            321
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { Z } \\in \\mathbb { R } ^ { | \\nu | \\times d ^ { \\prime } }$ encodes the structural feature $\\mathbf { A }$ and node feature $\\mathbf { X }$ . On the top of the node representations, we model the graph structure as edge distributions and frame the generation of explanatory subgraphs by sampling from the edge distributions: ",
+        "bbox": [
+            173,
+            332,
+            825,
+            376
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ea882c84bd7431668a232260600690fe7f50db0ff4229792444715824c8b6912.jpg",
+        "text": "$$\nP ( \\mathbf { M } | \\mathbf { Z } ) = \\prod _ { ( i , j ) \\in \\mathcal { E } } P ( M _ { i j } | \\mathbf { z } _ { i } , \\mathbf { z } _ { j } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            382,
+            609,
+            420
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $M _ { i j }$ indicates the importance of edge $( i , j )$ . Then the MLP encoder takes the concatenation of node representations $\\mathbf { z } _ { i }$ and $\\mathbf { z } _ { j }$ as the inputs and outputs the importance score. To approximate the importance score to the discrete distribution and optimize the generator via gradient propagation, we adopt the reparameterization trick [7], where an independent random variable $\\epsilon \\sim \\mathrm { U n i f o r m } ( 0 , 1 )$ is introduced. As such, the edge probability is formulated as: ",
+        "bbox": [
+            173,
+            428,
+            825,
+            498
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f6b15af9448dbb43c574a4c397ef4c29fc437d28ea10f7eb8bb1c6ade6ba6f62.jpg",
+        "text": "$$\nP ( M _ { i j } | \\mathbf { z } _ { i } , \\mathbf { z } _ { j } ) = \\sigma ( ( \\log \\frac { \\epsilon } { 1 - \\epsilon } + \\alpha _ { i j } ) / \\beta ) , \\quad \\mathrm { w i t h } \\quad \\alpha _ { i j } = \\mathbf { M L P } ( [ \\mathbf { z } _ { i } , \\mathbf { z } _ { j } ] ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            506,
+            738,
+            535
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ is the sigmoid function, and $\\beta$ denotes the temperature hyperparameter. It is worth emphasizing that our attributors is different from PGExplainer [7], where only one generative probabilistic model is involved. Thus, their attribution results are limited in differentiating the patterns of different classes and systematizing the class-wise knowledge. ",
+        "bbox": [
+            173,
+            541,
+            825,
+            598
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Pre-training Class-wise Attribution Module. We devise the following objective function for training the class-wise attributors. ",
+        "bbox": [
+            171,
+            609,
+            825,
+            638
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f3d4c3d3002f3d85e403dcf6ea11f50aceb36b073183ddf3061c54439e568ca6.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\mathcal { L } _ { 1 } + \\gamma \\mathcal { L } _ { c t s } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            647,
+            555,
+            669
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\gamma$ is the trade-off hyperparameter. We start from maximizing the mutual information between the attentive graphs and the target prediction of the graph, which is a widely-used learning paradigm in the literature [32, 6, 7]. It guides us to find the prediction-relevant explanatory subgraph, which equals to minimizing the following loss: ",
+        "bbox": [
+            173,
+            676,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bf7370324f3dccbaa443d193207257690137791e42060df5278c85ade8e01a29.jpg",
+        "text": "$$\n\\mathcal { L } _ { 1 } = - \\mathbb { E } _ { \\mathcal { G } } \\mathbb { E } _ { \\epsilon } \\mathbb { E } _ { c ^ { \\prime } } [ P ( Y = c ^ { \\prime } | G = \\mathcal { G } ) \\log P ( Y = c ^ { \\prime } | G = \\mathcal { G } _ { a t t } ^ { ( c ) } ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            741,
+            705,
+            762
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $G$ and $Y$ are the graph and prediction variables, respectively; $\\mathcal { G }$ is the full graph instance to explain; by sampling $\\epsilon \\in { \\mathrm { U n i f o r m } } ( 0 , 1 )$ and $c ^ { \\prime } \\in \\{ 1 , \\cdots , C \\}$ , the class-wise saliency map $\\mathbf { M } ^ { ( c ) }$ can be generated from Equation (4); $P ( Y = c ^ { \\prime } | G = \\mathcal { G } ) = f ( \\mathcal { G } ) _ { c ^ { \\prime } }$ is the output probabilities of the prediction being $c ^ { \\prime }$ when feeding $\\mathcal { G }$ to the GNN model $f$ ; analogously, $P ( Y = c ^ { \\prime } | G = \\mathcal { G } _ { a t t } ^ { ( c ) } ) =$ $f ( \\mathcal { G } _ { a t t } ^ { ( c ) } ) _ { c ^ { \\prime } }$ audits the output probability when feeding $\\mathcal { G } _ { a t t } ^ { ( c ) } = \\mathbf { A } \\odot \\mathbf { M } ^ { ( c ) }$ . ",
+        "bbox": [
+            173,
+            768,
+            825,
+            851
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Moreover, we introduce a contrastive learning [33, 34, 18, 35, 36, 37] loss to emphasize differences among the class-wise patterns — the substructure of the full graph that is distant to that of the graphs with a different prediction but close to that of the graphs with the same prediction. It makes each attributor focus on the unique and discriminative information within the class. Specifically, for the saliency maps $\\mathcal { G } _ { a t t 1 } ^ { ( c _ { 1 } ) }$ of $\\mathcal { G } _ { 1 }$ and $\\mathcal { G } _ { a t t 2 } ^ { ( c _ { 2 } ) }$ of $\\mathcal { G } _ { 2 }$ , it encourages the agreements between $\\mathcal { G } _ { a t t 1 } ^ { ( c _ { 1 } ) }$ and $\\mathcal { G } _ { a t t 2 } ^ { ( c _ { 2 } ) }$ when , compared to that when $c _ { 1 } \\neq c _ { 2 }$ : ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            88,
+            823,
+            121
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/974a212003ee1665a58a43a15577521fa4e1fd9930893dd616aac99c64608f8b.jpg",
+        "text": "$$\n\\mathcal { L } _ { c t s } = \\mathbb { E } _ { \\mathcal { G } , \\mathcal { G } ^ { \\prime } } \\mathbb { E } _ { \\epsilon , \\epsilon ^ { \\prime } } [ ( - 1 ) ^ { \\mathbb { I } ( c _ { 1 } = c _ { 2 } ) } \\times \\mu ( \\ell ( \\mathcal { G } _ { a t t 1 } ^ { ( c _ { 1 } ) } , \\mathcal { G } _ { a t t 2 } ^ { ( c _ { 2 } ) } ) ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            127,
+            676,
+            148
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where as the $\\mu$ is the softplus function [3presentation similarity — $\\ell$ arity bewhere een two subgraphs, which is setis the graph representations by $\\ell ( \\mathcal { G } _ { a t t 1 } ^ { ( c _ { 1 } ) } , \\mathcal { G } _ { a t t 2 } ^ { ( c _ { 2 } ) } ) = \\mathbf { h } _ { 1 } ^ { \\top } \\mathbf { h } _ { 2 }$ $\\mathbf { h } _ { 1 }$   \nfeeding G(c1)att1 into the encoder $\\mathrm { G N N } ^ { ( c _ { 1 } ) }$ and aggregating the node representations. Similar for $\\mathbf { h } _ { 2 }$ . In addition, following [6], we adopt the element-wise entropy and $L _ { 1 }$ norm on the edge probability. By jointly optimizing these two losses in Equation (6), the class-wise attribution module learns to stratify the discriminative information for different classes and generate the saliency maps with a global view of the target GNN. Taking an information-theoretical look at Equation (8), minimizing contrastive learning loss is maximizing a lower bound of the mutual information between the latent graph representations of two graphs within the same class. ",
+        "bbox": [
+            173,
+            155,
+            826,
+            287
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Fine-tuning Towards Local Explainability ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            305,
+            504,
+            320
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Having established the saliency map that exhibits the importance of each edge, the standard way is to rank all edges based on their importance scores and simply select the top edges as the explanatory subgraphs. However, we argue that such a coarser-grained selection fails to consider the dependencies of these selected edges explicitly. Within a high-quality explanatory subgraph, edges are supposed to cooperate with each other, form the coalition, and approach the target prediction better than individuals [38, 39]. Without considering such coalition effect, the quality of the explanatory subgraph is greatly limited.For example, when explaining why the molecule graph is classified as mutagenic [13], two connected nitrogen-oxygen (N-O) bonds form a chemical group $\\mathrm { N O _ { 2 } }$ and present more discriminative information about the mutagenic property [13]; whereas, two salient but disconnected N-O bonds from different chemical groups are less informative to interpret the mutagenic property. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Clearly, the coarser-grained saliency maps are insufficient to exhibit the coalition effect of edges, thus might be redundant and suboptimal explanations. Hence, we move forward to learn a finer-grained explanatory subgraph. Technically, on the top of the well-trained class-wise attribution module, we add the selection module: ",
+        "bbox": [
+            173,
+            474,
+            825,
+            531
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33a664f15d0d8f7c2f0570e908ebf7c40bcb58c0c96fb95d55bd611c458e3976.jpg",
+        "text": "$$\n\\mathbf { S } ^ { ( c ) } = \\mathcal { H } ( \\mathcal { G } _ { a t t } ^ { ( c ) } , f , c , \\rho ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            535,
+            576,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\rho$ is the number of edges selected in the explanatory subgraph; $\\mathcal { H }$ is a sampling (selection) function; $\\mathbf { S } ^ { ( c ) }$ preserves the elements selected by the selection function and sets the other elements as 0. Instead of the hard selection that picks up the edges with the highest probability, $\\mathcal { H }$ samples edges according to their probabilities. Allowing edges with low probabilities to be sampled can prevent the explainer from collapsing to suboptimal solutions with limited coalition effect. ",
+        "bbox": [
+            173,
+            563,
+            825,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With the new stochastic adjacency matrix $\\mathbf { S } ^ { ( c ) }$ , we are able to extract the subgraph $\\mathcal { G } _ { e x p } ^ { ( c ) }$ . To fine-tune the attribution and selection modules, we resort to maximize the mutual information between the explanation candidate $\\mathcal { G } _ { e x p } ^ { ( c ) }$ and the target prediction of the full graph: ",
+        "bbox": [
+            174,
+            643,
+            825,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a579a8d95028b363e40986ec53f21b02af1250a08b36e1bf2eb87087eb9a52e8.jpg",
+        "text": "$$\n\\mathcal { L } _ { 2 } = - \\mathbb { E } _ { \\mathcal { G } } \\mathbb { E } _ { \\epsilon } \\mathbb { E } _ { c ^ { \\prime } } [ P ( Y = c ^ { \\prime } | G = \\mathcal { G } ) \\log P ( Y = c ^ { \\prime } | G = \\mathcal { G } _ { e x p } ^ { ( c ) } ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            289,
+            698,
+            709,
+            719
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By optimizing the loss above, the selection module accounts for the edge coalition within $\\mathbf { S } ^ { ( c ) }$ , so as to achieve higher local fidelity. Moreover, as the selection module discards some elements in the stochastic adjacency matrix, it blocks parts of gradient backpropagation and possibly acts as a dropout function to avoid the overfitting on the instance-level explanations. ",
+        "bbox": [
+            173,
+            728,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            805,
+            313,
+            821
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We mainly aim to investigate the following questions: ",
+        "bbox": [
+            173,
+            837,
+            526,
+            852
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• RQ1: How effective is the pre-training phase of ReFine, as compared to that of existing methods? • RQ2: How effective is the fine-tuning phase of ReFine, as compared to that of the pre-training phase? ",
+        "bbox": [
+            171,
+            863,
+            826,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Settings ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            90,
+            367,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets and Target GNNs. We consider four datasets with various target GNNs: ",
+        "bbox": [
+            173,
+            116,
+            712,
+            131
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Molecule graph classification. We use the Mutagenicity dataset [40, 41], where 4, 337 molecule graphs are classified into two classes based on their mutagenic effect on a bacterium. The welltrained Graph Isomorphism Network (GIN) [26, 42] has achieved a $100 \\%$ testing accuracy. ",
+        "bbox": [
+            176,
+            140,
+            823,
+            183
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Scene graph classification. Following the previous work [10], we select 4, 443 (images, scene graphs) pairs from Visual Genome [43] to construct the VG-5 dataset. Wherein, the graphs are labeled with five classes: stadium, street, farm, surfing, forest. Each graph contains regions of the objects as the nodes, while edges indicates the relationships between object nodes. The target GNN is an APPNP [44] which achieves $6 4 . 3 \\%$ testing accuracy. ",
+        "bbox": [
+            174,
+            185,
+            826,
+            255
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Handwriting graph classification. We use the MNIST superpixel dataset [45], which converts 70,000 images into the graphs of superpixel adjacency. Every graph is labeled as one of ten digit classes. We trained a Spline-based GNN [46] which gains $9 7 . 9 \\%$ accuracy in the testing dataset. ",
+        "bbox": [
+            178,
+            258,
+            823,
+            301
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Motif graph classification. We follow prior studies [6, 7] to create a synthetic dataset, BA-3motif, which contains 3,000 graphs. Specifically, we adopt the Barabasi-Albert (BA) graphs as the base, and attach each base with one of three motifs: house, cycle, grid. The trained GNN model, ASAP [47], classifies them according to the type of attached motifs and achieved $100 \\%$ testing accuracy. ",
+        "bbox": [
+            174,
+            305,
+            826,
+            361
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We compare our ReFine with the state-of-the-art explanation methods: ",
+        "bbox": [
+            174,
+            376,
+            709,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• SA [9] directly uses the gradients of the model prediction w.r.t. the adjacency matrix of the input graph as the importance of edges.   \n• GNNExplainer [6] applies the soft masks on the messages carried by edges, where each mask indicates an edge’s importance. Note that the masks of graph instances are trained individually.   \n• PGExplainer [7] hires a neural network to learn to generate the masks for the input edges. The generative model is trained over multiple explained instances.   \n• PGM-Explainer [19] collects the prediction change on the random node perturbations, and then learns a Bayesian network from these perturbation-prediction observations, so as to capture the dependencies among the nodes and the prediction. Here we transfer it to model the edge importance. ",
+        "bbox": [
+            173,
+            398,
+            826,
+            536
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Optimization. For the parametric explanation methods (GNNExplainer, PGExplainer, PGMExplainer), we apply a grid search to tune their own hyperparameters. For our ReFine framework, we use the Adam optimizer and set the learning rate of pre-training and fine-tuning as 1e-3 and 1e-4, respectively. All experiments are done on a single Tesla V100 SXM2 GPU (32 GB). ",
+        "bbox": [
+            174,
+            553,
+            825,
+            608
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics. It is challenging to quantitatively evaluate the quality of explanations, since the ground-truth explanations are usually unavailable. In the literature, there are three widely-used evaluation metrics: ",
+        "bbox": [
+            174,
+            621,
+            825,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Predictive Accuracy $( \\mathbf { A C C } @ \\rho )$ [32, 48, 27]. It measures the fidelity of the explanatory subgraphs by feeding it solely into the target model and auditing how well it recovers the target prediction. We report the average $\\operatorname { A C C } @ \\rho$ over all graphs in the testing sets, and further denote ACC-AUC as the area under the ACC curve over different selection ratios $\\rho \\in \\{ 0 . 1 , 0 . 2 , \\cdot \\cdot \\cdot , 0 . 9 , 1 . 0 \\}$ . $\\operatorname { A C C } @ \\rho$ and ACC-AUC are suitable for all the datasets. ",
+        "bbox": [
+            174,
+            671,
+            826,
+            741
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Recall $@ N$ . As suggested in prior studies [6, 7, 32], we can create the “ground-truth explanations” for the synthetic dataset. Specifically, for BA-3motif, the motif of each graph can be viewed as the discriminative information coherent in the model knowledge. As such, we can frame the evaluation problem as the task of top edge ranking. To be more specific, for an explanatory subgraph, the edges within the motif are positive, while the others are negative. To this end, recall can be adopted as the evaluation protocols. More formally, Recall $\\ @ N = \\mathbb { E } _ { \\boldsymbol { \\mathcal { G } } } [ | \\mathcal { G } _ { s } \\cap \\mathcal { G } _ { s } ^ { * } | / | \\mathcal { G } _ { s } ^ { * } | ]$ where $\\mathcal { G } _ { s }$ is composed of the top- $N$ edges and $\\mathcal { G } _ { s } ^ { * }$ is the ground-truth explanatory subgraph. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Quantitative Evaluations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            858,
+            387,
+            872
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Influence of Pre-training (RQ1). To investigate the effectiveness of pre-training, we first compare the performance of the attribution module with the state-of-the-art explainers. We denote this variant by ReFine-FT, which disables the fine-tuning phase and simply constructs the explanatory subgraphs based on the saliency scores. Moreover, we build another variant ReFine-CT, which removes the contrastive loss (Equation (8)) from the pre-training phase, to study the effect of the contrastive loss on the class-wise knowledge modeling. To be more clear, we present the difference of PGExplainer [7], ReFine and its ablation models in Table 4.2. Table 2 presents the performance comparisons, from which we have several findings: ",
+        "bbox": [
+            173,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/97bdfa23724885b568bd14f541c1b339a8dcf8efe55634ecded98fce01905b18.jpg",
+        "table_caption": [
+            "Table 1: Structure/Training Difference of PGExplainer, ReFine and its ablation models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">Pre-training</td><td rowspan=\"2\">Fine-tuning</td></tr><tr><td>Class-wise Attributors</td><td>Contrastive Learning</td></tr><tr><td>PG-Explainer</td><td></td><td></td><td></td></tr><tr><td>Refine-CT</td><td></td><td></td><td></td></tr><tr><td>Refine-FT</td><td></td><td></td><td></td></tr><tr><td>Refine</td><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            232,
+            109,
+            764,
+            224
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e4e7fcda442fdbd50bec18de2ad571b750e5a9d9e32000c0e09345924e8dd9b.jpg",
+        "table_caption": [
+            "Table 2: Comparison of our ReFine and other baseline explainers "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Mutagenicity ACC-AUC</td><td rowspan=\"2\">VG-5 ACC-AUC</td><td rowspan=\"2\">MNIST ACC-AUC</td><td colspan=\"2\">BA-3motif</td></tr><tr><td>ACC-AUC</td><td>Recall@5</td></tr><tr><td>SA</td><td>0.769</td><td>0.769</td><td>0.559</td><td>0.518</td><td>0.243</td></tr><tr><td>GNNExplainer</td><td>0.895±0.010</td><td>0.895±0.003</td><td>0.535±0.013</td><td>0.528±0.005</td><td>0.157±0.002</td></tr><tr><td>PG-Explainer</td><td>0.631±0.008</td><td>0.790±0.004</td><td>0.504±0.010</td><td>0.586±0.004</td><td>0.293±0.001</td></tr><tr><td>PGM-Explainer</td><td>0.714±0.007</td><td>0.792±0.001</td><td>0.615±0.003</td><td>0.575±0.002</td><td>0.250±0.000</td></tr><tr><td>ReFine-CT</td><td>0.888±0.008</td><td>0.891±0.002</td><td>0.526±0.007</td><td>0.610±0.004</td><td>0.248±0.001</td></tr><tr><td>ReFine-FT</td><td>0.945±0.011</td><td>0.906±0.002</td><td>0.587±0.008</td><td>0.616±0.003</td><td>0.299±0.002</td></tr><tr><td>ReFine</td><td>0.955±0.005</td><td>0.914±0.001</td><td>0.636±0.003</td><td>0.630±0.006</td><td>0.304±0.000</td></tr><tr><td>Relative Impro.</td><td>6.7%</td><td>2.1%</td><td>3.4%</td><td>7.5%</td><td>3.8%</td></tr></table>",
+        "bbox": [
+            196,
+            258,
+            805,
+            421
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            446,
+            825,
+            531
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• ReFine-FT outperforms the baseline explainers in most cases. To be more specific, it achieves significant relative improvements over the strongest baselines w.r.t. ACC-AUC by $5 . 6 \\%$ and $5 . 1 \\%$ in Mutagenicity and BA-3motif, respectively. This demonstrates the rationality and effectiveness of the attribution module. We attribute these improvements to the class-wise knowledge modeling: (1) By specifying the attributor models for each class, ReFine-FT is able to capture the underlying patterns shared across the instances within the same class; and (2) Conducting the contrastive learning between different class-aware attributors makes ReFine-FT better stratify the discriminative information for different classes. The class-wise knowledge endows ReFine-FT with the global view of the target model’s workings.   \n• Although PGExplainer is also equipped with the global view of the target model, its performance is worse than that of ReFine-FT. We ascribe this to the limitations of PGExplainer’s global view, which is founded upon all the explained instances, but fails to differentiate the class-wise patterns. This again verifies the rationality and effectiveness of our attribution module.   \n• ReFine-FT outperforms ReFine-CT by a large margin, indicating that the contrastive learning plays a critical role in exhibiting the class-wise knowledge. Specifically, it summarizes the patterns across similar instances and focuses on the information pertinent to specific classes, while filtering the irrelevant and redundant information out.   \n• Interestingly, in MNIST, the result of ReFine-FT is worse than that of PGM-Explainer. One possible reason is that the random perturbations in PGM-Explainer create a collection of broken graphs and offer a more comprehensive observation of the graphs. We leave the exploration of subgraph-prediction relations as future work. ",
+        "bbox": [
+            171,
+            542,
+            826,
+            852
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Influence of Fine-tuning (RQ2). To justify the effectiveness of the fine-tuning phase, we report the performance of ReFine with our selection module in Tables 2 and 3, as compared to the performance before fine-tuning. We have the following observations: ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b62f2e7dbe160d755f893226c3353455f69903def1ab292aeb65415d3fc3f038.jpg",
+        "table_caption": [
+            "Table 3: Performance under different selection ratios before and after fine-tuning. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">ACC@p</td><td colspan=\"2\">Mutagenicity</td><td colspan=\"2\">VG-5</td><td colspan=\"2\">MNIST</td><td colspan=\"2\">BA-3motif</td></tr><tr><td>0.4</td><td>0.6</td><td>0.4</td><td>0.6</td><td>0.4</td><td>0.6</td><td>0.4</td><td>0.6</td></tr><tr><td>ReFine-FT</td><td>96.8%</td><td>94.0%</td><td>91.3%</td><td>91.4%</td><td>41.4%</td><td>61.4%</td><td>36.0%</td><td>65.7%</td></tr><tr><td>ReFine</td><td>97.8%</td><td>96.2%</td><td>92.2%</td><td>93.4%</td><td>71.4%</td><td>82.0%</td><td>39.0%</td><td>72.8%</td></tr><tr><td>Improvement</td><td>+1.0%</td><td>+2.2%</td><td>+0.9%</td><td>+2.0%</td><td>+30.0%</td><td>+20.6%</td><td>+3.0%</td><td>+7.1%</td></tr></table>",
+        "bbox": [
+            196,
+            109,
+            805,
+            205
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/958274b79d85bbe255779c56ef47bf505530dc4c10daaa10196febf0acb858d1.jpg",
+        "image_caption": [
+            "Figure 3: Qualitative Results in MNIST Superpixels dataset. Handwriting graphs are in black, which respectively represent number $\\mathbf { \\bar { \\theta } } ^ { 6 6 } 0 ^ { 9 }$ , $^ { \\cdot 6 } 2 ^ { \\cdot }$ , “8” within each block from left to right. Explanatory graphs are in red, where the top $10 \\%$ edges are highlighted. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            219,
+            820,
+            366
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Fine-tuning with the selection module can improves the explanation performance sustainably, which indicates the effectiveness of our pre-training and fine-tuning paradigm. Specifically, in MNIST, the predictive accuracy of the explanations after fine-tuning improves from $4 1 . 4 \\%$ to $7 1 . 4 \\%$ when the selection rato is 0.4. We attribute these improvements to the local insights on specific instances: (1) Benefiting from the saliency map obtained in the pre-training phase, the selection module is able to filter noisy edges out and narrow down to where the target model looks to make decisions; (2) Fine-tuning the explanatory subgraphs considers the coalition effect of edges, thus approaches more information to recover the target prediction. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            570
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "• Jointly analyzing Tables 2 and 3, ReFine consistently outperforms all baselines across the four datasets. Advantageous to the local or global explanations, our multi-grained explanations not only have the global understanding of model workings (i.e. the class-wise knowledge), but also account for the local insights on specific instances (i.e. the coalition effect of edges in the local context). It illustrates the superiority of our ReFine paradigm. ",
+        "bbox": [
+            174,
+            575,
+            826,
+            645
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Overall, the empirical supports justify the significance of fine-tuning well. The contributions of fine-tuning w.r.t. the overall improvements over PG-Explainer are $3 7 . 1 \\%$ and $3 1 . 8 \\%$ in MNIST and BA-3motif datasets, respectively. One possible reason that fine-tuning contributes only $3 . 1 \\%$ and $6 . 4 \\%$ portion of overall improvements in Mutagenicity and VG-5 as compared to PG-Explainer is the existance of rich node features in these two datasets. With the assistance of node features, the global patterns might be well-captured durining pre-training, thus leaving little space for the local patterns to improve. ",
+        "bbox": [
+            173,
+            655,
+            825,
+            752
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Qualitative Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            768,
+            352,
+            782
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We present the qualitative results on MNIST superpixel in Figure 3, where the pre-trained and fine-tuned explanations are the explanatory subgraphs before fine-tuning (i.e. extracted based on the saliency map) and after fine-tuning (i.e. derived from the selection module), respectively. ",
+        "bbox": [
+            174,
+            794,
+            823,
+            835
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Influence of Pre-training (RQ1). The pre-trained results (first row) well demonstrate the global patterns, where the explanatory subgraphs for interpreting the digit $\\mathbf { \\bar { \\theta } } ^ { 6 } 0 ^ { 9 }$ focus more on the edges between hollows in the middle and the fringe of the number. While interpreting the prediction $\\mathbf { \\Delta } ^ { 6 6 } 5 ^ { 9 }$ , the explanations identify the edges spread on the bend of the number as the most important features. Also, we observe an interesting pattern in the results for explaining the prediction $\\mathbf { \\vec { \\nu } } ^ { 6 } \\mathbf { \\vec { 8 } } ^ { 5 }$ , where the background edges draw more attention, rather than edges relevant to the digits, revealing the evidence for the target GNN to classify. It also shows the supporting evidence of the difference between the model explanation and the human explanation which focuses more on the digit graphs other than the background graphs. Through the pre-trained examples, the global patterns offer vital model understanding and inspections for the model’s decision-making process. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8c34ecf09b54fdf74ebfd5cd63461ec1c88fb307e8163089a1d2617a59c7f5bb.jpg",
+        "image_caption": [
+            "Figure 4: Qualitative Results in Mutagenicity dataset. The prediction of the molecule in the first row is mutagenic, while the molecule in the second row is predicted as non-mutagenic. The selection ratios range from $10 \\%$ to $50 \\%$ . Note that some opposite edges are visually coincident. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            89,
+            823,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/470800e94834f62bc8307cad5370e2cab17acab1347368b788ccd357d2a74de8.jpg",
+        "table_caption": [
+            "Table 4: Time costs (in second) of GNNExplainer, PG-Explainer and the fine-tuning phase of Refine. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Mutagenicity</td><td>VG-5</td><td>MNIST</td><td>BA-3motif</td></tr><tr><td>GNNExplainer</td><td>2.03</td><td>1.88</td><td>0.637</td><td>1.11</td></tr><tr><td>PG-Explainer</td><td>0.030</td><td>0.035</td><td>0.040</td><td>0.032</td></tr><tr><td>Refine(Fine-tuning)</td><td>0.821</td><td>0.583</td><td>0.535</td><td>0.423</td></tr></table>",
+        "bbox": [
+            258,
+            369,
+            735,
+            441
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            470,
+            825,
+            540
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Influence of Fine-tuning (RQ2). We now compare the pre-trained and fine-tuned explanations. Clearly, the fine-tuned explanatory graphs make clearer boundaries on the instances. The explanation adapted with the user-defined ratio pays greater attention to details that are only applicable to the specific instances. For example, one can take a closer look at the explanations in the 4-th column. Without the fine-tuning phase, the explanation may distracted by the edges across the digit and the background, such that these transition edges might be deemed as the most important features while achieve suboptimal predictive accuracies. In contrast, the fine-tuned explanation dispels such misunderstanding, with a higher local accuracy. Similar patterns can be found in other examples. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            664
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The qualitative results on Mutagenicity are presented in Figure 4, where each explanation has been fine-tuned on the corresponding ratio. We can see the flexibility on ReFine, which enables the fine-tuning on a specific user-defined ratio. With the selection ratio increases, the class probability output by the target GNN is generally stable or further improved. Moreover, the fine-tuning phase focuses more on the combination of features, with the constraint of selection ratio, to purse the higher accuracy rather than intercepting on a ranking based on the static edge importance, which is only valid under the addictive feature assumption [32]. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            767
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 Discussions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            292,
+            801
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Efficiency for Generating Explanations. The inference time [7] to explain a new instance by the pre-trained ReFine is the same as PGExplainer under the same attributor construction. Different from GNNExplainer which has to retrain the model for each graph, ReFine only needs a few finetuning steps on the pre-trained model (20 steps on average). Thus, ReFine can gain a boosting performance for explaining graphs while remaining efficient in terms of time complexity. Specifically, we summarize the time costs in the Table 4. Clearly, our ReFine is more efficient than GNNExplainer and is computationally comparable to PG-Explainer. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Limitations. Although ReFine can well-encode the class-wise knowledge by learning the parameters of multiple attributors, it can hardly map such knowledge to the structure representation as XGNN [13]. This limits the human understanding on the core of input data via a conciseness substructure. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            321,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We consider two classes of related work for GNNs explainability: studies on local explainability, which independently explain for each input graph without referring to other knowledge, e.g., training data; studies on global explainability, which provide explanations for multiple instances with the guide of the model-level or class-level knowledge. See [49, 8, 50] for more overviews. ",
+        "bbox": [
+            174,
+            183,
+            825,
+            238
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "• Local Explainability. In general, there are two research lines. (1) Non-parametric explanation methods [10, 9, 11] use some heuristics as the feature contributions of a specific instance, without involving additional trainable models. Gradient-like scores [10, 9, 11] are wisely-used heuristics, which is obtained by backpropagating the model prediction or loss to the input features, such as adjacency matrix [10], along with the model architecture. (2) Parametric explanation methods [6, 19, 51, 52] additionally train a parametrized explainer model to generate the saliency maps or explanatory subgraphs for individual instances. The explainer model is typically optimized towards local fidelity [32, 48, 27], which uses the explanations to recover the target predictions. For example, GNNExplainer [6] learns soft masks for an instance and applies them on the adjacency matrix. PGM-Explainer [19] trains an Bayesian network upon the pairs of graph perturbations and prediction changes. However, these methods fall short in capturing the prototypical patterns shared within the same groups or classes. ",
+        "bbox": [
+            173,
+            247,
+            825,
+            412
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "• Global Explainability. This direction is less explored compared to the local explainability of GNNs [8]. To provide a global understanding of the model prediction, PGExplainer [7] formulates the generation of multiple explanations based on its collective and inductive property, and designs the attributor as a deep neural network whose parameters are shared across the explained instances. XGNN [13] explains GNNs by training a graph generator, which outputs class-wise graph patterns to explain this class. As it is designed to explain the holistic class, making it hardly applicable on an specific instance, e.g., the graph patterns may not even exit on the instance. ",
+        "bbox": [
+            174,
+            417,
+            825,
+            515
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            532,
+            449,
+            550
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Multi-grained explainability promises to offer a flexible and all-round inspection of deep models’ decision-making, which has been less explored in the literature. Motivated by this, we proposed a novel generative probabilistic model, ReFine, to approach the multi-granularity explainability via pre-training and fine-tuning. To exhibit global explanations with the prototypical patterns, the pre-training phase is founded upon the class-aware attribution modules and distills the class-level knowledge by contrastive learning. When given a specific instance, the fine-tuning phase further adapts the global explanations in the local context with high fidelity. In the fashion of pre-training and fine-tuning, we can generate explanations with both global patterns and local features. Extensive results in four datasets show that our method indeed improves the quality of explanatory subgraphs. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            688
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As future direction, we consider the extension of ReFine to fulfill the counterfactual explanation [53], which answers ‘Why the target GNN model made a certain prediction, rather than another prediction?”, to enrich the multi-granularity explainability. Further, multi-grained explainability can be exhibited to explore the model robustness and heuristically guide the model construction. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            750
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            767,
+            553,
+            786
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Funding in direct support of this work: the Sea-NExT Joint Lab, Singapore MOE AcRF T2; the National Natural Science Foundation of China (U19A2079, 62121002); the National Key Research and Development Program of China (2020YFB1406703). ",
+        "bbox": [
+            174,
+            799,
+            825,
+            840
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            859,
+            267,
+            876
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Vijay Prakash Dwivedi, Chaitanya K. Joshi, Thomas Laurent, Yoshua Bengio, and Xavier Bresson. Benchmarking graph neural networks. CoRR, abs/2003.00982, 2020. ",
+        "bbox": [
+            187,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[2] Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and Philip S. Yu. A comprehensive survey on graph neural networks. TNNLS, 32(1):4–24, 2021.   \n[3] Shruthi Chari, Daniel M. Gruen, Oshani Seneviratne, and Deborah L. McGuinness. Directions for explainable knowledge-enabled systems. In Knowledge Graphs for eXplainable Artificial Intelligence: Foundations, Applications and Challenges, pages 245–261. 2020.   \n[4] Christopher J. Anders, Plamen Pasliev, Ann-Kathrin Dombrowski, Klaus-Robert Müller, and Pan Kessel. Fairwashing explanations with off-manifold detergent. In ICML, pages 314–323, 2020.   \n[5] Sebastian Lapuschkin, Stephan Wäldchen, Alexander Binder, Grégoire Montavon, Wojciech Samek, and Klaus-Robert Müller. Unmasking clever hans predictors and assessing what machines really learn. Nature communications, 10(1):1–8, 2019.   \n[6] Zhitao Ying, Dylan Bourgeois, Jiaxuan You, Marinka Zitnik, and Jure Leskovec. Gnnexplainer: Generating explanations for graph neural networks. In NeurIPS, pages 9240–9251, 2019.   \n[7] Dongsheng Luo, Wei Cheng, Dongkuan Xu, Wenchao Yu, Bo Zong, Haifeng Chen, and Xiang Zhang. Parameterized explainer for graph neural network. In NeurIPS, 2020.   \n[8] Hao Yuan, Haiyang Yu, Shurui Gui, and Shuiwang Ji. Explainability in graph neural networks: A taxonomic survey. CoRR, abs/2012.15445, 2020.   \n[9] Federico Baldassarre and Hossein Azizpour. Explainability techniques for graph convolutional networks. CoRR, abs/1905.13686, 2019.   \n[10] Phillip E. Pope, Soheil Kolouri, Mohammad Rostami, Charles E. Martin, and Heiko Hoffmann. Explainability methods for graph convolutional neural networks. In CVPR, pages 10772–10781, 2019.   \n[11] Thomas Schnake, Oliver Eberle, Jonas Lederer, Shinichi Nakajima, K. T. Schutt, Klaus-Robert Muller, and Grégoire Montavon. Higher-order explanations of graph neural networks via relevant walks. arXiv, 2020.   \n[12] Michael Sejr Schlichtkrull, Nicola De Cao, and Ivan Titov. Interpreting graph neural networks for NLP with differentiable edge masking. CoRR, abs/2010.00577, 2020.   \n[13] Hao Yuan, Jiliang Tang, Xia Hu, and Shuiwang Ji. XGNN: towards model-level explanations of graph neural networks. In Rajesh Gupta, Yan Liu, Jiliang Tang, and B. Aditya Prakash, editors, KDD, pages 430–438, 2020.   \n[14] Marco Túlio Ribeiro, Sameer Singh, and Carlos Guestrin. \"why should I trust you?\": Explaining the predictions of any classifier. In KDD, pages 1135–1144, 2016.   \n[15] Jeremy Howard and Sebastian Ruder. Universal language model fine-tuning for text classification. In ACL, pages 328–339, 2018.   \n[16] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.   \n[17] Ting Chen, Simon Kornblith, Mohammad Norouzi, and Geoffrey E. Hinton. A simple framework for contrastive learning of visual representations. In ICML, volume 119, pages 1597–1607, 2020.   \n[18] Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross B. Girshick. Momentum contrast for unsupervised visual representation learning. In CVPR, pages 9726–9735, 2020.   \n[19] Minh N. Vu and My T. Thai. Pgm-explainer: Probabilistic graphical model explanations for graph neural networks. In NeurIPS, 2020.   \n[20] Hongyang Gao and Shuiwang Ji. Graph u-nets. In ICML, volume 97, pages 2083–2092, 2019. ",
+        "bbox": [
+            171,
+            59,
+            828,
+            907
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            896,
+            823,
+            912
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[21] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua ´ Bengio. Graph attention networks. ICLR, 2018.   \n[22] William L. Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NeurIPS, pages 1024–1034, 2017.   \n[23] Xiang Wang, Xiangnan He, Meng Wang, Fuli Feng, and Tat-Seng Chua. Neural graph collaborative filtering. In SIGIR, pages 165–174, 2019.   \n[24] Xiang Wang, Xiangnan He, Yixin Cao, Meng Liu, and Tat-Seng Chua. KGAT: knowledge graph attention network for recommendation. In KDD, pages 950–958, 2019.   \n[25] Xiangnan He, Kuan Deng, Xiang Wang, Yan Li, Yong-Dong Zhang, and Meng Wang. Lightgcn: Simplifying and powering graph convolution network for recommendation. In SIGIR, pages 639–648, 2020.   \n[26] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In ICLR, 2019.   \n[27] Ian Covert, Scott Lundberg, and Su-In Lee. Feature removal is a unifying principle for model explanation methods. In NeurIPS, 2020.   \n[28] Marco Ancona, Enea Ceolini, Cengiz Öztireli, and Markus Gross. Towards better understanding of gradient-based attribution methods for deep neural networks. In ICLR, 2018.   \n[29] Constantin F Aliferis, Alexander Statnikov, Ioannis Tsamardinos, Subramani Mani, and Xenofon D Koutsoukos. Local causal and markov blanket induction for causal discovery and feature selection for classification part i: Algorithms and empirical evaluation. JMLR, 11(1), 2010.   \n[30] Peter D Hoff, Adrian E Raftery, and Mark S Handcock. Latent space approaches to social network analysis. Journal of the american Statistical association, 97(460):1090–1098, 2002.   \n[31] Max Welling Thomas N. Kipf. Variational graph auto-encoders. In NeurIPS Workshops, 2016.   \n[32] Jianbo Chen, Le Song, Martin J. Wainwright, and Michael I. Jordan. Learning to explain: An information-theoretic perspective on model interpretation. In ICML, pages 882–891, 2018.   \n[33] Lukas Faber, Amin K Moghaddam, and Roger Wattenhofer. Contrastive graph neural network explanation. 2021.   \n[34] R. Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Philip Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. In ICLR, 2019.   \n[35] Fan-Yun Sun, Jordan Hoffmann, Vikas Verma, and Jian Tang. Infograph: Unsupervised and semi-supervised graph-level representation learning via mutual information maximization. In ICLR, 2020.   \n[36] Yuning You, Tianlong Chen, Yongduo Sui, Ting Chen, Zhangyang Wang, and Yang Shen. Graph contrastive learning with augmentations. In NeurIPS, 2020.   \n[37] Jiancan Wu, Xiang Wang, Fuli Feng, Xiangnan He, Liang Chen, Jianxun Lian, and Xing Xie. Self-supervised graph learning for recommendation. In SIGIR, pages 726–735, 2021.   \n[38] Christopher Frye, Damien de Mijolla, Laurence Cowton, Megan Stanley, and Ilya Feige. Shapley-based explainability on the data manifold. In ICLR, 2021.   \n[39] H. W. Kuhn and A. W. Tucker. Contributions to the theory of games, volume 2. Princeton University Press, 1953.   \n[40] Jeroen Kazius, Ross McGuire, and Roberta Bursi. Derivation and validation of toxicophores for mutagenicity prediction. Journal of medicinal chemistry, 48(1):312–320, 2005.   \n[41] Kaspar Riesen and Horst Bunke. Iam graph database repository for graph based pattern recognition and machine learning. In SPR and SSPR, pages 287–297, 2008.   \n[42] Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay S. Pande, and Jure Leskovec. Strategies for pre-training graph neural networks. In ICLR, 2020.   \n[43] Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A. Shamma, Michael S. Bernstein, and Li Fei-Fei. Visual genome: Connecting language and vision using crowdsourced dense image annotations. IJCV, 123(1):32–73, 2017.   \n[44] Johannes Klicpera, Aleksandar Bojchevski, and Stephan Günnemann. Predict then propagate: Graph neural networks meet personalized pagerank. In ICLR, 2019.   \n[45] Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodolà, Jan Svoboda, and Michael M. Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In CVPR, pages 5425–5434, 2017.   \n[46] Matthias Fey, Jan Eric Lenssen, Frank Weichert, and Heinrich Müller. Splinecnn: Fast geometric deep learning with continuous b-spline kernels. In CVPR, pages 869–877, 2018.   \n[47] Ekagra Ranjan, Soumya Sanyal, and Partha P. Talukdar. ASAP: adaptive structure aware pooling for learning hierarchical graph representations. In AAAI, pages 5470–5477, 2020.   \n[48] Jian Liang, Bing Bai, Yuren Cao, Kun Bai, and Fei Wang. Adversarial infidelity learning for model interpretation. In KDD, pages 286–296, 2020.   \n[49] Hao Yuan, Haiyang Yu, Shurui Gui, and Shuiwang Ji. Explainability in graph neural networks: A taxonomic survey. CoRR, 2020.   \n[50] Thomas Schnake, Oliver Eberle, Jonas Lederer, Shinichi Nakajima, Kristof T. Schütt, KlausRobert Müller, and Grégoire Montavon. XAI for graphs: Explaining graph neural network predictions by identifying relevant walks. CoRR, abs/2006.03589, 2020.   \n[51] Hao Yuan, Haiyang Yu, Jie Wang, Kang Li, and Shuiwang Ji. On explainability of graph neural networks via subgraph explorations. ArXiv, 2021.   \n[52] Patrick Schwab and Walter Karlen. Cxplain: Causal explanations for model interpretation under uncertainty. In NeurIPS, pages 10220–10230, 2019.   \n[53] Raha Moraffah, Mansooreh Karami, Ruocheng Guo, Adrienne Raglin, and Huan Liu. Causal interpretability for machine learning-problems, methods and evaluation. SIGKDD Explorations, 22(1):18–33, 2020. ",
+        "bbox": [
+            171,
+            47,
+            828,
+            916
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            168,
+            90,
+            828,
+            604
+        ],
+        "page_idx": 12
+    }
+]

parse/train/KJ5h-yfUHa/KJ5h-yfUHa.md

@@ -0,0 +1,272 @@
+# Attention Bottlenecks for Multimodal Fusion
+
+Arsha Nagrani Shan Yang Anurag Arnab Aren Jansen Cordelia Schmid Chen Sun
+
+{anagrani, shanyang, aarnab, arenjansen, cordelias, chensun}@google.com
+
+Google Research
+
+# Abstract
+
+Humans perceive the world by concurrently processing and fusing highdimensional inputs from multiple modalities such as vision and audio. Machine perception models, in stark contrast, are typically modality-specific and optimised for unimodal benchmarks, and hence late-stage fusion of final representations or predictions from each modality (‘late-fusion’) is still a dominant paradigm for multimodal video classification. Instead, we introduce a novel transformer based architecture that uses ‘fusion bottlenecks’ for modality fusion at multiple layers. Compared to traditional pairwise self-attention, our model forces information between different modalities to pass through a small number of bottleneck latents, requiring the model to collate and condense relevant information in each modality and share what is necessary. We find that such a strategy improves fusion performance, at the same time reducing computational cost. We conduct thorough ablation studies, and achieve state-of-the-art results on multiple audio-visual classification benchmarks including Audioset, Epic-Kitchens and VGGSound. All code and models will be released.
+
+# 1 Introduction
+
+Simultaneous multimodal sensations are a crucial enabler of human perceptual learning [50]. For artificial learning systems, however, designing a unified model for modality fusion is challenging due to a number of factors: (i) variations in learning dynamics between modalities [56], (ii) different noise topologies, with some modality streams containing more information for the task at hand than others, as well as (iii) specialised input representations. The difference in input representations between audio and vision is particularly stark – many state of the art audio classification methods rely on short term Fourier analysis to produce log-mel spectrograms, often using them as inputs to CNN architectures designed for images [26, 48]. These time-frequency representations have different distributions to images – multiple acoustic objects can have energy at the same frequency, and the translation invariances of CNNs may no longer be a desired property (while an acoustic object can be shifted in time, a shift in frequency could alter the meaning entirely). In contrast, the visual stream in a video is three-dimensional (two spatial and one temporal), and while different spatial regions of the image correspond to different objects, there is the unique challenge of high redundancy across multiple frames. Hence input representations, and consequently neural network architectures and benchmarks tend to vary wildly for different modalities. For simplicity, the dominant paradigm for multimodal fusion therefore often consists of an ad-hoc scheme that involves integrating separate audio and visual networks via their output representations or scores i.e. ‘late-fusion’ [22, 44].
+
+In this work, we present a new transformer based model for audiovisual fusion in video. Despite originally being proposed for NLP tasks, there has been recent interest in transformers [54] as universal perceptual models [29], due to their ability to model dense correlations between tokens, at the same time making few assumptions about their inputs (and because continuous perceptual inputs can be tokenised). By dividing dense continuous signals into patches and rasterising them to 1D tokens, transformers have been shown to perform competitively for image (ViT [16]) and video classification (ViViT [6]), and more recently, audio classification (AST [23]). Because these models are able to elegantly handle variable length sequences, a natural first extension would be to feed in a sequence of both visual and auditory patches to a transformer, with minimal changes to the architecture. This ‘early fusion’ model allows free attention flow between different spatial and temporal regions in the image, as well as across frequency and time in the audio spectrogram. While theoretically appealing, we hypothesise that full pairwise attention at all layers of the model is not necessary because audio and visual inputs contain dense, fine-grained information, much of which is redundant. This is particularly the case for video, as shown by the performance of ‘factorised’ versions of [6]. Such a model would also not scale well to longer videos due to the quadratic complexity of pairwise attention with token sequence length. To mitigate this, we propose two methods to restrict the flow of attention in our model. The first follows from a common paradigm in multimodal learning, which is to restrict cross-modal flow to later layers of the network, allowing early layers to specialise in learning and extracting unimodal patterns. Henceforth this is is referred to as ‘mid fusion’ (Fig. 1, middle left), where the layer at which cross-modal interactions are introduced is called the ‘fusion layer’. The two extreme versions of this are ‘early fusion’ (all layers are cross-modal) and ‘late fusion’ (all are unimodal) which we compare to as a baselines. Our second idea (and main contribution), is to restrict cross-modal attention flow between tokens within a layer. We do this by allowing free attention flow within a modality, but force our model to collate and ‘condense’ information from each modality before sharing it with the other. The core idea is to introduce a small set of latent fusion units that form an ‘attention bottleneck’, through which cross-modal interactions within a layer must pass. We demonstrate that this ‘bottlenecked’ version, which we name Multimodal Bottleneck Transformer (MBT), outperforms or matches its unrestricted counterpart, but with lower computational cost.
+
+![](images/cf31d718e1493908ff58400e72597290e9e88c3348dcc4c9bd28952c3484a552.jpg)  
+Figure 1: Cross-modal Fusion. Unlike late fusion (left), where no cross-modal information is exchanged in the model until after the classifier, we investigate two pathways for the exchange of cross-modal information. The first is via standard pairwise self attention across all hidden units in a layer, but applied only to later layers in the model – mid fusion (middle, left). We also propose the use of ‘fusion bottlenecks’ (middle, right) that restrict attention flow within a layer through tight latent units. Both forms of restriction can be applied in conjunction (Bottleneck Mid Fusion) for optimal performance (right). We show $B = 2$ bottleneck units and 3 hidden units per modality. Grey boxes indicate tokens that receive attention flow from both audio and video tokens.
+
+Concretely, we make the following contributions: (i) We propose a new architecture (MBT) for audiovisual fusion. Our model restricts the flow of cross-modal information between latent units through tight fusion ‘bottlenecks’, that force the model to collect and ‘condense’ the most relevant inputs in each modality (and therefore share only that which is necessary with the other modality). This avoids the quadratic scaling cost of full pairwise attention, and leads to performance gains with less compute; (ii) We apply MBT to image and spectogram patches (Fig. 2), and explore a number of ablations related to the fusion layer, the sampling of inputs and data size; and finally (iii) We set the new state-of-the-art for video classification across a number of popular audio-visual benchmarks, including AudioSet [21], Epic-Kitchens100 [12] and VGGSound [10]. On the Audioset dataset, we outperform the current state of the art by $5 . 9 \mathrm { m A P }$ ( $12 . 7 \%$ relative improvement).
+
+# 2 Related work
+
+Audiovisual learning: Audiovisual multimodal learning has a rich history, both before and during the deep learning era [47]. Given the limited available data and computational resources, early work focused on relatively simple early-stage (e.g. stacking hand-designed features) and late-stage (e.g. score fusion) techniques [11]. Deep learning has allowed more sophisticated strategies in which modality-specific or joint latents are implicitly learned to mediate the fusion. The result has enabled major advances in a range of downstream supervised audiovisual tasks [43, 34, 17]. In the supervised setting, multiple modality-specific convolution networks can be jointly trained, whose intermediate activations are then combined by summation [32] or via ‘lateral connections’ [57]. In the unsupervised setting, audiovisual learning is commonly used to learn good unimodal representations, with a popular pretraining task being to synchronise signals from different modalities via a contrastive loss [4, 5, 7, 44, 30, 2, 3], however each modality is usually encoded separately under this setup.
+
+![](images/571f07835a2d97d79335d6c5c47ed9d82d879cd1029f0ee9a914560b0db1f7df.jpg)  
+Figure 2: A Multimodal Fusion Transformer applied to audiovisual inputs. The input sequence consists of image and spectrogram patches. These are then projected into tokens and appended to special CLS (classification) and FSN (fusion bottleneck) tokens. Our transformer encoder then uses self attention to model unimodal information, and restricts cross-modal information flow via cross attention with the bottleneck tokens at multiple layers of the network.
+
+Multimodal transformers: The self attention operation of transformers provides a natural mechanism to connect multimodal signals. Multimodal transformers have been applied to various tasks including audio enhancement [17, 53], speech recognition [24], image segmentation [58, 53], crossmodal sequence generation [39, 37, 49], image and video retrieval [25, 20, 8], visual navigation [46] and image/video captioning/classification [41, 52, 51, 36, 28]. For many works, the inputs to transformers are the output representations of single modality CNNs [35, 20] – unlike these works we use transformer blocks throughout, using only a single convolutional layer to rasterise 2D patches. The tokens from different modalities are usually combined directly as inputs to the transformers [38], for example, the recently released Perceiver model [29] introduces an iterative attention mechanism which takes concatenated raw multimodal signals as inputs, which corresponds to our ‘early fusion’ baseline. In contrast, we carefully examine the impact of different modality fusion strategies, including limiting cross-modal attention flow to later layers of our model, and ‘channeling’ cross-modal connections through bottlenecks in our proposed Multimodal Bottleneck Transformer (MBT).
+
+# 3 Multimodal fusion transformers
+
+In this section we describe our proposed Multimodal Bottleneck Transformer (MBT). We begin by summarising the recently proposed Vision Transformer (ViT) [16] and Audio Spectrogram Transformer (AST) [23], developed for image and audio classification respectively, in Sec. 3.1. We then describe our extension to the audio-visual fusion case. We discuss three different token fusion strategies (Sec. 3.2), and finally discuss the fusion pathway in the entire model (Sec. 3.3), which involves restricting multimodal fusion to certain layers of the model.
+
+# 3.1 The ViT and AST architectures
+
+Vision Transformer (ViT) [16] (and a recent extension to audio – Audio Spectrogram Transformer (AST) [23]) adapts the Transformer architecture [54], originally designed for natural language processing, to process 2D inputs with minimal changes. The key insight is to extract $N$ nonoverlapping patches from the RGB image (or the audio spectrogram), $x _ { i } \in \mathbb { R } ^ { h \times w }$ , and convert them into a series of 1D tokens $z _ { i } \in \mathbb { R } ^ { d }$ , as follows:
+
+$$
+\mathbf { z } = g ( \mathbf { x } ; \mathbf { E } , z _ { \mathrm { c l s } } ) = \left[ z _ { \mathrm { c l s } } , \mathbf { E } x _ { 1 } , \mathbf { E } x _ { 2 } , . . . , \mathbf { E } x _ { N } \right] + \mathbf { p } .
+$$
+
+Here, $\mathbf { E }$ is a linear projection mapping each token to $\mathbb { R } ^ { d }$ , $z _ { \mathrm { c l s } }$ is a special token prepended to this sequence so that its representation at the final layer can be passed to a classifier for classification tasks [15], and $\mathbf { p } \in \bar { \mathbb { R } } ^ { ( N + 1 ) \times d }$ is a learned positional embedding added to the tokens to retain positional information (as all subsequent self-attention operations are permutation invariant).
+
+The tokens are then passed through an encoder consisting of a sequence of $L$ transformer layers. Each transformer layer consists of Multi-Headed Self-Attention (MSA), Layer Normalisation (LN) and Multilayer Perceptron (MLP) blocks applied using residual connections. We denote a transformer layer, $\mathbf { z } ^ { \bar { l } + 1 } = \mathrm { T r a n s f o r m e r } ( \mathbf { z } ^ { l } )$ as
+
+$$
+\begin{array} { r } { \mathbf { y } ^ { l } = \mathrm { M S A } ( \mathrm { L N } ( \mathbf { z } ^ { l } ) ) + \mathbf { z } ^ { l } } \\ { \mathbf { z } ^ { l + 1 } = \mathrm { M L P } ( \mathrm { L N } ( \mathbf { y } ^ { l } ) ) + \mathbf { y } ^ { l } . } \end{array}
+$$
+
+Here, the MSA operation [54] computes dot-product attention [54] where the queries, keys and values are all linear projections of the same tensor, $\operatorname { M S A } ( \mathbf { X } ) = \operatorname { A t t e n t i o n } ( \mathbf { W } ^ { Q } \mathbf { X } , \mathbf { W } ^ { K } \mathbf { X } , { \dot { \mathbf { W } } } ^ { V } \mathbf { X } )$ . We further define Multi-Headed Cross Attention (MCA) between two tensors, $\mathbf { X }$ and $\mathbf { Y }$ , where $\mathbf { X }$ forms the query and $\mathbf { Y }$ forms the keys and values which are used to reweight the query as $\operatorname { M C A } ( \mathbf { X } , \mathbf { Y } ) = \operatorname { A t t e n t i o n } ( \mathbf { W } ^ { Q } \mathbf { X } , \mathbf { W } ^ { K } \mathbf { Y } , \mathbf { W } ^ { V } \mathbf { Y } )$ . This will be used in our multimodal case, as described next.
+
+# 3.2 Multimodal transformer
+
+We now describe our extension to the multimodal case. We begin by discussing three different token fusion strategies.
+
+# 3.2.1 Fusion via vanilla self-attention
+
+We begin by describing a ‘vanilla’ fusion model, which simply consists of the regular transformer applied to multimodal inputs. Our method of tokenising video is straightforward – given a video clip of length $t$ seconds, we uniformly sample $F$ RGB frames and convert the audio waveform into a single spectrogram. We then embed each frame and the spectrogram independently following the encoding proposed in ViT [16], and concatenate all tokens together into a single sequence.
+
+Formally, if we have extracted a total of $N _ { v }$ RGB patches from all $F$ sampled frames, $\mathbf { x } _ { \mathrm { r g b } } \in \mathbb { R } ^ { N _ { v } \times d }$ and $N _ { a }$ spectrogram patches, $\mathbf { x } _ { \mathrm { s p e c } } \in \mathbb { R } ^ { N _ { a } \times d }$ , our sequence of tokens is
+
+$\mathbf { z } = [ \mathbf { z } _ { \mathrm { r g b } } | | \mathbf { z } _ { \mathrm { s p e c } } ]$ where ${ \bf z } _ { \mathrm { r g b } } = g ( { \bf x } _ { \mathrm { r g b } } ; { \bf E } _ { \mathrm { r g b } } , z _ { \mathrm { c l s - r g b } } )$ and $\begin{array} { r } { \mathbf { z } _ { \mathrm { s p e c } } = g ( \mathbf { x } _ { \mathrm { s p e c } } ; \mathbf { E } _ { \mathrm { s p e c } } , z _ { \mathrm { c l s - s p e c } } ) . } \end{array}$ (4) Here, $\left[ \mathbf { z } _ { \mathrm { r g b } } | | \mathbf { z } _ { \mathrm { s p e c } } \right]$ denotes the concatenation of the tokens for each modality. We use different projections $\mathbf { E } _ { \mathrm { r g b } }$ and $\mathbf { E } _ { \mathrm { s p e c } }$ for RGB and spectrogram patches respectively, and prepend a separate classification token for each modality.
+
+Our multimodal encoder then applies a series of transformer layers in the same manner as above. Attention is allowed to flow freely through the network, i.e. each RGB token can attend to all other RGB and spectrogram tokens as follows: $\mathbf { \bar { z } } ^ { l + 1 } = \mathrm { T r a n s f o r m e r } ( \mathbf { z } ^ { l } ; \theta )$ with model parameters $\theta$ . Here Transformer refers to a standard transformer layer with vanilla self-attention blocks.
+
+# 3.2.2 Fusion with modality-specific parameters
+
+We can generalise this model by allowing each modality to have its own dedicated parameters $\theta _ { \mathrm { r g b } }$ and $\theta _ { \mathrm { s p e c } }$ , but still exchange information via the attention mechanism. For this purpose, we define a Cross-Transformer layer:
+
+$$
+\begin{array} { r l } & { \mathbf { z } _ { \mathrm { r g b } } ^ { l + 1 } = \mathrm { C r o s s - T r a n s f o r m e r } ( \mathbf { z } _ { \mathrm { r g b } } ^ { l } , \mathbf { z } ^ { l } ; \theta _ { \mathrm { r g b } } ) } \\ & { \mathbf { z } _ { \mathrm { s p e c } } ^ { l + 1 } = \mathrm { C r o s s - T r a n s f o r m e r } ( \mathbf { z } _ { \mathrm { s p e c } } ^ { l } , \mathbf { z } ^ { l } ; \theta _ { \mathrm { s p e c } } ) , } \end{array}
+$$
+
+where the Cross-Transformer employs the generalised cross-attention operation that takes two sets of inputs $\mathbf { z } _ { 1 }$ and $\mathbf { z } _ { 2 }$ that are not necessarily overlapping. This layer follows the original transformer layer with the difference being that Eq. 2 becomes
+
+$$
+\mathbf { y } ^ { l } = \mathrm { M C A } ( \mathrm { L N } ( \mathbf { z } _ { 1 } ^ { l } ) , \mathrm { L N } ( \mathbf { z } _ { 2 } ^ { l } ) ) + \mathbf { z } _ { 1 } ^ { l } .
+$$
+
+Finally, note that we have explicitly defined the parameters, $\theta _ { \mathrm { r g b } }$ and $\theta _ { \mathrm { s p e c } }$ of the cross-transformer layers in Eq. 5 as they are different for each modality. However, when $\theta _ { \mathrm { r g b } }$ and $\theta _ { \mathrm { s p e c } }$ are equal, $\theta _ { \mathrm { r g b } } = \theta _ { \mathrm { s p e c } } = \theta ,$ ), the computation defined in Eq. 5 is equivalent to Sec. 3.2.1.
+
+# 3.2.3 Fusion via attention bottlenecks
+
+In order to tame the quadratic complexity of pairwise attention, we next introduce a small set of $B$ fusion bottleneck tokens $\mathbf { z } _ { \mathrm { f s n } } = [ \dot { z } _ { \mathrm { f s n } } ^ { 1 } , z _ { \mathrm { f s n } } ^ { \dot { 2 } } , \dots , z _ { \mathrm { f s n } } ^ { B } ]$ to our input sequence (see Fig. 2). The input sequence is now
+
+$$
+\mathbf { z } = [ \mathbf { z } _ { \mathrm { r g b } } | | \mathbf { z } _ { \mathrm { f s n } } | | \mathbf { z } _ { \mathrm { s p e c } } ] .
+$$
+
+We then restrict all cross-modal attention flow in our model to be via these bottleneck tokens. More formally for layer $l$ , we compute token representations as follows:
+
+$$
+\begin{array} { r l } & { [ \mathbf { z } _ { \mathrm { i } } ^ { l + 1 } | | \hat { \mathbf { z } } _ { \mathrm { f s n } _ { i } } ^ { l + 1 } ] = \mathrm { T r a n s f o r m e r } ( [ \mathbf { z } _ { \mathrm { i } } ^ { l } | | \mathbf { z } _ { \mathrm { f s n } } ^ { l } ] ; \theta _ { \mathrm { i } } ) } \\ & { \qquad \mathbf { z } _ { \mathrm { f s n } } ^ { l + 1 } = \mathrm { A v g _ { i } } ( \hat { \mathbf { z } } _ { \mathrm { f s n } _ { i } } ^ { l + 1 } ) } \end{array}
+$$
+
+Here $i$ indexes each modality, in this case RGB and Spec, and $\mathbf { z } _ { \mathrm { r g b } }$ and $\mathbf { z } _ { \mathrm { s p e c } }$ can only exchange information via the bottleneck $\mathbf { z } _ { \mathrm { f s n } }$ within a transformer layer. We first create modality specific temporary bottleneck fusion tokens $\hat { \mathbf { z } } _ { \mathrm { f s n } _ { i } }$ , which are updated separately and simultaneously with audio and visual information (Equation 8). The final fusion tokens from each cross-modal update are then averaged in Equation 9. We also experiment with asymmetric updates for the bottleneck tokens (see appendix) and found performance was robust to this choice. We keep the number of bottleneck tokens in the network to be much smaller than the total number of latent units per modality $B \ll N _ { v }$ and $B \ll N _  a , $ ). Because all cross-modal attention flow must pass through these units, these tight ‘fusion’ bottlenecks force the model to condense information from each modality and share that which is necessary. As we show in the experiments, this increases or maintains performance for multimodal fusion, at the same time reducing computational complexity. We also note that our formulation is generic to the type and the number of modalities.
+
+# 3.3 Where to fuse: early, mid and late
+
+The above strategies discuss fusion within a layer, and in most transformer architectures (such as ViT), every layer consists of an identical set of operations. A common paradigm in multimodal learning, however, is to restrict early layers of a network to focus on unimodal processing, and only introduce cross-modal connections at later layers. This is conceptually intuitive if we believe lower layers are involved in processing low level features, while higher layers are focused on learning semantic concepts – low-level visual features such as edges and corners in images might not have a particular sound signature, and therefore might not benefit from early fusion with audio [57].
+
+This can be implemented with our model as follows: We initially perform vanilla self-attention among tokens from a single modality for $L _ { f }$ layers. Thereafter, we concatenate all latent tokens together, $\mathbf { z } ^ { L _ { f } } = [ \mathbf { z } _ { \mathrm { r g b } } ^ { L _ { f } } | | \mathbf { z } _ { \mathrm { s p e c } } ^ { L _ { f } } ]$ and pass them through the remaining $L - L _ { f }$ layers where the tokens are fused according to Sec. 3.2. Here, $L _ { f } = 0$ corresponds to an ‘early-fusion’ model, $L _ { f } = L$ a ‘late-fusion’ model, and $0 < L _ { f } < L$ a ‘mid-fusion’ one. More formally, this can be denoted as
+
+$$
+\begin{array} { r l } & { \mathbf { z } _ { \mathrm { r g b } } ^ { l + 1 } = \mathrm { T r a n s f o r m e r } ( \mathbf { z } _ { \mathrm { r g b } } ^ { l } ; \theta _ { \mathrm { r g b } } ) , \mathbf { z } _ { \mathrm { s p e c } } ^ { l + 1 } = \mathrm { T r a n s f o r m e r } ( \mathbf { z } _ { \mathrm { s p e c } } ^ { l } ; \theta _ { \mathrm { s p e c } } ) } & { \mathrm { i f ~ } l < L _ { f } } \\ & { \mathbf { z } ^ { l } = [ \mathbf { z } _ { \mathrm { r g b } } ^ { l } | | \mathbf { z } _ { \mathrm { s p e c } } ^ { l } ] , \mathbf { z } ^ { l + 1 } = \mathrm { M u l t i m o d a l - T r a n s f o r m e r } ( \mathbf { z } ^ { l } ; \theta _ { \mathrm { s p e c } } , \theta _ { \mathrm { r g b } } ) } & { \mathrm { o t h e r w i s e } } \end{array}
+$$
+
+where Multimodal-Transformer $( \cdot )$ can refer to either of the 3 fusion strategies described in Sec 3.2.
+
+# 3.4 Classification
+
+For all model variants described above, we pass output representations of the CLS tokens $z _ { \mathrm { c l s - r g b } } ^ { L }$ and $z _ { \mathrm { c l s - s p e c } } ^ { L }$ to the same linear classifier and average the pre-softmax logits.
+
+# 4 Experiments
+
+We apply MBT to the task of video classification. In this section we first describe the datasets used to train and test multimodal fusion and their respective evaluation protocols (Sec. 4.1), then discuss implementation details (Sec. 4.2). We then ablate the key design choices in our model (Sec. 4.3), before finally comparing our model to the state of the art (Sec. 4.4).
+
+# 4.1 Datasets and evaluation protocol
+
+We experiment with three video classification datasets – AudioSet [21], Epic-Kitchens-100 [12] and VGGSound [10], described in more detail below. Results on two additional datasets Moments in Time [42] and Kinetics [31] are provided in the appendix.
+
+AudioSet [21] consists of almost 2 million 10-second video clips from YouTube, annotated with 527 classes. Like other YouTube datasets, this is a dynamic dataset (we only use the clips still available online). This gives us 20,361 clips for the balanced train set (henceforth referred to as mini-AudioSet or miniAS) and 18,589 clips for the test set. This test set is exactly the same as recent works we compare to, including Perceiver [29]. Instead of using the 2M unbalanced training set, we train on a (slightly more) balanced subset consisting of 500K samples (AS-500K). Details are provided in the appendix. Because each sample has multiple labels, we train with a binary cross-entropy (BCE) loss and report mean average precision (mAP) over all classes, following standard practice.
+
+Epic-Kitchens 100 [12] consists of egocentric videos capturing daily kitchen activities. The dataset consists of 90,000 variable length clips spanning 100 hours. We report results for action recognition following standard protocol [12] - each action label is a combination of a verb and noun, and we predict both using a single network with two ‘heads’, both trained with a cross-entropy loss. The top scoring verb and action pair predicted by the network are used, and Top-1 action accuracy is the primary metric. Actions are mainly short-term (average length is 2.6s with minimum length 0.25s).
+
+VGGSound [10] contains almost 200K video clips of length 10s, annotated with 309 sound classes consisting of human actions, sound-emitting objects and human-object interactions. Unlike AudioSet, the sound source for each clip is ‘visually present’ in the video. This was ensured during dataset creation through the use of image classifiers. After filtering clips that are no longer available on YouTube, we end up with 172,427 training and 14,448 test clips. We train with a standard crossentropy loss for classification and report Top-1 and Top-5 classification accuracy.
+
+# 4.2 Implementation details
+
+Our backbone architecture follows that of ViT [16] identically, specifically we use ViT-Base (ViT-B, $L = 1 2$ , $N _ { H } = 1 2$ , $d = 3 0 7 2 )$ initialised from ImageNet-21K [14], however we note that our method is agnostic to transformer backbone. Unless otherwise specialised, we use $B = 4$ bottleneck tokens for all experiments with bottleneck fusion. Bottleneck tokens are initialized using a Gaussian with mean of 0 and standard deviation of 0.02, similar to the positional embeddings in the public ViT [16] code. We randomly sample clips of $t$ seconds for training. RGB frames for all datasets are extracted at 25 fps. For AudioSet and VGGSound we sample 8 RGB frames over the sampling window of length $t$ with a uniform stride of length $( t \times 2 5 ) / \bar { 8 }$ . We extract $1 6 \times 1 6$ patches from each frame of size $2 2 4 \times 2 2 4$ , giving us a total of $8 \times 1 4 \times 1 4 = 1 5 6 8$ patches per video. For Epic-Kitchens (because the segments are shorter), we sample 32 frames with stride 1. Audio for all datasets is sampled at $1 6 \mathrm { k H z }$ and converted to mono channel. Similar to [23], we extract log mel spectrograms with a frequency dimension of 128 computed using a $2 5 \mathrm { m s }$ Hamming window with hop length $1 0 \mathrm { m s }$ . This gives us an input of size $1 2 8 \times 1 0 0 t$ for $t$ seconds of audio. Spectrogram patches are extracted with size $1 6 \times 1 6$ , giving us $5 0 \times 8 = 4 0 0$ patches for 8 seconds of audio. For images we apply the standard data augmentations used in [6] (random crop, flip, colour jitter), and for spectrograms we use SpecAugment [45] with a max time mask length of 192 frames and max frequency mask length of 48 bins following AST [23]. We set the base learning rate to 0.5 and train for 50 epochs, using Mixup [59] with $\alpha = 0 . 3$ and stochastic depth regularisation [27] with probability $p = 0 . 3$ . All models (across datasets) are trained with a batch size of 64, synchronous SGD with momentum of 0.9, and a cosine learning rate schedule with warmup of 2.5 epochs on TPU accelerators using the Scenic library [13].
+
+Inference: Following standard practice, we uniformly sample multiple temporal crops from the clip and average per-view logits to obtain the final result. The number of test crops is set to 4.
+
+# 4.3 Ablation analysis
+
+In this section we investigate the impact of the different architectural choices in MBT. Unless otherwise specified, we use the mini-AudioSet split for training and report results on the AudioSet eval split. More ablations on backbone size and pretraining initalisation can be found in the appendix.
+
+# 4.3.1 Fusion strategies
+
+We implement all the three fusion strategies described in Sec. 3.2:
+
+(i) Vanilla self-attention – Unrestricted pairwise attention between all latent units within a layer; (ii) Vanilla cross-attention with separate weights: Same as above, but we now have separate weights for each modality. The latent units are updated via pairwise attention with all other latent units from both modalities; and finally
+
+(iii) Bottleneck fusion: Here all cross-modal attention must pass through bottleneck fusion latents. Note that these three fusion strategies only describe attention flow between tokens within a layer. For strategies (ii) and (iii), we also conduct experiments showing the impact of restricting cross-modal attention to layers after a fixed fusion layer $L _ { f }$ . We investigate models with different fusion layers, $L _ { f } = 0 , 2 , 4 , 6 , 8 , 1 0 , 1 2$ , and present the results in Fig. 3.2
+
+Sharing weights for both modalities: We first investigate the impact of sharing the encoder weights for both modalities (strategy (i) vs (ii)). The results can be found in Fig. 1 in the appendix. When modalities are fused at earlier layers, using separate encoders improves performance. For models with later fusion layers, performance is similar for both models. We hence use separate modality weights for further experiments.
+
+Fusion layer: We then investigate the impact of varying the fusion layer $L _ { f }$ , for the latter two strategies: (ii) Vanilla Cross-Attention and (iii) Bottleneck Fusion. We conduct experiments with $L _ { f } = \stackrel { \_ } { 0 } , 2 , 4 , 6 , 8 , 1 0 , 1 2$ . We fix the input span $t$ to 4s and the number of bottleneck tokens $B$ to 4. We conduct 3 runs for each experiment and report mean and std deviation. As can be seen from Fig. 3 (left), ‘mid fusion’ outperforms both early $( L _ { f } = 0 )$ ) and late fusion $( L _ { f } = 1 2 )$ ), with optimal performance obtained by using fusion layer $L _ { f } = 1 0$ for vanilla cross-attention and $L _ { f } = 8$ for bottleneck attention. This suggests that the model benefits from restricting cross-modal connections to later layers, allowing earlier layers to specialise to learning unimodal features, however still benefits from multiple layers of cross-modal information flow. In appendix $\mathbf { D }$ , we confirm that mid fusion outperforms late fusion across a number of different datasets.
+
+Attention bottlenecks: In Fig. 3, we also examine the effect of bottleneck attention vs vanilla cross-attention for multimodal fusion. We find that for all values of $L _ { f }$ restricting flow to bottlenecks improves or maintains performance, with improvements more prominent at lower values of $L _ { f }$ . At $L _ { f } = 1 0$ , both perform similarly, note that at this stage we only have 3 fusion layers in the model. Our best performing model uses attention bottlenecks with $L _ { f } = 8$ , and we fix this for all further experiments. We also compare the amount of computation, measured in GFLOPs, for both fusion strategies (Fig. 3, right). Using a small number of bottleneck tokens (in our experiments $B = 4$ ) adds negligible extra computation over a late fusion model, with computation remaining largely constant with varying fusion layer $L _ { f }$ . This is in contrast to vanilla cross-fusion, which has a non-negligible computational cost for every layer it is applied to. We note that for early fusion $\begin{array} { r } { { \cal L } _ { f } = 0 } \end{array}$ ), bottleneck fusion outperforms vanilla cross-attention by over $2 \mathrm { m A P } ,$ , with less than half the computational cost.
+
+Number of bottleneck tokens $B$ : We experiment with $B = 4$ , 36, 64, 256 and 1024, and find that performance is relatively consistent (all within $0 . 5 \mathrm { \ m A P }$ ). We hence fix the number of tokens to $B = 4$ for all experiments. It is interesting that with such a small number of cross-modal connections through only 4 hidden units $B = 4$ ) at each cross-modal layer, we get large performance gains over late fusion (Fig. 3), highlighting the importance of allowing cross-modal information to flow at multiple layers of the model.
+
+# 4.3.2 Input sampling and dataset size
+
+In this section we investigate the impact of different modality sampling strategies. We also compare to single modality baselines – the visual-only and audio-only baselines consist of a vanilla transformer model applied to only the RGB or spectrogram patches respectively.
+
+Sampling window size $t$ : An advantage of our transformer based model is that we can easily input variable length token sequences. We experiment with varying the sampling window $t$ with the following values $t = 2 , 4 , 6$ and 8 seconds (note that all videos in AudioSet are 10s), and show results in Fig. $\bar { 4 ^ { 3 } }$ . At inference, we uniformly sample multiple windows covering the entire video. While the number of spectrogram patches $N _ { a }$ changes with $t$ , we keep the number of RGB patches $N _ { v }$ fixed by changing the stride of frames (to avoid running out of memory). Our results indicate that the performance of both the audio and audio-visual fusion model increases with input span, however the performance of the visual-only model slightly decreases (we hypothesize that this is due to the increased fixed stride, meaning fewer frames are randomly sampled during training). We fix $t = 8 s$ in all further experiments.
+
+![](images/b9edffab7708afc79614b4e1edcbfb86b3d50d5eff07fed808b001f22d8ef7e4.jpg)  
+Figure 3: The impact of using attention bottlenecks for fusion on performance (left) and compute (right) at different fusion layers $L _ { f }$ on AudioSet, using clip span $t = 4$ and $B = 4$ bottleneck tokens. Attention bottlenecks improve performance at lower computational cost.
+
+![](images/78c397a11b2b43241bea996075b0420424a7ff01fc3b19a5640a831630113b57.jpg)  
+Figure 4: The effect of varying input clip span $t$ on the AudioSet test set.
+
+![](images/52df0536c4b0f292541eff06643a52573084266c8addf3a6b7d36d7642cbfec0.jpg)  
+Figure 5: The effect of training data size on the AudioSet test set.
+
+Synchronous vs asynchronous sampling: Given that auditory and visual events may not always be perfected aligned in videos [32], we also investigate asynchronous sampling of different modalities. Here input windows are sampled independently from the entire video clip for each modality. Results are provided in Fig. 2 in the appendix. We find performance to be largely robust to either case, and so for simplicity we use synchronised sampling for all further experiments.
+
+Modality MixUp: While applying Mixup regularization [59] to training, we note that there are two different ways to apply it for multimodal inputs – the standard approach is to sample one set of mixup weights from a Beta distribution using the parameter $\alpha$ , and use it to generate all virtual modality-label pairs [59]. We also explore a modified version which we call modality mixup, which samples an independent weight for each modality. Modality mixup imposes stronger augmentation than standard mixup, leading to a slight improvement $( 4 2 . 6 \ : \mathrm { m A P }$ to $4 3 . 9 \mathrm { m A P }$ ) on AudioSet.
+
+Impact of dataset size: We show the impact of varying the number of training samples in Fig. 5, and find a monotonic increase with dataset size (more steeply for audio-only than visual-only).
+
+# 4.4 Results
+
+Comparison to single modality performance: We compare MBT to visual-only and audio-only baselines on AudioSet (Table 1), Epic-Kitchens (Table 2) and VGGSound (Table 3). Note we use the best parameters obtained via the ablations above, i.e. bottleneck fusion with $t = 8$ , $B = 4$ , $F _ { l } = 8$ and modality mixup. For all datasets, multimodal fusion outperforms the higher-performing single modality baseline, demonstrating the value of complementary information. The relative importance of modalities for the classification labels varies (audio-only has higher relative performance for AudioSet and lower for Epic-Kitchens, while both audio and visual baselines are equally strong for VGGSound). This is (unsurprisingly) largely a function of the dataset annotation procedure and positions VGGSound as a uniquely suitable dataset for fusion. We also show that audio-visual fusion provides slight performance gains for traditionally video only datasets such as Kinetics and Moments in Time (details provided in Appendix C ). We also examine per-class performance on the Audioset dataset (Figures 3 and 4 in the Appendix), and find that for the top 60 classes (ranked by overall performance), audio-visual fusion improves performance over audio only or visual only for almost all (57 out of 60) classes, except for ‘bagpiping’, ‘emergency vehicle’ and ‘didgeridoo’ which have strong audio signatures. For classes such as ‘bicycle’ and ‘shuffling cards’ where audio signals are weaker, fusion improves over the audio-only baseline by over $60 \%$ in absolute AP.
+
+Table 1: Comparison to SOTA on AudioSet [21]. We report mean average precision (mAP). We outperform works that train on the full Audioset (2M samples), while we train on only $5 0 0 \mathrm { K }$ samples.   
+
+<table><tr><td>Model</td><td>Training Set</td><td>tAonly</td><td>V only</td><td>AVFusion</td></tr><tr><td>GBlend [56]</td><td>MiniAS</td><td>29.1</td><td>22.1</td><td>37.8</td></tr><tr><td>GBlend [56]</td><td>FullAS-2M</td><td>32.4</td><td>18.8</td><td>41.8</td></tr><tr><td>Attn Audio-Visual[18]</td><td>FullAS-2M</td><td>38.4</td><td>25.7</td><td>46.2</td></tr><tr><td>Perceiver [29]</td><td>FullAS-2M</td><td>38.4</td><td>25.8</td><td>44.2</td></tr><tr><td>MBT</td><td>MiniAS</td><td>31.3</td><td>27.7</td><td>43.9</td></tr><tr><td>MBT</td><td>AS-500K</td><td>44.3</td><td>32.3</td><td>52.1</td></tr></table>
+
+Table 2: Comparison to SOTA on EpicKitchens-100 [12]. Modalities are A: Audio, V: Visual, F: Optical flow. †Uses pretraining on VGGSound.   
+
+<table><tr><td>Model</td><td>Modalities</td><td>Verb</td><td>Noun</td><td>Action</td></tr><tr><td>Damen et al. [12]</td><td>A</td><td>42.1</td><td>21.5</td><td>14.8</td></tr><tr><td>AudioSlowFast [33]t</td><td>A</td><td>46.5</td><td>22.78</td><td>15.4</td></tr><tr><td>TSN [55]</td><td>V,F</td><td>60.2</td><td>46.0</td><td>33.2</td></tr><tr><td>TRN [60]</td><td>V,F</td><td>65.9</td><td>45.4</td><td>35.3</td></tr><tr><td>TBN [32]</td><td>A,V,F</td><td>66.0</td><td>47.2</td><td>36.7</td></tr><tr><td>TSM[40]</td><td>V,F</td><td>67.9</td><td>49.0</td><td>38.3</td></tr><tr><td>SlowFast [19]</td><td>V</td><td>65.6</td><td>50.0</td><td>38.5</td></tr><tr><td>MBT</td><td>A</td><td>44.3</td><td>22.4</td><td>13.0</td></tr><tr><td>MBT</td><td>V</td><td>62.0</td><td>56.4</td><td>40.7</td></tr><tr><td>MBT</td><td>A,V</td><td>64.8</td><td>58.0</td><td>43.4</td></tr></table>
+
+Comparison to state of the art: We compare MBT to previous fusion methods on AudioSet in Table 1. We outperform all previous works on fusion (even though we only train on a quarter of the training set – 500K samples), including the recently introduced Perceiver [29] which uses early fusion followed by multiple self attention layers, and Attn Audio-Visual [18] which uses self-attention fusion on top of individual modality CNNs. We compare to previous video classification methods on Epic-Kitchens in Table 2, and note that our model outperforms all previous works that use vision only, as well as TBN [32] which uses three modalities - RGB, audio and optical flow. Given VGGSound is a relatively new dataset, we compare to two existing audio-only works4 (Table 3), and set the first audiovisual benchmark (that we are aware of) on this dataset.
+
+Table 3: Comparison to the state of the art on VGGSound [10]. Modalities are A: Audio, V: Visual, F: Optical flow. $\ddagger$ We calculate metrics on our test set for a fair comparison using the scores provided by the authors.   
+
+<table><tr><td>Model</td><td>Modalities</td><td>Top-1 Acc</td><td>Top-5 Acc</td></tr><tr><td>Chen et al‡ [10]</td><td>A</td><td>48.8</td><td>76.5</td></tr><tr><td>AudioSlowFastt [33]</td><td>A</td><td>50.1</td><td>77.9</td></tr><tr><td>MBT</td><td>A</td><td>52.3</td><td>78.1</td></tr><tr><td>MBT</td><td>V</td><td>51.2</td><td>72.6</td></tr><tr><td>MBT</td><td>A,V</td><td>64.1</td><td>85.6</td></tr></table>
+
+![](images/514c1102137c765a226ed7728c9c0650366fea7402ea28932f1f1ccbd15adb39.jpg)  
+Figure 6: Attention Maps. We compute maps of the attention from the output CLS tokens to the RGB image input space for a vanilla self-attention model and MBT on the Audioset test set. For each video clip, we show the original middle frame on the left with the ground truth labels overlayed at the bottom. The attention is particularly focused on sound source regions in the video that contain motion, eg. the fingertips on the piano, the hands on the string instrument, faces of humans. The bottlenecks in MBT further force the attention to be localised to smaller regions of the images (i.e the mouth of the baby on the top left and the mouth of the woman singing on the bottom right).
+
+Visualisation of attention maps Finally, we compute maps of the attention from the output CLS tokens to the RGB image input space using Attention Rollout [1]. Results on test images for both a vanilla fusion model and MBT trained on Audioset-mini (fusion layer $L _ { f } = 8$ ) are shown in Figure 6. We show the attention maps summed over all the frames in the video clip. We note that first, the model focuses on semantically salient regions in the video for audio classification, particularly regions where there is motion that creates or modifies sound, i.e. the mouth of humans making sounds, fingertips on a piano, hands and instruments. This is unlike state of the art sound source localisation techniques trained with images [9], which tend to highlight the entire object. We further note that the attention maps for MBT are more localised to these regions, showing that the tight bottlenecks do force the model to focus only on the image patches that are actually relevant for the audio classification task and which benefit from early fusion with audio.
+
+# 5 Conclusion
+
+We propose a new transformer architecture (MBT) for audiovisual fusion, and explore a number of different fusion strategies using cross-attention between latent tokens. We propose a novel strategy to restrict cross-modal attention via a small set of fusion ‘bottlenecks’, and demonstrate that this improves performance over vanilla cross-attention at lower computational cost, achieving state of the art results on a number of benchmarks. Future work will involve extending MBT to other modalities such as text and optical flow.
+
+Limitations: The fusion layer is a hyperparameter and may need to be tuned specifically for different tasks and datasets. We also only explore fully supervised fusion, and future work will tackle extensions to a self-supervised learning framework.
+
+Broader impact: Multimodal fusion strategies are important for machine learning, as fusing complementary information from different modalities can increase robustness when applied to real world applications. We also note that transformers are in general compute-heavy, which can have adverse environmental effects. We propose a token fusion method via bottlenecks that helps reduce computational complexity when applying transformers for multimodal fusion. Finally, we observe that training datasets contain biases that may render models trained on them unsuitable for certain applications. It is thus possible that people use classification models (intentionally or not) to make decisions that impact different groups in society differently, and it is important to keep this in mind when deploying, analysing and building upon these models.
+
+Acknowledgements: We would like to thank Joao Carreira for helpful discussions on the Perceiver [29].
+
+# References
+
+[1] Samira Abnar and Willem Zuidema. Quantifying attention flow in transformers. arXiv preprint arXiv:2005.00928, 2020.   
+[2] Hassan Akbari, Linagzhe Yuan, Rui Qian, Wei-Hong Chuang, Shih-Fu Chang, Yin Cui, and Boqing Gong. Vatt: Transformers for multimodal self-supervised learning from raw video, audio and text. NeurIPS, 2021.   
+[3] Jean-Baptiste Alayrac, Adrià Recasens, Rosalia Schneider, Relja Arandjelovic, Jason Ramapu- ´ ram, Jeffrey De Fauw, Lucas Smaira, Sander Dieleman, and Andrew Zisserman. Self-supervised multimodal versatile networks. In NeurIPS, 2020.   
+[4] Relja Arandjelovic and Andrew Zisserman. Look, listen and learn. In ICCV, 2017.   
+[5] Relja Arandjelovic and Andrew Zisserman. Objects that sound. In ECCV, 2018.   
+[6] Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Luciˇ c, and Cordelia ´ Schmid. Vivit: A video vision transformer. ICCV, 2021.   
+[7] Yusuf Aytar, Carl Vondrick, and Antonio Torralba. Soundnet: Learning sound representations from unlabeled video. In NeurIPS, 2016.   
+[8] Max Bain, Arsha Nagrani, Gül Varol, and Andrew Zisserman. Frozen in time: A joint video and image encoder for end-to-end retrieval. ICCV, 2021.   
+[9] Honglie Chen, Weidi Xie, Triantafyllos Afouras, Arsha Nagrani, Andrea Vedaldi, and Andrew Zisserman. Localizing visual sounds the hard way. In CVPR, 2021.   
+[10] Honglie Chen, Weidi Xie, Andrea Vedaldi, and Andrew Zisserman. VGGSound: A large-scale audio-visual dataset. In ICASSP, 2020.   
+[11] Tsuhan Chen and Ram R Rao. Audio-visual integration in multimodal communication. Proceedings of the IEEE, 86(5):837–852, 1998.   
+[12] Dima Damen, Hazel Doughty, Giovanni Maria Farinella, Antonino Furnari, Evangelos Kazakos, Jian Ma, Davide Moltisanti, Jonathan Munro, Toby Perrett, Will Price, et al. Rescaling egocentric vision. arXiv preprint arXiv:2006.13256, 2020.   
+[13] Mostafa Dehghani, Alexey Gritsenko, Anurag Arnab, Matthias Minderer, and Yi Tay. Scenic: A JAX library for computer vision research and beyond. arXiv preprint arXiv:2110.11403, 2021.   
+[14] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pages 248–255. Ieee, 2009.   
+[15] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019.   
+[16] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   
+[17] Ariel Ephrat, Inbar Mosseri, Oran Lang, Tali Dekel, Kevin Wilson, Avinatan Hassidim, William T Freeman, and Michael Rubinstein. Looking to listen at the cocktail party: a speaker-independent audio-visual model for speech separation. ACM Transactions on Graphics (TOG), 37(4):1–11, 2018.   
+[18] Haytham M Fayek and Anurag Kumar. Large scale audiovisual learning of sounds with weakly labeled data. arXiv preprint arXiv:2006.01595, 2020.   
+[19] Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. Slowfast networks for video recognition. In ICCV, pages 6202–6211, 2019.   
+[20] Valentin Gabeur, Chen Sun, Karteek Alahari, and Cordelia Schmid. Multi-modal transformer for video retrieval. In ECCV, volume 5. Springer, 2020.   
+[21] Jort F Gemmeke, Daniel PW Ellis, Dylan Freedman, Aren Jansen, Wade Lawrence, R Channing Moore, Manoj Plakal, and Marvin Ritter. Audio set: An ontology and human-labeled dataset for audio events. In ICASSP, pages 776–780. IEEE, 2017.   
+[22] Bernard Ghanem, Juan Carlos Niebles, Cees Snoek, Fabian Caba Heilbron, Humam Alwassel, Victor Escorcia, Ranjay Krishna, Shyamal Buch, and Cuong Duc Dao. The activitynet largescale activity recognition challenge 2018 summary. arXiv preprint arXiv:1808.03766, 2018.   
+[23] Yuan Gong, Yu-An Chung, and James Glass. AST: audio spectrogram transformer. arXiv preprint arXiv:2104.01778, 2021.   
+[24] David Harwath, Antonio Torralba, and James R Glass. Unsupervised learning of spoken language with visual context. NeurIPS, 2017.   
+[25] Lisa Anne Hendricks, John Mellor, Rosalia Schneider, Jean-Baptiste Alayrac, and Aida Nematzadeh. Decoupling the role of data, attention, and losses in multimodal transformers. arXiv preprint arXiv:2102.00529, 2021.   
+[26] Shawn Hershey, Sourish Chaudhuri, Daniel PW Ellis, Jort F Gemmeke, Aren Jansen, R Channing Moore, Manoj Plakal, Devin Platt, Rif A Saurous, Bryan Seybold, et al. CNN architectures for large-scale audio classification. In ICASSP, pages 131–135. IEEE, 2017.   
+[27] Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, 2016.   
+[28] Vladimir Iashin and Esa Rahtu. Multi-modal dense video captioning. In CVPR Workshops, pages 958–959, 2020.   
+[29] Andrew Jaegle, Felix Gimeno, Andrew Brock, Andrew Zisserman, Oriol Vinyals, and Joao Carreira. Perceiver: General perception with iterative attention. arXiv preprint arXiv:2103.03206, 2021.   
+[30] Aren Jansen, Daniel PW Ellis, Shawn Hershey, R Channing Moore, Manoj Plakal, Ashok C Popat, and Rif A Saurous. Coincidence, categorization, and consolidation: Learning to recognize sounds with minimal supervision. In ICASSP, 2020.   
+[31] Will Kay, Joao Carreira, Karen Simonyan, Brian Zhang, Chloe Hillier, Sudheendra Vijayanarasimhan, Fabio Viola, Tim Green, Trevor Back, Paul Natsev, et al. The kinetics human action video dataset. arXiv preprint arXiv:1705.06950, 2017.   
+[32] Evangelos Kazakos, Arsha Nagrani, Andrew Zisserman, and Dima Damen. Epic-fusion: Audiovisual temporal binding for egocentric action recognition. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5492–5501, 2019.   
+[33] Evangelos Kazakos, Arsha Nagrani, Andrew Zisserman, and Dima Damen. Slow-fast auditory streams for audio recognition. In ICASSP, pages 855–859. IEEE, 2021.   
+[34] Yelin Kim, Honglak Lee, and Emily Mower Provost. Deep learning for robust feature generation in audiovisual emotion recognition. In ICASSP. IEEE, 2013.   
+[35] Sangho Lee, Youngjae Yu, Gunhee Kim, Thomas Breuel, Jan Kautz, and Yale Song. Parameter efficient multimodal transformers for video representation learning. arXiv preprint arXiv:2012.04124, 2020.   
+[36] Guang Li, Linchao Zhu, Ping Liu, and Yi Yang. Entangled transformer for image captioning. In ICCV, pages 8928–8937, 2019.   
+[37] Jiaman Li, Yihang Yin, Hang Chu, Yi Zhou, Tingwu Wang, Sanja Fidler, and Hao Li. Learning to generate diverse dance motions with transformer. arXiv preprint arXiv:2008.08171, 2020.   
+[38] Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, and Kai-Wei Chang. Visualbert: A simple and performant baseline for vision and language. arXiv preprint arXiv:1908.03557, 2019.   
+[39] Ruilong Li, Shan Yang, David A Ross, and Angjoo Kanazawa. Learn to dance with aist++: Music conditioned 3d dance generation. arXiv preprint arXiv:2101.08779, 2021.   
+[40] Ji Lin, Chuang Gan, and Song Han. Temporal shift module for efficient video understanding. 2019 ieee. In ICCV, pages 7082–7092, 2019.   
+[41] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. In NeurIPS, 2019.   
+[42] Mathew Monfort, Alex Andonian, Bolei Zhou, Kandan Ramakrishnan, Sarah Adel Bargal, Tom Yan, Lisa Brown, Quanfu Fan, Dan Gutfreund, Carl Vondrick, et al. Moments in time dataset: one million videos for event understanding. IEEE transactions on pattern analysis and machine intelligence, 42(2):502–508, 2019.   
+[43] Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew $\mathrm { ~ Y ~ N ~ g ~ }$ . Multimodal deep learning. In ICML, 2011.   
+[44] Andrew Owens and Alexei A Efros. Audio-visual scene analysis with self-supervised multisensory features. In ECCV, 2018.   
+[45] Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. Specaugment: A simple data augmentation method for automatic speech recognition. arXiv preprint arXiv:1904.08779, 2019.   
+[46] Alexander Pashevich, Cordelia Schmid, and Chen Sun. Episodic transformer for vision-andlanguage navigation. In ICCV, 2021.   
+[47] Dhanesh Ramachandram and Graham W Taylor. Deep multimodal learning: A survey on recent advances and trends. IEEE Signal Processing Magazine, 34(6):96–108, 2017.   
+[48] Justin Salamon and Juan Pablo Bello. Deep convolutional neural networks and data augmentation for environmental sound classification. IEEE Signal Processing Letters, 24(3):279–283, 2017.   
+[49] Paul Hongsuck Seo, Arsha Nagrani, and Cordelia Schmid. Look before you speak: Visually contextualized utterances. In CVPR, 2021.   
+[50] Linda Smith and Michael Gasser. The development of embodied cognition: Six lessons from babies. Artificial life, 11(1-2):13–29, 2005.   
+[51] Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Learning video representations using contrastive bidirectional transformer. arXiv preprint arXiv:1906.05743, 2019.   
+[52] Chen Sun, Austin Myers, Carl Vondrick, Kevin Murphy, and Cordelia Schmid. Videobert: A joint model for video and language representation learning. In ICCV, 2019.   
+[53] Efthymios Tzinis, Scott Wisdom, Aren Jansen, Shawn Hershey, Tal Remez, Daniel PW Ellis, and John R Hershey. Into the wild with audioscope: Unsupervised audio-visual separation of on-screen sounds. arXiv preprint arXiv:2011.01143, 2020.   
+[54] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017.   
+[55] Limin Wang, Yuanjun Xiong, Zhe Wang, Yu Qiao, Dahua Lin, Xiaoou Tang, and Luc Van Gool. Temporal segment networks: Towards good practices for deep action recognition. In ECCV. Springer, 2016.   
+[56] Weiyao Wang, Du Tran, and Matt Feiszli. What makes training multi-modal classification networks hard? In CVPR, pages 12695–12705, 2020.   
+[57] Fanyi Xiao, Yong Jae Lee, Kristen Grauman, Jitendra Malik, and Christoph Feichtenhofer. Audiovisual slowfast networks for video recognition. arXiv preprint arXiv:2001.08740, 2020.   
+[58] Linwei Ye, Mrigank Rochan, Zhi Liu, and Yang Wang. Cross-modal self-attention network for referring image segmentation. In CVPR, 2019.   
+[59] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.   
+[60] Bolei Zhou, Alex Andonian, Aude Oliva, and Antonio Torralba. Temporal relational reasoning in videos. In ECCV, pages 803–818, 2018.

parse/train/KJ5h-yfUHa/KJ5h-yfUHa_content_list.json

@@ -0,0 +1,1209 @@
+[
+    {
+        "type": "text",
+        "text": "Attention Bottlenecks for Multimodal Fusion ",
+        "text_level": 1,
+        "bbox": [
+            225,
+            122,
+            772,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Arsha Nagrani Shan Yang Anurag Arnab Aren Jansen Cordelia Schmid Chen Sun ",
+        "bbox": [
+            279,
+            196,
+            712,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "{anagrani, shanyang, aarnab, arenjansen, cordelias, chensun}@google.com ",
+        "bbox": [
+            225,
+            227,
+            771,
+            238
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Google Research ",
+        "bbox": [
+            442,
+            242,
+            555,
+            256
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            295,
+            535,
+            313
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Humans perceive the world by concurrently processing and fusing highdimensional inputs from multiple modalities such as vision and audio. Machine perception models, in stark contrast, are typically modality-specific and optimised for unimodal benchmarks, and hence late-stage fusion of final representations or predictions from each modality (‘late-fusion’) is still a dominant paradigm for multimodal video classification. Instead, we introduce a novel transformer based architecture that uses ‘fusion bottlenecks’ for modality fusion at multiple layers. Compared to traditional pairwise self-attention, our model forces information between different modalities to pass through a small number of bottleneck latents, requiring the model to collate and condense relevant information in each modality and share what is necessary. We find that such a strategy improves fusion performance, at the same time reducing computational cost. We conduct thorough ablation studies, and achieve state-of-the-art results on multiple audio-visual classification benchmarks including Audioset, Epic-Kitchens and VGGSound. All code and models will be released. ",
+        "bbox": [
+            233,
+            328,
+            766,
+            534
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            310,
+            577
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Simultaneous multimodal sensations are a crucial enabler of human perceptual learning [50]. For artificial learning systems, however, designing a unified model for modality fusion is challenging due to a number of factors: (i) variations in learning dynamics between modalities [56], (ii) different noise topologies, with some modality streams containing more information for the task at hand than others, as well as (iii) specialised input representations. The difference in input representations between audio and vision is particularly stark – many state of the art audio classification methods rely on short term Fourier analysis to produce log-mel spectrograms, often using them as inputs to CNN architectures designed for images [26, 48]. These time-frequency representations have different distributions to images – multiple acoustic objects can have energy at the same frequency, and the translation invariances of CNNs may no longer be a desired property (while an acoustic object can be shifted in time, a shift in frequency could alter the meaning entirely). In contrast, the visual stream in a video is three-dimensional (two spatial and one temporal), and while different spatial regions of the image correspond to different objects, there is the unique challenge of high redundancy across multiple frames. Hence input representations, and consequently neural network architectures and benchmarks tend to vary wildly for different modalities. For simplicity, the dominant paradigm for multimodal fusion therefore often consists of an ad-hoc scheme that involves integrating separate audio and visual networks via their output representations or scores i.e. ‘late-fusion’ [22, 44]. ",
+        "bbox": [
+            174,
+            590,
+            825,
+            825
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present a new transformer based model for audiovisual fusion in video. Despite originally being proposed for NLP tasks, there has been recent interest in transformers [54] as universal perceptual models [29], due to their ability to model dense correlations between tokens, at the same time making few assumptions about their inputs (and because continuous perceptual inputs can be tokenised). By dividing dense continuous signals into patches and rasterising them to 1D tokens, transformers have been shown to perform competitively for image (ViT [16]) and video classification (ViViT [6]), and more recently, audio classification (AST [23]). Because these models are able to elegantly handle variable length sequences, a natural first extension would be to feed in a sequence of both visual and auditory patches to a transformer, with minimal changes to the architecture. This ‘early fusion’ model allows free attention flow between different spatial and temporal regions in the image, as well as across frequency and time in the audio spectrogram. While theoretically appealing, we hypothesise that full pairwise attention at all layers of the model is not necessary because audio and visual inputs contain dense, fine-grained information, much of which is redundant. This is particularly the case for video, as shown by the performance of ‘factorised’ versions of [6]. Such a model would also not scale well to longer videos due to the quadratic complexity of pairwise attention with token sequence length. To mitigate this, we propose two methods to restrict the flow of attention in our model. The first follows from a common paradigm in multimodal learning, which is to restrict cross-modal flow to later layers of the network, allowing early layers to specialise in learning and extracting unimodal patterns. Henceforth this is is referred to as ‘mid fusion’ (Fig. 1, middle left), where the layer at which cross-modal interactions are introduced is called the ‘fusion layer’. The two extreme versions of this are ‘early fusion’ (all layers are cross-modal) and ‘late fusion’ (all are unimodal) which we compare to as a baselines. Our second idea (and main contribution), is to restrict cross-modal attention flow between tokens within a layer. We do this by allowing free attention flow within a modality, but force our model to collate and ‘condense’ information from each modality before sharing it with the other. The core idea is to introduce a small set of latent fusion units that form an ‘attention bottleneck’, through which cross-modal interactions within a layer must pass. We demonstrate that this ‘bottlenecked’ version, which we name Multimodal Bottleneck Transformer (MBT), outperforms or matches its unrestricted counterpart, but with lower computational cost. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf31d718e1493908ff58400e72597290e9e88c3348dcc4c9bd28952c3484a552.jpg",
+        "image_caption": [
+            "Figure 1: Cross-modal Fusion. Unlike late fusion (left), where no cross-modal information is exchanged in the model until after the classifier, we investigate two pathways for the exchange of cross-modal information. The first is via standard pairwise self attention across all hidden units in a layer, but applied only to later layers in the model – mid fusion (middle, left). We also propose the use of ‘fusion bottlenecks’ (middle, right) that restrict attention flow within a layer through tight latent units. Both forms of restriction can be applied in conjunction (Bottleneck Mid Fusion) for optimal performance (right). We show $B = 2$ bottleneck units and 3 hidden units per modality. Grey boxes indicate tokens that receive attention flow from both audio and video tokens. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            90,
+            823,
+            199
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            352,
+            825,
+            669
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Concretely, we make the following contributions: (i) We propose a new architecture (MBT) for audiovisual fusion. Our model restricts the flow of cross-modal information between latent units through tight fusion ‘bottlenecks’, that force the model to collect and ‘condense’ the most relevant inputs in each modality (and therefore share only that which is necessary with the other modality). This avoids the quadratic scaling cost of full pairwise attention, and leads to performance gains with less compute; (ii) We apply MBT to image and spectogram patches (Fig. 2), and explore a number of ablations related to the fusion layer, the sampling of inputs and data size; and finally (iii) We set the new state-of-the-art for video classification across a number of popular audio-visual benchmarks, including AudioSet [21], Epic-Kitchens100 [12] and VGGSound [10]. On the Audioset dataset, we outperform the current state of the art by $5 . 9 \\mathrm { m A P }$ ( $12 . 7 \\%$ relative improvement). ",
+        "bbox": [
+            174,
+            675,
+            825,
+            814
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            835,
+            316,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Audiovisual learning: Audiovisual multimodal learning has a rich history, both before and during the deep learning era [47]. Given the limited available data and computational resources, early work focused on relatively simple early-stage (e.g. stacking hand-designed features) and late-stage (e.g. score fusion) techniques [11]. Deep learning has allowed more sophisticated strategies in which modality-specific or joint latents are implicitly learned to mediate the fusion. The result has enabled major advances in a range of downstream supervised audiovisual tasks [43, 34, 17]. In the supervised setting, multiple modality-specific convolution networks can be jointly trained, whose intermediate activations are then combined by summation [32] or via ‘lateral connections’ [57]. In the unsupervised setting, audiovisual learning is commonly used to learn good unimodal representations, with a popular pretraining task being to synchronise signals from different modalities via a contrastive loss [4, 5, 7, 44, 30, 2, 3], however each modality is usually encoded separately under this setup. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/571f07835a2d97d79335d6c5c47ed9d82d879cd1029f0ee9a914560b0db1f7df.jpg",
+        "image_caption": [
+            "Figure 2: A Multimodal Fusion Transformer applied to audiovisual inputs. The input sequence consists of image and spectrogram patches. These are then projected into tokens and appended to special CLS (classification) and FSN (fusion bottleneck) tokens. Our transformer encoder then uses self attention to model unimodal information, and restricts cross-modal information flow via cross attention with the bottleneck tokens at multiple layers of the network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            88,
+            820,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            352,
+            825,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multimodal transformers: The self attention operation of transformers provides a natural mechanism to connect multimodal signals. Multimodal transformers have been applied to various tasks including audio enhancement [17, 53], speech recognition [24], image segmentation [58, 53], crossmodal sequence generation [39, 37, 49], image and video retrieval [25, 20, 8], visual navigation [46] and image/video captioning/classification [41, 52, 51, 36, 28]. For many works, the inputs to transformers are the output representations of single modality CNNs [35, 20] – unlike these works we use transformer blocks throughout, using only a single convolutional layer to rasterise 2D patches. The tokens from different modalities are usually combined directly as inputs to the transformers [38], for example, the recently released Perceiver model [29] introduces an iterative attention mechanism which takes concatenated raw multimodal signals as inputs, which corresponds to our ‘early fusion’ baseline. In contrast, we carefully examine the impact of different modality fusion strategies, including limiting cross-modal attention flow to later layers of our model, and ‘channeling’ cross-modal connections through bottlenecks in our proposed Multimodal Bottleneck Transformer (MBT). ",
+        "bbox": [
+            173,
+            463,
+            826,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Multimodal fusion transformers ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            661,
+            473,
+            678
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section we describe our proposed Multimodal Bottleneck Transformer (MBT). We begin by summarising the recently proposed Vision Transformer (ViT) [16] and Audio Spectrogram Transformer (AST) [23], developed for image and audio classification respectively, in Sec. 3.1. We then describe our extension to the audio-visual fusion case. We discuss three different token fusion strategies (Sec. 3.2), and finally discuss the fusion pathway in the entire model (Sec. 3.3), which involves restricting multimodal fusion to certain layers of the model. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 The ViT and AST architectures ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            792,
+            431,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Vision Transformer (ViT) [16] (and a recent extension to audio – Audio Spectrogram Transformer (AST) [23]) adapts the Transformer architecture [54], originally designed for natural language processing, to process 2D inputs with minimal changes. The key insight is to extract $N$ nonoverlapping patches from the RGB image (or the audio spectrogram), $x _ { i } \\in \\mathbb { R } ^ { h \\times w }$ , and convert them into a series of 1D tokens $z _ { i } \\in \\mathbb { R } ^ { d }$ , as follows: ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5645e1f391eda2168ceb75db451b6589e8671d9dc771ea73d8a687f52e808d47.jpg",
+        "text": "$$\n\\mathbf { z } = g ( \\mathbf { x } ; \\mathbf { E } , z _ { \\mathrm { c l s } } ) = \\left[ z _ { \\mathrm { c l s } } , \\mathbf { E } x _ { 1 } , \\mathbf { E } x _ { 2 } , . . . , \\mathbf { E } x _ { N } \\right] + \\mathbf { p } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            895,
+            666,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\mathbf { E }$ is a linear projection mapping each token to $\\mathbb { R } ^ { d }$ , $z _ { \\mathrm { c l s } }$ is a special token prepended to this sequence so that its representation at the final layer can be passed to a classifier for classification tasks [15], and $\\mathbf { p } \\in \\bar { \\mathbb { R } } ^ { ( N + 1 ) \\times d }$ is a learned positional embedding added to the tokens to retain positional information (as all subsequent self-attention operations are permutation invariant). ",
+        "bbox": [
+            174,
+            90,
+            825,
+            148
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The tokens are then passed through an encoder consisting of a sequence of $L$ transformer layers. Each transformer layer consists of Multi-Headed Self-Attention (MSA), Layer Normalisation (LN) and Multilayer Perceptron (MLP) blocks applied using residual connections. We denote a transformer layer, $\\mathbf { z } ^ { \\bar { l } + 1 } = \\mathrm { T r a n s f o r m e r } ( \\mathbf { z } ^ { l } )$ as ",
+        "bbox": [
+            173,
+            154,
+            825,
+            210
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85935015db6efc2dd0e28ab9c623193d55197ae35a11d0641b35dcc28e5224c9.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { y } ^ { l } = \\mathrm { M S A } ( \\mathrm { L N } ( \\mathbf { z } ^ { l } ) ) + \\mathbf { z } ^ { l } } \\\\ { \\mathbf { z } ^ { l + 1 } = \\mathrm { M L P } ( \\mathrm { L N } ( \\mathbf { y } ^ { l } ) ) + \\mathbf { y } ^ { l } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            212,
+            596,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here, the MSA operation [54] computes dot-product attention [54] where the queries, keys and values are all linear projections of the same tensor, $\\operatorname { M S A } ( \\mathbf { X } ) = \\operatorname { A t t e n t i o n } ( \\mathbf { W } ^ { Q } \\mathbf { X } , \\mathbf { W } ^ { K } \\mathbf { X } , { \\dot { \\mathbf { W } } } ^ { V } \\mathbf { X } )$ . We further define Multi-Headed Cross Attention (MCA) between two tensors, $\\mathbf { X }$ and $\\mathbf { Y }$ , where $\\mathbf { X }$ forms the query and $\\mathbf { Y }$ forms the keys and values which are used to reweight the query as $\\operatorname { M C A } ( \\mathbf { X } , \\mathbf { Y } ) = \\operatorname { A t t e n t i o n } ( \\mathbf { W } ^ { Q } \\mathbf { X } , \\mathbf { W } ^ { K } \\mathbf { Y } , \\mathbf { W } ^ { V } \\mathbf { Y } )$ . This will be used in our multimodal case, as described next. ",
+        "bbox": [
+            173,
+            255,
+            825,
+            338
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Multimodal transformer ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            353,
+            383,
+            368
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now describe our extension to the multimodal case. We begin by discussing three different token fusion strategies. ",
+        "bbox": [
+            174,
+            378,
+            825,
+            409
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 Fusion via vanilla self-attention ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            421,
+            444,
+            436
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We begin by describing a ‘vanilla’ fusion model, which simply consists of the regular transformer applied to multimodal inputs. Our method of tokenising video is straightforward – given a video clip of length $t$ seconds, we uniformly sample $F$ RGB frames and convert the audio waveform into a single spectrogram. We then embed each frame and the spectrogram independently following the encoding proposed in ViT [16], and concatenate all tokens together into a single sequence. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Formally, if we have extracted a total of $N _ { v }$ RGB patches from all $F$ sampled frames, $\\mathbf { x } _ { \\mathrm { r g b } } \\in \\mathbb { R } ^ { N _ { v } \\times d }$ and $N _ { a }$ spectrogram patches, $\\mathbf { x } _ { \\mathrm { s p e c } } \\in \\mathbb { R } ^ { N _ { a } \\times d }$ , our sequence of tokens is ",
+        "bbox": [
+            173,
+            520,
+            825,
+            551
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { z } = [ \\mathbf { z } _ { \\mathrm { r g b } } | | \\mathbf { z } _ { \\mathrm { s p e c } } ]$ where ${ \\bf z } _ { \\mathrm { r g b } } = g ( { \\bf x } _ { \\mathrm { r g b } } ; { \\bf E } _ { \\mathrm { r g b } } , z _ { \\mathrm { c l s - r g b } } )$ and $\\begin{array} { r } { \\mathbf { z } _ { \\mathrm { s p e c } } = g ( \\mathbf { x } _ { \\mathrm { s p e c } } ; \\mathbf { E } _ { \\mathrm { s p e c } } , z _ { \\mathrm { c l s - s p e c } } ) . } \\end{array}$ (4) Here, $\\left[ \\mathbf { z } _ { \\mathrm { r g b } } | | \\mathbf { z } _ { \\mathrm { s p e c } } \\right]$ denotes the concatenation of the tokens for each modality. We use different projections $\\mathbf { E } _ { \\mathrm { r g b } }$ and $\\mathbf { E } _ { \\mathrm { s p e c } }$ for RGB and spectrogram patches respectively, and prepend a separate classification token for each modality. ",
+        "bbox": [
+            174,
+            554,
+            826,
+            616
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our multimodal encoder then applies a series of transformer layers in the same manner as above. Attention is allowed to flow freely through the network, i.e. each RGB token can attend to all other RGB and spectrogram tokens as follows: $\\mathbf { \\bar { z } } ^ { l + 1 } = \\mathrm { T r a n s f o r m e r } ( \\mathbf { z } ^ { l } ; \\theta )$ with model parameters $\\theta$ . Here Transformer refers to a standard transformer layer with vanilla self-attention blocks. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            678
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 Fusion with modality-specific parameters ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            691,
+            513,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can generalise this model by allowing each modality to have its own dedicated parameters $\\theta _ { \\mathrm { r g b } }$ and $\\theta _ { \\mathrm { s p e c } }$ , but still exchange information via the attention mechanism. For this purpose, we define a Cross-Transformer layer: ",
+        "bbox": [
+            174,
+            714,
+            825,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb0294e9307f7a8ede9ae32b1c2d4737098d0e10cbd80a8b6550ec66318c974b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { z } _ { \\mathrm { r g b } } ^ { l + 1 } = \\mathrm { C r o s s - T r a n s f o r m e r } ( \\mathbf { z } _ { \\mathrm { r g b } } ^ { l } , \\mathbf { z } ^ { l } ; \\theta _ { \\mathrm { r g b } } ) } \\\\ & { \\mathbf { z } _ { \\mathrm { s p e c } } ^ { l + 1 } = \\mathrm { C r o s s - T r a n s f o r m e r } ( \\mathbf { z } _ { \\mathrm { s p e c } } ^ { l } , \\mathbf { z } ^ { l } ; \\theta _ { \\mathrm { s p e c } } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            758,
+            642,
+            803
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the Cross-Transformer employs the generalised cross-attention operation that takes two sets of inputs $\\mathbf { z } _ { 1 }$ and $\\mathbf { z } _ { 2 }$ that are not necessarily overlapping. This layer follows the original transformer layer with the difference being that Eq. 2 becomes ",
+        "bbox": [
+            173,
+            803,
+            823,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/32b2062f24980f619eb2dab672536ed4eed1c705e5b61169b46d92b57f83beff.jpg",
+        "text": "$$\n\\mathbf { y } ^ { l } = \\mathrm { M C A } ( \\mathrm { L N } ( \\mathbf { z } _ { 1 } ^ { l } ) , \\mathrm { L N } ( \\mathbf { z } _ { 2 } ^ { l } ) ) + \\mathbf { z } _ { 1 } ^ { l } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            848,
+            619,
+            867
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, note that we have explicitly defined the parameters, $\\theta _ { \\mathrm { r g b } }$ and $\\theta _ { \\mathrm { s p e c } }$ of the cross-transformer layers in Eq. 5 as they are different for each modality. However, when $\\theta _ { \\mathrm { r g b } }$ and $\\theta _ { \\mathrm { s p e c } }$ are equal, $\\theta _ { \\mathrm { r g b } } = \\theta _ { \\mathrm { s p e c } } = \\theta ,$ ), the computation defined in Eq. 5 is equivalent to Sec. 3.2.1. ",
+        "bbox": [
+            174,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 Fusion via attention bottlenecks ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            90,
+            446,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to tame the quadratic complexity of pairwise attention, we next introduce a small set of $B$ fusion bottleneck tokens $\\mathbf { z } _ { \\mathrm { f s n } } = [ \\dot { z } _ { \\mathrm { f s n } } ^ { 1 } , z _ { \\mathrm { f s n } } ^ { \\dot { 2 } } , \\dots , z _ { \\mathrm { f s n } } ^ { B } ]$ to our input sequence (see Fig. 2). The input sequence is now ",
+        "bbox": [
+            176,
+            114,
+            825,
+            156
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af4f1dac72e0c7d60524772f63734313bc2b0f94ca5e3f297a3cafa2f605cfdd.jpg",
+        "text": "$$\n\\mathbf { z } = [ \\mathbf { z } _ { \\mathrm { r g b } } | | \\mathbf { z } _ { \\mathrm { f s n } } | | \\mathbf { z } _ { \\mathrm { s p e c } } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            155,
+            570,
+            172
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We then restrict all cross-modal attention flow in our model to be via these bottleneck tokens. More formally for layer $l$ , we compute token representations as follows: ",
+        "bbox": [
+            174,
+            174,
+            825,
+            203
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d64c2ead00ee85823c36ee12318ad2bd770c9f416c10a38ac938c9d56278de3e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { [ \\mathbf { z } _ { \\mathrm { i } } ^ { l + 1 } | | \\hat { \\mathbf { z } } _ { \\mathrm { f s n } _ { i } } ^ { l + 1 } ] = \\mathrm { T r a n s f o r m e r } ( [ \\mathbf { z } _ { \\mathrm { i } } ^ { l } | | \\mathbf { z } _ { \\mathrm { f s n } } ^ { l } ] ; \\theta _ { \\mathrm { i } } ) } \\\\ & { \\qquad \\mathbf { z } _ { \\mathrm { f s n } } ^ { l + 1 } = \\mathrm { A v g _ { i } } ( \\hat { \\mathbf { z } } _ { \\mathrm { f s n } _ { i } } ^ { l + 1 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            227,
+            637,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $i$ indexes each modality, in this case RGB and Spec, and $\\mathbf { z } _ { \\mathrm { r g b } }$ and $\\mathbf { z } _ { \\mathrm { s p e c } }$ can only exchange information via the bottleneck $\\mathbf { z } _ { \\mathrm { f s n } }$ within a transformer layer. We first create modality specific temporary bottleneck fusion tokens $\\hat { \\mathbf { z } } _ { \\mathrm { f s n } _ { i } }$ , which are updated separately and simultaneously with audio and visual information (Equation 8). The final fusion tokens from each cross-modal update are then averaged in Equation 9. We also experiment with asymmetric updates for the bottleneck tokens (see appendix) and found performance was robust to this choice. We keep the number of bottleneck tokens in the network to be much smaller than the total number of latent units per modality $B \\ll N _ { v }$ and $B \\ll N _  a , $ ). Because all cross-modal attention flow must pass through these units, these tight ‘fusion’ bottlenecks force the model to condense information from each modality and share that which is necessary. As we show in the experiments, this increases or maintains performance for multimodal fusion, at the same time reducing computational complexity. We also note that our formulation is generic to the type and the number of modalities. ",
+        "bbox": [
+            173,
+            273,
+            825,
+            440
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Where to fuse: early, mid and late ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            449,
+            472
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The above strategies discuss fusion within a layer, and in most transformer architectures (such as ViT), every layer consists of an identical set of operations. A common paradigm in multimodal learning, however, is to restrict early layers of a network to focus on unimodal processing, and only introduce cross-modal connections at later layers. This is conceptually intuitive if we believe lower layers are involved in processing low level features, while higher layers are focused on learning semantic concepts – low-level visual features such as edges and corners in images might not have a particular sound signature, and therefore might not benefit from early fusion with audio [57]. ",
+        "bbox": [
+            173,
+            482,
+            825,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This can be implemented with our model as follows: We initially perform vanilla self-attention among tokens from a single modality for $L _ { f }$ layers. Thereafter, we concatenate all latent tokens together, $\\mathbf { z } ^ { L _ { f } } = [ \\mathbf { z } _ { \\mathrm { r g b } } ^ { L _ { f } } | | \\mathbf { z } _ { \\mathrm { s p e c } } ^ { L _ { f } } ]$ and pass them through the remaining $L - L _ { f }$ layers where the tokens are fused according to Sec. 3.2. Here, $L _ { f } = 0$ corresponds to an ‘early-fusion’ model, $L _ { f } = L$ a ‘late-fusion’ model, and $0 < L _ { f } < L$ a ‘mid-fusion’ one. More formally, this can be denoted as ",
+        "bbox": [
+            174,
+            585,
+            825,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0f7707c700a89b8a039061ac746476e7b278126894d461ed55687d7df16b7a40.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { z } _ { \\mathrm { r g b } } ^ { l + 1 } = \\mathrm { T r a n s f o r m e r } ( \\mathbf { z } _ { \\mathrm { r g b } } ^ { l } ; \\theta _ { \\mathrm { r g b } } ) , \\mathbf { z } _ { \\mathrm { s p e c } } ^ { l + 1 } = \\mathrm { T r a n s f o r m e r } ( \\mathbf { z } _ { \\mathrm { s p e c } } ^ { l } ; \\theta _ { \\mathrm { s p e c } } ) } & { \\mathrm { i f ~ } l < L _ { f } } \\\\ & { \\mathbf { z } ^ { l } = [ \\mathbf { z } _ { \\mathrm { r g b } } ^ { l } | | \\mathbf { z } _ { \\mathrm { s p e c } } ^ { l } ] , \\mathbf { z } ^ { l + 1 } = \\mathrm { M u l t i m o d a l - T r a n s f o r m e r } ( \\mathbf { z } ^ { l } ; \\theta _ { \\mathrm { s p e c } } , \\theta _ { \\mathrm { r g b } } ) } & { \\mathrm { o t h e r w i s e } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            667,
+            807,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where Multimodal-Transformer $( \\cdot )$ can refer to either of the 3 fusion strategies described in Sec 3.2. ",
+        "bbox": [
+            171,
+            717,
+            823,
+            733
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Classification ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            747,
+            307,
+            762
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For all model variants described above, we pass output representations of the CLS tokens $z _ { \\mathrm { c l s - r g b } } ^ { L }$ and $z _ { \\mathrm { c l s - s p e c } } ^ { L }$ to the same linear classifier and average the pre-softmax logits. ",
+        "bbox": [
+            174,
+            773,
+            823,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            824,
+            312,
+            842
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We apply MBT to the task of video classification. In this section we first describe the datasets used to train and test multimodal fusion and their respective evaluation protocols (Sec. 4.1), then discuss implementation details (Sec. 4.2). We then ablate the key design choices in our model (Sec. 4.3), before finally comparing our model to the state of the art (Sec. 4.4). ",
+        "bbox": [
+            174,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Datasets and evaluation protocol ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            92,
+            439,
+            106
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We experiment with three video classification datasets – AudioSet [21], Epic-Kitchens-100 [12] and VGGSound [10], described in more detail below. Results on two additional datasets Moments in Time [42] and Kinetics [31] are provided in the appendix. ",
+        "bbox": [
+            176,
+            118,
+            823,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "AudioSet [21] consists of almost 2 million 10-second video clips from YouTube, annotated with 527 classes. Like other YouTube datasets, this is a dynamic dataset (we only use the clips still available online). This gives us 20,361 clips for the balanced train set (henceforth referred to as mini-AudioSet or miniAS) and 18,589 clips for the test set. This test set is exactly the same as recent works we compare to, including Perceiver [29]. Instead of using the 2M unbalanced training set, we train on a (slightly more) balanced subset consisting of 500K samples (AS-500K). Details are provided in the appendix. Because each sample has multiple labels, we train with a binary cross-entropy (BCE) loss and report mean average precision (mAP) over all classes, following standard practice. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            270
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Epic-Kitchens 100 [12] consists of egocentric videos capturing daily kitchen activities. The dataset consists of 90,000 variable length clips spanning 100 hours. We report results for action recognition following standard protocol [12] - each action label is a combination of a verb and noun, and we predict both using a single network with two ‘heads’, both trained with a cross-entropy loss. The top scoring verb and action pair predicted by the network are used, and Top-1 action accuracy is the primary metric. Actions are mainly short-term (average length is 2.6s with minimum length 0.25s). ",
+        "bbox": [
+            174,
+            271,
+            825,
+            353
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "VGGSound [10] contains almost 200K video clips of length 10s, annotated with 309 sound classes consisting of human actions, sound-emitting objects and human-object interactions. Unlike AudioSet, the sound source for each clip is ‘visually present’ in the video. This was ensured during dataset creation through the use of image classifiers. After filtering clips that are no longer available on YouTube, we end up with 172,427 training and 14,448 test clips. We train with a standard crossentropy loss for classification and report Top-1 and Top-5 classification accuracy. ",
+        "bbox": [
+            174,
+            353,
+            825,
+            435
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Implementation details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            444,
+            374,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our backbone architecture follows that of ViT [16] identically, specifically we use ViT-Base (ViT-B, $L = 1 2$ , $N _ { H } = 1 2$ , $d = 3 0 7 2 )$ initialised from ImageNet-21K [14], however we note that our method is agnostic to transformer backbone. Unless otherwise specialised, we use $B = 4$ bottleneck tokens for all experiments with bottleneck fusion. Bottleneck tokens are initialized using a Gaussian with mean of 0 and standard deviation of 0.02, similar to the positional embeddings in the public ViT [16] code. We randomly sample clips of $t$ seconds for training. RGB frames for all datasets are extracted at 25 fps. For AudioSet and VGGSound we sample 8 RGB frames over the sampling window of length $t$ with a uniform stride of length $( t \\times 2 5 ) / \\bar { 8 }$ . We extract $1 6 \\times 1 6$ patches from each frame of size $2 2 4 \\times 2 2 4$ , giving us a total of $8 \\times 1 4 \\times 1 4 = 1 5 6 8$ patches per video. For Epic-Kitchens (because the segments are shorter), we sample 32 frames with stride 1. Audio for all datasets is sampled at $1 6 \\mathrm { k H z }$ and converted to mono channel. Similar to [23], we extract log mel spectrograms with a frequency dimension of 128 computed using a $2 5 \\mathrm { m s }$ Hamming window with hop length $1 0 \\mathrm { m s }$ . This gives us an input of size $1 2 8 \\times 1 0 0 t$ for $t$ seconds of audio. Spectrogram patches are extracted with size $1 6 \\times 1 6$ , giving us $5 0 \\times 8 = 4 0 0$ patches for 8 seconds of audio. For images we apply the standard data augmentations used in [6] (random crop, flip, colour jitter), and for spectrograms we use SpecAugment [45] with a max time mask length of 192 frames and max frequency mask length of 48 bins following AST [23]. We set the base learning rate to 0.5 and train for 50 epochs, using Mixup [59] with $\\alpha = 0 . 3$ and stochastic depth regularisation [27] with probability $p = 0 . 3$ . All models (across datasets) are trained with a batch size of 64, synchronous SGD with momentum of 0.9, and a cosine learning rate schedule with warmup of 2.5 epochs on TPU accelerators using the Scenic library [13]. ",
+        "bbox": [
+            173,
+            470,
+            825,
+            761
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inference: Following standard practice, we uniformly sample multiple temporal crops from the clip and average per-view logits to obtain the final result. The number of test crops is set to 4. ",
+        "bbox": [
+            173,
+            761,
+            823,
+            789
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Ablation analysis ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            810,
+            333,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section we investigate the impact of the different architectural choices in MBT. Unless otherwise specified, we use the mini-AudioSet split for training and report results on the AudioSet eval split. More ablations on backbone size and pretraining initalisation can be found in the appendix. ",
+        "bbox": [
+            176,
+            837,
+            825,
+            878
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3.1 Fusion strategies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            92,
+            343,
+            106
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We implement all the three fusion strategies described in Sec. 3.2: ",
+        "bbox": [
+            173,
+            116,
+            606,
+            128
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(i) Vanilla self-attention – Unrestricted pairwise attention between all latent units within a layer; (ii) Vanilla cross-attention with separate weights: Same as above, but we now have separate weights for each modality. The latent units are updated via pairwise attention with all other latent units from both modalities; and finally ",
+        "bbox": [
+            174,
+            130,
+            825,
+            184
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "(iii) Bottleneck fusion: Here all cross-modal attention must pass through bottleneck fusion latents. Note that these three fusion strategies only describe attention flow between tokens within a layer. For strategies (ii) and (iii), we also conduct experiments showing the impact of restricting cross-modal attention to layers after a fixed fusion layer $L _ { f }$ . We investigate models with different fusion layers, $L _ { f } = 0 , 2 , 4 , 6 , 8 , 1 0 , 1 2$ , and present the results in Fig. 3.2 ",
+        "bbox": [
+            174,
+            185,
+            825,
+            255
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Sharing weights for both modalities: We first investigate the impact of sharing the encoder weights for both modalities (strategy (i) vs (ii)). The results can be found in Fig. 1 in the appendix. When modalities are fused at earlier layers, using separate encoders improves performance. For models with later fusion layers, performance is similar for both models. We hence use separate modality weights for further experiments. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            323
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fusion layer: We then investigate the impact of varying the fusion layer $L _ { f }$ , for the latter two strategies: (ii) Vanilla Cross-Attention and (iii) Bottleneck Fusion. We conduct experiments with $L _ { f } = \\stackrel { \\_ } { 0 } , 2 , 4 , 6 , 8 , 1 0 , 1 2$ . We fix the input span $t$ to 4s and the number of bottleneck tokens $B$ to 4. We conduct 3 runs for each experiment and report mean and std deviation. As can be seen from Fig. 3 (left), ‘mid fusion’ outperforms both early $( L _ { f } = 0 )$ ) and late fusion $( L _ { f } = 1 2 )$ ), with optimal performance obtained by using fusion layer $L _ { f } = 1 0$ for vanilla cross-attention and $L _ { f } = 8$ for bottleneck attention. This suggests that the model benefits from restricting cross-modal connections to later layers, allowing earlier layers to specialise to learning unimodal features, however still benefits from multiple layers of cross-modal information flow. In appendix $\\mathbf { D }$ , we confirm that mid fusion outperforms late fusion across a number of different datasets. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Attention bottlenecks: In Fig. 3, we also examine the effect of bottleneck attention vs vanilla cross-attention for multimodal fusion. We find that for all values of $L _ { f }$ restricting flow to bottlenecks improves or maintains performance, with improvements more prominent at lower values of $L _ { f }$ . At $L _ { f } = 1 0$ , both perform similarly, note that at this stage we only have 3 fusion layers in the model. Our best performing model uses attention bottlenecks with $L _ { f } = 8$ , and we fix this for all further experiments. We also compare the amount of computation, measured in GFLOPs, for both fusion strategies (Fig. 3, right). Using a small number of bottleneck tokens (in our experiments $B = 4$ ) adds negligible extra computation over a late fusion model, with computation remaining largely constant with varying fusion layer $L _ { f }$ . This is in contrast to vanilla cross-fusion, which has a non-negligible computational cost for every layer it is applied to. We note that for early fusion $\\begin{array} { r } { { \\cal L } _ { f } = 0 } \\end{array}$ ), bottleneck fusion outperforms vanilla cross-attention by over $2 \\mathrm { m A P } ,$ , with less than half the computational cost. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            613
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Number of bottleneck tokens $B$ : We experiment with $B = 4$ , 36, 64, 256 and 1024, and find that performance is relatively consistent (all within $0 . 5 \\mathrm { \\ m A P }$ ). We hence fix the number of tokens to $B = 4$ for all experiments. It is interesting that with such a small number of cross-modal connections through only 4 hidden units $B = 4$ ) at each cross-modal layer, we get large performance gains over late fusion (Fig. 3), highlighting the importance of allowing cross-modal information to flow at multiple layers of the model. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            695
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3.2 Input sampling and dataset size ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            444,
+            727
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we investigate the impact of different modality sampling strategies. We also compare to single modality baselines – the visual-only and audio-only baselines consist of a vanilla transformer model applied to only the RGB or spectrogram patches respectively. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Sampling window size $t$ : An advantage of our transformer based model is that we can easily input variable length token sequences. We experiment with varying the sampling window $t$ with the following values $t = 2 , 4 , 6$ and 8 seconds (note that all videos in AudioSet are 10s), and show results in Fig. $\\bar { 4 ^ { 3 } }$ . At inference, we uniformly sample multiple windows covering the entire video. While the number of spectrogram patches $N _ { a }$ changes with $t$ , we keep the number of RGB patches $N _ { v }$ fixed by changing the stride of frames (to avoid running out of memory). Our results indicate that the performance of both the audio and audio-visual fusion model increases with input span, however the performance of the visual-only model slightly decreases (we hypothesize that this is due to the increased fixed stride, meaning fewer frames are randomly sampled during training). We fix $t = 8 s$ in all further experiments. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b9edffab7708afc79614b4e1edcbfb86b3d50d5eff07fed808b001f22d8ef7e4.jpg",
+        "image_caption": [
+            "Figure 3: The impact of using attention bottlenecks for fusion on performance (left) and compute (right) at different fusion layers $L _ { f }$ on AudioSet, using clip span $t = 4$ and $B = 4$ bottleneck tokens. Attention bottlenecks improve performance at lower computational cost. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            90,
+            821,
+            222
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/78c397a11b2b43241bea996075b0420424a7ff01fc3b19a5640a831630113b57.jpg",
+        "image_caption": [
+            "Figure 4: The effect of varying input clip span $t$ on the AudioSet test set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            284,
+            472,
+            439
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/52df0536c4b0f292541eff06643a52573084266c8addf3a6b7d36d7642cbfec0.jpg",
+        "image_caption": [
+            "Figure 5: The effect of training data size on the AudioSet test set. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            522,
+            282,
+            802,
+            439
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            496,
+            825,
+            564
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Synchronous vs asynchronous sampling: Given that auditory and visual events may not always be perfected aligned in videos [32], we also investigate asynchronous sampling of different modalities. Here input windows are sampled independently from the entire video clip for each modality. Results are provided in Fig. 2 in the appendix. We find performance to be largely robust to either case, and so for simplicity we use synchronised sampling for all further experiments. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            633
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Modality MixUp: While applying Mixup regularization [59] to training, we note that there are two different ways to apply it for multimodal inputs – the standard approach is to sample one set of mixup weights from a Beta distribution using the parameter $\\alpha$ , and use it to generate all virtual modality-label pairs [59]. We also explore a modified version which we call modality mixup, which samples an independent weight for each modality. Modality mixup imposes stronger augmentation than standard mixup, leading to a slight improvement $( 4 2 . 6 \\ : \\mathrm { m A P }$ to $4 3 . 9 \\mathrm { m A P }$ ) on AudioSet. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            717
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Impact of dataset size: We show the impact of varying the number of training samples in Fig. 5, and find a monotonic increase with dataset size (more steeply for audio-only than visual-only). ",
+        "bbox": [
+            174,
+            717,
+            825,
+            744
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Results ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            761,
+            263,
+            775
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison to single modality performance: We compare MBT to visual-only and audio-only baselines on AudioSet (Table 1), Epic-Kitchens (Table 2) and VGGSound (Table 3). Note we use the best parameters obtained via the ablations above, i.e. bottleneck fusion with $t = 8$ , $B = 4$ , $F _ { l } = 8$ and modality mixup. For all datasets, multimodal fusion outperforms the higher-performing single modality baseline, demonstrating the value of complementary information. The relative importance of modalities for the classification labels varies (audio-only has higher relative performance for AudioSet and lower for Epic-Kitchens, while both audio and visual baselines are equally strong for VGGSound). This is (unsurprisingly) largely a function of the dataset annotation procedure and positions VGGSound as a uniquely suitable dataset for fusion. We also show that audio-visual fusion provides slight performance gains for traditionally video only datasets such as Kinetics and Moments in Time (details provided in Appendix C ). We also examine per-class performance on the Audioset dataset (Figures 3 and 4 in the Appendix), and find that for the top 60 classes (ranked by overall performance), audio-visual fusion improves performance over audio only or visual only for almost all (57 out of 60) classes, except for ‘bagpiping’, ‘emergency vehicle’ and ‘didgeridoo’ which have strong audio signatures. For classes such as ‘bicycle’ and ‘shuffling cards’ where audio signals are weaker, fusion improves over the audio-only baseline by over $60 \\%$ in absolute AP. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/333428d305c00902c3e8dc2209df8a44b444b6230c5a3c638a647ca99a2ed997.jpg",
+        "table_caption": [
+            "Table 1: Comparison to SOTA on AudioSet [21]. We report mean average precision (mAP). We outperform works that train on the full Audioset (2M samples), while we train on only $5 0 0 \\mathrm { K }$ samples. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Training Set</td><td>tAonly</td><td>V only</td><td>AVFusion</td></tr><tr><td>GBlend [56]</td><td>MiniAS</td><td>29.1</td><td>22.1</td><td>37.8</td></tr><tr><td>GBlend [56]</td><td>FullAS-2M</td><td>32.4</td><td>18.8</td><td>41.8</td></tr><tr><td>Attn Audio-Visual[18]</td><td>FullAS-2M</td><td>38.4</td><td>25.7</td><td>46.2</td></tr><tr><td>Perceiver [29]</td><td>FullAS-2M</td><td>38.4</td><td>25.8</td><td>44.2</td></tr><tr><td>MBT</td><td>MiniAS</td><td>31.3</td><td>27.7</td><td>43.9</td></tr><tr><td>MBT</td><td>AS-500K</td><td>44.3</td><td>32.3</td><td>52.1</td></tr></table>",
+        "bbox": [
+            250,
+            88,
+            746,
+            203
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/2e147ab4f85de997e76a274860a5bf1486453fdbaf386b8fc5a020b6a9aea0eb.jpg",
+        "table_caption": [
+            "Table 2: Comparison to SOTA on EpicKitchens-100 [12]. Modalities are A: Audio, V: Visual, F: Optical flow. †Uses pretraining on VGGSound. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Modalities</td><td>Verb</td><td>Noun</td><td>Action</td></tr><tr><td>Damen et al. [12]</td><td>A</td><td>42.1</td><td>21.5</td><td>14.8</td></tr><tr><td>AudioSlowFast [33]t</td><td>A</td><td>46.5</td><td>22.78</td><td>15.4</td></tr><tr><td>TSN [55]</td><td>V,F</td><td>60.2</td><td>46.0</td><td>33.2</td></tr><tr><td>TRN [60]</td><td>V,F</td><td>65.9</td><td>45.4</td><td>35.3</td></tr><tr><td>TBN [32]</td><td>A,V,F</td><td>66.0</td><td>47.2</td><td>36.7</td></tr><tr><td>TSM[40]</td><td>V,F</td><td>67.9</td><td>49.0</td><td>38.3</td></tr><tr><td>SlowFast [19]</td><td>V</td><td>65.6</td><td>50.0</td><td>38.5</td></tr><tr><td>MBT</td><td>A</td><td>44.3</td><td>22.4</td><td>13.0</td></tr><tr><td>MBT</td><td>V</td><td>62.0</td><td>56.4</td><td>40.7</td></tr><tr><td>MBT</td><td>A,V</td><td>64.8</td><td>58.0</td><td>43.4</td></tr></table>",
+        "bbox": [
+            287,
+            270,
+            710,
+            439
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            522,
+            825,
+            619
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Comparison to state of the art: We compare MBT to previous fusion methods on AudioSet in Table 1. We outperform all previous works on fusion (even though we only train on a quarter of the training set – 500K samples), including the recently introduced Perceiver [29] which uses early fusion followed by multiple self attention layers, and Attn Audio-Visual [18] which uses self-attention fusion on top of individual modality CNNs. We compare to previous video classification methods on Epic-Kitchens in Table 2, and note that our model outperforms all previous works that use vision only, as well as TBN [32] which uses three modalities - RGB, audio and optical flow. Given VGGSound is a relatively new dataset, we compare to two existing audio-only works4 (Table 3), and set the first audiovisual benchmark (that we are aware of) on this dataset. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            717
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/1501ed1b9c217be75cd27072b8ae537abbdee05ad833a6de9fb6687a4d8cfdc3.jpg",
+        "table_caption": [
+            "Table 3: Comparison to the state of the art on VGGSound [10]. Modalities are A: Audio, V: Visual, F: Optical flow. $\\ddagger$ We calculate metrics on our test set for a fair comparison using the scores provided by the authors. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Modalities</td><td>Top-1 Acc</td><td>Top-5 Acc</td></tr><tr><td>Chen et al‡ [10]</td><td>A</td><td>48.8</td><td>76.5</td></tr><tr><td>AudioSlowFastt [33]</td><td>A</td><td>50.1</td><td>77.9</td></tr><tr><td>MBT</td><td>A</td><td>52.3</td><td>78.1</td></tr><tr><td>MBT</td><td>V</td><td>51.2</td><td>72.6</td></tr><tr><td>MBT</td><td>A,V</td><td>64.1</td><td>85.6</td></tr></table>",
+        "bbox": [
+            284,
+            755,
+            714,
+            856
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/514c1102137c765a226ed7728c9c0650366fea7402ea28932f1f1ccbd15adb39.jpg",
+        "image_caption": [
+            "Figure 6: Attention Maps. We compute maps of the attention from the output CLS tokens to the RGB image input space for a vanilla self-attention model and MBT on the Audioset test set. For each video clip, we show the original middle frame on the left with the ground truth labels overlayed at the bottom. The attention is particularly focused on sound source regions in the video that contain motion, eg. the fingertips on the piano, the hands on the string instrument, faces of humans. The bottlenecks in MBT further force the attention to be localised to smaller regions of the images (i.e the mouth of the baby on the top left and the mouth of the woman singing on the bottom right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            87,
+            821,
+            268
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            406,
+            821,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Visualisation of attention maps Finally, we compute maps of the attention from the output CLS tokens to the RGB image input space using Attention Rollout [1]. Results on test images for both a vanilla fusion model and MBT trained on Audioset-mini (fusion layer $L _ { f } = 8$ ) are shown in Figure 6. We show the attention maps summed over all the frames in the video clip. We note that first, the model focuses on semantically salient regions in the video for audio classification, particularly regions where there is motion that creates or modifies sound, i.e. the mouth of humans making sounds, fingertips on a piano, hands and instruments. This is unlike state of the art sound source localisation techniques trained with images [9], which tend to highlight the entire object. We further note that the attention maps for MBT are more localised to these regions, showing that the tight bottlenecks do force the model to focus only on the image patches that are actually relevant for the audio classification task and which benefit from early fusion with audio. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            587
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            607,
+            297,
+            625
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We propose a new transformer architecture (MBT) for audiovisual fusion, and explore a number of different fusion strategies using cross-attention between latent tokens. We propose a novel strategy to restrict cross-modal attention via a small set of fusion ‘bottlenecks’, and demonstrate that this improves performance over vanilla cross-attention at lower computational cost, achieving state of the art results on a number of benchmarks. Future work will involve extending MBT to other modalities such as text and optical flow. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            722
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Limitations: The fusion layer is a hyperparameter and may need to be tuned specifically for different tasks and datasets. We also only explore fully supervised fusion, and future work will tackle extensions to a self-supervised learning framework. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Broader impact: Multimodal fusion strategies are important for machine learning, as fusing complementary information from different modalities can increase robustness when applied to real world applications. We also note that transformers are in general compute-heavy, which can have adverse environmental effects. We propose a token fusion method via bottlenecks that helps reduce computational complexity when applying transformers for multimodal fusion. Finally, we observe that training datasets contain biases that may render models trained on them unsuitable for certain applications. It is thus possible that people use classification models (intentionally or not) to make decisions that impact different groups in society differently, and it is important to keep this in mind when deploying, analysing and building upon these models. ",
+        "bbox": [
+            173,
+            763,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            563,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: We would like to thank Joao Carreira for helpful discussions on the Perceiver [29]. ",
+        "bbox": [
+            173,
+            118,
+            825,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            167,
+            266,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Samira Abnar and Willem Zuidema. Quantifying attention flow in transformers. arXiv preprint arXiv:2005.00928, 2020.   \n[2] Hassan Akbari, Linagzhe Yuan, Rui Qian, Wei-Hong Chuang, Shih-Fu Chang, Yin Cui, and Boqing Gong. Vatt: Transformers for multimodal self-supervised learning from raw video, audio and text. NeurIPS, 2021.   \n[3] Jean-Baptiste Alayrac, Adrià Recasens, Rosalia Schneider, Relja Arandjelovic, Jason Ramapu- ´ ram, Jeffrey De Fauw, Lucas Smaira, Sander Dieleman, and Andrew Zisserman. Self-supervised multimodal versatile networks. In NeurIPS, 2020.   \n[4] Relja Arandjelovic and Andrew Zisserman. Look, listen and learn. In ICCV, 2017.   \n[5] Relja Arandjelovic and Andrew Zisserman. Objects that sound. In ECCV, 2018.   \n[6] Anurag Arnab, Mostafa Dehghani, Georg Heigold, Chen Sun, Mario Luciˇ c, and Cordelia ´ Schmid. Vivit: A video vision transformer. ICCV, 2021.   \n[7] Yusuf Aytar, Carl Vondrick, and Antonio Torralba. Soundnet: Learning sound representations from unlabeled video. In NeurIPS, 2016.   \n[8] Max Bain, Arsha Nagrani, Gül Varol, and Andrew Zisserman. Frozen in time: A joint video and image encoder for end-to-end retrieval. ICCV, 2021.   \n[9] Honglie Chen, Weidi Xie, Triantafyllos Afouras, Arsha Nagrani, Andrea Vedaldi, and Andrew Zisserman. Localizing visual sounds the hard way. In CVPR, 2021.   \n[10] Honglie Chen, Weidi Xie, Andrea Vedaldi, and Andrew Zisserman. VGGSound: A large-scale audio-visual dataset. In ICASSP, 2020.   \n[11] Tsuhan Chen and Ram R Rao. Audio-visual integration in multimodal communication. Proceedings of the IEEE, 86(5):837–852, 1998.   \n[12] Dima Damen, Hazel Doughty, Giovanni Maria Farinella, Antonino Furnari, Evangelos Kazakos, Jian Ma, Davide Moltisanti, Jonathan Munro, Toby Perrett, Will Price, et al. Rescaling egocentric vision. arXiv preprint arXiv:2006.13256, 2020.   \n[13] Mostafa Dehghani, Alexey Gritsenko, Anurag Arnab, Matthias Minderer, and Yi Tay. Scenic: A JAX library for computer vision research and beyond. arXiv preprint arXiv:2110.11403, 2021.   \n[14] Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pages 248–255. Ieee, 2009.   \n[15] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In NAACL, 2019.   \n[16] Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.   \n[17] Ariel Ephrat, Inbar Mosseri, Oran Lang, Tali Dekel, Kevin Wilson, Avinatan Hassidim, William T Freeman, and Michael Rubinstein. Looking to listen at the cocktail party: a speaker-independent audio-visual model for speech separation. ACM Transactions on Graphics (TOG), 37(4):1–11, 2018.   \n[18] Haytham M Fayek and Anurag Kumar. Large scale audiovisual learning of sounds with weakly labeled data. arXiv preprint arXiv:2006.01595, 2020.   \n[19] Christoph Feichtenhofer, Haoqi Fan, Jitendra Malik, and Kaiming He. Slowfast networks for video recognition. In ICCV, pages 6202–6211, 2019.   \n[20] Valentin Gabeur, Chen Sun, Karteek Alahari, and Cordelia Schmid. Multi-modal transformer for video retrieval. In ECCV, volume 5. Springer, 2020.   \n[21] Jort F Gemmeke, Daniel PW Ellis, Dylan Freedman, Aren Jansen, Wade Lawrence, R Channing Moore, Manoj Plakal, and Marvin Ritter. Audio set: An ontology and human-labeled dataset for audio events. In ICASSP, pages 776–780. IEEE, 2017.   \n[22] Bernard Ghanem, Juan Carlos Niebles, Cees Snoek, Fabian Caba Heilbron, Humam Alwassel, Victor Escorcia, Ranjay Krishna, Shyamal Buch, and Cuong Duc Dao. The activitynet largescale activity recognition challenge 2018 summary. arXiv preprint arXiv:1808.03766, 2018.   \n[23] Yuan Gong, Yu-An Chung, and James Glass. AST: audio spectrogram transformer. arXiv preprint arXiv:2104.01778, 2021.   \n[24] David Harwath, Antonio Torralba, and James R Glass. Unsupervised learning of spoken language with visual context. NeurIPS, 2017.   \n[25] Lisa Anne Hendricks, John Mellor, Rosalia Schneider, Jean-Baptiste Alayrac, and Aida Nematzadeh. Decoupling the role of data, attention, and losses in multimodal transformers. arXiv preprint arXiv:2102.00529, 2021.   \n[26] Shawn Hershey, Sourish Chaudhuri, Daniel PW Ellis, Jort F Gemmeke, Aren Jansen, R Channing Moore, Manoj Plakal, Devin Platt, Rif A Saurous, Bryan Seybold, et al. CNN architectures for large-scale audio classification. In ICASSP, pages 131–135. IEEE, 2017.   \n[27] Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In ECCV, 2016.   \n[28] Vladimir Iashin and Esa Rahtu. Multi-modal dense video captioning. In CVPR Workshops, pages 958–959, 2020.   \n[29] Andrew Jaegle, Felix Gimeno, Andrew Brock, Andrew Zisserman, Oriol Vinyals, and Joao Carreira. Perceiver: General perception with iterative attention. arXiv preprint arXiv:2103.03206, 2021.   \n[30] Aren Jansen, Daniel PW Ellis, Shawn Hershey, R Channing Moore, Manoj Plakal, Ashok C Popat, and Rif A Saurous. Coincidence, categorization, and consolidation: Learning to recognize sounds with minimal supervision. In ICASSP, 2020.   \n[31] Will Kay, Joao Carreira, Karen Simonyan, Brian Zhang, Chloe Hillier, Sudheendra Vijayanarasimhan, Fabio Viola, Tim Green, Trevor Back, Paul Natsev, et al. The kinetics human action video dataset. arXiv preprint arXiv:1705.06950, 2017.   \n[32] Evangelos Kazakos, Arsha Nagrani, Andrew Zisserman, and Dima Damen. Epic-fusion: Audiovisual temporal binding for egocentric action recognition. In Proceedings of the IEEE/CVF International Conference on Computer Vision, pages 5492–5501, 2019.   \n[33] Evangelos Kazakos, Arsha Nagrani, Andrew Zisserman, and Dima Damen. Slow-fast auditory streams for audio recognition. In ICASSP, pages 855–859. IEEE, 2021.   \n[34] Yelin Kim, Honglak Lee, and Emily Mower Provost. Deep learning for robust feature generation in audiovisual emotion recognition. In ICASSP. IEEE, 2013.   \n[35] Sangho Lee, Youngjae Yu, Gunhee Kim, Thomas Breuel, Jan Kautz, and Yale Song. Parameter efficient multimodal transformers for video representation learning. arXiv preprint arXiv:2012.04124, 2020.   \n[36] Guang Li, Linchao Zhu, Ping Liu, and Yi Yang. Entangled transformer for image captioning. In ICCV, pages 8928–8937, 2019.   \n[37] Jiaman Li, Yihang Yin, Hang Chu, Yi Zhou, Tingwu Wang, Sanja Fidler, and Hao Li. Learning to generate diverse dance motions with transformer. arXiv preprint arXiv:2008.08171, 2020.   \n[38] Liunian Harold Li, Mark Yatskar, Da Yin, Cho-Jui Hsieh, and Kai-Wei Chang. Visualbert: A simple and performant baseline for vision and language. arXiv preprint arXiv:1908.03557, 2019.   \n[39] Ruilong Li, Shan Yang, David A Ross, and Angjoo Kanazawa. Learn to dance with aist++: Music conditioned 3d dance generation. arXiv preprint arXiv:2101.08779, 2021.   \n[40] Ji Lin, Chuang Gan, and Song Han. Temporal shift module for efficient video understanding. 2019 ieee. In ICCV, pages 7082–7092, 2019.   \n[41] Jiasen Lu, Dhruv Batra, Devi Parikh, and Stefan Lee. Vilbert: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. In NeurIPS, 2019.   \n[42] Mathew Monfort, Alex Andonian, Bolei Zhou, Kandan Ramakrishnan, Sarah Adel Bargal, Tom Yan, Lisa Brown, Quanfu Fan, Dan Gutfreund, Carl Vondrick, et al. Moments in time dataset: one million videos for event understanding. IEEE transactions on pattern analysis and machine intelligence, 42(2):502–508, 2019.   \n[43] Jiquan Ngiam, Aditya Khosla, Mingyu Kim, Juhan Nam, Honglak Lee, and Andrew $\\mathrm { ~ Y ~ N ~ g ~ }$ . Multimodal deep learning. In ICML, 2011.   \n[44] Andrew Owens and Alexei A Efros. Audio-visual scene analysis with self-supervised multisensory features. In ECCV, 2018.   \n[45] Daniel S Park, William Chan, Yu Zhang, Chung-Cheng Chiu, Barret Zoph, Ekin D Cubuk, and Quoc V Le. Specaugment: A simple data augmentation method for automatic speech recognition. arXiv preprint arXiv:1904.08779, 2019.   \n[46] Alexander Pashevich, Cordelia Schmid, and Chen Sun. Episodic transformer for vision-andlanguage navigation. In ICCV, 2021.   \n[47] Dhanesh Ramachandram and Graham W Taylor. Deep multimodal learning: A survey on recent advances and trends. IEEE Signal Processing Magazine, 34(6):96–108, 2017.   \n[48] Justin Salamon and Juan Pablo Bello. Deep convolutional neural networks and data augmentation for environmental sound classification. IEEE Signal Processing Letters, 24(3):279–283, 2017.   \n[49] Paul Hongsuck Seo, Arsha Nagrani, and Cordelia Schmid. Look before you speak: Visually contextualized utterances. In CVPR, 2021.   \n[50] Linda Smith and Michael Gasser. The development of embodied cognition: Six lessons from babies. Artificial life, 11(1-2):13–29, 2005.   \n[51] Chen Sun, Fabien Baradel, Kevin Murphy, and Cordelia Schmid. Learning video representations using contrastive bidirectional transformer. arXiv preprint arXiv:1906.05743, 2019.   \n[52] Chen Sun, Austin Myers, Carl Vondrick, Kevin Murphy, and Cordelia Schmid. Videobert: A joint model for video and language representation learning. In ICCV, 2019.   \n[53] Efthymios Tzinis, Scott Wisdom, Aren Jansen, Shawn Hershey, Tal Remez, Daniel PW Ellis, and John R Hershey. Into the wild with audioscope: Unsupervised audio-visual separation of on-screen sounds. arXiv preprint arXiv:2011.01143, 2020.   \n[54] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. arXiv preprint arXiv:1706.03762, 2017.   \n[55] Limin Wang, Yuanjun Xiong, Zhe Wang, Yu Qiao, Dahua Lin, Xiaoou Tang, and Luc Van Gool. Temporal segment networks: Towards good practices for deep action recognition. In ECCV. Springer, 2016.   \n[56] Weiyao Wang, Du Tran, and Matt Feiszli. What makes training multi-modal classification networks hard? In CVPR, pages 12695–12705, 2020.   \n[57] Fanyi Xiao, Yong Jae Lee, Kristen Grauman, Jitendra Malik, and Christoph Feichtenhofer. Audiovisual slowfast networks for video recognition. arXiv preprint arXiv:2001.08740, 2020.   \n[58] Linwei Ye, Mrigank Rochan, Zhi Liu, and Yang Wang. Cross-modal self-attention network for referring image segmentation. In CVPR, 2019.   \n[59] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. arXiv preprint arXiv:1710.09412, 2017.   \n[60] Bolei Zhou, Alex Andonian, Aude Oliva, and Antonio Torralba. Temporal relational reasoning in videos. In ECCV, pages 803–818, 2018. ",
+        "bbox": [
+            171,
+            176,
+            828,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            30,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            32,
+            828,
+            920
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            90,
+            828,
+            270
+        ],
+        "page_idx": 13
+    }
+]

parse/train/SJg9z6VFDr/SJg9z6VFDr.md

@@ -0,0 +1,601 @@
+# ORDINARY DIFFERENTIAL EQUATIONS ON GRAPH NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recently various neural networks have been proposed for irregularly structured data such as graphs and manifolds. To our knowledge, all existing graph networks have discrete depth. Inspired by neural ordinary differential equation (NODE) for data in the Euclidean domain, we extend the idea of continuous-depth models to graphs, and propose graph ordinary differential equation (GODE). The derivative of hidden node states are parameterized with a graph neural network, and the output states are the solution to this ordinary differential equation. Noticing that NODEs are typically trained with the adjoint method, with the advantages of adaptive evaluation and a free-form continuous invertible model; however, their performance on benchmark image classification tasks is significantly inferior to discrete-layer models. We show the reason is adjoint method generates inaccurate gradient due to numerical error in reverse-mode integration. We then propose a memory-efficient framework for free-form ODEs with accurate gradient estimation, which is fundamental to deep-learning models. Furthermore, when applied to invertible blocks, our method achieves constant memory cost with GODE (NODE). We show our method for free-form ODEs generalizes to various model structures and achieves high accuracy for both NODE and GODE in benchmark tasks.
+
+# 1 INTRODUCTION
+
+Convolutional neural networks (CNN) have achieved great success in various tasks, such as image classification (He et al., 2016) and segmentation (Long et al., 2015), video processing (Deng et al., 2014) and machine translation (Sutskever et al., 2014). However, CNNs are limited to data that can be represented by a grid in the Euclidean domain, such as images (2D grid) and text (1D grid), which hinders their application in irregularly structured datasets.
+
+A graph data structure represents objects as nodes and relations between objects as edges. Graphs are widely used to model irregularly structured data, such as social networks (Kipf & Welling, 2016), protein interaction networks (Fout et al., 2017), citation and knowledge graphs (Hamaguchi et al., 2017). Early works use traditional methods such as random walk (Lovasz et al., 1993), independent ´ component analysis (ICA) (Hyvarinen & Oja, 2000) and graph embedding (Yan et al., 2006) to ¨ model graphs, however their performance is inferior due to the low expressive capacity.
+
+Recently a new class of models called graph neural networks (GNN) (Scarselli et al., 2008) were proposed. Inspired by the success of CNNs, researchers generalize convolution operations to graphs to capture the local information. There are mainly two types of methods to perform convolution on a graph: spectral methods and non-spectral methods. Spectral methods typically first compute the graph Laplacian, then perform filtering in the spectral domain (Bruna et al., 2013). Other methods aim to approximate the filters without computing the graph Laplacian for faster speed (Defferrard et al., 2016). For non-spectral methods, the convolution operation is directly performed in the graph domain, aggregating information only from the neighbors of a node (Duvenaud et al., 2015; Atwood & Towsley, 2016). The recently proposed GraphSAGE (Hamilton et al., 2017) learns a convolution kernel in an inductive manner.
+
+To our knowledge, all existing GNN models mentioned above have a structure of discrete layers. The discrete structure makes it hard for the GNN to model continuous diffusion processes (Freidlin & Wentzell, 1993; Kondor & Lafferty, 2002) in graphs. The recently proposed neural ordinary differential equation (NODE) (Chen et al., 2018) views a neural network as an ordinary differential equation (ODE), whose derivative is parameterized by the network, and the output is the solution to this ODE. We extend NODE from the Euclidean domain to graphs and propose graph ordinary differential equations (GODE), where the message propagation on a graph is modeled as an ODE.
+
+NODEs are typically trained with adjoint method. NODEs have the advantages of adaptive evaluation, accuracy-speed control by changing error tolerance, and are free-form continuous invertible models (Chen et al., 2018; Grathwohl et al., 2018). However, to our knowledge, in benchmark image classification tasks, NODEs are significantly inferior to state-of-the-art discrete-layer models (error rate: $19 \%$ for NODE vs $7 \%$ for ResNet18 on CIFAR10) (Dupont et al., 2019; Gholami et al., 2019). In this work, we show this is caused by error in gradient estimation during training of NODE, and propose a memory-efficient framework for accurate gradient estimation. We demonstrate our framework for free-form ODEs generalizes to various model structures, and achieves high accuracy for both NODE and GODE in benchmark tasks. Our contribution can be summarized as follows:
+
+1. We propose a framework for free-form NODEs to accurately estimate the gradient, which is fundamental to deep-learning models. Our method significantly improves the performance on benchmark classification (reduces test error from $19 \%$ to $5 \%$ on CIFAR10).
+
+2. Our framework is memory-efficient for free-form ODEs. When applied to restricted-form invertible blocks, the model achieves constant memory usage.
+
+. We generalize ODE to graph data and propose GODE models.
+
+4. We demonstrate improved performance on different graph models and various datasets.
+
+# 2 RELATED WORKS
+
+# 2.1 NEURAL NETWORKS AND DIFFERENTIAL EQUATIONS
+
+There have been efforts to view neural networks as differential equations. Lu (2017) viewed a residual network as a discretization of a differential equation and proposed several new architectures based on numerical methods in ODE solver. Haber & Ruthotto (2017) proposed a stable architecture based on analysis of the ODE. Chen et al. (2018) proposed neural ordinary differential equation (NODE), which treats the neural network as a continuous ODE. NODE was later used in a continuous normalizing flow for generative models (Grathwohl et al., 2018).
+
+There have been many studies on the training of NODE. The adjoint method has long been widely used in optimal control (Stapor et al., 2018) and geophysical problems (Plessix, 2006), and recently applied to ODE (Chen et al., 2018). Dupont et al. (2019) proposed augmented neural ODEs to improve the expressive capacity of NODEs. However, to our knowledge, none of the methods above discusses the inaccurate gradient estimation issue; empirical performances of NODE in benchmark classification tasks are significantly inferior to state-of-the-art discrete-layer models.
+
+# 2.2 GRAPH NEURAL NETWORKS
+
+GNNs can be divided into two categories: spectral methods and non-spectral methods. Spectral GNNs perform filtering in the Fourier domain of a graph, thus need information of the whole graph to determine the graph Laplacian. In contrast, non-spectral GNNs only consider message aggregation around neighbor nodes, therefore are localized and generally require less computation (Zhou et al., 2018).
+
+We first briefly introduce several spectral methods. Bruna et al. (2013) first introduced graph convolution in the Fourier domain based on the graph Laplacian, however the computation burden is heavy because of non-localized filters. Henaff et al. (2015) incorporated a graph estimation procedure in spectral networks and parameterized spectral filters into a localized version with smooth coefficients. Defferrard et al. (2016) used Chebyshev expansion to approximate the filters without the need to compute the graph Laplacian and its eigenvectors, therefore significantly accelerated the running speed. Kipf & Welling (2016) proposed to use a localized first-order approximation of graph convolution on graph data and achieved superior performance in semi-supervised tasks for node classification. Defferrard et al. (2016) proposed fast localized spectral filtering on graphs.
+
+Non-spectral methods typically define convolution operations on a graph, only considering neighbors of a certain node. MoNet (Monti, 2017) uses a mixture of CNNs to generalize convolution to graphs. GraphSAGE (Hamilton et al., 2017) samples a fixed size of neighbors for each node for fast localized inference. Graph attention networks (Velickovi ˇ c et al., 2017) learn different weights ´ for different neighbors of a node. The graph isomorphism network (GIN) (Xu et al., 2018) has a structure as expressive as the Weisfeiler-Lehman graph isomorphism test.
+
+# 2.3 INVERTIBLE BLOCKS
+
+Invertible blocks are a family of neural network blocks whose forward function is a bijective mapping. Therefore, the input to a bijective block can be accurately reconstructed from its outputs. Invertible blocks have been used in normalizing flow (Rezende & Mohamed, 2015; Dinh, 2016; Kingma & Dhariwal, 2018; Dinh et al., 2014; Kingma et al., 2016), where the model is required to be invertible in order to calculate the log-density of data distribution. Later on, Jacobsen et al. (2018) used bijective blocks to build invertible networks. Gomez et al. (2017) proposed to use invertible blocks to perform back propagation without storing activation, which achieves a memory-efficient network structure. They were able to discard activation of middle layers, because each layer’s activation can be reconstructed from the next layer with invertible blocks.
+
+# 3 ACCURATE GRADIENT ESTIMATION FOR TRAINING OF NODE
+
+# 3.1 FROM DISCRETE MODELS TO CONTINUOUS MODELS
+
+We first consider discrete-layer models with residual connection (He et al., 2016), which can be represented as:
+
+$$
+x _ { k + 1 } = x _ { k } + f _ { k } ( x _ { k } )
+$$
+
+where $x _ { k }$ is the states in the $k$ th layer; $f _ { k } ( \cdot )$ is any differentiable function whose output has the same shape as its input.
+
+When we add more layers with shared weights, and let the stepsize in Eq. 1 go to infinitesimal, the difference equation turns into a neural ordinary differential equation (NODE) (Chen et al., 2018):
+
+$$
+\frac { \mathrm { d } \boldsymbol { z } ( t ) } { \mathrm { d } t } = \boldsymbol { f } ( \boldsymbol { z } ( t ) , t )
+$$
+
+We use $z ( t )$ in the continuous case and $x _ { k }$ in the discrete case to represent hidden states. $f ( \cdot )$ is the derivative parameterized by a network. Note that a key difference between Eq. 1 and 2 is the form of $f$ : in the discrete case, different layers (different $k$ values) have their own function $f _ { k }$ ; while in the continuous case, $f$ is shared across all time $t$ .
+
+The forward pass of model with discrete layers can be written as:
+
+$$
+x _ { 0 } = i n p u t , x _ { 1 } = x _ { 0 } + f _ { 0 } ( x _ { 0 } ) , . . . , x _ { K } = x _ { K - 1 } + f _ { K - 1 } ( x _ { K - 1 } )
+$$
+
+where $K$ is the total number of layers. Then an output layer (e.g. fully-connected layer for classification) is applied on $x _ { K }$ .
+
+The forward pass of a NODE is:
+
+$$
+z ( T ) = z ( 0 ) + \int _ { t = 0 } ^ { T } { \frac { \mathrm { d } z ( t ) } { \mathrm { d } t } } \mathrm { d } t = \operatorname* { i n p u t } + \int _ { t = 0 } ^ { T } f ( z ( t ) , t ) \mathrm { d } t
+$$
+
+where $z ( 0 ) =$ input and $T$ is the integration time, corresponding to number of layers $K$ in the discrete case. The transformation of states $z$ is modeled as the solution to the NODE. Then an output layer is applied on $z ( T )$ . Integration in the forward pass can be performed with any ODE solver, such as the Euler Method, Runge-Kutta Method, VODE solver and Dopris Solver (Milne & Milne, 1953; Brown et al., 1989; Ascher et al., 1997).
+
+# 3.2 BACK-PROP WITH ADJOINT METHOD IS SENSITIVE TO NUMERICAL ERROR
+
+The adjoint method is widely used in optimal process control and functional analysis (Stapor et al., 2018; Pontryagin, 2018). We follow the method by (Chen et al., 2018). Denote model parameters as $\theta$ , which is independent of time. Define the adjoint as:
+
+$$
+a ( t ) = { \frac { \partial L } { \partial z ( t ) } }
+$$
+
+![](images/a266a18753e3b01d3f24e4840d9ceb58da8ca03434e2bd9e41a4d8ef64be4f4d.jpg)  
+Figure 1: Comparison of two methods for back-propagation on NODE. As in figure (a), the ODE solver is discretized at points $\left\{ t _ { 0 } , t _ { 1 } , . . . , t _ { N } \right\}$ during forward pass. Black dashed curve shows hidden state solved in forward-time, denoted as $z ( t )$ . Figure (b) shows the adjoint method, red solid line shows the hidden state solved in reverse-time, denoted as $h ( t )$ . Ideally $z ( t ) = h ( t )$ and dashed curve overlaps with solid curve; however, the reverse-time solution could be numerically unstable, and causes $z ( t ) \neq h ( \bar { t } )$ , thus causes error in gradient. Figure (c) shows the direct back-propagation through ODE solver. In direct back-propagation, we save evaluation time points $\left\{ t _ { 0 } , t _ { 1 } , . . . t _ { N } \right\}$ during forward pass; during backward pass, we re-build the computation graph by directly evaluating at the same time points. In this way, $z ( t _ { i } ) = h ( t _ { i } )$ . Since the hidden state can be accurately reconstructed, the gradient can be accurately evaluated.
+
+where $L$ is the loss function. Then we have
+
+$$
+\frac { \mathrm { d } a ( t ) } { \mathrm { d } t } = - a ( t ) ^ { T } \frac { \partial f ( z ( t ) , t , \theta ) } { z ( t ) } , \quad \frac { \mathrm { d } L } { \mathrm { d } \theta } = - \int _ { T } ^ { 0 } a ( t ) ^ { T } \frac { \partial f ( z ( t ) , t , \theta ) } { \partial \theta } \mathrm { d } t
+$$
+
+with detailed proof from optimization perspective in appendix F. Then we can perform gradient descent to optimize $\theta$ to minimize $L$ . Eq. 6 is a reverse-time integration, which can be solved with any ODE solver (Chen et al., 2018). To evaluate $\frac { \partial f (  { \boldsymbol { z } } ( t ) , t , \theta ) } { \partial \theta }$ , we need to determine $z ( t )$ by solving Eq. 2 reverse-time (Directly storing $z ( t )$ during forward pass requires a large memory consumption, because the continuous model is equivalent to an infinite-layer model). To summarize, in the forward pass we solve Eq. 2 forward in time; in the backward pass, we solve Eq. 2 and 6 reverse in time, with initial condition determined from Eq. 5 at time $T$ .
+
+We give an intuition why the reverse-time ODE solver causes inaccurate gradient in adjoint methods. The backward pass (Eq. 6) requires determining $f ( z ( t ) , t , \theta )$ and $\frac { \partial \mathbf { \tilde { f } } ( \boldsymbol { z } ( t ) , t , \theta ) } { \partial \theta }$ , which requires determining $z ( t )$ by solving Eq. 2 reverse-time. As shown in Fig. 1 (a,b), the hidden state solved forward-time $( z ( t _ { i } ) )$ and the hidden state solved reverse-time $( h ( t _ { i } ) )$ may not be equal; this could be caused by the instability of reverse-time ODE, and is represented by the mismatch between $z ( t )$ (dashed curve) and $h ( t )$ (solid curve). Error $h ( t ) - z ( t )$ will cause error in gradient $\frac { \mathrm { d } L } { \mathrm { d } \theta }$
+
+Proposition 1 For an ODE in the form $\begin{array} { r } { \frac { \mathrm { d } \boldsymbol { z } ( t ) } { \mathrm { d } t } = \boldsymbol { f } ( \boldsymbol { z } ( t ) , t ) , } \end{array}$ , denote the Jacobian of $f$ as $J _ { f }$ . If this ODE is stable both in forward-time and reverse-time, then $\operatorname { R e } ( \lambda _ { i } ( J _ { f } ) ) = 0 ~ \forall i$ , where $\lambda _ { i } ( J _ { f } )$ is the ith eigenvalue of $J _ { f }$ , and $\mathrm { R e } ( \lambda )$ is the real part of $\lambda$ .
+
+Detailed proof is in appendix C. Proposition 1 indicates that if the Jacobian of the original system Eq. 2 has eigenvalues whose real-part are not 0, then either the reverse-time or forward-time ODE is unstable. When $| \mathrm { R e } ( \lambda ) |$ is large, either forward-time or reverse-time ODE is sensitive to numerical errors. This phenomenon is also addressed in Chang et al. (2018). This instability affects the accuracy of solution to Eq. 2 and 6, thus affects the accuracy of the computed gradient.
+
+# 3.3 MEMORY-EFFICIENT DIRECT BACK-PROPAGATION THROUGH ODE SOLVER
+
+The adjoint method might be sensitive to numerical errors when solving the ODE in reverse-time.   
+To resolve this, we propose to directly back-propagate through the ODE solver.
+
+As in Fig. 1(a), the ODE solver uses discretization for numerical integration, evaluated at time points $\left\{ t _ { 0 } , t _ { 1 } , . . . t _ { N } \right\}$ . Fig. 1(c) demonstrates the direct back-propagation with accurate hidden states $h ( t _ { i } )$ , which can be achieved with two methods: (1) the activation $z ( t _ { i } )$ can be saved in cache for back-prop, but requires huge memory; or (2) we can accurately reconstruct $z ( t _ { i } )$ by re-building the computation graph directly at evaluated time points $\{ t _ { i } \}$ . Since the model is evaluated at the same time points $t _ { i }$ in forward-time, it’s guaranteed that $\dot { z } ( \dot { t } _ { i } ) ~ = ~ h ( t _ { i } )$ . Therefore direct back-prop is accurate, regardless of the stability of Eq. 2.
+
+Similar to the continuous case, we can define the adjoint with discrete time. Then we have:
+
+$$
+a _ { i } = \frac { \partial L } { \partial z ( t _ { i } ) } , \quad a _ { i + 1 } = a _ { i } \frac { \partial z ( t _ { i + 1 } ) } { \partial z ( t _ { i } ) } , \quad \frac { \mathrm { d } L } { \mathrm { d } \theta } = \sum _ { i = 1 } ^ { N } a _ { i } \frac { \partial z ( t _ { i } ) } { \partial \theta }
+$$
+
+where $a _ { i }$ is the adjoint for the ith step in discrete forward-time ODE solution. Eq. 7 can be viewed as a numerical discretization of Eq. 6. We show Eq. 6 can be derived from an optimization perspective. Detailed derivations of Eq. 6-7 are in appendix E and F.
+
+# Algorithm 1: Algorithm for accurate gradient estimation in ODE solver for free-form functions
+
+Define model $\begin{array} { r } { \frac { \mathrm { d } \boldsymbol { z } ( t ) } { \mathrm { d } t } = \boldsymbol { f } ( \boldsymbol { z } ( t ) , t ) } \end{array}$ , where $f$ is a free-form function. Denote integration time as $T$
+
+Forward $( f , T , z _ { 0 } , t o l e r a n c e ) \colon$ : $t = 0 , z = z _ { 0 }$ $s t a t e _ { 0 } = f . s t a t e \_ d i c t ( )$ , cache.save $\left( s t a t e _ { 0 } \right)$ Select initial step size $h = h _ { 0 }$ (adaptively with adaptive step-size solver). time points $: =$ empty list() While $t < T$ : state = f.state dict(), accept step = F alse While Not accept step: $f$ .load state dict(state) with grad disabled: $z . n e w , e r r o r \_ e s t i m a t e = s t e p ( f , z , t , h )$ If error estimate $<$ tolerance: accept step = T rue $\ z = z . n e w , \ t = t + h , \ t i m e \mathrm { - } p o i n t s . a p p e n d ( t )$ else: reduce stepsize $h$ according to error estimate delete $z$ new, error estimate and related local computation graph cache.save(time points) return $z$ , cache   
+Backward $( f , T , z _ { 0 } , t o l e r a n c e , c a c h e )$ : $\left\{ t _ { 0 } , t _ { 1 } , t _ { 2 } , . . . t _ { N - 1 } , t _ { N } \right\} = c a c$ che.time points For $t _ { i }$ in $\left\{ t _ { 0 } , t _ { 1 } , t _ { 2 } , . . . t _ { N - 1 } , t _ { N } \right\}$ : $z ( t _ { i + 1 } ) = s t e p ( f , z ( t _ { i } ) , t _ { i } , s t e p = t _ { i + 1 } - t _ { i } )$ For $t _ { i }$ in $\left\{ t _ { N } , t _ { N - 1 } , . . . , t _ { 1 } , t _ { 0 } \right\}$ : Determine $\begin{array} { r } { a ( t _ { i } ) = \frac { \partial L } { \partial z ( t _ { i } ) } } \end{array}$ and $\frac { \partial z ( t _ { i } ) } { \partial { \theta } }$ dLdθ PNi=1 ai ∂z(ti∂θ return dL dθ
+
+Details of our method are summarized in Algorithm 1. We discuss its properties below:
+
+Summary of the algorithm (1) During forward pass, the solver performs a numerical integration, with the stepsize adaptively varying with error estimation. (2) During forward pass, the solver outputs the integrated value, and the evaluation time points $\{ t _ { i } \}$ . All middle activations are deleted to save memory. (3) During backward pass, the solver re-builds the computation graph, by directly evaluating at saved time points, without adaptive searching. (4) During backward pass, the solver performs a numerical version (Eq. 7) of reverse-time integration (Eq. 6).
+
+Support for free-form continuous dynamics There’s no constraint on the form of $f$ . Therefore, our algorithm is a generic method.
+
+Memory consumption analysis (1) Suppose $f$ has $N _ { f }$ layers, the number of forward evaluation step is $N _ { t }$ on average, and the evaluations to adaptively search for an optimal stepsize is $K$ . A naive solver will take ${ \bar { O ( N _ { f } \times N _ { t } \times K ) } }$ , while our method consumes $O ( N _ { f } \times N _ { t } )$ because all middle activations are deleted during forward pass, and we don’t need to search for optimal stepsize in backward pass. (2) If we perform step-wise checkpoint method, where we only store $z ( t _ { i } )$ for all $t _ { i }$ , and compute the gradient $\frac { \partial z ( t _ { i + 1 } ) } { \partial z ( t _ { i } ) }$ for one $t _ { i }$ at a time, then the memory consumption can be reduced to $O ( N _ { f } + N _ { t } )$ . (3) Since the solver can handle free-form functions, it can also handle restricted form invertible block (see below). In this case, we don’t need to store $z ( t _ { i } )$ , and the memory consumption can reduce to $O ( N _ { f } )$ .
+
+More memory-efficient solver with invertible blocks Restricting the form of $f$ to invertible blocks (Gomez et al., 2017) allows for $O ( N _ { f } )$ memory consumption. For invertible blocks, input $x$ is split into two parts $( x _ { 1 } , x _ { 2 } )$ of the same size (e.g. $x$ has shape $N \times C$ , where $N$ is batch size, $C$ is channel number; we can split $x$ into $x _ { 1 }$ and $x _ { 2 }$ with shape $N \times { \frac { C } { 2 } } .$ ). The forward and inverse of a bijective block can be denoted as:
+
+$$
+\left\{ \begin{array} { c } { { y _ { 2 } = \psi { \Big ( } x _ { 2 } , F ( x _ { 1 } ) { \Big ) } } } \\ { { y _ { 1 } = \psi { \Big ( } x _ { 1 } , G ( y _ { 2 } ) { \Big ) } } } \end{array} \right. \left\{ \begin{array} { c } { { x _ { 1 } = \psi ^ { - 1 } { \Big ( } y _ { 1 } , G ( y _ { 2 } ) { \Big ) } } } \\ { { x _ { 2 } = \psi ^ { - 1 } { \Big ( } y _ { 2 } , F ( x _ { 1 } ) { \Big ) } } } \end{array} \right.
+$$
+
+where the output of a bijective block is denoted as $( y _ { 1 } , y _ { 2 } )$ with the same size as $( x _ { 1 } , x _ { 2 } )$ . $F$ and $G$ are any differentiable neural networks, whose output has the same shape as the input. $\psi ( \alpha , \beta )$ is a differentiable bijective function $w . r . t \alpha$ when $\beta$ is given; $\psi ^ { - 1 } ( \alpha , \beta )$ is the inverse function of $\psi$ .
+
+Theorem 1 If $\psi ( \alpha , \beta )$ is a bijective function w.r.t $\alpha$ when $\beta$ is given, then the block defined by Eq. 8 is a bijective mapping.
+
+Proof of Theorem 1 is given in appendix D. Based on this, we can apply different $\psi$ functions for different tasks. Since $x$ can be accurately reconstructed from $y$ , there’s no need to store activations, hence is memory-efficient. Details for back-prop without storing activation are in appendix $\mathbf { B }$ .
+
+# 4 NEURAL ORDINARY DIFFERENTIAL EQUATION ON GRAPH NETWORKS
+
+We first introduce graph neural networks with discrete layers, then extend to the continuous case and introduce graph ordinary differential equations (GODE).
+
+# 4.1 MESSAGE PASSING IN GNN
+
+As shown in Fig. 2, a graph is represented with nodes (marked with circles) and edges (solid lines). We assign a unique color to each node for ease of visualization. Current GNNs can generally be represented in a message passing scheme (Fey & Lenssen, 2019):
+
+$$
+m e s s a g e _ { ( v , u ) } = \phi ^ { ( k ) } ( x _ { k - 1 } ^ { u } , x _ { k - 1 } ^ { v } , \mathbf { e } _ { u , v } )
+$$
+
+$$
+a g g r e g a t i o n _ { u } = \zeta _ { v \in N ( u ) } ( m e s s a g e _ { ( v , u ) } )
+$$
+
+$$
+x _ { k } ^ { u } = \gamma ^ { ( k ) } ( x _ { k - 1 } ^ { u } , a g g r e g a t i o n _ { u } )
+$$
+
+where $x _ { k } ^ { u }$ represents states of the uth node in the graph at $k$ th layer and $\mathbf { e } _ { u , v }$ represents the edge between nodes $u$ and $v$ . $\mathcal { N } ( u )$ represents the set of neighbor nodes for node $u$ . $\zeta$ represents a differentiable, permutation invariant operation such as mean, max or sum. $\gamma ^ { ( k ) }$ and $\phi ^ { ( k ) }$ are differentiable functions parameterized by neural networks.
+
+For a specific node $u$ , a GNN can be viewed as a 3-stage model, corresponding to Eq. 9-11: (1) Message passing, where neighbor nodes $v \in \mathcal { N } ( u )$ send information to node $u$ , denoted by $m e s s a g e _ { ( v , u ) }$ . The message is generated from function $\phi ( \cdot )$ , parameterized by a neural network. (2) Message aggregation, where a node $u$ aggregates all messages from its neighbors $\mathcal { N } ( u )$ , denoted as aggregationu. The aggregation function $\zeta$ is typically permutation invariant operations such as mean and sum, because graphs are invariant to permutation. (3) Update, where the states of a node are updated according to its original states $x _ { k - 1 } ^ { u }$ and aggregation of messages aggregationu, denoted as $\gamma ( \cdot )$ .
+
+# 4.2 CONTINUOUS-TIME MODELS ON GRAPHS
+
+We can convert a discrete-time GNN to continuous-time GNN by replacing $f$ in Eq. 2 with the message passing process defined in Eq. 9 to 11, which we call graph ordinary differential equation (GODE). A diagram of GODE is shown in Fig. 2. Because GODE is an ODE in nature, it can capture highly non-linear functions, thus has the potential to outperform its discrete-layer counterparts.
+
+We demonstrate that the asymptotic stability of GODE could be related to the over-smoothing phenomena (Li et al., 2018). It’s demonstrated that graph convolution is a special case of Laplacian smoothing (Li et al., 2018), which can be written as $\bar { Y } = ( I - \gamma \tilde { D } ^ { - 1 / 2 } \tilde { L } \tilde { D } ^ { - 1 / 2 } ) X$ where $X$ and $Y$ are the input and output of a graph-conv layer respectively, ${ \tilde { A } } = A + I$ where $A$ is the adjacency matrix, and $\tilde { D }$ is the corresponding degree matrix of $\tilde { A }$ , and $\gamma$ is a positive scaling constant.
+
+When modified from a discrete model to a continuous model, the continuous smoothing process is:
+
+$$
+\frac { d X } { d t } = - \gamma \tilde { D } ^ { - 1 / 2 } \tilde { L } \tilde { D } ^ { - 1 / 2 } X
+$$
+
+Since all eigenvalues of the symmetrically normalized Laplacian are real and non-negative, then all eigenvalues of the above ODE are real and non-positive. Suppose all eigenvalues of the normalized Laplacian are non-zero. In this case, the ODE has only negative eigenvalues, hence the ODE above is asymptotically stable (Lyapunov, 1992). Hence as time $t$ grows sufficiently large, all trajectories are close enough. In the experiments, this suggests if integration time $T$ is large enough, all nodes (from different classes) will have very similar features, thus the classification accuracy will drop.
+
+![](images/055f8f1070df1a0d3a6040c4dafaf97b391c03157a31b25e5f051b6010a7b899.jpg)  
+Figure 2: Diecrete-time and continuous-time models on a graph. Nodes are represented with circles, and each node is represented with a unique color. Edges are represented with solid lines. For discrete-time models in (a), the hidden states of nodes are updated with discrete steps. For continuous-time models in (b), hidden states of each node evolves continuously with time. The dynamics of nodes are represented with dashed lines, with the same color as corresponding nodes.
+
+# 5 EXPERIMENTS
+
+# 5.1 DATASETS
+
+To evaluate our method on general NODE, we conducted experiments with a CNN-NODE on two benchmark image classification tasks (CIFAR10 and CIFAR100) (Krizhevsky et al., 2009).
+
+We also evaluated our method on benchmark graph datasets, including 2 bioinformatic graph classification datasets (MUTAG and PROTEINS), 2 social network graph classification datasets (IMDBBINRAY, REDDIT-BINARY) (Yanardag & Vishwanathan, 2015), and 3 citation networks (Cora, CiteSeer and PubMed). For graph classification tasks, different from the experiment settings in $\mathrm { X u }$ et al. (2018), we input the raw dataset into our models without pre-processing. For node classification tasks, we performed transductive inference and strictly followed the train-validation-test split by Kipf & Welling (2016), where less than $6 \%$ nodes are used as training examples. Details of datasets are summarized in appendix A.
+
+# 5.2 MODEL STRUCTURES
+
+For image classification tasks, we directly modify a ResNet18 into its corresponding NODE model. For each block, the function is $\begin{array} { r } { \frac { d z ( t ) } { d t } \stackrel { \cdot } { = } \stackrel { \cdot } { f } ( z ( t ) ) } \end{array}$ where $f$ is a sequence of $c o n v \mathrm { ~ - ~ } b n \mathrm { ~ - ~ } r e l u \mathrm { ~ - ~ }$ $c o n v - b n - r e l u$ layers. $f$ is the same as residual branch in ResNet, and it can be replaced with any free-form functions.
+
+<table><tr><td rowspan="2"></td><td colspan="5">Ours</td><td colspan="4">Literature</td></tr><tr><td></td><td>Adaptive Stepsize Solvers</td><td></td><td>Fixed stepsize solvers</td><td></td><td>adjoint-ODE</td><td>ResNet18</td><td>ResNet50</td><td>ResNet101</td></tr><tr><td>CIFAR10</td><td>Heun-Euler</td><td>RK23</td><td>RK45</td><td>Euler</td><td>RK2 RK4</td><td></td><td></td><td></td><td></td></tr><tr><td>CIFAR100</td><td>4.85 22.66</td><td>4.92 24.13</td><td>5.29 23.56</td><td>5.52 24.44</td><td>5.27 5.24 24.44 24.43</td><td>19.2 37.6</td><td>6.98 27.08</td><td>6.38 25.73</td><td>6.25 24.84</td></tr></table>
+
+Table 1: Error rate on test set. “Ours” represent NODE models directly modified from ResNet18, trained with Heun-Euler solver, but tested with different solvers. “Adjoint” is the result when trained and tested with adjoint method, reported by (Gholami et al., 2019). We also report results from standard ResNet.
+
+Table 2: Accuracy of adjoint method and direct back-prop, for a GODE model with GCN as the derivative function.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>MUTAG</td><td rowspan=1 colspan=1>PROTEINS</td><td rowspan=1 colspan=1>IMDB</td><td rowspan=1 colspan=1>REDDIT</td></tr><tr><td rowspan=1 colspan=1>adjoint</td><td rowspan=1 colspan=1>68.1± 4.6</td><td rowspan=1 colspan=1>67.0±3.7</td><td rowspan=1 colspan=1>72.1±0.4</td><td rowspan=1 colspan=1>69.5±5.9</td></tr><tr><td rowspan=1 colspan=1>ours</td><td rowspan=1 colspan=1>80.8±8.3</td><td rowspan=1 colspan=1>73.9±3.1</td><td rowspan=1 colspan=1>74.6±5.1</td><td rowspan=1 colspan=1>92.4±2.1</td></tr></table>
+
+For tasks on graph datasets, GODE can be applied to any graph neural network by simply replacing $f$ in Eq. 2 with corresponding structures (free-form functions), or replacing $F , G$ in Eq. 8 with other structures (invertible blocks). To demonstrate that GODE is easily generalized to existing structures, we used several different GNN architectures, including the graph convolutional network (GCN) (Kipf & Welling, 2016), graph attention network (GAT) (Velickovi ˇ c et al., 2017), graph ´ network approximated with Chebyshev expansion (ChebNet) (Defferrard et al., 2016), and graph isomorphism network (GIN) (Xu et al., 2018). For a fair comparison, we trained GNNs with different depths of layers (1-3 middle layers, besides an initial layer to transform data into specified channels, and a final layer to generate prediction), and reported the best results among all depths for each model structure.
+
+On the same task, different models use the same hyper-parameters on model structures, such as channel number. For graph classification tasks, we set the channel number of hidden layers as 32 for all models; for ChebNet, we set the number of hops as 16. For node classification tasks, we set the channel number as 16 for GCN and ChebNet, and set number of hops as 3 for ChebNet; for GAT, we used 8 heads, and set each head as 8 channels.
+
+For every GNN structure, we experimented with different number of hidden layers (1,2,3), and calculated the mean and variance of accuracy of 10 runs.
+
+# 5.3 COMPARISON OF BACK-PROPAGATION METHODS
+
+We compared the adjoint method and direct back-propagation on the same network, and demonstrated direct back-prop generates higher accuracy. For CNN-NODE on classification tasks, we directly modify a ResNet18 into NODE18, and report resuls in Table. 1; for graph networks, we train a GODE model with a GCN to parameterize the derivative, and report results in Table. 2.
+
+Empirical performance Direct back-propagation consistently outperformed the adjoint method for both tasks. This result validates our analysis on the instability of the adjoint method, which is intuitively caused by the instability of the reverse-time ODE. On image classification tasks, compared to adjoint method, our training method reduces error rate of NODE18 from $19 \%$ $( 3 7 \% )$ to $5 \% ( 2 3 \% )$ on CIFAR10 (CIFAR100). Furthermore, NODE18 has the same number of parameters as ResNet18, but outperforms deeper networks such as ResNet101 on both datasets. Our method also consistently outperforms the adjoint method on several benchmark graph datasets, as shown in Table. 2.
+
+Robustness to ODE solvers We implemented adaptive ODE solvers of different orders, as shown in Table 1. HeunEuler, RK23, RK45 are of order 1, 2, 4 respectively, i.e., for each step forward in time $f$ is evaluated 1, 2, 4 times respectively. During inference, using different solvers is equivalent to changing model depth (without re-training the network): for discrete-layer models, it generally causes huge error; for continuous models, we observe only around $1 \%$ increase in error rate. This suggests our method is robust to different orders of ODE solvers.
+
+Support for free-form functions Our method supports NODE and GODE models with free-form functions; for example, $f$ in NODE18 in Table. 1 is a free-form function.
+
+<table><tr><td rowspan=1 colspan=3>Model</td><td rowspan=1 colspan=1>MUTAG</td><td rowspan=1 colspan=1>PROTEINS</td><td rowspan=1 colspan=1>IMDB</td><td rowspan=1 colspan=1>REDDIT</td></tr><tr><td rowspan=3 colspan=1>GCN</td><td rowspan=1 colspan=2>DISC</td><td rowspan=1 colspan=1>73.3±5.2</td><td rowspan=1 colspan=1>72.4±3.1</td><td rowspan=1 colspan=1>74.2±3.6</td><td rowspan=1 colspan=1>85.9±1.8</td></tr><tr><td rowspan=2 colspan=1>ODE</td><td rowspan=1 colspan=1>INV</td><td rowspan=1 colspan=1>78.1±6.2**</td><td rowspan=1 colspan=1>74.7±4.3**</td><td rowspan=1 colspan=1>75.3±5.3*</td><td rowspan=1 colspan=1>89.2±3.2**</td></tr><tr><td rowspan=1 colspan=1>free</td><td rowspan=1 colspan=1>75.1±5.3**</td><td rowspan=1 colspan=1>76.6±3.9**</td><td rowspan=1 colspan=1>73.9±4.6</td><td rowspan=1 colspan=1>88.5±3.0**</td></tr><tr><td rowspan=3 colspan=1>Cheb</td><td rowspan=1 colspan=2>DISC</td><td rowspan=1 colspan=1>84.0±6.4</td><td rowspan=1 colspan=1>70.6±3.9</td><td rowspan=1 colspan=1>71.9±3.8</td><td rowspan=1 colspan=1>91.0±1.5</td></tr><tr><td rowspan=2 colspan=1>ODE</td><td></td><td></td><td></td><td></td><td rowspan=1 colspan=1>91.2±1.5</td></tr><tr><td rowspan=1 colspan=1>free</td><td rowspan=1 colspan=1>86.1±6.3*</td><td rowspan=1 colspan=1>72.5±4.7**</td><td rowspan=1 colspan=1>73.6±4.0**</td><td rowspan=1 colspan=1>92.4±1.6**</td></tr><tr><td rowspan=2 colspan=1>GIN</td><td rowspan=1 colspan=2>DISC</td><td rowspan=1 colspan=1>85.0±6.4</td><td rowspan=1 colspan=1>73.0±3.1</td><td rowspan=1 colspan=1>73.3±5.1</td><td rowspan=1 colspan=1>89.2±2.5</td></tr><tr><td rowspan=1 colspan=1>ODE</td><td></td><td></td><td></td><td></td><td rowspan=1 colspan=1>90.5±1.5**</td></tr></table>
+
+Table 3: Results on node classification tasks. We compared various discrete-layer structures (marked with DISC) and their corresponding GODE models (marked with ODE). We tested GODE model with different $\psi$ functions (“l sig” represents linear sigmoid). For each model, we use $^ { \ast } \left( { ^ { \ast \ast \ast } } \right)$ to mark GODE models that outperform corresponding discrete-layer baselines at a $5 \%$ $( 1 \% )$ significance level under paired t-test.   
+
+<table><tr><td rowspan=1 colspan=2>Model</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>Cora</td><td rowspan=1 colspan=1>CiteSeer</td><td rowspan=1 colspan=1>PubMed</td></tr><tr><td rowspan=3 colspan=1>GCN</td><td rowspan=1 colspan=1>DISC</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>81.6±0.5</td><td rowspan=1 colspan=1>71.6±0.3</td><td rowspan=1 colspan=1>79.2±0.1</td></tr><tr><td rowspan=2 colspan=1>ODE</td><td rowspan=1 colspan=1>add</td><td rowspan=1 colspan=1>81.7±0.7</td><td rowspan=1 colspan=1>72.4±0.6**</td><td rowspan=1 colspan=1>80.0±0.2**</td></tr><tr><td rowspan=1 colspan=1>1.sig</td><td rowspan=1 colspan=1>81.8±0.3**</td><td rowspan=1 colspan=1>72.4±0.8**</td><td rowspan=1 colspan=1>80.1±0.3**</td></tr><tr><td rowspan=3 colspan=1>GAT</td><td rowspan=1 colspan=1>DISC</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>82.9±0.3</td><td rowspan=1 colspan=1>71.7±0.8</td><td rowspan=1 colspan=1>78.9±0.3</td></tr><tr><td rowspan=2 colspan=1>ODE</td><td rowspan=1 colspan=1>add</td><td rowspan=1 colspan=1>83.3±0.3**</td><td rowspan=1 colspan=1>72.1±0.6**</td><td rowspan=1 colspan=1>79.1±0.5*</td></tr><tr><td rowspan=1 colspan=1>Lsig</td><td rowspan=1 colspan=1>83.1±0.4*</td><td rowspan=1 colspan=1>72.1±0.3**</td><td rowspan=1 colspan=1>79.0±0.5</td></tr><tr><td rowspan=3 colspan=1>Cheb</td><td rowspan=1 colspan=1>DISC</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>82.1±0.5</td><td rowspan=1 colspan=1>70.8±0.5</td><td rowspan=1 colspan=1>76.6±0.8</td></tr><tr><td rowspan=2 colspan=1>ODE</td><td rowspan=1 colspan=1>add</td><td rowspan=1 colspan=1>82.4±0.5*</td><td rowspan=1 colspan=1>71.1±0.5**</td><td rowspan=1 colspan=1>77.8±1.2**</td></tr><tr><td rowspan=1 colspan=1>L_sig</td><td rowspan=1 colspan=1>82.2±0.4*</td><td rowspan=1 colspan=1>70.8±0.6</td><td rowspan=1 colspan=1>77.0±1.1*</td></tr></table>
+
+Table 4: Results on graph-classification tasks. For each base model structure, discerete-layer model is marked with DISC; for corresponding GODE, we tested both free-form functions (“free”), and their invertible block form (“INV”). For each model, we use $^ { \ast } \left( ^ { \ast \ast } \right)$ to mark GODE models that outperform corresponding discrete-layer baselines at a $5 \%$ $( 1 \% )$ significance level under paired t-test.
+
+<table><tr><td>Integrationtime</td><td>0.5</td><td>1.0</td><td>1.5</td><td>2.0</td><td>5.0</td><td>10.0</td><td>20.0</td><td>100.0</td></tr><tr><td>Cora</td><td>80.5</td><td>81.6</td><td>80.1</td><td>80.1</td><td>79.3</td><td>77.6</td><td>68.9</td><td>35.1</td></tr><tr><td>CIFAR10</td><td>91.3</td><td>95.2</td><td>94.2</td><td>88.4</td><td>10.0</td><td>10.0</td><td>-</td><td>-</td></tr></table>
+
+Table 5: Accuracy of a free-form GCNODE on Cora and NODE18 on CIFAR10, varying with integration time.
+
+# 5.4 GENERAL BIJECTIVE BLOCKS
+
+We demonstrate that bijective blocks defined as Eq. 8 can be easily generalized: $F$ and $G$ are general neural networks, which can be adapted to different tasks; $\psi ( \alpha , \beta )$ can be any differentiable bijective mapping w.r.t. $\alpha$ when $\beta$ is given. We demonstrate two examples of $\psi$ : (1) additive, forward is $\eta = \psi ( \alpha , \beta ) = \alpha + \beta$ , inverse is $\alpha = \psi ^ { - 1 } ( \eta , \beta ) = \eta - \bar { \beta }$ ; (2) linear sigmoid, forward is $\eta = \psi ( \alpha , \beta ) = \alpha \times \mathrm { s i g m o i d } ( \beta )$ , inverse is $\alpha = \psi ^ { - 1 } ( \eta , \beta ) = \eta / \mathrm { s i g m o i d } ( \beta )$ .
+
+Results for different $\psi$ are reported in Table 3. Note that we experimented with different depths and reported the best accuracy for each model, and performed a paired t-test on results from GODE and their discrete-layer counterparts. Most GODE models outperformed their corresponding discretelayer models significantly, validating the effectiveness of GODE; different $\psi$ functions behaved similarly on our node classification tasks, indicating the continuous-time model is more important than coupling function $\psi$ . We also validate the lower memory cost, with details in appendix B.
+
+# 5.5 RESULTS ON GRAPH CLASSIFICATION TASK
+
+Results for different models on graph classification tasks are summarized in Table 4. We experimented with different structures, including GCN, ChebNet and GIN; for corresponding GODE models (marked with ODE), we tested both free-form (marked with “free”) and invertible block (marked with “INV”). We performed paired t-test comparing GODE and its discrete-layer counterparts. For most experiments, GODE models performed significantly better. This indicates the continuous process model might be important for graph models.
+
+# 5.6 IMPACT OF INTEGRATION TIME
+
+For a NODE and GODE model, during inference, we test the influence of integration time. Results are summarized in Table. 5. When integration time is short, the network does not gather sufficient information from neighbors; when integration time is too long, the model is sensitive to over-smooth issue, as discussed in Sec. 4.2. We observe accuracy drop in both cases.
+
+# 6 CONCLUSIONS
+
+We propose GODE, which enables us to model continuous diffusion process on graphs. We propose a memory-efficient direct back-propagation method to accurately determine the gradient for general free-form NODEs, and validate its superior performance on both image classification tasks and graph data. Furthermore, we related the over-smoothing of GNN to asymptotic stability of ODE. Our paper tackles the fundamental problem of gradient estimation for NODE; to our knowledge, it’s the first paper to improve accuracy on benchmark tasks to comparable with state-of-the-art discrete layer models. It’s an important step to apply NODE from theory to practice.
+
+# REFERENCES
+
+Uri M Ascher, Steven J Ruuth, and Raymond J Spiteri. Implicit-explicit runge-kutta methods for time-dependent partial differential equations. Applied Numerical Mathematics, 25(2-3):151–167, 1997.
+
+James Atwood and Don Towsley. Diffusion-convolutional neural networks. In NIPS, 2016.
+
+Peter N Brown, George D Byrne, and Alan C Hindmarsh. Vode: A variable-coefficient ode solver. SIAM, 1989.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
+
+Bo Chang, Lili Meng, Eldad Haber, Lars Ruthotto, David Begert, and Elliot Holtham. Reversible architectures for arbitrarily deep residual neural networks. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Tian Qi Chen, Yulia Rubanova, Jesse Bettencourt, and David K Duvenaud. Neural ordinary differential equations. In Advances in neural information processing systems, pp. 6571–6583, 2018.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In Advances in neural information processing systems, pp. 3844–3852, 2016.
+
+Li Deng, Dong Yu, et al. Deep learning: methods and applications. Foundations and Trends $\textsuperscript { \textregistered }$ in Signal Processing, 7(3–4):197–387, 2014.
+
+Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: Non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014.
+
+Laurent et al Dinh. Density estimation using real nvp. arXiv, 2016.
+
+Emilien Dupont, Arnaud Doucet, and Yee Whye Teh. Augmented neural odes. arXiv preprint arXiv:1904.01681, 2019.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan´ Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015.
+
+Matthias Fey and Jan Eric Lenssen. Fast graph representation learning with pytorch geometric. arXiv preprint arXiv:1903.02428, 2019.
+
+Alex Fout, Jonathon Byrd, Basir Shariat, and Asa Ben-Hur. Protein interface prediction using graph convolutional networks. In Advances in Neural Information Processing Systems, pp. 6530–6539, 2017.
+
+Mark I Freidlin and Alexander D Wentzell. Diffusion processes on graphs and the averaging principle. The Annals of probability, 1993.
+
+Amir Gholami, Kurt Keutzer, and George Biros. Anode: Unconditionally accurate memory-efficient gradients for neural odes. arXiv preprint arXiv:1902.10298, 2019.
+
+Aidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. In Advances in neural information processing systems, pp. 2214–2224, 2017.
+
+Will Grathwohl, Ricky TQ Chen, Jesse Betterncourt, Ilya Sutskever, and David Duvenaud. Ffjord: Free-form continuous dynamics for scalable reversible generative models. arXiv preprint arXiv:1810.01367, 2018.
+
+Eldad Haber and Lars Ruthotto. Stable architectures for deep neural networks. Inverse Problems, 2017.
+
+Takuo Hamaguchi, Hidekazu Oiwa, Masashi Shimbo, and Yuji Matsumoto. Knowledge transfer for out-of-knowledge-base entities: A graph neural network approach. arXiv preprint arXiv:1706.05674, 2017.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017.
+
+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.
+
+Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015.
+
+Aapo Hyvarinen and Erkki Oja. Independent component analysis: algorithms and applications. ¨ Neural networks, 13(4-5):411–430, 2000.
+
+Jorn-Henrik Jacobsen, Arnold Smeulders, and Edouard Oyallon. i-revnet: Deep invertible networks. ¨ arXiv preprint arXiv:1802.07088, 2018.
+
+Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In NIPS, 2018.
+
+Durk P Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, and Max Welling. Improved variational inference with inverse autoregressive flow. In Advances in neural information processing systems, pp. 4743–4751, 2016.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Risi Imre Kondor and John Lafferty. Diffusion kernels on graphs and other discrete structures. In ICML, 2002.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. Technical report, Citeseer, 2009.
+
+Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Jonathan Long, Evan Shelhamer, and Trevor Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 3431–3440, 2015.
+
+Laszl ´ o Lov ´ asz et al. Random walks on graphs: A survey. ´ Combinatorics, Paul erdos is eighty, 2(1): 1–46, 1993.
+
+Yiping et al Lu. Beyond finite layer neural networks: Bridging deep architectures and numerical differential equations. arXiv, 2017.
+
+Aleksandr Mikhailovich Lyapunov. The general problem of the stability of motion. International journal of control, 55(3):531–534, 1992.
+
+William Edmund Milne and WE Milne. Numerical solution of differential equations. 1953.
+
+Federico et al Monti. Geometric deep learning on graphs and manifolds using mixture model cnns. In CVPR, 2017.
+
+R-E Plessix. A review of the adjoint-state method for computing the gradient of a functional with geophysical applications. Geophysical Journal International, 167(2):495–503, 2006.
+
+Lev Semenovich Pontryagin. Mathematical theory of optimal processes. Routledge, 2018.
+
+Danilo Jimenez Rezende and Shakir Mohamed. Variational inference with normalizing flows. arXiv, 2015.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.   
+Paul Stapor, Fabian Froehlich, and Jan Hasenauer. Optimization and uncertainty analysis of ode models using second order adjoint sensitivity analysis. BioRxiv, pp. 272005, 2018.   
+Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks. In Advances in neural information processing systems, pp. 3104–3112, 2014.   
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.   
+Shuicheng Yan, Dong Xu, Benyu Zhang, Hong-Jiang Zhang, Qiang Yang, and Stephen Lin. Graph embedding and extensions: A general framework for dimensionality reduction. IEEE transactions on pattern analysis and machine intelligence, 29(1):40–51, 2006.   
+Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In ACM KDD, 2015.   
+Jie Zhou, Ganqu Cui, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, and Maosong Sun. Graph neural networks: A review of methods and applications. arXiv preprint arXiv:1812.08434, 2018.
+
+# A DATASETS
+
+We perform experiments on various datasets, including citation networks (Cora, CiteSeer, PubMed), social networks (COLLAB, IMDB-BINARY, REDDIT-BINARY), and bioinformatics datasets (MUTAG, PROTEINS). Details of each dataset are summarized in Table 1.
+
+Table 1: Statistics of datasets   
+
+<table><tr><td>Dataset</td><td>Graphs</td><td>Nodes</td><td>Edges</td><td>Features</td><td>Classes</td><td>Label rate</td></tr><tr><td>Cora</td><td>1</td><td>2,708</td><td>5,278</td><td>1,433</td><td>7</td><td>0.052</td></tr><tr><td>CiteSeer</td><td>1</td><td>3,327</td><td>4,552</td><td>3,703</td><td>6</td><td>0.036</td></tr><tr><td>PubMEd</td><td>1</td><td>19,717</td><td>44,324</td><td>500</td><td>3</td><td>0.003</td></tr><tr><td>MUTAG</td><td>188</td><td>17.93</td><td>19.79</td><td>7</td><td>2</td><td>0.8</td></tr><tr><td>PROTEINS</td><td>1,113</td><td>39.06</td><td>72.82</td><td>3</td><td>2</td><td>0.8</td></tr><tr><td>IMDB-BINARY</td><td>1,000</td><td>19.77</td><td>96.53</td><td>1</td><td>2</td><td>0.8</td></tr><tr><td>REDDIT-BINARY</td><td>200</td><td>429.63</td><td>497.76</td><td>=</td><td>2</td><td>0.8</td></tr></table>
+
+# B DETAILS ABOUT INVERTIBLE BLOCKS
+
+![](images/2011989f5d649b6fc78262f66ceae12c33391a4cd479ff46686ed56b363cbc87.jpg)  
+Figure 1: Structure of bijective blocks. $F$ and $G$ can be any differentiable neural network whose output has the same shape as its input. Blue dot (Orange diamond) represents the forward (inverse) of a bijective function, corresponding to $\psi$ $( \psi ^ { \hat { - } 1 } )$ in Eq. 8 of the main paper. Left (right) figure represents the forward (inverse) as in Eq. 8.
+
+We explain the structure and conduct experiments for the invertible block here.
+
+Structure of invertible blocks Structure of invertible blocks are shown in Fig. 1. We follow the work of Gomez et al. (2017) with two important modifications: (1) We generalize to a family of bijective blocks with different $\psi$ in Eq. 8 in the main paper, while Gomez et al. (2017) restrict the form of $\psi$ to be sum. (2) We propose a parameter state checkpoint method, which enables bijective blocks to be called more than once, while still generating accurate inversion.
+
+The algorithm is summarized in Algo. 2. We write the pseudo code for forward and backward function as in PyTorch. Note that we use “inversion” to represent reconstructing input from the output, and use “backward” to denote calculation of the gradient. To reduce memory consumption, in the forward function, we only keep the outputs $y _ { 1 } , y _ { 2 }$ and delete all other variables and computation graphs. In the backward function, we first “inverse” the block to calculate $x _ { 1 } , x _ { 2 }$ from $y _ { 1 } , y _ { 2 }$ , then perform a local forward and calculate the gradient $\frac { \partial [ y _ { 1 } , y _ { 2 } ] } { \partial [ x _ { 1 } , x _ { 2 } ] }$ .
+
+Experiments In this section we demonstrate that our bijective block is memory efficient. We trained a GODE model with bijective blocks, and compared the memory consumption using our memory-efficient function as in Algo. 2 and a memory-inefficient method as in conventional backpropagation. Results were measured with a batchsize of 100 on MUTAG dataset.
+
+Table 2: Memory consumption of bijective blocks. “Conventional” represents storing activation of all layers in cache, “memory-efficient” represents our method in Algo. 2.   
+
+<table><tr><td rowspan=1 colspan=1>Depth</td><td rowspan=1 colspan=1>Memory-efficient</td><td rowspan=1 colspan=1>Conventional</td></tr><tr><td rowspan=1 colspan=1>10</td><td rowspan=1 colspan=1>2.2G</td><td rowspan=1 colspan=1>5.3G</td></tr><tr><td rowspan=1 colspan=1>20</td><td rowspan=1 colspan=1>2.6G</td><td rowspan=1 colspan=1>10.5G</td></tr></table>
+
+Results are summarized in Table. 2. We measured the memory consumption with different depths, which is the number of ODE blocks. When depth increases from 10 to 20, the memory by conventional methods increases from 5.3G to 10.5G, while our memory-efficient version only increases from 2.2G to 2.6G. In theory, our bijective block takes $\mathcal { O } ( 1 )$ memory, because we only need to store the outputs in cache, while deleting activations of middle layers. For memory-efficient network, the slightly increased memory consumption is because states of $F , G$ need to be cached; but this step takes up minimal memory compared to input data.
+
+Algorithm 2: Function for memory-efficient bijective blocks   
+
+<table><tr><td>Forward (cache,x1,x2,F,G,$) cache.save([F states,G states])</td><td>Backward(cache, y1, y2,F,G,,y， aL aL y2 Reset Fand G states from cache</td></tr><tr><td>forward in Eq. 8</td><td>Inverse from y1,y2 to x1,2</td></tr><tr><td>n1 =F(x1),y2=γ(x2,n1)</td><td>n2 =G(y2),x1=-1(yi,n2)</td></tr><tr><td>n2=G(y2)，yi=γ(x1,n2)</td><td>η1 =F(x1),x2=-1(y2,n1)</td></tr><tr><td>delete ni,n2,x1,x2</td><td>Local forward passand gradient</td></tr><tr><td>delete computation graphs generated by F and G return cache,y1, y2</td><td>X1,X2= x1.detach(),x2.detach()</td></tr><tr><td></td><td>calculateY1,Y2 from X1,X2 as Eq. 8</td></tr><tr><td></td><td>determine δ[Yi,Y2]/a[X1,X2,0F,0G]</td></tr><tr><td></td><td>aL aL a[Y,Y2]</td></tr><tr><td></td><td>x1,x2] 0y1,y2]0XX2] aL aL Y，Y2]</td></tr><tr><td></td><td>[0F,G] y1y2]FG]</td></tr><tr><td></td><td>deleteY,Y2,X1,X2</td></tr><tr><td></td><td>return dL/d[x1,x2],δL/δ[0F,0G]</td></tr><tr><td></td><td></td></tr></table>
+
+# C PROOF FOR PROPOSITION 1
+
+Proposition 1 For an ODE in the form $\begin{array} { r } { \frac { \mathrm { d } \boldsymbol { z } ( t ) } { \mathrm { d } t } = \boldsymbol { f } ( \boldsymbol { z } ( t ) , t ) , } \end{array}$ , denote the Jacobian of $f$ as $J _ { f }$ . If this ODE is stable both in forward-time and reverse-time, then $\operatorname { R e } ( \lambda _ { i } ( J _ { f } ) ) = 0 ~ \forall i$ , where $\lambda _ { i } ( \dot { J } _ { f } )$ is the ith eigenvalue of $J _ { f }$ , and $\mathrm { R e } ( \lambda )$ is the real part of $\lambda$ .
+
+Proof Denote $s = T - t$ , where $T$ is the end time. Notice that the reverse-time in $t$ is equivalent to forward-time in $s$ .
+
+Therefore, we have forward-time ODE:
+
+$$
+\frac { \mathrm { d } \boldsymbol { z } ( t ) } { \mathrm { d } t } = \boldsymbol { f } ( \boldsymbol { z } ( t ) , t )
+$$
+
+and reverse-time ODE:
+
+$$
+\frac { \mathrm { d } z ( s ) } { \mathrm { d } s } = - f ( z ( s ) , s ) = g ( z ( s ) , s )
+$$
+
+Therefore, we have $\lambda ( J _ { f } ) = - \lambda ( J _ { g } )$ . For both forward-time and reverse-time ODE to be stable, the eigenvalues of $J$ need to have non-positive real part.
+
+Therefore
+
+$$
+\mathrm { R e } \lambda _ { i } ( J _ { f } ) \leq 0 , \ \mathrm { R e } \lambda _ { i } ( J _ { g } ) = - \mathrm { R e } \lambda _ { i } ( J _ { f } ) \leq 0 , \ \forall i
+$$
+
+The only solution is
+
+$$
+\mathrm { R e } \lambda _ { i } ( J _ { g } ) = - \mathrm { R e } \lambda _ { i } ( J _ { f } ) = 0 , \ \forall i
+$$
+
+# D PROOF FOR THEOREM 1
+
+Theorem 1 For bijective block whose forward and reverse mappings are defined as
+
+$$
+F o r w a r d ( x _ { 1 } , x _ { 2 } ) = \left\{ \begin{array} { l l } { y _ { 2 } = \psi \Big ( x _ { 2 } , F ( x _ { 1 } ) \Big ) } \\ { y _ { 1 } = \psi \Big ( x _ { 1 } , G ( y _ { 2 } ) \Big ) } \end{array} \right. R e v e r s e ( y _ { 1 } , y _ { 2 } ) = \left\{ \begin{array} { l l } { x _ { 1 } = \psi ^ { - 1 } \Big ( y _ { 1 } , G ( y _ { 2 } ) \Big ) } \\ { x _ { 2 } = \psi ^ { - 1 } \Big ( y _ { 2 } , F ( x _ { 1 } ) \Big ) } \end{array} \right.
+$$
+
+If $\psi ( \alpha , \beta )$ is a bijective function w.r.t $\alpha$ when $\beta$ is given, then the block is a bijective mapping.
+
+Proof To prove the forward mapping is bijective, it is equivalent to prove the mapping is both injective and surjective.
+
+Injective We need to prove, if F o $\mathbf { \cdot } w a r d ( x _ { 1 } , x _ { 2 } ) = F o r w a r d ( x _ { 3 } , x _ { 4 } )$ , then $x _ { 1 } = x _ { 3 } , x _ { 2 } = x _ { 4 } $
+
+The assumption above is equivalent to
+
+$$
+{ \begin{array} { r l r } & { } & { F o r w a r d ( x _ { 1 } , x _ { 2 } ) = F o r w a r d ( x _ { 3 } , x _ { 4 } ) \iff y _ { 2 } = \psi ( x _ { 2 } , F ( x _ { 1 } ) ) = \psi ( x _ { 4 } , F ( x _ { 3 } ) ) } \\ & { } & { \psi ( x _ { 1 } , G ( y _ { 2 } ) ) = \psi ( x _ { 3 } , G ( y _ { 2 } ) ) } \end{array} }
+$$
+
+Since $\psi ( \alpha , \beta )$ is bijective $w . r . t \alpha$ when $\beta$ is given, from Eq.(6), we have $x _ { 1 } = x _ { 3 }$ .   
+Similarly, condition on $x _ { 1 } = x _ { 3 }$ and Eq.(5), using bijective property of $\psi$ , we have $x _ { 2 } = x _ { 4 }$ .   
+Therefore, the mapping is injective.
+
+Surjective We need to prove $\forall [ y _ { 1 } , y _ { 2 } ]$ , ∃ $[ x _ { 1 } , x _ { 2 } ]$ s.t. F orward(x1, x2) = [y1, y2].
+
+Given $y _ { 1 } , y _ { 2 }$ , we construct
+
+$$
+x _ { 1 } = \psi ^ { - 1 } { \Big ( } y _ { 1 } , G ( y _ { 2 } ) { \Big ) } , x _ { 2 } = \psi ^ { - 1 } { \Big ( } y _ { 2 } , F ( x _ { 1 } ) { \Big ) }
+$$
+
+Then for the forward function, given bijective property of $\psi$ , apply F orward and Reverse defined in the proposition statement,
+
+$$
+z _ { 2 } = \psi ( x _ { 2 } , F ( x _ { 1 } ) ) = \psi \Bigl ( \psi ^ { - 1 } \bigl ( y _ { 2 } , F ( x _ { 1 } ) \bigr ) , F ( x _ { 1 } ) \Bigr ) = y _ { 2 }
+$$
+
+$$
+z _ { 1 } = \psi ( x _ { 1 } , G ( y _ { 2 } ) ) = \psi \Bigl ( \psi ^ { - 1 } \bigl ( y _ { 1 } , G ( y _ { 2 } ) \bigr ) , G ( y _ { 2 } ) \Bigr ) = y _ { 1 }
+$$
+
+Therefore we construct $x _ { 1 } , x _ { 2 }$ s.t. F orwar $d ( x _ { 1 } , x _ { 2 } ) = [ y _ { 1 } , y _ { 2 } ]$ .
+
+Therefore the mapping is surjective.
+
+Therefore is bijective.
+
+# E DERIVATION OF GRADIENT IN DISCRETE CASE
+
+We use a figure to demonstrate the computation graph, and derive the gradient from the computation graph.
+
+![](images/58e79ce38c14741a6d93e07e7b9de57045ed65718f4ae455a07e936d312544c7.jpg)
+
+The loss is $L$ , forward pass is denoted with black arrows, gradient back-propagation is shown with red arrows. We use $p$ to denote each path from $\theta$ to $L$ , corresponding to all paths in red that goes from $L$ to $\theta$ .
+
+$$
+{ \frac { \mathrm { d } L } { \mathrm { d } \theta } } = \sum _ { p } { \frac { \partial L _ { p } } { \partial \theta } } = \sum _ { i } { \frac { \partial L } { \partial z _ { ( } t _ { i } ) } } { \frac { \partial z ( t _ { i } ) } { \partial \theta } } = \sum _ { i } a _ { i } { \frac { \partial z ( t _ { i } ) } { \partial \theta } }
+$$
+
+$$
+a _ { i } = \frac { \partial L } { \partial z ( t _ { i } ) } = \frac { \partial L } { \partial z ( t _ { i + 1 } ) } \frac { \partial z ( t _ { i + 1 } ) } { \partial z ( t _ { i } ) } = a _ { i + 1 } \frac { \partial z ( t _ { i + 1 } ) } { \partial z ( t _ { i } ) }
+$$
+
+# F DERIVATION OF PARAMETER GRADIENTS IN CONTINUOUS CASE
+
+In this section we derive the gradient of parameters in an neural-ODE model from an optimization perspective. Then we extend from continuous cases to discrete cases.
+
+Notations With the same notations as in the main paper, we use $z ( t )$ to denote hidden states $z$ at time $t$ . Denote parameters as $\theta$ , and input as $x$ , target as $y$ , and predicted output as $\hat { y }$ . Denote the loss as $J ( \hat { y } , y )$ . Denote the integration time as 0 to $T$ .
+
+Problem setup The continuous model is defined to follow an ODE:
+
+$$
+\frac { d z ( t ) } { d t } = f ( z ( t ) , t , \theta ) , s . t . z ( 0 ) = x
+$$
+
+We assume $f$ is differentiable, since $f$ is represented by a neural network in our case. The forward pass is defined as:
+
+$$
+\hat { y } = z ( T ) = z ( 0 ) + \int _ { 0 } ^ { T } f ( z ( t ) , t , \theta ) d t
+$$
+
+The loss function is defined as:
+
+$$
+J ( \hat { y } , y ) = J ( z ( T ) , y )
+$$
+
+We formulate the training process as an optimization problem:
+
+$$
+\operatorname { a r g m i n } _ { \theta } \frac { 1 } { N } \sum _ { i = 1 } ^ { N } J ( \hat { y } _ { i } , y _ { i } ) { s . t . } \frac { d z ( t ) } { d t } = f ( z ( t ) , t , \theta ) , { z } _ { i } ( 0 ) = x _ { i }
+$$
+
+For simplicity, Eq. 15 only considers one ODE block. In the case of multiple blocks, $z ( T )$ is the input to the next ODE block. As long as we can derive $\textstyle { \frac { d L o s s } { d \theta } }$ and $\begin{array} { r } { \frac { d L o s s } { d z ( 0 ) } } \end{array}$ when $\begin{array} { l } { \frac { d L o s s } { d z ( T ) } } \end{array}$ is given, the same analysis here can be applied to the case with a chain of ODE blocks.
+
+Lagrangian Multiplier Method We use the Lagrangian Multiplier Method to solve the problem defined in Eq. 15. For simplicity, only consider one example (can be easily extended to multiple examples cases), the Lagrangian is
+
+$$
+L = J ( z ( T ) , y ) + \int _ { 0 } ^ { T } \lambda ( t ) [ \frac { d z ( t ) } { d t } - f ( z ( t ) , t , \theta ) ] d t
+$$
+
+Karush-Kuhn-Tucker (KKT) conditions are necessary conditions for an solution to be optimal. In the following sections we start from the KKT condition and derive our results.
+
+Derivative w.r.t. $\lambda$ At optimal point, we have $\begin{array} { r } { \frac { \delta L } { \delta \lambda } = 0 } \end{array}$ . Note that $\lambda$ is a function of $t$ , we derive the derivative from calculus of variation.
+
+Consider a cotninuous and differentiable perturbation $\overline { { \lambda ( t ) } }$ on $\lambda ( t )$ , and a scalar $\epsilon$ , $L$ now becomes a function of $\epsilon$ ,
+
+$$
+L ( \epsilon ) = J ( z ( 0 ) + \int _ { 0 } ^ { T } f ( z ( t ) , t , \theta ) , y ) + \int _ { 0 } ^ { T } ( \lambda ( t ) + \epsilon { \overline { { \lambda ( t ) } } } ) [ { \frac { d z ( t ) } { d t } } - f ( z ( t ) , t , \theta ) ] d t
+$$
+
+It’s easy to check the conditions for Leibniz integral rule, and we can switch integral and differentiation, thus:
+
+$$
+\frac { d L } { d \epsilon } = \int _ { 0 } ^ { T } \overline { { \lambda ( t ) } } [ \frac { d z ( t ) } { d t } - f ( z ( t ) , t , \theta ) ] d t
+$$
+
+At optimal $\begin{array} { r } { \lambda ( t ) , \frac { d L } { d \epsilon } | _ { \epsilon = 0 } = 0 } \end{array}$ for all continuous differentiable $\overline { { \lambda ( t ) } }$
+
+Therefore,
+
+$$
+\frac { d z ( t ) } { d t } - f ( z ( t ) , t , \theta ) = 0 , \forall t \in ( 0 , T )
+$$
+
+Derivative w.r.t $z$ Consider perturbation $\overline { { z ( t ) } }$ on $z ( t )$ , with scale $\epsilon$ . With similar analysis:
+
+$$
+L ( \epsilon ) = J ( z ( T ) + \epsilon \overline { { z ( T ) } } , y ) + \int _ { 0 } ^ { T } \lambda ( t ) [ \frac { d z ( t ) + \epsilon \overline { { z ( t ) } } } { d t } - f ( z ( t ) + \epsilon \overline { { z ( t ) } } , t , \theta ) ] d t
+$$
+
+Take derivative w.r.t $\epsilon$ , it’s easy to check conditions for Leibniz integral rule are satisfied, when $f$ and $\overline { { z ( t ) } }$ are Lipschitz continuous differentiable functions:
+
+(1) $f ( z ( t ) , t , \theta )$ is a Lebesgue-integrable function of $\theta$ for each $\boldsymbol { z } ( t ) \in \mathbf { R } ^ { d }$ , since we use a neural network to represent $f$ , which is continuous and differentiable almost everywhere.
+
+(2) for almost all θ, ∂f (z(t),t,θ) exists for almost all $x \in \mathbf { R } ^ { d }$ .
+
+(3 ) ∂f(z(t),t,θ)∂z(t) is bounded by g(θ) for all z(t) for almost all θ.
+
+Then we calculat e dL()d , note that we can switch integral and derivative:
+
+$$
+\begin{array} { r l } { \frac { d L } { d \varepsilon } | _ { - \infty } = - \frac { \partial J } { \partial \varepsilon ( T ) } \overline { { \varepsilon ( T ) } } + \frac { d } { d \varepsilon } \int _ { 0 } ^ { 2 \pi } \lambda ( t ) \frac { d \varepsilon ( t ) } { d t } + \overline { { \varepsilon ( t ) } } - f ( \varepsilon ( t ) + \varepsilon \overline { { \varepsilon ( t ) } } , t , \theta ) | d t } & { ( 2 1 , \theta ) } \\ & { = \frac { \partial J } { \partial \varepsilon ( T ) } \overline { { \varepsilon ( T ) } } + \int _ { 0 } ^ { 2 \pi } \lambda ( t ) \frac { d \overline { { \varepsilon ( t ) } } } { d t } - \frac { \partial J } { \partial \varepsilon } \frac { \partial \overline { { \varepsilon ( t ) } } ( \varepsilon , t , \theta ) } { \partial \varepsilon ( t ) } \overline { { \varepsilon ( t ) } } | d t } & { ( 2 2 , \theta ) } \\ & { = \frac { \partial J } { \partial \varepsilon ( T ) } \overline { { \varepsilon ( T ) } } + \int _ { 0 } ^ { T } \mathbb { I } ( \lambda ( t ) \frac { d \overline { { \varepsilon ( t ) } } } { d t } + \frac { d \lambda ( t ) } { d t } \overline { { \varepsilon ( t ) } } - \frac { d \lambda ( t ) } { d t } \overline { { \varepsilon ( t ) } } - \lambda ( t ) \frac { \partial \overline { { \varepsilon ( t ) } } ( \varepsilon , t , \theta ) } { \partial \varepsilon ( t ) } \overline { { \varepsilon ( t ) } } | d t } \\ & { = \frac { \partial J } { \partial \varepsilon ( T ) } \overline { { \varepsilon ( T ) } } + \lambda ( t ) \overline { { \varepsilon ( t ) } } | _ { 0 } ^ { \pi } - \int _ { 0 } ^ { T } \overline { { \varepsilon ( t ) } } | \frac { d \lambda ( t ) } { d t } + \lambda ( t ) \frac { \partial \overline { { f } } [ \varepsilon ( t ) , t , \theta ) } { \partial \varepsilon ( t ) } | d t } & { ( 2 4 , \theta ) } \\ & { = \frac { \partial J } { \partial \varepsilon ( T ) } \overline { { \varepsilon ( T ) } } + \lambda ( \overline { { \varepsilon ( T ) } } \overline { { \varepsilon ( T ) } } - \lambda ( t ) \overline { { \varepsilon ( 0 ) } } - \int _ { 0 } ^ { T } \overline { { \varepsilon ( t ) } } | \frac { d \lambda ( t ) } { d t } + \lambda ( t ) \frac { \partial \overline { { f } } ( \varepsilon ( t ) , t , \theta ) } { \partial \varepsilon ( t ) } | d t } &  ( 2 \overline { { s } } \end{array}
+$$
+
+Since the initial condition $z ( 0 ) = x$ is given, perturbation $\overline { { z ( 0 ) } }$ at $t = 0$ is 0, then we have:
+
+$$
+\frac { d L } { d \epsilon } | _ { \epsilon = 0 } = ( \frac { \partial J } { \partial z ( T ) } + \lambda ( T ) ) \overline { { z ( T ) } } - \int _ { 0 } ^ { T } \overline { { z ( t ) } } [ \frac { d \lambda ( t ) } { d t } + \lambda ( t ) \frac { \partial f ( z ( t ) , t , \theta ) } { \partial z ( t ) } ] d t = 0
+$$
+
+for any $\overline { { z ( t ) } }$ s.t. $\overline { { z ( 0 ) } } = 0$ and $\overline { { z ( t ) } }$ is differentiable.
+
+The solution is:
+
+$$
+\begin{array} { c } { \displaystyle \frac { \partial J } { \partial z ( T ) } + \lambda ( T ) = 0 } \\ { \displaystyle \frac { d \lambda ( t ) } { d t } + \lambda ( t ) \frac { \partial f ( z ( t ) , t , \theta ) } { \partial z ( t ) } = 0 \mathrm { ~ } \forall t \in ( 0 , T ) } \end{array}
+$$
+
+Derivative w.r.t $\theta$ From Eq. 16,
+
+$$
+\frac { d L } { d \theta } = - \int _ { 0 } ^ { T } \lambda ( t ) \frac { \partial f ( z ( t ) , t , \theta ) } { \partial \theta } d t
+$$
+
+To sum up, first solve the ODE forward-in-time with Eq. 19, then determine the boundary condition by Eq. 28, then solve the ODE backward with Eq. 29, and finally calculate the gradient with Eq. 30. In fact $\lambda$ corresponds to the negative adjoint.
+
+From continuous to discrete case To derive corresponding results in discrete cases, we need to replace all integration with finite sum.
+
+In discrete cases, the ODE condition turns into:
+
+$$
+\frac { z _ { i + 1 } - z _ { i } } { t _ { i + 1 } - t _ { i } } = f ( z _ { i } , t _ { i } , \theta )
+$$
+
+from Eq. 31, we can get:
+
+$$
+\frac { \partial L } { \partial z _ { i } } = \frac { \partial L } { \partial z _ { i + 1 } } \frac { \partial z _ { i + 1 } } { \partial z _ { i } } = \frac { \partial L } { \partial z _ { i + 1 } } ( I + \frac { \partial f ( z _ { i } , t _ { i } , \theta ) } { \partial z _ { i } } ( t _ { i + 1 } - t _ { i } ) )
+$$
+
+Re-arranging terms we have:
+
+$$
+[ ( - \frac { \partial L } { \partial z _ { i + 1 } } ) - ( - \frac { \partial L } { \partial z _ { i } } ) ] / [ t _ { i + 1 } - t _ { i } ] + ( - \frac { \partial L } { \partial z _ { i + 1 } } ) \frac { \partial f ( z _ { i } , t _ { i } , \theta ) } { \partial z _ { i } } = 0
+$$
+
+which is the discrete version of Eq. 29. Which also corresponds to our analysis in Eq. 10 and 11.

parse/train/rylNH20qFQ/rylNH20qFQ.md

@@ -0,0 +1,331 @@
+# LEARNING TO INFER AND EXECUTE 3D SHAPE PROGRAMS
+
+Yonglong Tian†, Andrew Luo†, Xingyuan $\mathbf { S u n } ^ { \ddagger }$ , Kevin Ellis†, William T. Freeman†∗, Joshua B. Tenenbaum† & Jiajun Wu†
+
+†Massachusetts Institute of Technology   
+‡Princeton University   
+∗Google Research   
+{yonglong,aluo,ellisk,billf,jbt,jiajunwu}@mit.edu   
+xs5@princeton.edu
+
+# ABSTRACT
+
+Human perception of 3D shapes goes beyond reconstructing them as a set of points or a composition of geometric primitives: we also effortlessly understand higherlevel shape structure such as the repetition and reflective symmetry of object parts. In contrast, recent advances in 3D shape sensing focus more on low-level geometry but less on these higher-level relationships. In this paper, we propose $3 D$ shape programs, integrating bottom-up recognition systems with top-down, symbolic program structure to capture both low-level geometry and high-level structural priors for 3D shapes. Because there are no annotations of shape programs for real shapes, we develop neural modules that not only learn to infer 3D shape programs from raw, unannotated shapes, but also to execute these programs for shape reconstruction. After initial bootstrapping, our end-to-end differentiable model learns 3D shape programs by reconstructing shapes in a self-supervised manner. Experiments demonstrate that our model accurately infers and executes 3D shape programs for highly complex shapes from various categories. It can also be integrated with an image-to-shape module to infer 3D shape programs directly from an RGB image, leading to 3D shape reconstructions that are both more accurate and more physically plausible.
+
+# 1 INTRODUCTION
+
+Given the table in Figure 1, humans are able to instantly recognize its parts and regularities: there exist sharp edges, smooth surfaces, a table top that is a perfect circle, and two lower, square layers. Beyond these basic components, we also perceive higher-level, abstract concepts: the shape is bilateral symmetric; the legs are all of equal length and laid out on the opposite positions of a 2D grid. Knowledge like this is crucial for visual recognition and reasoning (Koffka, 2013; Dilks et al., 2011).
+
+Recent AI systems for 3D shape understanding have made impressive progress on shape classification, parsing, reconstruction, and completion (Qi et al., 2017; Tulsiani et al., 2017), many making use of large shape repositories like ShapeNet (Chang et al., 2015). Popular shape representations include voxels (Wu et al., 2015), point clouds (Qi et al., 2017), and meshes (Wang et al., 2018). While each has its own advantages, these methods fall short on capturing the strong shape priors we just described, such as sharp edges and smooth surfaces.
+
+A few recent papers have studied modeling 3D shapes as a collection of primitives (Tulsiani et al., 2017), with simple operations such as addition and subtraction (Sharma et al., 2018). These representations have demonstrated success in explaining complex 3D shapes. In this paper, we go beyond them to capture the high-level regularity within a 3D shape, such as symmetry and repetition.
+
+In this paper, we propose to represent 3D shapes as shape programs. We define a domain-specific language (DSL) for shapes, containing both basic shape primitives for parts with their geometric and semantic attributes, as well as statements such as loops to enforce higher-level structural priors.
+
+![](images/0078615a136e87ccda4833b82ddc1a3755c2b08066ad9a09f38bb79f25ca614b.jpg)  
+Figure 1: A 3D shape can be represented by a program via a program generator. This program can be executed by a neural program executor to produce the corresponding 3D shape.
+
+Because 3D shape programs are a new shape representation, there exist no annotations of shape programs for 3D shapes. The lack of annotations makes it difficult to train an inference model with full supervision. To overcome this obstacle, we propose to learn a shape program executor that reconstructs a 3D shape from a shape program. After initial bootstrapping, our model can then learn in a self-supervised way, by attempting to explain and reconstruct unlabeled 3D shapes with 3D shape programs. This design minimizes the amount of supervision needed to get our model off the ground.
+
+With the learned neural program executor, our model learns to explain input shapes without ground truth program annotations. Experiments on ShapeNet show that our model infers accurate 3D shape programs for highly complex shapes from various categories. We further extend our model by integrating with an image-to-shape reconstruction module, so it directly infers a 3D shape program from a color image. This leads to 3D shape reconstructions that are both more accurate and more physically plausible.
+
+Our contributions are three-fold. First, we propose 3D shape programs: a new representation for shapes, building on classic findings in cognitive science and computer graphics. Second, we propose to infer 3D shape programs by explaining the input shape, making use of a neural shape program executor. Third, we demonstrate that the inference model, the executor, and the programs they recover all achieve good performance on ShapeNet, learning to explain and reconstruct complex shapes. We further show that an extension of the model can infer shape programs and reconstruct 3D shapes directly from images.
+
+# 2 RELATED WORK
+
+Inverse procedural graphics. The problem of inferring programs from voxels is closely related to inverse procedural graphics, where a procedural graphics program is inferred from an image or declarative specification (Ritchie et al., 2016; St’ava et al. ˇ , 2010). Where the systems have been most successful, however, are when they leverage a large shape–component library (Chaudhuri et al., 2011; Schulz et al., 2017) or are applied to a sparse solution space (van den Hengel et al., 2015). Kulkarni et al. (2015a) approached the problem of inverse graphics as inference in a probabilistic program for generating 2D images, or image contours, from an underlying 3D model. They demonstrated results on several different applications using parametric generative models for faces, bodies, and simple multi-part objects based on generalized cylinders. In this work, we extend the idea of inverse procedural graphics to 3-D voxel representations, and show how this idea can apply to large data sets like ShapeNet. We furthermore do not have to match components to a library of possible shapes, instead using a neural network to directly infer shapes and their parameters.
+
+A few recent papers have explored the use of simple geometric primitives to describe shapes (Tulsiani et al., 2017; Zou et al., 2017; Liu et al., 2018), putting the classic idea of generalized cylinders (Roberts, 1963; Binford, 1971) or geons (Biederman, 1987) in the modern context of deep learning. In particular, Sharma et al. (2018) extended these papers and addressed the problem of inferring 3-D CAD programs from perceptual input. We find this work inspiring, but also feel that a key goal of 3-D program inference is to reconstruct a program in terms of semantically meaningful parts and their spatial regularity, which we address here. Some other graphics papers also explore regularity, but without using programs (Mitra et al., 2013; Zhu et al., 2018; Nishida et al., 2018; Li et al., 2017).
+
+Work in the HCI community has also addressed the problem of inferring parametric graphics primitives from perceptual input. For example, Nishida et al. (2016) proposed to learn to instantiate procedural primitives for an interactive modeling system. In our work, we instead learn to instantiate multiple procedural graphics primitives simultaneously, without assistance from a human user.
+
+Table 1: The domain specific language (DSL) for 3D shapes. Semantics depends on the types of objects that are modeled, i.e., semantics for vehicle and furniture should be different. For details of DSL in our experimental setting, please refer to supplementary.   
+
+<table><tr><td>Program</td><td>→</td></tr><tr><td>Statement</td><td>Draw(Semantics,Shape,Position_Params,Geometry Params)</td></tr><tr><td>Statement</td><td>For(For_Params); Program; EndFor</td></tr><tr><td>Semantics</td><td>semantics 1|semantics 2|semantics 3|..</td></tr><tr><td>Shape</td><td>Cuboid|Cylinder丨Rectangle|Circle|Line</td></tr><tr><td>Position_Params</td><td>(x,y,z)</td></tr><tr><td>Geometry_Params</td><td>(g1,92,93,94,...)</td></tr><tr><td>For_Params</td><td>Translation_Params|Rotation_Params</td></tr><tr><td>Translation_Params</td><td>(times i, orientation u)</td></tr><tr><td>Rotation_Params</td><td>(times i,angle θ,axis a)</td></tr></table>
+
+Program synthesis. In the AI literature, Ellis et al. (2018) leveraged symbolic program synthesis techniques to infer 2D graphics programs from images, extending their earlier work by using neural nets for faster inference of low-level cues such as strokes (Ellis et al., 2015). Here, we show how a purely end–to–end network can recover 3D graphics programs from voxels, conceptually relevant to RobustFill (Devlin et al., 2017), which presents a purely end-to-end neural program synthesizer for text editing. The very recent SPIRAL system (Ganin et al., 2018) also takes as its goal to learn structured program–like models from (2D) images. An important distinction from our work here is that SPIRAL explains an image in terms of paint-like “brush strokes”, whereas we explain 3D voxels in terms of high-level objects and semantically meaningful parts of objects, like legs or tops. Other tangential related work on program synthesis includes Balog et al. (2017); Devlin et al. (2017); Parisotto et al. (2017); Gaunt et al. (2016); Sun et al. (2018a); Liu et al. (2019).
+
+Learning to execute programs. Neural Program Interpreters (NPI) have been extensively studied for programs that abstract and execute tasks such as sorting, shape manipulation, and grade-school arithmetic (Reed & De Freitas, 2016; Cai et al., 2017; Bosnjak et al. ˇ , 2017). In NPI (Reed & De Freitas, 2016), the key insight is that a program execution trace can be decomposed into predefined operations that are more primitive; and at each step, an NPI learns to predict what operation to take next depending on the general environment, domain specific state , and previous actions. Cai et al. (2017) improved the generalization of NPIs by adding recursion. Johnson et al. (2017) learned to execute programs for visual question and answering. In this paper, we also learn a 3D shape program executor that renders 3D shapes from programs as a component of our model.
+
+# 3 3D SHAPE PROGRAMS
+
+In this section, we define the domain-specific language for 3D shapes, as well as the problem of shape program synthesis.
+
+Table 1 shows our DSL for 3D shape programs. Each shape program consists of a variable number of program statements. A program statement can be either Draw, which describes a shape primitive as well as its geometric and semantic attributes, or For, which contains a sub-program and parameters specifying how the subprogram should be repeatedly executed. The number of arguments for each program statement varies. We tokenize programs for the purpose of neural network prediction.
+
+Each shape primitive models a semantically-meaningful part of an object. Its geometric attributes (Table 1: Geometry Params, Position Params) specify the position and orientation of the part. Its semantic attributes (Table 1: Semantics) specify its relative role within the whole shape (e.g., top, back, leg). They do not affect the geometry of the primitive; instead, they associate geometric parts with their semantic meanings conveying how parts can be shared across object categories semantically and functionally (e.g., a chair and a table may have similar legs).
+
+Our For statement captures high-level regularity across parts. For example, the legs of a table can be symmetric with respect to particular rotation angles. The horizontal bars of a chair may lay out regularly with a fixed vertical gap. Each For statement can contain sub-programs, allowing recursive generation of shape programs.
+
+![](images/c46d39b3d3edb1639719777c7549269b6cc0b684983a73fa25a926867bf35aad.jpg)  
+Figure 2: The core of our 3D shape program generator are two LSTMs. The Block LSTM emits features for each program block. The Step LSTM takes these features as input and outputs programs inside each block, which includes either a single drawing statement or compound statements.
+
+The problem of inferring a 3D shape program is defined as follows: predicting a 3D shape program that reconstructs the input shape when the program is executed. In this paper, we use voxelized shapes as input with a resolution of $3 2 \times 3 2 \times 3 2$ .
+
+# 4 INFERRING AND EXECUTING 3D SHAPE PROGRAMS
+
+Our model, called Shape Programs, consists of a program generator and a neural program executor. The program generator takes a 3D shape as input and outputs a sequence of primitive programs that describe this 3D shape. The neural program executor takes these programs as input and generates the corresponding 3D shapes. This allows our model to learn in a self-supervised way by generating programs from input shapes, executing these programs, and back-propagating the difference between the generated shapes and the raw input.
+
+# 4.1 PROGRAM GENERATOR
+
+We model program generation as a sequential prediction problem. We partition full programs into two types of subprograms, which we call blocks: (1) a single drawing statement describing a semantic part, e.g. circle top; and (2) compound statements, which are a loop structure that interprets a set of translated or rotated parts, e.g. four symmetric legs. This part-based, symmetry-aware decomposition is inspired by human perception (Fleuret et al., 2011).
+
+Our program generator is shown in Figure 2. The core of the program generator consists of two orthogonal LSTMs. The first one,the Block LSTM, connects sequential blocks. The second one, the Step LSTM, generates programs for each block. At each block, we first render the shape described by previous program blocks with a graphics engine. Then, the rendered shape and the raw shape are combined along the channel dimension and fed into a 3D ConvNet. The Block LSTM takes the features output by the 3D ConvNet and outputs features of the current block, which are further fed into the step LSTM to predict the block programs. The reason why we need the step LSTM is that each block might have a different length (e.g., loop bodies of different sizes).
+
+Given block feature $h _ { b l k }$ , the Step LSTM predicts a sequence of program tokens, each consisting of a program id and an argument matrix. The $i$ -th row of the argument matrix serves for the $i$ -th primitive program. From the LSTM hidden state $h _ { t }$ , two decoders generate the output. The softmax classification probability over program sets is obtained by $f _ { \mathrm { p r o g } } : \mathbb { R } ^ { M } \to \mathbb { R } ^ { N }$ . The argument matrix is computed by $f _ { \mathrm { p a r a m } } : \mathbb { R } ^ { M } \to \mathbb { R } ^ { N \times K }$ , where $N$ is the total number of program primitives and $K$ is the maximum possible number of arguments. The feed-forward steps of the Step LSTM are summarized as
+
+$$
+\begin{array} { r l } & { h _ { t } = f _ { \mathrm { l s t m } } ( x _ { t } , h _ { t - 1 } ) , } \\ & { p _ { t } = f _ { \mathrm { p r o g } } ( h _ { t } ) , ~ a _ { t } = f _ { \mathrm { p a r a m } } ( h _ { t } ) , } \end{array}
+$$
+
+where the $p _ { t }$ and $a _ { t }$ corresponds to the program probability distribution and argument matrix at time $t$ . After getting the program $\mathrm { I D }$ , we obtain its arguments by retrieving the corresponding row in the argument matrix. At each time step, the input of the Step LSTM $x _ { t }$ is the embedding of the output in the previous step. For the first step, the block feature $h _ { b l k }$ is used instead.
+
+![](images/46c86448fd736070a798429d012aa62b2c97a64d9db7f626d2ab0cc25adfb483.jpg)  
+Figure 3: The learned program executor consits of an LSTM, which encodes multiple steps of programs, and a subsequent 3D DeconvNet which decodes the features to a 3D shape.
+
+We pretrain our program generator on a synthetic dataset with a few pre-defined simple program templates. The set of all templates for tables are shown in Section A1. These templates are much simpler than the actual shapes. The generator is trained to predict the program token and regress the corresponding arguments via the following loss $\begin{array} { r } { l _ { \mathrm { g e n } } = \sum _ { b , i } w _ { p } l _ { \mathrm { c l s } } ( p _ { b , i } , \hat { p _ { b , i } } ) ) + w _ { a } l _ { \mathrm { r e g } } ( a _ { b , i } , \hat { a } _ { b , i } ) } \end{array}$ , where $l _ { \mathrm { c l s } } ( p _ { b , i } , \hat { p } _ { b , i } ) )$ and $l _ { \mathrm { r e g } } ( a _ { b , i } , \hat { a } _ { b , i } )$ are the cross-entropy loss of program ID classification and the $\mathscr { L } \mathrm { - } 2$ loss of argument regression, in step $i$ of block $b$ , respectively. The weights $w _ { p }$ and $w _ { a }$ balance the losses between classification and regression.
+
+# 4.2 NEURAL PROGRAM EXECUTOR
+
+We propose to learn a neural program executor, an approximate but differentiable graphics engine, which generates a shape from a program. The program executor can then be used for training the program generator by back-propagating gradients. An alternative is to design a graphics engine that explicitly executes a symbolic program to produce a voxelized 3D shape. Certain high-level program commands, such as For statements, will make the executor non-differentiable. Our use of a neural, differentiable executor enables gradient-based fine-tuning of the program synthesizer on unannotated shapes, which allows the model to generalize effectively to novel shapes outside training categories.
+
+Learning to execute a long sequence of programs is difficult, since an executor has to learn to interpret not only single statements but also complex combinations of multiple statements. We decompose the problem by learning an executor that executes programs at the block level, e.g., either a single drawing statement or a compound statements. Afterwards, we integrate these block-level shapes by max-pooling to form the shape corresponding to a long sequence of programs. Our neural program executor includes an LSTM followed by a deconv CNN, as shown in Figure 3. The LSTM aggregates the block-level program into a fixed-length representation. The following deconv CNN takes this representation and generates the desired shape.
+
+To train the program executor, we synthesize large amounts of block-level programs and their corresponding shapes. During training, we minimize the sum of the weighted binary cross-entropy losses over all voxels via
+
+$$
+\mathcal { L } = \sum _ { v \in V } - w _ { 1 } y _ { v } \log \hat { y } _ { v } - w _ { 0 } ( 1 - y _ { v } ) \log ( 1 - \hat { y } _ { v } ) ,
+$$
+
+where $v$ is a single voxel of the whole voxel space $V$ , $y _ { v }$ and $\hat { y } _ { v }$ are the ground truth and prediction, respectively, while $w _ { 0 }$ and $w _ { 1 }$ balance the losses between vacant and occupied voxels. This training leverages only synthetic data, not annotated shape and program pairs, which is a blessing of our disentangled representation.
+
+# 4.3 GUIDED ADAPTATION
+
+A program generator trained only on a synthetic dataset does not generalize well to real-world datasets. With the learned differentiable neural program executor, we can adapt our model to other datasets such as ShapeNet, where program-level supervision is not available. We execute the predicted program by the learned neural program executor and compute the reconstruction loss between the generated shape and the input. Afterwards, the program generator is updated by the gradient back-propagated from the learned program executor, whose weights are frozen.
+
+This adaptation is guided by the learned program executor and therefore called guided adaptation $( G A )$ , and is shown in Figure 4. Given an input shape, the program generator first outputs multiple block programs. Each block is interpreted as 3D shapes by the program executor. A max-pooling operation over these block-level shapes generates the reconstructed shape. The use of max-pooling also enables our executor to handle programs of variable length. Vacant tokens are also executed and pooled. Gradients can then propagate through vacant tokens and the model can learn to add new program primitives accordingly. Here, the loss for Guided Adaptation is the summation of the binary cross-entropy loss over all voxels.
+
+![](images/e201fc250df4b206c3ca6217d010ceddee2a10e165fd5ac0051309bd0d971d13.jpg)  
+Figure 4: Given an input 3D shape, the neural program executor executes the generated programs. Errors between the rendered shape and the raw input are back-propagated.
+
+# 5 EXPERIMENTS
+
+We present program generation and shape reconstruction results on three datasets: our synthetic dataset, ShapeNet (Chang et al., 2015), and Pix3D (Sun et al., 2018b).
+
+Setup. In our experiments, we use a single model to predict programs for multiple categories. Our model is first pretrained on the synthetic dataset and subsequently adapted to target dataset such as ShapeNet and Pix3D under the guidance of the neural program executor. All components of our model are trained with Adam (Kingma & Ba, 2015).
+
+# 5.1 EVALUATION ON THE SYNTHETIC DATASET
+
+Program generator. We first pre-train our program generator on our synthetic dataset with simple templates. The synthetic training set includes 100,000 chairs and 100,000 tables. The generator is evaluated on 5,000 chairs and tables. More than $9 9 . 9 \%$ of the programs are accurately predicted. The shapes rendered by the predicted programs have an average IoU of 0.991 with the input shapes. This high accuracy is due to the simplicity of the synthetic dataset.
+
+Program executor. Our program executor is trained on 500,000 pairs of synthetic block programs and corresponding shapes, and tested on 30,000 pairs. The IoU between the shapes rendered by the executor and the ground truth is 0.93 for a single drawing statement and 0.88 for compound statements. This shows the neural program executor is a good approximation of the graphics engine.
+
+# 5.2 GUIDED ADAPTATION ON SHAPENET
+
+Setup. We validate the effectiveness of guided adaptation by testing our model on unseen examples from ShapeNet. For both tables and chairs, we randomly select 1,000 shapes for evaluation and all the remaining ones for guided adaptation.
+
+Quantitative results. After our model generates programs from input shapes, we execute these programs with a graphics engine and measure the reconstruction quality. Evaluation metrics include IoU, Chamfer distance (CD) (Barrow et al., 1977), and Earth Mover’s distance (EMD) (Rubner et al., 2000). While the pre-trained model achieves 0.99 IoU on the synthetic dataset, the IoU drops below 0.5 on ShapeNet, showing the significant disparity between these two domains. As shown in Table 2, all evaluation metrics suggests improvement after guided adaptation. For example, the IoUs of table and chair increase by 0.104 and 0.094, respectively. We compare our method with Tulsiani et al. (2017), which describes shapes with a set of primitives; and CSGNet (Sharma et al., 2018), which learns to describe shapes by applying arithmetic over primitives. For CSGNet, we evaluate two variants: first, CSGNet-original, where we directly test the model released by the original authors;
+
+Table 2: Shape reconstruction results on ShapeNet, evaluated in intersection over union (IoU, higher is better), Chamfer distance (CD, lower is better), and Earth Mover’s distance (EMD, lower is better). Our model outperforms the baselines.   
+
+<table><tr><td rowspan="2">Models</td><td colspan="2">IoU↑</td><td colspan="2">CD↓</td><td colspan="2">EMD↓</td></tr><tr><td>table</td><td>chair</td><td>table</td><td>chair</td><td>table</td><td>chair</td></tr><tr><td>CSGNet-original</td><td>0.111</td><td>0.154</td><td>0.216</td><td>0.175</td><td>0.205</td><td>0.177</td></tr><tr><td>Tulsiani et al. (2017)</td><td>0.357</td><td>0.406</td><td>0.083</td><td>0.079</td><td>0.073</td><td>0.072</td></tr><tr><td>CSGNet-augmented</td><td>0.406</td><td>0.365</td><td>0.072</td><td>0.077</td><td>0.069</td><td>0.076</td></tr><tr><td>Nearest Neighbour</td><td>0.445</td><td>0.389</td><td>0.083</td><td>0.084</td><td>0.084</td><td>0.084</td></tr><tr><td>Shape Programs w/o GA</td><td>0.487</td><td>0.422</td><td>0.067</td><td>0.072</td><td>0.063</td><td>0.072</td></tr><tr><td> Shape Programs</td><td>0.591</td><td>0.516</td><td>0.058</td><td>0.063</td><td>0.056</td><td>0.060</td></tr></table>
+
+second, CSGNet-augmented, where we retrain CSGNet on our dataset with the additional shape primitives we introduced. We also introduce a nearest neighbor baseline, where we use Hamming distance to search for a nearest neighbour from the training set for each testing sample.
+
+Our model without guided adaptation outperforms Tulsiani et al. (2017) and CSGNet by a margin, showing the benefit of capturing regularities such as symmetry and translation. The NN baseline suggests that simply memorizing the training set does not generalize well to test shapes. With the learned neural program executor, we try to directly train our program generator on ShapeNet without any pre-training. This trial failed, possibly because of the extremely huge and complicated combinatorial space of programs. However, the initial programs for pre-training can be very simple: e.g., 10 simple table templates (Fig. A1) are sufficient to initialize the model, which later achieves good performance under execution-guided adaptation.
+
+Qualitative results. Figure 5 shows some program generation and shape reconstruction results for tables and chairs, respectively. The input shapes can be noisy and contain components that are not covered by templates in our synthetic dataset. After guided adaption, our model is able to extract more meaningful programs and reconstruct the input shape reasonably well.
+
+Our model can be adapted to either add or delete programs, as shown in Figure 5. In (a), we observe an addition of translation describing the armrests. In (b) the “cylinder support” program is removed and a nested translation is added to describe four legs. In (c) and (d), the addition of “Horizontal bar” and “Rectangle layer” leads to more accurate representation. Improvements utilizing modifications to compound programs are not restricted to translations, but can also be observed in rotations, e.g., the times of rotation in (a) is increased from 4 to 5. We also notice new templates emerges after adaptation, e.g., tables in (c) and (d) are not in the synthetic dataset (check the synthetic templates for tables in supplementary). These changes are significant because it indicates the generator can map complex, non-linear relationships to the program space.
+
+# 5.3 STABILITY AND CONNECTIVITY MEASUREMENT
+
+Stability and connectivity are necessary for the functioning of many real-world shapes. This is difficult to capture using purely low-level primitives, but are better suited to our program representations.
+
+We define a shape as stable if its center of mass falls within the convex hull of its ground contacts, and we define a shape as connected if all voxels form one connected component. In Table 3 we compare our model against Tulsiani et al. (2017) and observe significant improvements in the stability of shapes produced by our model when compared to this baseline. This is likely because our model is able to represent multiple identical objects by utilizing translations and rotations. Before GA, our model produces chairs with lower connectivity, but we observe significant improvements with GA. This can be explained by the significant diversity in the ShapeNet dataset under the “chair” class. However, the improvements with GA also demonstrate an ability for our model to generalize. Measured by the percentage of produced shapes that are stable and connected, our model gets significantly better results, and continues to improve with guided adaptation.
+
+![](images/ded628b82e2a5fb0e0c1e5652b34007fdbbb0e1d2e7e74ee68570a9cb7d4dd5d.jpg)  
+Figure 5: The program generation for ShapeNet chairs and tables. For each shape, the first and second rows represent results before and after guided adaptation. Best viewed in color.
+
+<table><tr><td rowspan="2">Models</td><td colspan="2">Stable (%)</td><td colspan="2">Conn. (%)</td><td colspan="2">Stable &amp; Conn. (%)</td></tr><tr><td>table</td><td>chair</td><td>table</td><td>chair</td><td>table</td><td>chair</td></tr><tr><td>Tulsiani et al. (2017)</td><td>36.7</td><td>31.3</td><td>37.1</td><td>68.9</td><td>15.4</td><td>19.6</td></tr><tr><td> Shape Programs w/o GA</td><td>94.7</td><td>95.1</td><td>76.6</td><td>54.2</td><td>73.7</td><td>51.6</td></tr><tr><td>Shape Programs</td><td>97.0</td><td>96.5</td><td>78.4</td><td>68.5</td><td>77.0</td><td>66.0</td></tr><tr><td>Ground Truth</td><td>98.9</td><td>97.6</td><td>98.8</td><td>97.8</td><td>97.7</td><td>95.5</td></tr></table>
+
+Table 3: Measurement of stability and connectivity. Our model is able to capture shape regularity such as symmetry. Therefore, shapes represented by our programs are more stable and better connected.
+
+# 5.4 GENERALIZATION ON OTHER SHAPES
+
+While our program generator is pre-trained only on synthetic chairs and tables, generalization on other shape categories is desirable. We further demonstrate that with guided adaptation, our program generator can be transferred to other unseen categories.
+
+<table><tr><td rowspan="3">Models</td><td colspan="4">IoU↑</td><td colspan="4">CD←</td></tr><tr><td>bed</td><td>sofa</td><td>cabinet</td><td>bench</td><td>bed</td><td>sofa</td><td>cabinet</td><td>bench</td></tr><tr><td>Shape Programs w/o GA</td><td>0.234</td><td>0.296</td><td>0.251</td><td>0.176</td><td>0.126</td><td>0.103</td><td>0.104</td><td>0.098</td></tr><tr><td>Shape Programs</td><td>0.367</td><td>0.597</td><td>0.478</td><td>0.418</td><td>0.096</td><td>0.067</td><td>0.092</td><td>0.059</td></tr></table>
+
+Table 4: Shape reconstruction results on unseen categories. Results with or without guided adaptation in intersection over union (IoU, higher is better) and Chamfer distance (CD, lower is better).
+
+![](images/72d80cc5701ec201976be27ab0d60378add0c4e625fd011f4babf62f5825b50b.jpg)  
+Figure 6: ShapeNet objects from unseen categories reconstructed with shape programs before and after guided adaptation. Shape Programs can learn to adapt and explain objects from novel classes.
+
+![](images/d45ccafaf1881850b1fbd7f3cf75bc6aaaaaccfd983e2e7e370be3bb66a72ac8.jpg)  
+Figure 7: 3D reconstruction results on Pix3D dataset. MarrNet generates fragmentary shapes and our model further smooths and completes such shapes.
+
+We consider Bed, Bench, Cabinet, and Sofa, which share similar semantics with table and chair but are unseen during pre-training. We split $80 \%$ shapes of each category for guided adaptation and the remaining for evaluation. Table 4 suggests the pre-trained model performs poorly for these unseen shapes but its performance improves with this unsupervised guided adaptation. The IoU of bed improves from 0.23 to 0.37, sofa from 0.30 to 0.60, cabinet from 0.25 to 0.48, and bench from 0.18 to 0.42. This clearly illustrates the generalization ability of our framework. Visualized examples are show in Figure 6.
+
+# 5.5 SHAPE COMPLETION AND SMOOTHING BY PROGRAMS
+
+One natural application of our model is to complete and smooth fragmentary shapes reconstructed from 2D images. We separately train a MarrNet (Wu et al., 2017) model for chairs and tables on ShapeNet, and then reconstruct 3D shapes from 2D images on the Pix3D dataset. As shown in Figure 7, MarrNet can generate fragmentary shapes, which are then fed into our model to generate programs. These programs are executed by the graphics engine to produce a smooth and complete shape. For instance, our model can complete the legs of chairs and tables, as shown in Figure 7.
+
+While stacking our model on top of MarrNet does not change the IoU of 3D reconstruction, our model produces more visually appealing and human-perceptible results. A user study on AMT shows that $78 . 9 \%$ of the participant responses prefer our results rather than MarrNet’s.
+
+# 6 DISCUSSION
+
+We have introduced 3D shape programs as a new shape representation. We have also proposed a model for inferring shape programs, which combines a neural program synthesizer and a neural executor. Experiments on ShapeNet show that our model successfully explains shapes as programs and generalizes to shapes outside training categories. Further experiments on Pix3D show our model can be extended to infer shape programs and reconstruct 3D shapes directly from color images. We now discuss key design choices and future work.
+
+![](images/010f1a29adc54fcf714d9d5a3d3edeb695bb863a4eb34f384d3174a8754b9fd9.jpg)  
+Figure 8: We visualize the effect of manipulating individual dimensions in the intermediate representation of neural program executor. For example, dimension 27 corresponds to the height of primitives, dimension 25 to the radius of primitives, and dimension 41 to the times of primitive repetition.
+
+Analyzing the neural program executor. We look deep into the intermediate representation of the neural program executor, which is a 64-dimensional vector output by the LSTM (see Figure 3). We manipulate individual dimensions and visualize the generated voxels. Figure 8 shows that these dimensions capture interpretable geometric features (e.g., height, radius, and number of repetitions).
+
+Design of the DSL. Our design of the DSL for shape programs makes certain semantic commitments. A DSL with these semantics has advantages and disadvantages: it naturally supports semantic correspondences across shapes and enables better in-class reconstructions; on the other hand, it may limit the ability to generalize to shapes outside training classes. Our current instantiation focuses on the semantics of furniture (a superclass, whose subclasses share similar semantics). Within this superclass, our model generalizes well: trained on chairs and tables, it generalizes to new furniture categories such as beds. In future work, we are interested in learning a library of shape primitives directly from data, which will allow our approach to adapt automatically to new superclasses or domains of shape.
+
+Structure search vs. amortized inference. For our program synthesis task, we use neural nets for amortized inference rather than structure search, due to the large search space and our desire to return a shape interpretation nearly instantaneously, effectively trading neural net training time for fast inference at test time. Our model takes $5 \mathrm { m s }$ to infer a shape program with a Titan X GPU. We also considered various possible approaches for structured search over the space of shape programs, but decided that these would most likely be too our slow for our goals.
+
+One approach to structured search is constraint solving. Ellis et al. (2015) used the performant Z3 SMT solver (De Moura & Bjørner, 2008) to infer 2D graphics programs, taking 5-20 minutes for problems arguably simpler than our 3D shape programs. Other approaches could be based on stochastic search, such as MCMC in the space of programs. For the related problem of inverse graphics from 2D images, MCMC, like constraint solving, takes too long for perception at a glance (Kulkarni et al., 2015b). Efficient integration of discrete search and amortized inference, however, is a promising future research direction.
+
+Acknowledgments. We thank Keyulu Xu and Xiuming Zhang for insightful discussions and anonymous reviewers for their feedback. This work is supported by the Center for Brains, Minds and Machines (NSF #1231216), NSF #1447476, ONR MURI N00014-16-1-2007, and Facebook.
+
+# REFERENCES
+
+Matej Balog, Alexander L Gaunt, Marc Brockschmidt, Sebastian Nowozin, and Daniel Tarlow. Deepcoder: Learning to write programs. In ICLR, 2017. 3
+
+Harry G Barrow, Jay M Tenenbaum, Robert C Bolles, and Helen C Wolf. Parametric correspondence and chamfer matching: Two new techniques for image matching. In IJCAI, 1977. 6
+
+Irving Biederman. Recognition-by-components: a theory of human image understanding. Psychol. Rev., 94(2):115, 1987. 2
+
+Thomas O Binford. Visual perception by computer. Invited talk at IEEE Conf. on Systems and Control, 1971. 2
+
+Matko Bosnjak, Tim Rockt ˇ aschel, Jason Naradowsky, and Sebastian Riedel. Programming with a ¨ differentiable forth interpreter. In ICML, 2017. 3
+
+Jonathon Cai, Richard Shin, and Dawn Song. Making neural programming architectures generalize via recursion. In ICLR, 2017. 3
+
+Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, Jianxiong Xiao, Li Yi, and Fisher Yu. Shapenet: An information-rich 3d model repository. arXiv:1512.03012, 2015. 1, 6
+
+Siddhartha Chaudhuri, Evangelos Kalogerakis, Leonidas Guibas, and Vladlen Koltun. Probabilistic reasoning for assembly-based 3d modeling. ACM TOG, 30(4):35, 2011. 2
+
+Leonardo De Moura and Nikolaj Bjørner. Z3: An efficient smt solver. In TACAS, 2008. 10
+
+Jacob Devlin, Jonathan Uesato, Surya Bhupatiraju, Rishabh Singh, Abdel-rahman Mohamed, and Pushmeet Kohli. Robustfill: Neural program learning under noisy i/o. In ICML, 2017. 3
+
+Daniel D Dilks, Joshua B Julian, Jonas Kubilius, Elizabeth S Spelke, and Nancy Kanwisher. Mirrorimage sensitivity and invariance in object and scene processing pathways. J. Neurosci., 31(31): 11305–11312, 2011. 1
+
+Kevin Ellis, Armando Solar-Lezama, and Josh Tenenbaum. Unsupervised learning by program synthesis. In NeurIPS, 2015. 3, 10
+
+Kevin Ellis, Daniel Ritchie, Armando Solar-Lezama, and Joshua B Tenenbaum. Learning to infer graphics programs from hand-drawn imatges. In NeurIPS, 2018. 3
+
+Franc¸ois Fleuret, Ting Li, Charles Dubout, Emma K Wampler, Steven Yantis, and Donald Geman. Comparing machines and humans on a visual categorization test. PNAS, 108(43):17621–17625, 2011. 4
+
+Yaroslav Ganin, Tejas Kulkarni, Igor Babuschkin, SM Eslami, and Oriol Vinyals. Synthesizing programs for images using reinforced adversarial learning. In ICML, 2018. 3
+
+Alexander L Gaunt, Marc Brockschmidt, Rishabh Singh, Nate Kushman, Pushmeet Kohli, Jonathan Taylor, and Daniel Tarlow. Terpret: A probabilistic programming language for program induction. arXiv preprint arXiv:1608.04428, 2016. 3
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. Inferring and executing programs for visual reasoning. In ICCV, 2017. 3
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. 6
+
+Kurt Koffka. Principles of Gestalt psychology. Routledge, 2013. 1
+
+Tejas D Kulkarni, Pushmeet Kohli, Joshua B Tenenbaum, and Vikash Mansinghka. Picture: A probabilistic programming language for scene perception. In CVPR, 2015a. 2
+
+Tejas D Kulkarni, William F Whitney, Pushmeet Kohli, and Josh Tenenbaum. Deep convolutional inverse graphics network. In NeurIPS, 2015b. 10
+
+Jun Li, Kai Xu, Siddhartha Chaudhuri, Ersin Yumer, Hao Zhang, and Leonidas Guibas. Grass: Generative recursive autoencoders for shape structures. In SIGGRAPH, 2017. 2
+
+Yunchao Liu, Zheng Wu, Daniel Ritchie, William T Freeman, Joshua B Tenenbaum, and Jiajun Wu. Learning to describe scenes with programs. In ICLR, 2019. 3
+
+Zhijian Liu, William T Freeman, Joshua B Tenenbaum, and Jiajun Wu. Physical primitive decomposition. In ECCV, 2018. 2
+
+Niloy Mitra, Michael Wand, Hao Richard Zhang, Daniel Cohen-Or, Vladimir Kim, and Qi-Xing Huang. Structure-aware shape processing. In SIGGRAPH Asia Courses, 2013. 2
+
+Gen Nishida, Ignacio Garcia-Dorado, Daniel G Aliaga, Bedrich Benes, and Adrien Bousseau. Interactive sketching of urban procedural models. ACM TOG, 35(4):130, 2016. 2
+
+Gen Nishida, Adrien Bousseau, and Daniel G Aliaga. Procedural modeling of a building from a single image. CGF, 37(2):415–429, 2018. 2
+
+Emilio Parisotto, Abdel-rahman Mohamed, Rishabh Singh, Lihong Li, Dengyong Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. In ICLR, 2017. 3
+
+Charles R Qi, Li Yi, Hao Su, and Leonidas J Guibas. Pointnet++: Deep hierarchical feature learning on point sets in a metric space. In NeurIPS, 2017. 1
+
+Scott Reed and Nando De Freitas. Neural programmer-interpreters. In ICLR, 2016. 3
+
+Daniel Ritchie, Anna Thomas, Pat Hanrahan, and Noah Goodman. Neurally-guided procedural models: Amortized inference for procedural graphics programs using neural networks. In NeurIPS, 2016. 2
+
+Lawrence G Roberts. Machine perception of three-dimensional solids. PhD thesis, Massachusetts Institute of Technology, 1963. 2
+
+Yossi Rubner, Carlo Tomasi, and Leonidas J Guibas. The earth mover’s distance as a metric for image retrieval. IJCV, 40(2):99–121, 2000. 6
+
+Adriana Schulz, Ariel Shamir, Ilya Baran, David IW Levin, Pitchaya Sitthi-Amorn, and Wojciech Matusik. Retrieval on parametric shape collections. ACM TOG, 36(1):11, 2017. 2
+
+Gopal Sharma, Rishabh Goyal, Difan Liu, Evangelos Kalogerakis, and Subhransu Maji. Csgnet: Neural shape parser for constructive solid geometry. In CVPR, 2018. 1, 2, 6
+
+Ondrej St’ava, Bedrich Bene ˇ s, Radomir M ˇ ech, Daniel G Aliaga, and Peter Kri ˇ stof. Inverse procedural ˇ modeling by automatic generation of l-systems. CGF, 29(2):665–674, 2010. 2
+
+Shao-Hua Sun, Hyeonwoo Noh, Sriram Somasundaram, and Joseph Lim. Neural program synthesis from diverse demonstration videos. In ICML, 2018a. 3
+
+Xingyuan Sun, Jiajun Wu, Xiuming Zhang, Zhoutong Zhang, Chengkai Zhang, Tianfan Xue, Joshua B Tenenbaum, and William T Freeman. Pix3d: Dataset and methods for single-image 3d shape modeling. In CVPR, 2018b. 6
+
+Shubham Tulsiani, Hao Su, Leonidas J Guibas, Alexei A Efros, and Jitendra Malik. Learning shape abstractions by assembling volumetric primitives. In CVPR, 2017. 1, 2, 6, 7, 8
+
+Anton van den Hengel, Chris Russell, Anthony Dick, John Bastian, Daniel Pooley, Lachlan Fleming, and Lourdes Agapito. Part-based modelling of compound scenes from images. In CVPR, 2015. 2
+
+Nanyang Wang, Yinda Zhang, Zhuwen Li, Yanwei Fu, Wei Liu, and Yu-Gang Jiang. Pixel2mesh: Generating 3d mesh models from single rgb images. In ECCV, 2018. 1
+
+Jiajun Wu, Yifan Wang, Tianfan Xue, Xingyuan Sun, William T Freeman, and Joshua B Tenenbaum. MarrNet: 3D Shape Reconstruction via 2.5D Sketches. In NeurIPS, 2017. 9
+
+Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao. 3d shapenets: A deep representation for volumetric shapes. In CVPR, 2015. 1
+
+Chenyang Zhu, Kai Xu, Siddhartha Chaudhuri, Renjiao Yi, and Hao Zhang. Scores: Shape composition with recursive substructure priors. In SIGGRAPH Asia, 2018. 2
+
+Chuhang Zou, Ersin Yumer, Jimei Yang, Duygu Ceylan, and Derek Hoiem. 3d-prnn: Generating shape primitives with recurrent neural networks. In ICCV, 2017. 2
+
+# A.1 DEFINED PROGRAMS
+
+The details of semantics and shape primitives in our experimental setting for furniture are shown in Table 5. Due to the semantic nature of objects, while a few semantics are category specific, e.g., “ChairBeam”, other semantics are shared across different shape categories, e.g., “Leg” and “Top”.
+
+<table><tr><td rowspan="6"></td><td>Leg</td><td>Chair leg, table leg,etc. Usually long and used jointly for support</td></tr><tr><td>Top</td><td>Seat top, table top,etc.Usually a broad and flat surface</td></tr><tr><td>Layer</td><td>Shelf embedded in table,cabinet shelf etc.Usually a flat surface between other similar shapes</td></tr><tr><td>Support</td><td>Chair support, table support etc.A monolithic object used to raise things off the ground</td></tr><tr><td>Base</td><td>Base of an sofa, table etc. Usually a flat surface on the ground to help with stability</td></tr><tr><td>Sideboard</td><td>Sideboard of a cabinet, table etc.A vertical, flat surface on the</td></tr><tr><td>Semantics Horizontal Bar</td><td>bottom half of an object Horizontal bar of a chair etc.A thin bar used for structural</td></tr><tr><td>Vertical Board</td><td>integrity Vertical board of a arm rest etc.A vertical, flat surface used by</td></tr><tr><td>Locker</td><td>humans for arm support Table drawer etc. A boxy object used to put things in</td></tr><tr><td>Back</td><td>Chair back, Sofa back etc.A surface used for resting backs on</td></tr><tr><td>Back support</td><td>Office chair back support beam etc.A beam used to support a</td></tr><tr><td>ChairBeam</td><td>back rest Arm rest support beam in chairs,benches etc.A long object used</td></tr><tr><td rowspan="5"> Shapes</td><td>Cylinder (Cyl)</td><td>to support an arm rest P = (x,y,z),G = (t,r),draw a cylinder at (x,y,z) with sizes (t,r)</td></tr><tr><td>Cuboid (Cub)</td><td>P = (x,y,z),G = (t,r1,r2,[angl), draw a cuboid at (x,y,z) with sizes (t,r1,r2) and optional ang of tilt along front/back</td></tr><tr><td>Circle (Cir)</td><td>P = (x,y,z),G = (t,r), draw a circle at (x,y,z) with sizes (t,r),t is usually small</td></tr><tr><td>Square (Sqr)</td><td>P = (x,y,z),G = (t,r), draw a square at (x,y,z) with sizes (t,r),t is usually small</td></tr><tr><td>Rectangle (Rect)</td><td>P = (x,y,z),G= (t,r1,r2), draw a rectangle at (x,y,z) with sizes (t,r1,r2),t is usually small</td></tr><tr><td>Line (Line)</td><td></td><td>P = (𝑥1,y1,z1),G = (x2,y2, z2),draw a line from P to G</td></tr></table>
+
+Table 5: The list of semantics and shapes, as well as associated parameters used by our model
+
+# A.2 ARCHITECTURE DETAILS
+
+Program Generator. The program executor contains a 3D ConvNet and two LSTMS. (1) 3D ConvNet. This 3D ConvNet is the first part of the program generator model. It consists of 8 3D convolutional layers. The kernel size of each layer is 3 except for the first one whose kernel size is 5. The number of output channels are (8,16,16,32,32,64,64,64), respectively. The output of the last layer is averaged over the spatial resolution, which gives a 64-dimension embedding. (2) Block LSTM and Step LSTM. These two LSTMs share similar structure. Both are one-layer LSTMs. The dimensions of the input and hidden state are both 64.
+
+![](images/446a9041dff0425de2ff3b31a52f092ebc14555950b91bc78b2585d8ef128a88.jpg)  
+Figure A1: (a) shows random samples from all of our 10 table templates for synthetic dataset (b) shows raw and reconstructed tables on ShapeNet
+
+Program Executor. The program executor contains an LSTM and a 3D DeConvNet. (1) LSTM. This LSTM aggregates a block-level programs into a 64-dimensional vector. The dimension of the hidden state is also 64. The input of each time step is the concatenation of category distribution over programs and the corresponding parameters retrieved from the parameter matrix. (2) 3D DeConvNet. It consists of 7 layers. TransposedConv layer with kernel size 4 and Conv layer with kernel size 3 are alternating. The number of output channels are (64, 64, 16, 16, 4, 4, 2), respectively. The output of the last layer is fed into a sigmoid function to generate the 3D voxel shape.
+
+End-to-end differentiability. The end-to-end differentiability is obtained via our design of the neural program executor. The output of the program inference model is actually continuous. A real execution engine (not the neural executor) actually contains two steps: (1) discretize such output, and (2) execute the discretized program to generate the voxel. Our neural executor is learned to jointly approximate both steps, thus the whole pipeline can be differentiable in an end-to-end manner.
+
+# A.3 SYNTHETIC TEMPLATES V.S. SHAPENET
+
+ShapeNet was proposed to be the ImageNet of shapes; it is therefore highly diverse and intrinsically challenging. Our synthetic dataset were designed to provide minimal, simple guidance to the network. In Figure A1, (a) shows sampled shapes from all of our 10 table templates, while (b) shows the ground truth and reconstructed tables in ShapeNet, which are siginificantly more complex. Such disparity of complexity explains why we saw a dramatic drop of IoU when we directly tested on ShapeNet with model only pretrained on synthetic dataset. Our guided adaptation further adapt the pre-trained model.
+
+# A.4 ADDITIONAL RESULTS
+
+In Figure A2 through Figure A8, we show the generated shape and programs using a network that is only pretrained jointly on synthetic “table” and “chair” objects, and a network that is pretrained then further enhanced by guided adaptation on ShapeNet data. Figure A2 and Figure A3 correspond to “chairs”, Figure A4 to “tables”, Figure A5 to “benches”, Figure A6 to “couches”, Figure A7 to “cabinets”, and Figure A8 to “beds”. In Figure A2, Figure A3, and Figure A4, even though “chair” and “table” have been seen in the synthetic dataset, we still note improvements in program inference and shape reconstruction on ShapeNet after guided adaptation. This is because our synthetic data is simpler than ShapeNet data. When directly using a model pretrained on synthetic “chairs” and “tables” to other classes, it is not surprised some shapes are interpreted as tables or chairs. However, such mispredictions dramatically drop after our guided adaptation.
+
+![](images/d6ab01c9a904e2222475f38726f9131b96f5c828c52a7740ba16b3141be41c55.jpg)  
+Figure A2: (a) to (f) show the generated shapes and programs for ShapeNet chairs
+
+![](images/52ca785d25fe5c151e6c0918acb987306ae61ca2fa7f6927dc2df5e3c96fea77.jpg)  
+Figure A3: (a) to (f) show the generated shapes and programs for ShapeNet chairs
+
+![](images/5a66c558f74805a02a426ed56d7b5ecb7e3158c60ec23e4b8e43fd70d918bca6.jpg)  
+Figure A4: (a) to (f) show the generated shapes and programs for ShapeNet tables
+
+![](images/4872d1ad12fecb6b999a3a3922a6875175193b8d709678ab242887cd7d483052.jpg)  
+Figure A5: (a) to (f) show the generated shapes and programs for ShapeNet benches
+
+![](images/8eb4283962893da5968b2f641d78910cf5a82ffcf131f8bdda603741e1f67d44.jpg)  
+Figure A6: (a) to (f) show the generated shapes and programs for ShapeNet couches
+
+![](images/d172a3fc7d4bc1d82cd1097244706708aa357ba84be148faff4556fdfd5ce34f.jpg)  
+Figure A7: (a) to (d) show the generated shapes and programs for ShapeNet cabinets
+
+![](images/25e7d4760083ffbc28c6484f3c016a3c1a06a10ed7c758a4746bda07ab487df4.jpg)  
+Figure A8: (a) and (b) show the generated shapes and programs for ShapeNet beds

parse/train/rylNH20qFQ/rylNH20qFQ_content_list.json

@@ -0,0 +1,1815 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING TO INFER AND EXECUTE 3D SHAPE PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            607,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yonglong Tian†, Andrew Luo†, Xingyuan $\\mathbf { S u n } ^ { \\ddagger }$ , Kevin Ellis†, William T. Freeman†∗, Joshua B. Tenenbaum† & Jiajun Wu† ",
+        "bbox": [
+            183,
+            169,
+            769,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "†Massachusetts Institute of Technology   \n‡Princeton University   \n∗Google Research   \n{yonglong,aluo,ellisk,billf,jbt,jiajunwu}@mit.edu   \nxs5@princeton.edu ",
+        "bbox": [
+            184,
+            200,
+            661,
+            270
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            308,
+            544,
+            321
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Human perception of 3D shapes goes beyond reconstructing them as a set of points or a composition of geometric primitives: we also effortlessly understand higherlevel shape structure such as the repetition and reflective symmetry of object parts. In contrast, recent advances in 3D shape sensing focus more on low-level geometry but less on these higher-level relationships. In this paper, we propose $3 D$ shape programs, integrating bottom-up recognition systems with top-down, symbolic program structure to capture both low-level geometry and high-level structural priors for 3D shapes. Because there are no annotations of shape programs for real shapes, we develop neural modules that not only learn to infer 3D shape programs from raw, unannotated shapes, but also to execute these programs for shape reconstruction. After initial bootstrapping, our end-to-end differentiable model learns 3D shape programs by reconstructing shapes in a self-supervised manner. Experiments demonstrate that our model accurately infers and executes 3D shape programs for highly complex shapes from various categories. It can also be integrated with an image-to-shape module to infer 3D shape programs directly from an RGB image, leading to 3D shape reconstructions that are both more accurate and more physically plausible. ",
+        "bbox": [
+            232,
+            337,
+            766,
+            574
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            336,
+            613
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Given the table in Figure 1, humans are able to instantly recognize its parts and regularities: there exist sharp edges, smooth surfaces, a table top that is a perfect circle, and two lower, square layers. Beyond these basic components, we also perceive higher-level, abstract concepts: the shape is bilateral symmetric; the legs are all of equal length and laid out on the opposite positions of a 2D grid. Knowledge like this is crucial for visual recognition and reasoning (Koffka, 2013; Dilks et al., 2011). ",
+        "bbox": [
+            174,
+            630,
+            825,
+            699
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent AI systems for 3D shape understanding have made impressive progress on shape classification, parsing, reconstruction, and completion (Qi et al., 2017; Tulsiani et al., 2017), many making use of large shape repositories like ShapeNet (Chang et al., 2015). Popular shape representations include voxels (Wu et al., 2015), point clouds (Qi et al., 2017), and meshes (Wang et al., 2018). While each has its own advantages, these methods fall short on capturing the strong shape priors we just described, such as sharp edges and smooth surfaces. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            790
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A few recent papers have studied modeling 3D shapes as a collection of primitives (Tulsiani et al., 2017), with simple operations such as addition and subtraction (Sharma et al., 2018). These representations have demonstrated success in explaining complex 3D shapes. In this paper, we go beyond them to capture the high-level regularity within a 3D shape, such as symmetry and repetition. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            853
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose to represent 3D shapes as shape programs. We define a domain-specific language (DSL) for shapes, containing both basic shape primitives for parts with their geometric and semantic attributes, as well as statements such as loops to enforce higher-level structural priors. ",
+        "bbox": [
+            176,
+            861,
+            825,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/0078615a136e87ccda4833b82ddc1a3755c2b08066ad9a09f38bb79f25ca614b.jpg",
+        "image_caption": [
+            "Figure 1: A 3D shape can be represented by a program via a program generator. This program can be executed by a neural program executor to produce the corresponding 3D shape. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            816,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Because 3D shape programs are a new shape representation, there exist no annotations of shape programs for 3D shapes. The lack of annotations makes it difficult to train an inference model with full supervision. To overcome this obstacle, we propose to learn a shape program executor that reconstructs a 3D shape from a shape program. After initial bootstrapping, our model can then learn in a self-supervised way, by attempting to explain and reconstruct unlabeled 3D shapes with 3D shape programs. This design minimizes the amount of supervision needed to get our model off the ground. ",
+        "bbox": [
+            174,
+            238,
+            825,
+            321
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "With the learned neural program executor, our model learns to explain input shapes without ground truth program annotations. Experiments on ShapeNet show that our model infers accurate 3D shape programs for highly complex shapes from various categories. We further extend our model by integrating with an image-to-shape reconstruction module, so it directly infers a 3D shape program from a color image. This leads to 3D shape reconstructions that are both more accurate and more physically plausible. ",
+        "bbox": [
+            174,
+            329,
+            825,
+            412
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our contributions are three-fold. First, we propose 3D shape programs: a new representation for shapes, building on classic findings in cognitive science and computer graphics. Second, we propose to infer 3D shape programs by explaining the input shape, making use of a neural shape program executor. Third, we demonstrate that the inference model, the executor, and the programs they recover all achieve good performance on ShapeNet, learning to explain and reconstruct complex shapes. We further show that an extension of the model can infer shape programs and reconstruct 3D shapes directly from images. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            343,
+            556
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Inverse procedural graphics. The problem of inferring programs from voxels is closely related to inverse procedural graphics, where a procedural graphics program is inferred from an image or declarative specification (Ritchie et al., 2016; St’ava et al. ˇ , 2010). Where the systems have been most successful, however, are when they leverage a large shape–component library (Chaudhuri et al., 2011; Schulz et al., 2017) or are applied to a sparse solution space (van den Hengel et al., 2015). Kulkarni et al. (2015a) approached the problem of inverse graphics as inference in a probabilistic program for generating 2D images, or image contours, from an underlying 3D model. They demonstrated results on several different applications using parametric generative models for faces, bodies, and simple multi-part objects based on generalized cylinders. In this work, we extend the idea of inverse procedural graphics to 3-D voxel representations, and show how this idea can apply to large data sets like ShapeNet. We furthermore do not have to match components to a library of possible shapes, instead using a neural network to directly infer shapes and their parameters. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A few recent papers have explored the use of simple geometric primitives to describe shapes (Tulsiani et al., 2017; Zou et al., 2017; Liu et al., 2018), putting the classic idea of generalized cylinders (Roberts, 1963; Binford, 1971) or geons (Biederman, 1987) in the modern context of deep learning. In particular, Sharma et al. (2018) extended these papers and addressed the problem of inferring 3-D CAD programs from perceptual input. We find this work inspiring, but also feel that a key goal of 3-D program inference is to reconstruct a program in terms of semantically meaningful parts and their spatial regularity, which we address here. Some other graphics papers also explore regularity, but without using programs (Mitra et al., 2013; Zhu et al., 2018; Nishida et al., 2018; Li et al., 2017). ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Work in the HCI community has also addressed the problem of inferring parametric graphics primitives from perceptual input. For example, Nishida et al. (2016) proposed to learn to instantiate procedural primitives for an interactive modeling system. In our work, we instead learn to instantiate multiple procedural graphics primitives simultaneously, without assistance from a human user. ",
+        "bbox": [
+            174,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a43c2aec2f86f6b7930f5c6c571629e3e1b4e4b9a0d633373ee2ed3d474602c.jpg",
+        "table_caption": [
+            "Table 1: The domain specific language (DSL) for 3D shapes. Semantics depends on the types of objects that are modeled, i.e., semantics for vehicle and furniture should be different. For details of DSL in our experimental setting, please refer to supplementary. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Program</td><td>→</td></tr><tr><td>Statement</td><td>Draw(Semantics,Shape,Position_Params,Geometry Params)</td></tr><tr><td>Statement</td><td>For(For_Params); Program; EndFor</td></tr><tr><td>Semantics</td><td>semantics 1|semantics 2|semantics 3|..</td></tr><tr><td>Shape</td><td>Cuboid|Cylinder丨Rectangle|Circle|Line</td></tr><tr><td>Position_Params</td><td>(x,y,z)</td></tr><tr><td>Geometry_Params</td><td>(g1,92,93,94,...)</td></tr><tr><td>For_Params</td><td>Translation_Params|Rotation_Params</td></tr><tr><td>Translation_Params</td><td>(times i, orientation u)</td></tr><tr><td>Rotation_Params</td><td>(times i,angle θ,axis a)</td></tr></table>",
+        "bbox": [
+            196,
+            88,
+            799,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Program synthesis. In the AI literature, Ellis et al. (2018) leveraged symbolic program synthesis techniques to infer 2D graphics programs from images, extending their earlier work by using neural nets for faster inference of low-level cues such as strokes (Ellis et al., 2015). Here, we show how a purely end–to–end network can recover 3D graphics programs from voxels, conceptually relevant to RobustFill (Devlin et al., 2017), which presents a purely end-to-end neural program synthesizer for text editing. The very recent SPIRAL system (Ganin et al., 2018) also takes as its goal to learn structured program–like models from (2D) images. An important distinction from our work here is that SPIRAL explains an image in terms of paint-like “brush strokes”, whereas we explain 3D voxels in terms of high-level objects and semantically meaningful parts of objects, like legs or tops. Other tangential related work on program synthesis includes Balog et al. (2017); Devlin et al. (2017); Parisotto et al. (2017); Gaunt et al. (2016); Sun et al. (2018a); Liu et al. (2019). ",
+        "bbox": [
+            174,
+            304,
+            825,
+            458
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Learning to execute programs. Neural Program Interpreters (NPI) have been extensively studied for programs that abstract and execute tasks such as sorting, shape manipulation, and grade-school arithmetic (Reed & De Freitas, 2016; Cai et al., 2017; Bosnjak et al. ˇ , 2017). In NPI (Reed & De Freitas, 2016), the key insight is that a program execution trace can be decomposed into predefined operations that are more primitive; and at each step, an NPI learns to predict what operation to take next depending on the general environment, domain specific state , and previous actions. Cai et al. (2017) improved the generalization of NPIs by adding recursion. Johnson et al. (2017) learned to execute programs for visual question and answering. In this paper, we also learn a 3D shape program executor that renders 3D shapes from programs as a component of our model. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            599
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 3D SHAPE PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            393,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we define the domain-specific language for 3D shapes, as well as the problem of shape program synthesis. ",
+        "bbox": [
+            174,
+            665,
+            823,
+            694
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows our DSL for 3D shape programs. Each shape program consists of a variable number of program statements. A program statement can be either Draw, which describes a shape primitive as well as its geometric and semantic attributes, or For, which contains a sub-program and parameters specifying how the subprogram should be repeatedly executed. The number of arguments for each program statement varies. We tokenize programs for the purpose of neural network prediction. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Each shape primitive models a semantically-meaningful part of an object. Its geometric attributes (Table 1: Geometry Params, Position Params) specify the position and orientation of the part. Its semantic attributes (Table 1: Semantics) specify its relative role within the whole shape (e.g., top, back, leg). They do not affect the geometry of the primitive; instead, they associate geometric parts with their semantic meanings conveying how parts can be shared across object categories semantically and functionally (e.g., a chair and a table may have similar legs). ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our For statement captures high-level regularity across parts. For example, the legs of a table can be symmetric with respect to particular rotation angles. The horizontal bars of a chair may lay out regularly with a fixed vertical gap. Each For statement can contain sub-programs, allowing recursive generation of shape programs. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c46d39b3d3edb1639719777c7549269b6cc0b684983a73fa25a926867bf35aad.jpg",
+        "image_caption": [
+            "Figure 2: The core of our 3D shape program generator are two LSTMs. The Block LSTM emits features for each program block. The Step LSTM takes these features as input and outputs programs inside each block, which includes either a single drawing statement or compound statements. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            80,
+            823,
+            261
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The problem of inferring a 3D shape program is defined as follows: predicting a 3D shape program that reconstructs the input shape when the program is executed. In this paper, we use voxelized shapes as input with a resolution of $3 2 \\times 3 2 \\times 3 2$ . ",
+        "bbox": [
+            174,
+            335,
+            825,
+            377
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 INFERRING AND EXECUTING 3D SHAPE PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            398,
+            638,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our model, called Shape Programs, consists of a program generator and a neural program executor. The program generator takes a 3D shape as input and outputs a sequence of primitive programs that describe this 3D shape. The neural program executor takes these programs as input and generates the corresponding 3D shapes. This allows our model to learn in a self-supervised way by generating programs from input shapes, executing these programs, and back-propagating the difference between the generated shapes and the raw input. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            517
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 PROGRAM GENERATOR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            535,
+            377,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We model program generation as a sequential prediction problem. We partition full programs into two types of subprograms, which we call blocks: (1) a single drawing statement describing a semantic part, e.g. circle top; and (2) compound statements, which are a loop structure that interprets a set of translated or rotated parts, e.g. four symmetric legs. This part-based, symmetry-aware decomposition is inspired by human perception (Fleuret et al., 2011). ",
+        "bbox": [
+            174,
+            561,
+            825,
+            632
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our program generator is shown in Figure 2. The core of the program generator consists of two orthogonal LSTMs. The first one,the Block LSTM, connects sequential blocks. The second one, the Step LSTM, generates programs for each block. At each block, we first render the shape described by previous program blocks with a graphics engine. Then, the rendered shape and the raw shape are combined along the channel dimension and fed into a 3D ConvNet. The Block LSTM takes the features output by the 3D ConvNet and outputs features of the current block, which are further fed into the step LSTM to predict the block programs. The reason why we need the step LSTM is that each block might have a different length (e.g., loop bodies of different sizes). ",
+        "bbox": [
+            174,
+            638,
+            825,
+            751
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given block feature $h _ { b l k }$ , the Step LSTM predicts a sequence of program tokens, each consisting of a program id and an argument matrix. The $i$ -th row of the argument matrix serves for the $i$ -th primitive program. From the LSTM hidden state $h _ { t }$ , two decoders generate the output. The softmax classification probability over program sets is obtained by $f _ { \\mathrm { p r o g } } : \\mathbb { R } ^ { M } \\to \\mathbb { R } ^ { N }$ . The argument matrix is computed by $f _ { \\mathrm { p a r a m } } : \\mathbb { R } ^ { M } \\to \\mathbb { R } ^ { N \\times K }$ , where $N$ is the total number of program primitives and $K$ is the maximum possible number of arguments. The feed-forward steps of the Step LSTM are summarized as ",
+        "bbox": [
+            174,
+            756,
+            825,
+            854
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e4b0a3c37c26bf0efebc9ab54755f80a6dbfca69b9dcc7afaf6684cba04d46d1.jpg",
+        "text": "$$\n\\begin{array} { r l } & { h _ { t } = f _ { \\mathrm { l s t m } } ( x _ { t } , h _ { t - 1 } ) , } \\\\ & { p _ { t } = f _ { \\mathrm { p r o g } } ( h _ { t } ) , ~ a _ { t } = f _ { \\mathrm { p a r a m } } ( h _ { t } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            852,
+            606,
+            890
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the $p _ { t }$ and $a _ { t }$ corresponds to the program probability distribution and argument matrix at time $t$ . After getting the program $\\mathrm { I D }$ , we obtain its arguments by retrieving the corresponding row in the argument matrix. At each time step, the input of the Step LSTM $x _ { t }$ is the embedding of the output in the previous step. For the first step, the block feature $h _ { b l k }$ is used instead. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/46c86448fd736070a798429d012aa62b2c97a64d9db7f626d2ab0cc25adfb483.jpg",
+        "image_caption": [
+            "Figure 3: The learned program executor consits of an LSTM, which encodes multiple steps of programs, and a subsequent 3D DeconvNet which decodes the features to a 3D shape. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            80,
+            820,
+            154
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            210,
+            823,
+            239
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We pretrain our program generator on a synthetic dataset with a few pre-defined simple program templates. The set of all templates for tables are shown in Section A1. These templates are much simpler than the actual shapes. The generator is trained to predict the program token and regress the corresponding arguments via the following loss $\\begin{array} { r } { l _ { \\mathrm { g e n } } = \\sum _ { b , i } w _ { p } l _ { \\mathrm { c l s } } ( p _ { b , i } , \\hat { p _ { b , i } } ) ) + w _ { a } l _ { \\mathrm { r e g } } ( a _ { b , i } , \\hat { a } _ { b , i } ) } \\end{array}$ , where $l _ { \\mathrm { c l s } } ( p _ { b , i } , \\hat { p } _ { b , i } ) )$ and $l _ { \\mathrm { r e g } } ( a _ { b , i } , \\hat { a } _ { b , i } )$ are the cross-entropy loss of program ID classification and the $\\mathscr { L } \\mathrm { - } 2$ loss of argument regression, in step $i$ of block $b$ , respectively. The weights $w _ { p }$ and $w _ { a }$ balance the losses between classification and regression. ",
+        "bbox": [
+            173,
+            246,
+            825,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 NEURAL PROGRAM EXECUTOR ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            362,
+            431,
+            376
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We propose to learn a neural program executor, an approximate but differentiable graphics engine, which generates a shape from a program. The program executor can then be used for training the program generator by back-propagating gradients. An alternative is to design a graphics engine that explicitly executes a symbolic program to produce a voxelized 3D shape. Certain high-level program commands, such as For statements, will make the executor non-differentiable. Our use of a neural, differentiable executor enables gradient-based fine-tuning of the program synthesizer on unannotated shapes, which allows the model to generalize effectively to novel shapes outside training categories. ",
+        "bbox": [
+            174,
+            387,
+            825,
+            486
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning to execute a long sequence of programs is difficult, since an executor has to learn to interpret not only single statements but also complex combinations of multiple statements. We decompose the problem by learning an executor that executes programs at the block level, e.g., either a single drawing statement or a compound statements. Afterwards, we integrate these block-level shapes by max-pooling to form the shape corresponding to a long sequence of programs. Our neural program executor includes an LSTM followed by a deconv CNN, as shown in Figure 3. The LSTM aggregates the block-level program into a fixed-length representation. The following deconv CNN takes this representation and generates the desired shape. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            604
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To train the program executor, we synthesize large amounts of block-level programs and their corresponding shapes. During training, we minimize the sum of the weighted binary cross-entropy losses over all voxels via ",
+        "bbox": [
+            174,
+            611,
+            825,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/169d4a3542dea6e6aad93d77b2376ec05a6739000ea8f6b23cb3f1c47d70230d.jpg",
+        "text": "$$\n\\mathcal { L } = \\sum _ { v \\in V } - w _ { 1 } y _ { v } \\log \\hat { y } _ { v } - w _ { 0 } ( 1 - y _ { v } ) \\log ( 1 - \\hat { y } _ { v } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            654,
+            666,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $v$ is a single voxel of the whole voxel space $V$ , $y _ { v }$ and $\\hat { y } _ { v }$ are the ground truth and prediction, respectively, while $w _ { 0 }$ and $w _ { 1 }$ balance the losses between vacant and occupied voxels. This training leverages only synthetic data, not annotated shape and program pairs, which is a blessing of our disentangled representation. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 GUIDED ADAPTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            765,
+            367,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A program generator trained only on a synthetic dataset does not generalize well to real-world datasets. With the learned differentiable neural program executor, we can adapt our model to other datasets such as ShapeNet, where program-level supervision is not available. We execute the predicted program by the learned neural program executor and compute the reconstruction loss between the generated shape and the input. Afterwards, the program generator is updated by the gradient back-propagated from the learned program executor, whose weights are frozen. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This adaptation is guided by the learned program executor and therefore called guided adaptation $( G A )$ , and is shown in Figure 4. Given an input shape, the program generator first outputs multiple block programs. Each block is interpreted as 3D shapes by the program executor. A max-pooling operation over these block-level shapes generates the reconstructed shape. The use of max-pooling also enables our executor to handle programs of variable length. Vacant tokens are also executed and pooled. Gradients can then propagate through vacant tokens and the model can learn to add new program primitives accordingly. Here, the loss for Guided Adaptation is the summation of the binary cross-entropy loss over all voxels. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/e201fc250df4b206c3ca6217d010ceddee2a10e165fd5ac0051309bd0d971d13.jpg",
+        "image_caption": [
+            "Figure 4: Given an input 3D shape, the neural program executor executes the generated programs. Errors between the rendered shape and the raw input are back-propagated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            101,
+            754,
+            234
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            290,
+            825,
+            359
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            381,
+            326,
+            397
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We present program generation and shape reconstruction results on three datasets: our synthetic dataset, ShapeNet (Chang et al., 2015), and Pix3D (Sun et al., 2018b). ",
+        "bbox": [
+            173,
+            415,
+            823,
+            443
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Setup. In our experiments, we use a single model to predict programs for multiple categories. Our model is first pretrained on the synthetic dataset and subsequently adapted to target dataset such as ShapeNet and Pix3D under the guidance of the neural program executor. All components of our model are trained with Adam (Kingma & Ba, 2015). ",
+        "bbox": [
+            174,
+            453,
+            825,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 EVALUATION ON THE SYNTHETIC DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            526,
+            517,
+            541
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Program generator. We first pre-train our program generator on our synthetic dataset with simple templates. The synthetic training set includes 100,000 chairs and 100,000 tables. The generator is evaluated on 5,000 chairs and tables. More than $9 9 . 9 \\%$ of the programs are accurately predicted. The shapes rendered by the predicted programs have an average IoU of 0.991 with the input shapes. This high accuracy is due to the simplicity of the synthetic dataset. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Program executor. Our program executor is trained on 500,000 pairs of synthetic block programs and corresponding shapes, and tested on 30,000 pairs. The IoU between the shapes rendered by the executor and the ground truth is 0.93 for a single drawing statement and 0.88 for compound statements. This shows the neural program executor is a good approximation of the graphics engine. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 GUIDED ADAPTATION ON SHAPENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            472,
+            720
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Setup. We validate the effectiveness of guided adaptation by testing our model on unseen examples from ShapeNet. For both tables and chairs, we randomly select 1,000 shapes for evaluation and all the remaining ones for guided adaptation. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            775
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Quantitative results. After our model generates programs from input shapes, we execute these programs with a graphics engine and measure the reconstruction quality. Evaluation metrics include IoU, Chamfer distance (CD) (Barrow et al., 1977), and Earth Mover’s distance (EMD) (Rubner et al., 2000). While the pre-trained model achieves 0.99 IoU on the synthetic dataset, the IoU drops below 0.5 on ShapeNet, showing the significant disparity between these two domains. As shown in Table 2, all evaluation metrics suggests improvement after guided adaptation. For example, the IoUs of table and chair increase by 0.104 and 0.094, respectively. We compare our method with Tulsiani et al. (2017), which describes shapes with a set of primitives; and CSGNet (Sharma et al., 2018), which learns to describe shapes by applying arithmetic over primitives. For CSGNet, we evaluate two variants: first, CSGNet-original, where we directly test the model released by the original authors; ",
+        "bbox": [
+            173,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b01be23ffd408f276b1c532dfffdc4832507032aa30b9011aceb0e858e3c19e3.jpg",
+        "table_caption": [
+            "Table 2: Shape reconstruction results on ShapeNet, evaluated in intersection over union (IoU, higher is better), Chamfer distance (CD, lower is better), and Earth Mover’s distance (EMD, lower is better). Our model outperforms the baselines. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td colspan=\"2\">IoU↑</td><td colspan=\"2\">CD↓</td><td colspan=\"2\">EMD↓</td></tr><tr><td>table</td><td>chair</td><td>table</td><td>chair</td><td>table</td><td>chair</td></tr><tr><td>CSGNet-original</td><td>0.111</td><td>0.154</td><td>0.216</td><td>0.175</td><td>0.205</td><td>0.177</td></tr><tr><td>Tulsiani et al. (2017)</td><td>0.357</td><td>0.406</td><td>0.083</td><td>0.079</td><td>0.073</td><td>0.072</td></tr><tr><td>CSGNet-augmented</td><td>0.406</td><td>0.365</td><td>0.072</td><td>0.077</td><td>0.069</td><td>0.076</td></tr><tr><td>Nearest Neighbour</td><td>0.445</td><td>0.389</td><td>0.083</td><td>0.084</td><td>0.084</td><td>0.084</td></tr><tr><td>Shape Programs w/o GA</td><td>0.487</td><td>0.422</td><td>0.067</td><td>0.072</td><td>0.063</td><td>0.072</td></tr><tr><td> Shape Programs</td><td>0.591</td><td>0.516</td><td>0.058</td><td>0.063</td><td>0.056</td><td>0.060</td></tr></table>",
+        "bbox": [
+            233,
+            94,
+            759,
+            241
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "second, CSGNet-augmented, where we retrain CSGNet on our dataset with the additional shape primitives we introduced. We also introduce a nearest neighbor baseline, where we use Hamming distance to search for a nearest neighbour from the training set for each testing sample. ",
+        "bbox": [
+            176,
+            316,
+            821,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our model without guided adaptation outperforms Tulsiani et al. (2017) and CSGNet by a margin, showing the benefit of capturing regularities such as symmetry and translation. The NN baseline suggests that simply memorizing the training set does not generalize well to test shapes. With the learned neural program executor, we try to directly train our program generator on ShapeNet without any pre-training. This trial failed, possibly because of the extremely huge and complicated combinatorial space of programs. However, the initial programs for pre-training can be very simple: e.g., 10 simple table templates (Fig. A1) are sufficient to initialize the model, which later achieves good performance under execution-guided adaptation. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Qualitative results. Figure 5 shows some program generation and shape reconstruction results for tables and chairs, respectively. The input shapes can be noisy and contain components that are not covered by templates in our synthetic dataset. After guided adaption, our model is able to extract more meaningful programs and reconstruct the input shape reasonably well. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            556
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our model can be adapted to either add or delete programs, as shown in Figure 5. In (a), we observe an addition of translation describing the armrests. In (b) the “cylinder support” program is removed and a nested translation is added to describe four legs. In (c) and (d), the addition of “Horizontal bar” and “Rectangle layer” leads to more accurate representation. Improvements utilizing modifications to compound programs are not restricted to translations, but can also be observed in rotations, e.g., the times of rotation in (a) is increased from 4 to 5. We also notice new templates emerges after adaptation, e.g., tables in (c) and (d) are not in the synthetic dataset (check the synthetic templates for tables in supplementary). These changes are significant because it indicates the generator can map complex, non-linear relationships to the program space. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            689
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.3 STABILITY AND CONNECTIVITY MEASUREMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            718,
+            552,
+            732
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Stability and connectivity are necessary for the functioning of many real-world shapes. This is difficult to capture using purely low-level primitives, but are better suited to our program representations. ",
+        "bbox": [
+            176,
+            750,
+            823,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We define a shape as stable if its center of mass falls within the convex hull of its ground contacts, and we define a shape as connected if all voxels form one connected component. In Table 3 we compare our model against Tulsiani et al. (2017) and observe significant improvements in the stability of shapes produced by our model when compared to this baseline. This is likely because our model is able to represent multiple identical objects by utilizing translations and rotations. Before GA, our model produces chairs with lower connectivity, but we observe significant improvements with GA. This can be explained by the significant diversity in the ShapeNet dataset under the “chair” class. However, the improvements with GA also demonstrate an ability for our model to generalize. Measured by the percentage of produced shapes that are stable and connected, our model gets significantly better results, and continues to improve with guided adaptation. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ded628b82e2a5fb0e0c1e5652b34007fdbbb0e1d2e7e74ee68570a9cb7d4dd5d.jpg",
+        "image_caption": [
+            "Figure 5: The program generation for ShapeNet chairs and tables. For each shape, the first and second rows represent results before and after guided adaptation. Best viewed in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            85,
+            821,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/955465af30e73d939953b25ca0339ce567a10495906873f6360b846ca8e6b64d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td colspan=\"2\">Stable (%)</td><td colspan=\"2\">Conn. (%)</td><td colspan=\"2\">Stable &amp; Conn. (%)</td></tr><tr><td>table</td><td>chair</td><td>table</td><td>chair</td><td>table</td><td>chair</td></tr><tr><td>Tulsiani et al. (2017)</td><td>36.7</td><td>31.3</td><td>37.1</td><td>68.9</td><td>15.4</td><td>19.6</td></tr><tr><td> Shape Programs w/o GA</td><td>94.7</td><td>95.1</td><td>76.6</td><td>54.2</td><td>73.7</td><td>51.6</td></tr><tr><td>Shape Programs</td><td>97.0</td><td>96.5</td><td>78.4</td><td>68.5</td><td>77.0</td><td>66.0</td></tr><tr><td>Ground Truth</td><td>98.9</td><td>97.6</td><td>98.8</td><td>97.8</td><td>97.7</td><td>95.5</td></tr></table>",
+        "bbox": [
+            225,
+            693,
+            769,
+            813
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Measurement of stability and connectivity. Our model is able to capture shape regularity such as symmetry. Therefore, shapes represented by our programs are more stable and better connected. ",
+        "bbox": [
+            173,
+            821,
+            826,
+            851
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 GENERALIZATION ON OTHER SHAPES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            859,
+            478,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While our program generator is pre-trained only on synthetic chairs and tables, generalization on other shape categories is desirable. We further demonstrate that with guided adaptation, our program generator can be transferred to other unseen categories. ",
+        "bbox": [
+            174,
+            886,
+            825,
+            928
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c52f28037e29231d27581c976a36b942dff1486db435ae1188fe25df579a9c5d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Models</td><td colspan=\"4\">IoU↑</td><td colspan=\"4\">CD←</td></tr><tr><td>bed</td><td>sofa</td><td>cabinet</td><td>bench</td><td>bed</td><td>sofa</td><td>cabinet</td><td>bench</td></tr><tr><td>Shape Programs w/o GA</td><td>0.234</td><td>0.296</td><td>0.251</td><td>0.176</td><td>0.126</td><td>0.103</td><td>0.104</td><td>0.098</td></tr><tr><td>Shape Programs</td><td>0.367</td><td>0.597</td><td>0.478</td><td>0.418</td><td>0.096</td><td>0.067</td><td>0.092</td><td>0.059</td></tr></table>",
+        "bbox": [
+            179,
+            88,
+            813,
+            166
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 4: Shape reconstruction results on unseen categories. Results with or without guided adaptation in intersection over union (IoU, higher is better) and Chamfer distance (CD, lower is better). ",
+        "bbox": [
+            174,
+            174,
+            823,
+            202
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/72d80cc5701ec201976be27ab0d60378add0c4e625fd011f4babf62f5825b50b.jpg",
+        "image_caption": [
+            "Figure 6: ShapeNet objects from unseen categories reconstructed with shape programs before and after guided adaptation. Shape Programs can learn to adapt and explain objects from novel classes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            212,
+            821,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/d45ccafaf1881850b1fbd7f3cf75bc6aaaaaccfd983e2e7e370be3bb66a72ac8.jpg",
+        "image_caption": [
+            "Figure 7: 3D reconstruction results on Pix3D dataset. MarrNet generates fragmentary shapes and our model further smooths and completes such shapes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            367,
+            823,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We consider Bed, Bench, Cabinet, and Sofa, which share similar semantics with table and chair but are unseen during pre-training. We split $80 \\%$ shapes of each category for guided adaptation and the remaining for evaluation. Table 4 suggests the pre-trained model performs poorly for these unseen shapes but its performance improves with this unsupervised guided adaptation. The IoU of bed improves from 0.23 to 0.37, sofa from 0.30 to 0.60, cabinet from 0.25 to 0.48, and bench from 0.18 to 0.42. This clearly illustrates the generalization ability of our framework. Visualized examples are show in Figure 6. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            669
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 SHAPE COMPLETION AND SMOOTHING BY PROGRAMS",
+        "text_level": 1,
+        "bbox": [
+            174,
+            684,
+            593,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "One natural application of our model is to complete and smooth fragmentary shapes reconstructed from 2D images. We separately train a MarrNet (Wu et al., 2017) model for chairs and tables on ShapeNet, and then reconstruct 3D shapes from 2D images on the Pix3D dataset. As shown in Figure 7, MarrNet can generate fragmentary shapes, which are then fed into our model to generate programs. These programs are executed by the graphics engine to produce a smooth and complete shape. For instance, our model can complete the legs of chairs and tables, as shown in Figure 7. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "While stacking our model on top of MarrNet does not change the IoU of 3D reconstruction, our model produces more visually appealing and human-perceptible results. A user study on AMT shows that $78 . 9 \\%$ of the participant responses prefer our results rather than MarrNet’s. ",
+        "bbox": [
+            174,
+            801,
+            821,
+            843
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            863,
+            310,
+            878
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We have introduced 3D shape programs as a new shape representation. We have also proposed a model for inferring shape programs, which combines a neural program synthesizer and a neural executor. Experiments on ShapeNet show that our model successfully explains shapes as programs and generalizes to shapes outside training categories. Further experiments on Pix3D show our model can be extended to infer shape programs and reconstruct 3D shapes directly from color images. We now discuss key design choices and future work. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/010f1a29adc54fcf714d9d5a3d3edeb695bb863a4eb34f384d3174a8754b9fd9.jpg",
+        "image_caption": [
+            "Figure 8: We visualize the effect of manipulating individual dimensions in the intermediate representation of neural program executor. For example, dimension 27 corresponds to the height of primitives, dimension 25 to the radius of primitives, and dimension 41 to the times of primitive repetition. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            83,
+            815,
+            339
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            421,
+            825,
+            477
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Analyzing the neural program executor. We look deep into the intermediate representation of the neural program executor, which is a 64-dimensional vector output by the LSTM (see Figure 3). We manipulate individual dimensions and visualize the generated voxels. Figure 8 shows that these dimensions capture interpretable geometric features (e.g., height, radius, and number of repetitions). ",
+        "bbox": [
+            174,
+            488,
+            825,
+            544
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Design of the DSL. Our design of the DSL for shape programs makes certain semantic commitments. A DSL with these semantics has advantages and disadvantages: it naturally supports semantic correspondences across shapes and enables better in-class reconstructions; on the other hand, it may limit the ability to generalize to shapes outside training classes. Our current instantiation focuses on the semantics of furniture (a superclass, whose subclasses share similar semantics). Within this superclass, our model generalizes well: trained on chairs and tables, it generalizes to new furniture categories such as beds. In future work, we are interested in learning a library of shape primitives directly from data, which will allow our approach to adapt automatically to new superclasses or domains of shape. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Structure search vs. amortized inference. For our program synthesis task, we use neural nets for amortized inference rather than structure search, due to the large search space and our desire to return a shape interpretation nearly instantaneously, effectively trading neural net training time for fast inference at test time. Our model takes $5 \\mathrm { m s }$ to infer a shape program with a Titan X GPU. We also considered various possible approaches for structured search over the space of shape programs, but decided that these would most likely be too our slow for our goals. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One approach to structured search is constraint solving. Ellis et al. (2015) used the performant Z3 SMT solver (De Moura & Bjørner, 2008) to infer 2D graphics programs, taking 5-20 minutes for problems arguably simpler than our 3D shape programs. Other approaches could be based on stochastic search, such as MCMC in the space of programs. For the related problem of inverse graphics from 2D images, MCMC, like constraint solving, takes too long for perception at a glance (Kulkarni et al., 2015b). Efficient integration of discrete search and amortized inference, however, is a promising future research direction. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            871
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments. We thank Keyulu Xu and Xiuming Zhang for insightful discussions and anonymous reviewers for their feedback. This work is supported by the Center for Brains, Minds and Machines (NSF #1231216), NSF #1447476, ONR MURI N00014-16-1-2007, and Facebook. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matej Balog, Alexander L Gaunt, Marc Brockschmidt, Sebastian Nowozin, and Daniel Tarlow. Deepcoder: Learning to write programs. In ICLR, 2017. 3 ",
+        "bbox": [
+            174,
+            133,
+            826,
+            164
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Harry G Barrow, Jay M Tenenbaum, Robert C Bolles, and Helen C Wolf. Parametric correspondence and chamfer matching: Two new techniques for image matching. In IJCAI, 1977. 6 ",
+        "bbox": [
+            173,
+            172,
+            823,
+            202
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Irving Biederman. Recognition-by-components: a theory of human image understanding. Psychol. Rev., 94(2):115, 1987. 2 ",
+        "bbox": [
+            173,
+            212,
+            823,
+            241
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Thomas O Binford. Visual perception by computer. Invited talk at IEEE Conf. on Systems and Control, 1971. 2 ",
+        "bbox": [
+            173,
+            250,
+            823,
+            279
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matko Bosnjak, Tim Rockt ˇ aschel, Jason Naradowsky, and Sebastian Riedel. Programming with a ¨ differentiable forth interpreter. In ICML, 2017. 3 ",
+        "bbox": [
+            171,
+            289,
+            823,
+            318
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathon Cai, Richard Shin, and Dawn Song. Making neural programming architectures generalize via recursion. In ICLR, 2017. 3 ",
+        "bbox": [
+            171,
+            327,
+            825,
+            356
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Angel X Chang, Thomas Funkhouser, Leonidas Guibas, Pat Hanrahan, Qixing Huang, Zimo Li, Silvio Savarese, Manolis Savva, Shuran Song, Hao Su, Jianxiong Xiao, Li Yi, and Fisher Yu. Shapenet: An information-rich 3d model repository. arXiv:1512.03012, 2015. 1, 6 ",
+        "bbox": [
+            174,
+            366,
+            823,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Siddhartha Chaudhuri, Evangelos Kalogerakis, Leonidas Guibas, and Vladlen Koltun. Probabilistic reasoning for assembly-based 3d modeling. ACM TOG, 30(4):35, 2011. 2 ",
+        "bbox": [
+            171,
+            417,
+            825,
+            446
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Leonardo De Moura and Nikolaj Bjørner. Z3: An efficient smt solver. In TACAS, 2008. 10 ",
+        "bbox": [
+            173,
+            457,
+            771,
+            472
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Jonathan Uesato, Surya Bhupatiraju, Rishabh Singh, Abdel-rahman Mohamed, and Pushmeet Kohli. Robustfill: Neural program learning under noisy i/o. In ICML, 2017. 3 ",
+        "bbox": [
+            176,
+            481,
+            823,
+            511
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel D Dilks, Joshua B Julian, Jonas Kubilius, Elizabeth S Spelke, and Nancy Kanwisher. Mirrorimage sensitivity and invariance in object and scene processing pathways. J. Neurosci., 31(31): 11305–11312, 2011. 1 ",
+        "bbox": [
+            173,
+            520,
+            825,
+            563
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kevin Ellis, Armando Solar-Lezama, and Josh Tenenbaum. Unsupervised learning by program synthesis. In NeurIPS, 2015. 3, 10 ",
+        "bbox": [
+            174,
+            571,
+            823,
+            602
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kevin Ellis, Daniel Ritchie, Armando Solar-Lezama, and Joshua B Tenenbaum. Learning to infer graphics programs from hand-drawn imatges. In NeurIPS, 2018. 3 ",
+        "bbox": [
+            173,
+            611,
+            823,
+            640
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Fleuret, Ting Li, Charles Dubout, Emma K Wampler, Steven Yantis, and Donald Geman. Comparing machines and humans on a visual categorization test. PNAS, 108(43):17621–17625, 2011. 4 ",
+        "bbox": [
+            173,
+            648,
+            825,
+            693
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yaroslav Ganin, Tejas Kulkarni, Igor Babuschkin, SM Eslami, and Oriol Vinyals. Synthesizing programs for images using reinforced adversarial learning. In ICML, 2018. 3 ",
+        "bbox": [
+            171,
+            702,
+            823,
+            732
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander L Gaunt, Marc Brockschmidt, Rishabh Singh, Nate Kushman, Pushmeet Kohli, Jonathan Taylor, and Daniel Tarlow. Terpret: A probabilistic programming language for program induction. arXiv preprint arXiv:1608.04428, 2016. 3 ",
+        "bbox": [
+            176,
+            739,
+            825,
+            784
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Judy Hoffman, Li Fei-Fei, C Lawrence Zitnick, and Ross Girshick. Inferring and executing programs for visual reasoning. In ICCV, 2017. 3 ",
+        "bbox": [
+            176,
+            792,
+            825,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015. 6 ",
+        "bbox": [
+            171,
+            845,
+            823,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kurt Koffka. Principles of Gestalt psychology. Routledge, 2013. 1 ",
+        "bbox": [
+            173,
+            871,
+            612,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tejas D Kulkarni, Pushmeet Kohli, Joshua B Tenenbaum, and Vikash Mansinghka. Picture: A probabilistic programming language for scene perception. In CVPR, 2015a. 2 ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tejas D Kulkarni, William F Whitney, Pushmeet Kohli, and Josh Tenenbaum. Deep convolutional inverse graphics network. In NeurIPS, 2015b. 10 ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jun Li, Kai Xu, Siddhartha Chaudhuri, Ersin Yumer, Hao Zhang, and Leonidas Guibas. Grass: Generative recursive autoencoders for shape structures. In SIGGRAPH, 2017. 2 ",
+        "bbox": [
+            174,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yunchao Liu, Zheng Wu, Daniel Ritchie, William T Freeman, Joshua B Tenenbaum, and Jiajun Wu. Learning to describe scenes with programs. In ICLR, 2019. 3 ",
+        "bbox": [
+            173,
+            180,
+            825,
+            210
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhijian Liu, William T Freeman, Joshua B Tenenbaum, and Jiajun Wu. Physical primitive decomposition. In ECCV, 2018. 2 ",
+        "bbox": [
+            173,
+            219,
+            823,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Niloy Mitra, Michael Wand, Hao Richard Zhang, Daniel Cohen-Or, Vladimir Kim, and Qi-Xing Huang. Structure-aware shape processing. In SIGGRAPH Asia Courses, 2013. 2 ",
+        "bbox": [
+            173,
+            258,
+            821,
+            287
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gen Nishida, Ignacio Garcia-Dorado, Daniel G Aliaga, Bedrich Benes, and Adrien Bousseau. Interactive sketching of urban procedural models. ACM TOG, 35(4):130, 2016. 2 ",
+        "bbox": [
+            174,
+            296,
+            823,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gen Nishida, Adrien Bousseau, and Daniel G Aliaga. Procedural modeling of a building from a single image. CGF, 37(2):415–429, 2018. 2 ",
+        "bbox": [
+            176,
+            337,
+            823,
+            366
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Emilio Parisotto, Abdel-rahman Mohamed, Rishabh Singh, Lihong Li, Dengyong Zhou, and Pushmeet Kohli. Neuro-symbolic program synthesis. In ICLR, 2017. 3 ",
+        "bbox": [
+            176,
+            375,
+            825,
+            404
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Charles R Qi, Li Yi, Hao Su, and Leonidas J Guibas. Pointnet++: Deep hierarchical feature learning on point sets in a metric space. In NeurIPS, 2017. 1 ",
+        "bbox": [
+            174,
+            412,
+            823,
+            443
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed and Nando De Freitas. Neural programmer-interpreters. In ICLR, 2016. 3 ",
+        "bbox": [
+            173,
+            452,
+            735,
+            468
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Ritchie, Anna Thomas, Pat Hanrahan, and Noah Goodman. Neurally-guided procedural models: Amortized inference for procedural graphics programs using neural networks. In NeurIPS, 2016. 2 ",
+        "bbox": [
+            176,
+            477,
+            825,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Lawrence G Roberts. Machine perception of three-dimensional solids. PhD thesis, Massachusetts Institute of Technology, 1963. 2 ",
+        "bbox": [
+            173,
+            530,
+            825,
+            559
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yossi Rubner, Carlo Tomasi, and Leonidas J Guibas. The earth mover’s distance as a metric for image retrieval. IJCV, 40(2):99–121, 2000. 6 ",
+        "bbox": [
+            174,
+            569,
+            821,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adriana Schulz, Ariel Shamir, Ilya Baran, David IW Levin, Pitchaya Sitthi-Amorn, and Wojciech Matusik. Retrieval on parametric shape collections. ACM TOG, 36(1):11, 2017. 2 ",
+        "bbox": [
+            173,
+            607,
+            821,
+            637
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gopal Sharma, Rishabh Goyal, Difan Liu, Evangelos Kalogerakis, and Subhransu Maji. Csgnet: Neural shape parser for constructive solid geometry. In CVPR, 2018. 1, 2, 6 ",
+        "bbox": [
+            173,
+            646,
+            823,
+            676
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ondrej St’ava, Bedrich Bene ˇ s, Radomir M ˇ ech, Daniel G Aliaga, and Peter Kri ˇ stof. Inverse procedural ˇ modeling by automatic generation of l-systems. CGF, 29(2):665–674, 2010. 2 ",
+        "bbox": [
+            173,
+            686,
+            823,
+            717
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shao-Hua Sun, Hyeonwoo Noh, Sriram Somasundaram, and Joseph Lim. Neural program synthesis from diverse demonstration videos. In ICML, 2018a. 3 ",
+        "bbox": [
+            173,
+            726,
+            823,
+            755
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xingyuan Sun, Jiajun Wu, Xiuming Zhang, Zhoutong Zhang, Chengkai Zhang, Tianfan Xue, Joshua B Tenenbaum, and William T Freeman. Pix3d: Dataset and methods for single-image 3d shape modeling. In CVPR, 2018b. 6 ",
+        "bbox": [
+            176,
+            765,
+            823,
+            808
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shubham Tulsiani, Hao Su, Leonidas J Guibas, Alexei A Efros, and Jitendra Malik. Learning shape abstractions by assembling volumetric primitives. In CVPR, 2017. 1, 2, 6, 7, 8 ",
+        "bbox": [
+            171,
+            816,
+            825,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Anton van den Hengel, Chris Russell, Anthony Dick, John Bastian, Daniel Pooley, Lachlan Fleming, and Lourdes Agapito. Part-based modelling of compound scenes from images. In CVPR, 2015. 2 ",
+        "bbox": [
+            174,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nanyang Wang, Yinda Zhang, Zhuwen Li, Yanwei Fu, Wei Liu, and Yu-Gang Jiang. Pixel2mesh: Generating 3d mesh models from single rgb images. In ECCV, 2018. 1 ",
+        "bbox": [
+            173,
+            895,
+            826,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Wu, Yifan Wang, Tianfan Xue, Xingyuan Sun, William T Freeman, and Joshua B Tenenbaum. MarrNet: 3D Shape Reconstruction via 2.5D Sketches. In NeurIPS, 2017. 9 ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhirong Wu, Shuran Song, Aditya Khosla, Fisher Yu, Linguang Zhang, Xiaoou Tang, and Jianxiong Xiao. 3d shapenets: A deep representation for volumetric shapes. In CVPR, 2015. 1 ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chenyang Zhu, Kai Xu, Siddhartha Chaudhuri, Renjiao Yi, and Hao Zhang. Scores: Shape composition with recursive substructure priors. In SIGGRAPH Asia, 2018. 2 ",
+        "bbox": [
+            174,
+            178,
+            825,
+            208
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chuhang Zou, Ersin Yumer, Jimei Yang, Duygu Ceylan, and Derek Hoiem. 3d-prnn: Generating shape primitives with recurrent neural networks. In ICCV, 2017. 2 ",
+        "bbox": [
+            173,
+            217,
+            825,
+            246
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 DEFINED PROGRAMS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            401,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The details of semantics and shape primitives in our experimental setting for furniture are shown in Table 5. Due to the semantic nature of objects, while a few semantics are category specific, e.g., “ChairBeam”, other semantics are shared across different shape categories, e.g., “Leg” and “Top”. ",
+        "bbox": [
+            173,
+            135,
+            826,
+            178
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/03fc8be5d4cf013221ea28ef3d47cdb67b05486a25c96fbf0941e4ee93b19928.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"6\"></td><td>Leg</td><td>Chair leg, table leg,etc. Usually long and used jointly for support</td></tr><tr><td>Top</td><td>Seat top, table top,etc.Usually a broad and flat surface</td></tr><tr><td>Layer</td><td>Shelf embedded in table,cabinet shelf etc.Usually a flat surface between other similar shapes</td></tr><tr><td>Support</td><td>Chair support, table support etc.A monolithic object used to raise things off the ground</td></tr><tr><td>Base</td><td>Base of an sofa, table etc. Usually a flat surface on the ground to help with stability</td></tr><tr><td>Sideboard</td><td>Sideboard of a cabinet, table etc.A vertical, flat surface on the</td></tr><tr><td>Semantics Horizontal Bar</td><td>bottom half of an object Horizontal bar of a chair etc.A thin bar used for structural</td></tr><tr><td>Vertical Board</td><td>integrity Vertical board of a arm rest etc.A vertical, flat surface used by</td></tr><tr><td>Locker</td><td>humans for arm support Table drawer etc. A boxy object used to put things in</td></tr><tr><td>Back</td><td>Chair back, Sofa back etc.A surface used for resting backs on</td></tr><tr><td>Back support</td><td>Office chair back support beam etc.A beam used to support a</td></tr><tr><td>ChairBeam</td><td>back rest Arm rest support beam in chairs,benches etc.A long object used</td></tr><tr><td rowspan=\"5\"> Shapes</td><td>Cylinder (Cyl)</td><td>to support an arm rest P = (x,y,z),G = (t,r),draw a cylinder at (x,y,z) with sizes (t,r)</td></tr><tr><td>Cuboid (Cub)</td><td>P = (x,y,z),G = (t,r1,r2,[angl), draw a cuboid at (x,y,z) with sizes (t,r1,r2) and optional ang of tilt along front/back</td></tr><tr><td>Circle (Cir)</td><td>P = (x,y,z),G = (t,r), draw a circle at (x,y,z) with sizes (t,r),t is usually small</td></tr><tr><td>Square (Sqr)</td><td>P = (x,y,z),G = (t,r), draw a square at (x,y,z) with sizes (t,r),t is usually small</td></tr><tr><td>Rectangle (Rect)</td><td>P = (x,y,z),G= (t,r1,r2), draw a rectangle at (x,y,z) with sizes (t,r1,r2),t is usually small</td></tr><tr><td>Line (Line)</td><td></td><td>P = (𝑥1,y1,z1),G = (x2,y2, z2),draw a line from P to G</td></tr></table>",
+        "bbox": [
+            176,
+            189,
+            830,
+            741
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 5: The list of semantics and shapes, as well as associated parameters used by our model ",
+        "bbox": [
+            186,
+            746,
+            805,
+            761
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 ARCHITECTURE DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            437,
+            809
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Program Generator. The program executor contains a 3D ConvNet and two LSTMS. (1) 3D ConvNet. This 3D ConvNet is the first part of the program generator model. It consists of 8 3D convolutional layers. The kernel size of each layer is 3 except for the first one whose kernel size is 5. The number of output channels are (8,16,16,32,32,64,64,64), respectively. The output of the last layer is averaged over the spatial resolution, which gives a 64-dimension embedding. (2) Block LSTM and Step LSTM. These two LSTMs share similar structure. Both are one-layer LSTMs. The dimensions of the input and hidden state are both 64. ",
+        "bbox": [
+            173,
+            825,
+            826,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/446a9041dff0425de2ff3b31a52f092ebc14555950b91bc78b2585d8ef128a88.jpg",
+        "image_caption": [
+            "Figure A1: (a) shows random samples from all of our 10 table templates for synthetic dataset (b) shows raw and reconstructed tables on ShapeNet "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            107,
+            818,
+            219
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Program Executor. The program executor contains an LSTM and a 3D DeConvNet. (1) LSTM. This LSTM aggregates a block-level programs into a 64-dimensional vector. The dimension of the hidden state is also 64. The input of each time step is the concatenation of category distribution over programs and the corresponding parameters retrieved from the parameter matrix. (2) 3D DeConvNet. It consists of 7 layers. TransposedConv layer with kernel size 4 and Conv layer with kernel size 3 are alternating. The number of output channels are (64, 64, 16, 16, 4, 4, 2), respectively. The output of the last layer is fed into a sigmoid function to generate the 3D voxel shape. ",
+        "bbox": [
+            173,
+            279,
+            826,
+            376
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "End-to-end differentiability. The end-to-end differentiability is obtained via our design of the neural program executor. The output of the program inference model is actually continuous. A real execution engine (not the neural executor) actually contains two steps: (1) discretize such output, and (2) execute the discretized program to generate the voxel. Our neural executor is learned to jointly approximate both steps, thus the whole pipeline can be differentiable in an end-to-end manner. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            453
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3 SYNTHETIC TEMPLATES V.S. SHAPENET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            563,
+            488
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "ShapeNet was proposed to be the ImageNet of shapes; it is therefore highly diverse and intrinsically challenging. Our synthetic dataset were designed to provide minimal, simple guidance to the network. In Figure A1, (a) shows sampled shapes from all of our 10 table templates, while (b) shows the ground truth and reconstructed tables in ShapeNet, which are siginificantly more complex. Such disparity of complexity explains why we saw a dramatic drop of IoU when we directly tested on ShapeNet with model only pretrained on synthetic dataset. Our guided adaptation further adapt the pre-trained model. ",
+        "bbox": [
+            174,
+            505,
+            825,
+            603
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            622,
+            415,
+            638
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Figure A2 through Figure A8, we show the generated shape and programs using a network that is only pretrained jointly on synthetic “table” and “chair” objects, and a network that is pretrained then further enhanced by guided adaptation on ShapeNet data. Figure A2 and Figure A3 correspond to “chairs”, Figure A4 to “tables”, Figure A5 to “benches”, Figure A6 to “couches”, Figure A7 to “cabinets”, and Figure A8 to “beds”. In Figure A2, Figure A3, and Figure A4, even though “chair” and “table” have been seen in the synthetic dataset, we still note improvements in program inference and shape reconstruction on ShapeNet after guided adaptation. This is because our synthetic data is simpler than ShapeNet data. When directly using a model pretrained on synthetic “chairs” and “tables” to other classes, it is not surprised some shapes are interpreted as tables or chairs. However, such mispredictions dramatically drop after our guided adaptation. ",
+        "bbox": [
+            173,
+            655,
+            826,
+            795
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6ab01c9a904e2222475f38726f9131b96f5c828c52a7740ba16b3141be41c55.jpg",
+        "image_caption": [
+            "Figure A2: (a) to (f) show the generated shapes and programs for ShapeNet chairs "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            66,
+            795,
+            886
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/52ca785d25fe5c151e6c0918acb987306ae61ca2fa7f6927dc2df5e3c96fea77.jpg",
+        "image_caption": [
+            "Figure A3: (a) to (f) show the generated shapes and programs for ShapeNet chairs "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            102,
+            823,
+            842
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a66c558f74805a02a426ed56d7b5ecb7e3158c60ec23e4b8e43fd70d918bca6.jpg",
+        "image_caption": [
+            "Figure A4: (a) to (f) show the generated shapes and programs for ShapeNet tables "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            127,
+            815,
+            839
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/4872d1ad12fecb6b999a3a3922a6875175193b8d709678ab242887cd7d483052.jpg",
+        "image_caption": [
+            "Figure A5: (a) to (f) show the generated shapes and programs for ShapeNet benches "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            141,
+            816,
+            857
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/8eb4283962893da5968b2f641d78910cf5a82ffcf131f8bdda603741e1f67d44.jpg",
+        "image_caption": [
+            "Figure A6: (a) to (f) show the generated shapes and programs for ShapeNet couches "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            181,
+            825,
+            834
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/d172a3fc7d4bc1d82cd1097244706708aa357ba84be148faff4556fdfd5ce34f.jpg",
+        "image_caption": [
+            "Figure A7: (a) to (d) show the generated shapes and programs for ShapeNet cabinets "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            126,
+            820,
+            539
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/25e7d4760083ffbc28c6484f3c016a3c1a06a10ed7c758a4746bda07ab487df4.jpg",
+        "image_caption": [
+            "Figure A8: (a) and (b) show the generated shapes and programs for ShapeNet beds "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            662,
+            821,
+            837
+        ],
+        "page_idx": 20
+    }
+]