Add files using upload-large-folder tool

parse/train/HJe4Cp4KwH/HJe4Cp4KwH.md

@@ -0,0 +1,273 @@
+# GNN-FILM: GRAPH NEURAL NETWORKS WITH FEATURE-WISE LINEAR MODULATION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+This paper presents a new Graph Neural Network (GNN) type using feature-wise linear modulation (FiLM). Many standard GNN variants propagate information along the edges of a graph by computing “messages” based only on the representation of the source of each edge. In GNN-FiLM, the representation of the target node of an edge is additionally used to compute a transformation that can be applied to all incoming messages, allowing feature-wise modulation of the passed information.
+
+Results of experiments comparing different GNN architectures on three tasks from the literature are presented, based on re-implementations of baseline methods. Hyperparameters for all methods were found using extensive search, yielding somewhat surprising results: differences between baseline models are smaller than reported in the literature. Nonetheless, GNN-FiLM outperforms baseline methods on a regression task on molecular graphs and performs competitively on other tasks.
+
+# 1 INTRODUCTION
+
+Learning from graph-structured data has seen explosive growth over the last few years, as graphs are a convenient formalism to model the broad class of data that has objects (treated as vertices) with some known relationships (treated as edges). Example usages include reasoning about physical and biological systems, knowledge bases, computer programs, and relational reasoning in computer vision tasks. This graph construction is a highly complex form of feature engineering, mapping the knowledge of a domain expert into a graph structure which can be consumed and exploited by high-capacity neural network models.
+
+Many neural graph learning methods can be summarised as neural message passing (Gilmer et al., 2017): nodes are initialised with some representation and then exchange information by transforming their current state (in practice with a single linear layer) and sending it as a message to all neighbours in the graph. At each node, messages are aggregated in some way and then used to update the associated node representation. In this setting, the message is entirely determined by the source node (and potentially the edge type) and the target node is not taken into consideration. A (partial) exception to this is the family of Graph Attention Networks (Velickovi ˇ c et al., 2018), where ´ the agreement between source and target representation of an edge is used to determine the weight of the message in an attention architecture. However, this weight is applied to all dimensions of the message at the same time.
+
+A simple consequence of this observation may be to simply compute messages from the pair of source and target node state. However, the linear layer commonly used to compute messages would only allow additive interactions between the representations of source and target nodes. More complex transformation functions are often impractical, as computation in GNN implementations is dominated by the message transformation function.
+
+However, this need for non-trivial interaction between different information sources is a common problem in neural network design. A recent trend has been the use of hypernetworks (Ha et al., 2017), neural networks that compute the weights of other networks. In this setting, interaction between two signal sources is achieved by using one of them as the input to a hypernetwork and the other as input to the computed network. While an intellectually pleasing approach, it is often impractical because the prediction of weights of non-trivial neural networks is computationally expensive.
+
+Approaches to mitigate this exist (e.g., Wu et al. (2019) handle this in natural language processing), but are often domain-specific.
+
+A more general mitigation method is to restrict the structure of the computed network. Recently, “feature-wise linear modulations” (FiLM) were introduced in the visual question answering domain (Perez et al., 2017). Here, the hypernetwork is fed with an encoding of a question and produces an element-wise affine function that is applied to the features extracted from a picture. This can be adapted to the graph message passing domain by using the representation of the target node to compute the affine function. This compromise between expressiveness and computational feasibility has been very effective in some domains and the results presented in this article indicate that it is also a good fit for the graph domain.
+
+This article explores the use of hypernetworks in learning on graphs. Sect. 2 first reviews existing GNN models from the related work to identify commonalities and differences. This involves generalising a number of existing formalisms to new formulations that are able to handle graphs with different types of edges, which are often used to model different relationship between vertices. Then, two new formalisms are introduced: Relational Graph Dynamic Convolutional Networks (RGDCN), which dynamically compute the neural message passing function as a linear layer, and Graph Neural Networks with Feature-wise Linear Modulation (GNN-FiLM), which combine learned message passing functions with dynamically computed element-wise affine transformations. In Sect. 3, a range of baselines are compared in extensive experiments on three tasks from the literature, spanning classification, regression and ranking tasks on small and large graphs. Experiments were performed on re-implementations of existing model architectures in the same framework and hyperparameter setting searches were performed with the same computational budgets across all architectures. The results show that differences between baselines are smaller than the literature suggests and that the new FiLM model performs well on a number of interesting tasks.
+
+# 2 MODEL
+
+Notation. Let $\mathcal { L }$ be a finite (usually small) set of edge types. Then, a directed graph $\mathcal { G } = ( \nu , \mathcal { E } )$ has nodes $\nu$ and typed edges $\mathcal { E } \subseteq \mathcal { V } \times \mathcal { L } \times \mathcal { V }$ , where $( u , \ell , v ) \in \mathcal { E }$ denotes an edge from node $u$ to node $v$ of type $\ell$ , usually written as $u \xrightarrow { \ell _ { \setminus } } v$ .
+
+Graph Neural Networks. As discussed above, Graph Neural Networks operate by propagating information along the edges of a given graph. Concretely, each node $v$ is associated with an initial representation $\boldsymbol { h } _ { v } ^ { ( 0 ) }$ (for example obtained from the label of that node, or by some other model component). Then, a GNN layer updates the node representations using the node representations of its neighbours in the graph, yielding representations $\pmb { h } _ { v } ^ { ( 1 ) }$ . This process can be unrolled through time by repeatedly applying the same update function, yielding representations $h _ { v } ^ { ( 2 ) } \ldots h _ { v } ^ { ( T ) }$ . Alternatively, several GNN layers can be stacked, which is intuitively similar to unrolling through time, but increases the GNN capacity by using different parameters for each timestep.
+
+In Gated Graph Neural Networks (GGNN) (Li et al., 2016), the update rule uses one linear layer $W _ { \ell }$ per edge type $\ell$ to compute messages and combines the aggregated messages with the current representation of a node using a recurrent unit $r$ (e.g., GRU or LSTM cells), yielding the following definition.
+
+$$
+\pmb { h } _ { v } ^ { ( t + 1 ) } = r ( \pmb { h } _ { v } ^ { ( t ) } , \sum _ { u  v \in \mathcal { E } } W _ { \ell } \pmb { h } _ { u } ^ { ( t ) } ; \pmb { \theta } _ { r } )
+$$
+
+The learnable parameters of the model are the edge-type-dependent weights $W _ { \ell }$ and the recurrent cell parameters $\pmb { \theta } _ { r }$ .
+
+In Relational Graph Convolutional Networks (R-GCN) (Schlichtkrull et al., 2018), the gated unit is replaced by a simple non-linearity $\sigma$ (e.g., the hyperbolic tangent).
+
+$$
+\pmb { h } _ { v } ^ { ( t + 1 ) } = \sigma \left( \sum _ { u \not \in \mathcal { E } } \frac { 1 } { c _ { v , \ell } } \cdot W _ { \ell } \pmb { h } _ { u } ^ { ( t ) } \right)
+$$
+
+Here, $c _ { v , \ell }$ is a normalisation factor usually set to the number of edges of type $\ell$ ending in $v$ . The learnable parameters of the model are the edge-type-dependent weights $W _ { \ell }$ . It is important to note that in this setting, the edge type set $\mathcal { L }$ is assumed to contain a special edge type 0 for self-loops $v \xrightarrow { 0 } v$ , allowing state associated with a node to be kept.
+
+In Graph Attention Networks (GAT) (Velickovi ˇ c et al., 2018), new node representations are com- ´ puted from a weighted sum of neighbouring node representations. The model can be generalised from the original definitional to support different edge types as follows (we will call this R-GAT below).1
+
+$$
+\begin{array} { r l } & { \boldsymbol { e } _ { u , \ell , v } = \mathrm { L e a k y R e L U } ( \boldsymbol { \alpha } _ { \ell } \cdot ( W _ { \ell } \boldsymbol { h } _ { u } ^ { ( t ) } \| W _ { \ell } \boldsymbol { h } _ { v } ^ { ( t ) } ) ) } \\ & { \qquad \boldsymbol { a } _ { v } = \mathrm { s o f t m a x } ( \boldsymbol { e } _ { u , \ell , v } \mid \boldsymbol { u } \xrightarrow { \ell } \boldsymbol { v } \in \mathcal { E } ) } \\ & { \quad \boldsymbol { h } _ { v } ^ { ( t + 1 ) } = \sigma \left( \displaystyle \sum _ { u \xrightarrow { \ell } v \in \mathcal { E } } ( \boldsymbol { a } _ { v } ) _ { u \xrightarrow { \ell } v } \cdot W _ { \ell } \boldsymbol { h } _ { u } ^ { ( t ) } \right) } \end{array}
+$$
+
+Here, $\pmb { \alpha } _ { \ell }$ is a learnable row vector used to weigh different feature dimensions in the computation of an attention (“relevance”) score of the node representations, $\mathbf { \Delta x } \Vert \mathbf { \Delta y }$ is the concatenation of vectors $_ { \textbf { \em x } }$ and $\textbf {  { y } }$ , and $( \pmb { a } _ { v } ) _ { u } \mathcal { L } _ { v }$ refers to the weight computed by the softmax for that edge. The learnable parameters of the model are the edge-type-dependent weights $W _ { \ell }$ and the attention parameters $\pmb { \alpha } _ { \ell }$ . In practice, GATs usually employ several attention heads that independently implement the mechanism above in parallel, using separate learnable parameters. The results of the different attention heads are then concatenated after each propagation round to yield the value of $h _ { v } ^ { ( t + 1 ) }$ .
+
+More recently, $\mathrm { X u }$ et al. (2019) analysed the expressiveness of different GNN types, comparing their ability to distinguish similar graphs with the Weisfeiler-Lehman (WL) graph isomorphism test. Their results show that GCNs and the GraphSAGE model Hamilton et al. (2017) are strictly weaker than the WL test and hence they developed Graph Isomorphism Networks (GIN) (Xu et al., 2019), which are indeed as powerful as the WL test. While the GIN definition is limited to a single edge type, Corollary 6 of $\mathrm { X u }$ et al. (2019) shows that using the definition
+
+$$
+\pmb { h } _ { v } ^ { ( t + 1 ) } = \varphi ( ( 1 + \epsilon ) \cdot f ( \pmb { h } _ { v } ^ { ( t ) } ) + \sum _ { u  v \in \mathcal { E } } f ( \pmb { h } _ { u } ^ { ( t ) } ) ) ,
+$$
+
+there are choices for $\epsilon$ , $\varphi$ and $f$ such that the node representation update is sufficient for the overall network to be as powerful as the WL test. In the setting of different edge types, the function $f$ in the sum over neighbouring nodes needs to reflect different edge types to distinguish graphs such as $v \ \bot \rangle \ u \ \ll \ w$ and $v \ \bar { 2 } \gg \ u \ \ll \ w$ from each other. Using different functions $f _ { \ell }$ for different edge types makes it possible to unify the use of the current node representation $h _ { v } ^ { ( t ) }$ with the use of neighbouring node representations by again using a fresh edge type 0 for self-loops $v \ a \ $ . In that setting, the factor $( 1 + \epsilon )$ can be integrated into $f _ { 0 }$ . Finally, following an argument similar to $\mathrm { X u }$ et al. (2019), $\varphi$ and $f$ at subsequent layers can be “merged” into a single function which can be approximated by a multilayer perceptron (MLP), yielding the final R-GIN definition
+
+$$
+\pmb { h } _ { v } ^ { ( t + 1 ) } = \sigma \left( \sum _ { u \downarrow v \in \mathcal { E } } M L P ( \pmb { h } _ { u } ^ { ( t ) } ; \pmb { \theta } _ { \ell } ) \right) .
+$$
+
+The learnable parameters here are the edge-specific weights $\pmb { \theta } _ { \ell }$ . Note that Eq. (4) is very similar to the definition of R-GCNs (Eq. (2)), only dropping the normalisation factor $\frac { \hat { \mathbf { 1 } } } { c _ { v , \ell } }$ and replacing linear layers by an MLP.
+
+While many more GNN variants exist, the four formalisms above are broadly representative of general trends. It is notable that in all of these models, the information passed from one node to another is based on the learned weights and the representation of the source of an edge. In contrast, the representation of the target of an edge is only updated (in the GGNN case Eq. (1)), treated as another incoming message (in the R-GCN case Eq. (2) and the R-GIN case Eq. (4)), or used to weight the relevance of an edge (in the R-GAT case Eq. (3)). Sometimes unnamed GNN variants of the above are used (e.g., by Selsam et al. (2019); Paliwal et al. (2019)), replacing the linear layers to compute the messages for each edge by MLPs applied to the concatenation of the representations of source and target nodes. In the experiments, this will be called GNN-MLP, formally defined as follows.2
+
+$$
+\pmb { h } _ { v } ^ { ( t + 1 ) } = \sigma \left( \sum _ { u \xrightarrow [ ] { \ell } v \in \mathcal { E } } \frac { 1 } { c _ { v , \ell } } \cdot M L P \left( \pmb { h } _ { u } ^ { ( t ) } \| \pmb { h } _ { v } ^ { ( t ) } \ ; \ \pmb { \theta } _ { \ell } \right) \right)
+$$
+
+Below, we will instantiate the $M L P$ with a single linear layer to obtain what we call GNN-MLP0, which only differs from R-GCNs (Eq. (2)) in that the message passing function is applied to the concatenation of source and target state.
+
+# 2.1 GRAPH HYPERNETWORKS
+
+Hypernetworks (i.e., neural networks computing the parameters of another neural network) (Ha et al., 2017) have been successfully applied to a number of different tasks; naturally raising the question if they are also applicable in the graph domain.
+
+Intuitively, a hypernetwork corresponds to a higher-order function, i.e., it can be viewed as a function computing another function. Hence, a natural idea would be to use the target of a message propagation step to compute the function computing the message; essentially allowing it to focus on features that are especially relevant for the update of the target node representation.
+
+Relational Graph Dynamic Convolutional Networks (RGDCN) A first attempt would be to adapt (2) to replace the learnable message transformation $W _ { \ell }$ by the result of some learnable function $f$ that operates on the target representation:
+
+$$
+\pmb { h } _ { v } ^ { ( t + 1 ) } = \sigma \left( \sum _ { u \downarrow v \in \mathcal { E } } f ( \pmb { h } _ { v } ^ { ( t ) } ; \pmb { \theta } _ { f , \ell } ) \pmb { h } _ { u } ^ { ( t ) } \right)
+$$
+
+However, for a representation size $D$ , $f$ would need to produce a matrix of size $D ^ { 2 }$ from $D$ inputs. Hence, if implemented as a simple linear layer, $f$ would have on the order of $\mathcal { O } ( D ^ { 3 } )$ parameters, quickly making it impractical in most contexts.
+
+This can be somewhat mitigated by splitting the node representations $h _ { v } ^ { ( t ) }$ into $C$ “chunks” $h _ { v , c } ^ { ( t ) }$ of dimension $\begin{array} { r } { K = { \frac { D } { C } } } \end{array}$ :
+
+$$
+\begin{array} { r l } & { W _ { \ell , t , v , c } = f ( \pmb { h } _ { v } ^ { ( t ) } ; \pmb { \theta } _ { f , \ell , c } ) } \\ & { \qquad \mathbf { h } _ { v } ^ { ( t + 1 ) } = \displaystyle \operatorname* { l i } _ { 1 \leq c \leq C } \sigma \left( \sum _ { u } \pounds _ { v \in \mathcal { E } } W _ { \ell , t , v , c } \pmb { h } _ { u , c } ^ { ( t ) } \right) } \end{array}
+$$
+
+The number of parameters of the model can now be reduced by tying the value of some instances of $\theta _ { f , \ell , c }$ . For example, the update function for a chunk $c$ can be computed using only the corresponding chunk of the node representation $h _ { v , c } ^ { ( t ) }$ , or the same update function can be applied to all “chunks” by setting $\pmb { \theta } _ { f , \ell , 1 } = . . . = \pmb { \theta } _ { f , \ell , C }$ . The learnable parameters of the model are only the hypernetwork parameters $\theta _ { f , \ell , c }$ . This is somewhat less desirable than the related idea of Wu et al. (2019), which operates on sequences, where sharing between neighbouring elements of the sequence has an intuitive interpretation that is not applicable in the general graph setting.
+
+Graph Neural Networks with Feature-wise Linear Modulation (GNN-FiLM) In (6), the message passing layer is a linear transformation conditioned on the target node representation, focusing on separate chunks of the node representation at a time. In the extreme case in which the dimension of each chunk is 1, this method coincides with the ideas of Perez et al. (2017), who propose to use layers of element-wise affine transformations to modulate feature maps in the visual question answering setting; there, a natural language question is the input used to compute the affine transformation applied to the features extracted from a picture.
+
+In the graph setting, we can use each node’s representation as an input that determines an elementwise affine transformation of incoming messages, allowing the model to dynamically up-weight and down-weight features based on the information present at the target node of an edge. This yields the following update rule, using a learnable function $g$ to compute the parameters of the affine transformation.
+
+$$
+\begin{array} { r l } & { \beta _ { \ell , v } ^ { ( t ) } , \gamma _ { \ell , v } ^ { ( t ) } = g ( \pmb { h } _ { v } ^ { ( t ) } ; \pmb { \theta } _ { g , \ell } ) } \\ & { \quad \pmb { h } _ { v } ^ { ( t + 1 ) } = \sigma \left( \displaystyle \sum _ { u \in \mathcal { E } } \gamma _ { \ell , v } ^ { ( t ) } \odot W _ { \ell } \pmb { h } _ { u } ^ { ( t ) } + \beta _ { \ell , v } ^ { ( t ) } \right) } \end{array}
+$$
+
+The learnable parameters of the model are both the hypernetwork parameters $\theta _ { g , \ell }$ and the weights $W _ { \ell }$ . In practice, implementing $g$ as a single linear layer works well.
+
+In the case of using a single linear layer, the resulting message passing function is bilinear in source and target node representation, as the message computation is centred around $( W _ { g } \pmb { h } _ { v } ^ { ( t ) } ) \odot ( W _ { \ell } \pmb { h } _ { u } ^ { ( t ) } )$ . This is the core difference to the (linear) interaction of source and target node representations in models that use $W _ { \ell } ( \pmb { h } _ { u } ^ { ( t ) } | | \pmb { h } _ { v } ^ { ( t ) } )$ .
+
+A simple toy example may illustrate the usefulness of such a mechanism: assuming a graph of nodes $\nu _ { A }$ and $\gamma _ { B }$ and edge types 1 and 2, a task may involve counting the number of 1-neighbours of $\nu _ { A }$ nodes and of 2-neighbours of $\gamma _ { B }$ nodes. By setting $\gamma _ { 1 , v _ { a } } = 1$ , $\gamma _ { 2 , v _ { a } } = 0$ for $v _ { a } \in \mathcal { V } _ { A }$ and $\gamma _ { 1 , v _ { b } } = 0$ , $\gamma _ { 2 , v _ { b } } = 1$ for $v _ { b } \in \mathcal { V } _ { B }$ , GNN-FiLM can solve this in a single layer. Simpler approaches can solve this by counting $A / 1 , A / 2 , B / 1$ and $B / 2$ neighbours separately in one layer and then projecting to the correct counter, but require more feature dimensions and layers for this. As this toy example illustrates, a core capability of GNN-FiLM is to learn to ignore graph edges based on the representation of target nodes.
+
+Note that the featurewise modulation can also be viewed of an extension of the gating mechanism of GRU or LSTM cells used in GGNNs. Concretely, the “forgetting” of memories in a GRU/LSTM is similar to down-weighting messages computed for the self-loop edges and the gating of the cell input is similar to the modulation of other incoming messages. However, GGNNs apply this gating to the sum of all incoming messages (cf. Eq. (1), wheras in GNN-FiLM the modulation additionally depends on the edge type, allowing for a more fine-grained gating mechanism.
+
+Finally, a small implementation bug brought focus to the fact that applying the non-linearity $\sigma$ after summing up messages from neighbouring nodes can make it harder to perform tasks such as counting the number of neighbours with a certain feature. In experiments, applying the non-linearity before aggregation as in the following update rule improved performance.
+
+$$
+\pmb { h } _ { v } ^ { ( t + 1 ) } = l \left( \sum _ { u \downarrow } \sigma _ { v \in \mathcal { E } } \sigma \left( \gamma _ { \ell , v } ^ { ( t ) } \odot W _ { \ell } \pmb { h } _ { u } ^ { ( t ) } + \beta _ { \ell , v } ^ { ( t ) } \right) ; \pmb { \theta } _ { l } \right)
+$$
+
+However, this means that the magnitude of node representations is now dependent on the degree of nodes in the handled graph. This can sometimes lead to instability during training, which can in turn be controlled by adding an additional layer $l$ after message passing, which can be a simple bounded nonlinearity (e.g. tanh), a fully connected layer, or layer normalisation (Ba et al., 2016), or any combination of these.
+
+# 3 EVALUATION
+
+# 3.1 GNN BENCHMARK TASKS
+
+Due to the versatile nature of the GNN modelling formalism, many fundamentally different tasks are studied in the research area and it should be noted that good results on one task often do not transfer over to other tasks. This is due to the widely varying requirements of different tasks, as the following summary of tasks from the literature should illustrate.
+
+• Cora/Citeseer/Pubmed (Sen et al., 2008): Each task consists of a single graph of $\sim 1 0 0 0 0$ nodes corresponding to documents and undirected (sic!) edges corresponding to references. The sparse $\sim 1 0 0 0$ node features are a bag of words representation of the corresponding documents. The goal is to assign a subset of nodes to a small number of classes. State of the art performance on these tasks is achieved with two propagation steps along graph edges.
+
+• PPI (Zitnik & Leskovec, 2017): A protein-protein interaction dataset consisting of 24 graphs of $\sim \ 2 5 0 0$ nodes corresponding to different human tissues. Each node has 50 features selected by domain experts and the goal is node-level classification, where each node may belong to several of the 121 classes. State of the art performance on this task requires three propagation steps. QM9 property prediction (Ramakrishnan et al., 2014): $\sim 1 3 0 0 0 0$ graphs of $\sim 8$ nodes represent molecules, where nodes are heavy atoms and undirected, typed edges are bonds between these atoms, different edge types indicating single/double/etc. bonds. The goal is to regress each graph to a number of quantum chemical properties. State of the art performance on these tasks requires at least four propagation steps. VarMisuse (Allamanis et al., 2018): $\sim 2 3 5 0 0 0$ graphs of $\sim 2 5 0 0$ nodes each represent program fragments, where nodes are tokens in the program text and different edge types represent the program’s abstract syntax tree, data flow between variables, etc. The goal is to select one of a set of candidate nodes per graph. State of the art performance requires at least six propagation steps.
+
+Hence, tasks differ in the complexity of edges (from undirected and untyped to directed and manytyped), the size of the considered graphs, the size of the dataset, the importance of node-level vs. graph-level representations, and the number of required propagation steps.
+
+This article includes results on the PPI, QM9 and VarMisuse tasks. Preliminary experiments on the citation network data showed results that were at best comparable to the baseline methods, but changes of a random seed led to substantial fluctuations (mirroring the problems with evaluation on these tasks reported by Shchur et al. (2018)).
+
+# 3.2 IMPLEMENTATION
+
+To allow for a wider comparison, the implementation of GNN-FiLM is accompanied by implementations of a range of baseline methods. These include GGNN (Li et al., 2016) (see Eq. (1)), R-GCN (Schlichtkrull et al., 2018) (see Eq. (2)), R-GAT (Velickovi ˇ c et al., 2018) (see Eq. ´ (3)), and R-GIN (Hamilton et al., 2017) (see Eq. (4))3. Additionally, GNN-MLP0 is a variant of R-GCN using a single linear layer to compute the edge message from both source and target state (i.e., Eq. (5) instantiated with an “MLP” without hidden layers), and GNN-MLP1 is the same with a single hidden layer. The baseline methods were re-implemented in TensorFlow and individually tested to reach performance equivalent to results reported in their respective source papers. All code for the implementation of these GNNs is released on https://revealed/after/double/blind/ lifted, together with implementations of all tasks and scripts necessary to reproduce the results reported in this paper. This includes the hyperparameter settings found by search, which are stored in tasks/default hypers/ and are selected by default on the respective tasks. The code is designed to facilitate testing new GNN types on existing tasks and easily adding new tasks, allowing for rapid evaluation of new architectures.
+
+Early on in the experiments, it became clear that the RGDCN approach (Eq. (6)) as presented is infeasible. It is extremely sensitive to the parameter initialisation and hence changes to the random seed lead to wild swings in the target metrics. Hence, no experimental results are reported for it in the following. It is nonetheless included in the article (and the implementation) to show the thought process leading to GNN-FiLM, as well as to allow other researchers to build upon this. In the following, GNN-FiLM refers to the formulation of Eq. (8), which performed better than the variant of Eq. (7) across all experiments. Somewhat surprisingly, the same trick (of moving the non-linearity before the message aggregation step) did not help the other GNN types. For all models, using each layer only for a single propagation step performed better than using fewer layers with several propagation steps.
+
+In all experiments, models were trained until the target metric did not improve anymore for some additional epochs (25 for PPI and QM9, 5 for VarMisuse). The reported results on the held-out test data are averaged across the results of a number of training runs, each starting from different random parameter initializations.
+
+# 3.3 EXPERIMENTAL RESULTS
+
+# 3.3.1 PROTEIN-PROTEIN INTERACTIONS (PPI)
+
+The models are first evaluated on the node-level classification PPI task (Zitnik & Leskovec, 2017), following the dataset split from earlier papers. Training hence used a set of 20 graphs and validation and test sets of two separate graphs each. The graphs use two edge types: the dataset-provided untyped edges as well as a fresh “self-loop” edge type to allows nodes to keep state across propagation steps.
+
+Hyperparameters for all models were selected based on results from earlier papers and a small grid search of a number of author-selected hyperparameter ranges (see App. A for details). This resulted in three (R-GAT), four (GGNN, GNN-FiLM, GNN-MLP1, R-GCN), or five (GNN-MLP0, R-GIN) layers (propagation steps) and a node representation size of 256 (GNN-MLP0, R-GIN) or 320 (all others). All models use dropout on the node representations before all GNN layers, with a keep ratio of 0.9. After selecting hyperparameters, all models were trained ten times with different random seeds on a NVidia V100.
+
+Tab. 1 shows the micro-averaged F1 score on the classification task on the test graphs, with standard deviations and training times in seconds computed over the ten runs. The results for all re-implemented models are better than the results reported by Velickovi ˇ c et al. (2018) ´ for the GAT model (without edge types). A cursory exploration of the reasons yielded three factors. First, the generalisation to different edge types (cf. Eq. (3)) and the subsequent use of a special self-loop edge type helps R-GAT (and all other models) significantly. Second, using dropout between layers significantly im
+
+Table 1: GNN results on PPI task. $\mathrm { G A T ^ { * } }$ result taken from Velickovi ˇ c et al. (2018). ´   
+
+<table><tr><td>Model</td><td>Avg. Micro-F1</td><td>Time (s)</td></tr><tr><td>GAT*</td><td>0.973 ±0.002</td><td>n/a</td></tr><tr><td>GGNN</td><td>0.990 ±0.001</td><td>432.6</td></tr><tr><td>R-GCN</td><td>0.989 ±0.000</td><td>759.0</td></tr><tr><td>R-GAT</td><td>0.989 ±0.001</td><td>782.3</td></tr><tr><td>R-GIN</td><td>0.991 ±0.001</td><td>704.8</td></tr><tr><td>GNN-MLP0</td><td>0.992±0.000</td><td>556.9</td></tr><tr><td>GNN-MLP1</td><td>0.992±0.001</td><td>479.2</td></tr><tr><td>GNN-FiLM</td><td>0.992±0.000</td><td>308.1</td></tr></table>
+
+proved the results. Third, the larger node representation sizes (compared to 256 used by Velickovi ˇ c´ et al. (2018)) improved the results again. However, the new GNN-FiLM improves slightly over these four baselines from the literature, while converging substantially faster than all baselines, mainly because it converges in significantly fewer training steps (approx. 240 epochs compared to 400-600 epochs for the other models).
+
+# 3.3.2 QUANTUM CHEMISTRY (QM9)
+
+All models were additionally evaluated on graph-level regression tasks on the QM9 molecule data set (Ramakrishnan et al., 2014), considering thirteen different quantum chemical properties. The ${ \sim } 1 3 0 k$ molecular graphs in the dataset were split into training, validation and test data by randomly selecting 10 000 graphs for the latter two sets. Additionally, another data split without a test set was used for the hyperparameter search (see below). The graphs use five edge types: the datasetprovided typed edges (single, double, triple and aromatic bonds between atoms) as well as a fresh “self-loop” edge type that allows nodes to keep state across propagation steps. The evaluation differs from the setting reported by Gilmer et al. (2017), as no additional molecular information is encoded as edge features, nor are the graphs augmented by master nodes or additional edges.4
+
+Hyperparameters for all models were found using a staged search process. First, 500 hyperparameter configurations were sampled from an author-provided search space (see App. A for details) and run on the first three regression tasks. The top three configurations for each of these three tasks were then run on all thirteen tasks and the final configuration was chosen as the one with the lowest average mean absolute error across all properties, as evaluated on the validation data of that dataset split. This process led to eight layers / propagation steps for all models but GGNN and R-GIN, which showed best performance with six layers. Furthermore, all models used residual connections connecting every second layer and GGNN, R-GCN, GNN-FiLM and GNN-MLP0 additionally used layer normalisation (as in Eq. (8)).
+
+Table 2: GNN average error rates and standard deviations on QM9 target values.   
+
+<table><tr><td>Property</td><td>GGNN</td><td>R-GCN</td><td>R-GAT</td><td>R-GIN</td><td>GNN-MLP0</td><td>GNN-MLP1</td><td>GNN-FiLM</td></tr><tr><td>mu</td><td>3.85 ±0.16</td><td>3.21 ±0.06</td><td>2.68 ±0.06</td><td>2.64 ±0.11</td><td>2.36 ±0.04</td><td>2.44 ±0.12</td><td>2.38 ±0.13</td></tr><tr><td>alpha</td><td>5.22 ±0.86</td><td>4.22 ±0.45</td><td>4.65 ±0.44</td><td>4.67 ±0.52</td><td>4.27 ±0.36</td><td>4.63 ±0.54</td><td>3.75 ±0.11</td></tr><tr><td>HOMO</td><td>1.67 ±0.07</td><td>1.45 ±0.01</td><td>1.48 ±0.03</td><td>1.42 ±0.01</td><td>1.25 ±0.04</td><td>1.29 ±0.06</td><td>1.22 ±0.07</td></tr><tr><td>LUMO</td><td>1.74 ±0.06</td><td>1.62 ±0.04</td><td>1.53 ±0.07</td><td>1.50 ±0.09</td><td>1.35 ±0.04</td><td>1.50 ±0.19</td><td>1.30 ±0.05</td></tr><tr><td>gap</td><td>2.60 ±0.06</td><td>2.42 ±0.14</td><td>2.31 ±0.06</td><td>2.27 ±0.09</td><td>2.04 ±0.05</td><td>2.06 ±0.10</td><td>1.96 ±0.06</td></tr><tr><td>R2</td><td>35.94 ±35.68</td><td>16.38 ±0.49</td><td>52.39 ±42.58</td><td>15.63 ±1.40</td><td>14.86 ±1.62</td><td>15.81 ±1.42</td><td>15.59 ±1.38</td></tr><tr><td>ZPVE</td><td>17.84 ±3.61</td><td>17.40 ±3.56</td><td>14.87 ±2.88</td><td>12.93 ±1.81</td><td>12.00 ±1.66</td><td>14.12 ±1.10</td><td>11.00 ±0.74</td></tr><tr><td>UO</td><td>8.65 ±2.46</td><td>7.82 ±0.80</td><td>7.61 ±0.46</td><td>5.88 ±1.01</td><td>5.55 ±0.38</td><td>6.94 ±0.64</td><td>5.43 ±0.96</td></tr><tr><td>U</td><td>9.24 ±2.26</td><td>8.24 ±1.25</td><td>6.86 ±0.53</td><td>18.71 ±23.36</td><td>6.20 ±0.88</td><td>7.00 ±1.06</td><td>5.95 ±0.46</td></tr><tr><td>H</td><td>9.35 ±0.96</td><td>9.05 ±1.21</td><td>7.64 ±0.92</td><td>5.62 ±0.81</td><td>5.96 ±0.45</td><td>7.98 ±0.88</td><td>5.59 ±0.57</td></tr><tr><td>G</td><td>7.14 ±1.15</td><td>7.00 ±1.51</td><td>6.54 ±0.36</td><td>5.38±0.75</td><td>5.09 ±0.57</td><td>7.14 ±0.51</td><td>5.17 ±1.13</td></tr><tr><td>Cv</td><td>8.86 ±9.07</td><td>3.93 ±0.48</td><td>4.11 ±0.27</td><td>3.53 ±0.37</td><td>3.38 ±0.20</td><td>4.60 ±0.74</td><td>3.46 ±0.21</td></tr><tr><td>Omega</td><td>1.57 ±0.53</td><td>1.02 ±0.05</td><td>1.48 ±0.87</td><td>1.05 ±0.11</td><td>0.84±0.02</td><td>5.60 ±8.82</td><td>0.98 ±0.06</td></tr></table>
+
+Table 3: Accuracy on VarMisuse task. GGNN∗ result taken from appendix of Allamanis et al. (2018).   
+
+<table><tr><td>Model</td><td>TRAIN</td><td>VALID</td><td>SEENPROJTEST</td><td>UNSEENPROJTEST</td></tr><tr><td>GGNN*</td><td>n/a</td><td>n/a</td><td>84.0 n/a</td><td>74.1 n/a</td></tr><tr><td>GGNN</td><td>87.5±1.8%</td><td>82.1±0.9%</td><td>85.7 ±0.5%</td><td>79.3 ±1.2%</td></tr><tr><td>R-GCN</td><td>88.7±3.1%</td><td>85.7±1.6%</td><td>87.2±1.5%</td><td>81.4±2.3%</td></tr><tr><td>R-GAT</td><td>90.4±3.9%</td><td>84.2±1.0%</td><td>86.9 ±0.7%</td><td>81.2 ±0.9%</td></tr><tr><td>R-GIN</td><td>93.4±1.8%</td><td>84.2±1.0%</td><td>87.1 ±0.1%</td><td>81.1 ±0.9%</td></tr><tr><td>GNN-MLP0</td><td>95.3±2.4%</td><td>83.4±0.3%</td><td>86.5 ±0.2%</td><td>80.5 ±1.4%</td></tr><tr><td>GNN-MLP1</td><td>94.7±1.2%</td><td>84.4±0.4%</td><td>86.9 ±0.3%</td><td>81.4±0.7%</td></tr><tr><td>GNN-FiLM</td><td>94.3±1.0%</td><td>84.6±0.6%</td><td>87.0 ±0.2%</td><td>81.3 ±0.9%</td></tr></table>
+
+Each model was trained for each of the properties separately five times using different random seeds on compute nodes with NVidia P100 cards. The average results of the five runs are reported in Tab. 2, with their respective standard deviations.5 The results indicate that the new GNN-FiLM model outperforms the standard baselines on all tasks and the usually not considered GNN-MLP variants on the majority of tasks.
+
+# 3.3.3 VARIABLE USAGE IN PROGRAMS (VARMISUSE)
+
+Finally, the models were evaluated on the VarMisuse task of Allamanis et al. (2018). This task requires to process a graph representing an abstraction of a program fragment and then select one of a few candidate nodes (representing program variables) based on the representation of another node (representing the location to use a variable in). The experiments are performed using the released split of the dataset, which contains $\sim 1 3 0 k$ training graphs, $\sim 2 0 k$ validation graphs and two test sets: SEENPROJTEST, which contains $\sim 5 5 k$ graphs extracted from open source projects that also contributed data to the training and validation sets, and UNSEENPROJTEST, which contains $\sim 3 0 k$ graphs extracted from completely unseen projects.
+
+Due to the inherent cost of training models on this dataset (Balog et al. (2019) provide an in-depth performance analysis), a limited hyperparameter grid search was performed, with only $\sim 3 0$ candidate configurations for each model (see App. A for details). For each model, the configuration yielding the best results on the validation data set fold was selected. This led to six layers for GGNN and R-GIN, eight layers for R-GAT and GNN-MLP0, and ten layers for the remaining models. Graph node hidden sizes were 128 for all models but GGNN and R-GAT, which performed better with 96 dimensions.
+
+The results, shown in Tab. 3, are somewhat surprising, as they indicate a different ranking of model architectures as the results on PPI and QM9, with R-GCN performing best. All re-implemented baselines beat the results reported by Allamanis et al. (2018), who also reported that R-GCN and GGNN show very similar performance. This is in spite of a simpler implementation of the task than in the original paper, as it only uses the string labels of nodes for the representation and does not use the additional type information provided in the dataset. However, the re-implementation of the task uses the insights from Cvitkovic et al. (2019), who use character CNNs to encode node labels and furthermore introduce extra nodes for subtokens appearing in labels of different nodes, connecting them to their sources (e.g., nodes labelled openWullfrax and closeWullfrax are both connected to a fresh Wullfrax node).
+
+A deeper investigation results showed that the more complex models seem to suffer from significant overfitting to the training data, as can be seen in the results for training and validation accuracy reported in Tab. 3. A brief exploration of more aggressive regularisation methods (more dropout, weight decay) showed no improvement and a deeper understanding of the cause of these results remains for future work.
+
+Furthermore, the large variance in results on the validation set (especially for R-GCN) makes it likely that the hyperparameter grid search with only one training run per configuration did not yield the best configuration for each model.
+
+# 4 DISCUSSION & CONCLUSIONS
+
+After a review of existing graph neural network architectures, the idea of using hypernetworkinspired models in the graph setting was explored. This led to two models, Graph Dynamic Convolutional Networks and GNNs with feature-wise linear modulation, were presented. While GDCNs seem to be impractical to train, experiments show that GNN-FiLM is competitive with or improving on baseline models on three tasks from the literature.
+
+The extensive experiments also show that a number of results from the literature could benefit from more substantial hyperparameter search and are often missing comparisons to a number of obvious baselines:
+
+• The results in Tab. 1 indicate that GATs have no advantage over GGNNs or R-GCNs on the PPI task, which does not match the findings by Velickovi ˇ c et al. (2018). ´ • The results in Tab. 3 indicate that R-GCNs are outperforming GGNNs substantially on the VarMisuse task, contradicting the findings of Allamanis et al. (2018). • The GNN-MLP models are obvious extensions that are often alluded to, but are not part of the usually considered set of baseline models. Nonetheless, experiments across all three tasks have shown that these methods outperform better-published techniques such as GGNNs, R-GCNs and GATs, without a substantial runtime penalty.
+
+These results indicate that there is substantial value in independent reproducibility efforts and comparisons that include “obvious” baselines, matching the experiences from other areas of machine learning as well as earlier work by Shchur et al. (2018) on reproducing experimental results for GNNs on citation network tasks.
+
+# REFERENCES
+
+Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations (ICLR), 2018.
+
+Lei Jimmy Ba, Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. CoRR, abs/1607.06450, 2016.
+
+Matej Balog, Bart van Merrienboer, Subhodeep Moitra, Yujia Li, and Daniel Tarlow. Fast training ¨ of sparse graph neural networks on dense hardware. CoRR, abs/1906.11786, 2019.
+
+Dan Busbridge, Dane Sherburn, Pietro Cavallo, and Nils Y. Hammerla. Relational graph attention networks. CoRR, abs/1904.05811, 2019.
+
+Milan Cvitkovic, Badal Singh, and Anima Anandkumar. Open vocabulary learning on source code with a graph-structured cache. In International Conference on Machine Learning (ICML), 2019.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning (ICML), 2017.
+
+David Ha, Andrew M. Dai, and Quoc V. Le. HyperNetworks. In International Conference on Learning Representations (ICLR), 2017.
+
+William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems (NeurIPS), 2017.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR), 2016.
+
+Aditya Paliwal, Sarah M. Loos, Markus N. Rabe, Kshitij Bansal, and Christian Szegedy. Graph representations for higher-order logic and theorem proving. CoRR, abs/1905.10006, 2019.
+
+Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. FiLM: Visual reasoning with a general conditioning layer. In AAAI Conference on Artificial Intelligence, 2017.
+
+Raghunathan Ramakrishnan, Pavlo O. Dral, Matthias Rupp, and O. Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific Data, 1, 2014.
+
+Michael Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional network. In Extended Semantic Web Conference (ESWC), 2018.
+
+Daniel Selsam, Matthew Lamm, Benedikt Bunz, Percy Liang, Leonardo de Moura, and David L. ¨ Dill. Learning a SAT solver from single-bit supervision. In International Conference on Learning Representations (ICLR), 2019.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29, 2008.
+
+Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Gunnemann. Pitfalls ¨ of graph neural network evaluation. CoRR, abs/1811.05868, 2018.
+
+Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li ´ o, and Yoshua \` Bengio. Graph Attention Networks. In International Conference on Learning Representations (ICLR), 2018.
+
+Felix Wu, Angela Fan, Alexei Baevski, Yann Dauphin, and Michael Auli. Pay less attention with lightweight and dynamic convolutions. In International Conference on Learning Representations (ICLR), 2019.
+
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations (ICLR), 2019.
+
+Marinka Zitnik and Jure Leskovec. Predicting multicellular function through multi-layer tissue networks. Bioinformatics, 33, 2017.
+
+# A HYPERPARAMETER SEARCH SPACES
+
+A.1 PPI
+
+For all models, a full grid search considering all combinations of the following parameters was performed:
+
+• hidden siz $\textsf { e } \in \{ 1 9 2 , 2 5 6 , 3 2 0 \}$ - size of per-node representations. • graph num layers $\in \{ 2 , 3 , 4 , 5 \}$ - number of propagation steps / layers. • graph layer input dropout keep prob $\in \ \{ 0 . 8 , 0 . 9 , 1 . 0 \}$ - dropout applied before propagation steps.
+
+# A.2 QM9
+
+For all models, 500 configurations were considered, sampling hyperparameter settings uniformly from the following options:
+
+• hidden siz $\textsf { e } \in \{ 6 4 , 9 6 , 1 2 8 \}$ - size of per-node representations.   
+• graph num layers $\in \{ 4 , 6 , 8 \}$ - number of propagation steps / layers.   
+• graph layer input dropout keep prob $\in \ \{ 0 . 8 , 0 . 9 , 1 . 0 \}$ - dropout applied before propagation steps.   
+• layer norm $\in \{ T r u e , F a l s e \}$ - decided if layer norm is applied after each propagation step.   
+• dense layers $\in \{ 1 , 2 , 3 2 \}$ - insert a fully connected layer applied to node representations between every dense layers propagation steps. (32 effectively turns this off) res connection $\in \quad \{ 1 , 2 , 3 2 \}$ - insert a residual connection between every res connection propagation steps. (32 effectively turns this off)   
+• graph activation function $\in$ {relu, leaky relu, elu, gelu, tanh} - non-linearity applied after message passing.   
+• optimizer $\in \{ R M S P r o p , A d a m \}$ - optimizer used (with TF 1.13.1 default parameters).   
+• $\mathtt { l r } \in [ 0 . 0 0 0 5 , 0 . 0 0 1 ]$ - learning rate.   
+• $\mathsf { c e l 1 } \in \{ R N N , G R U , L S T M \}$ - gated cell used for GGNN (only part of search space for GGNN).   
+• num heads $\in \{ 4 , 8 , 1 6 \}$ - number of attention heads used for R-GAT (only part of search space for R-GAT).
+
+# A.3 VARMISUSE
+
+For all models, a full grid search considering all combinations of the following parameters was performed:
+
+• hidden si $z \in \{ 6 4 , 9 6 , 1 2 8 \}$ - size of per-node representations.   
+• graph num layers $\in \{ 6 , 8 , 1 0 \}$ - number of propagation steps / layers. graph layer input dropout keep prob $\in \ \{ 0 . 8 , 0 . 9 , 1 . 0 \}$ - dropout applied before propagation steps.   
+$\mathsf { c e l 1 } \in \mathsf { \Omega } \{ G R U , L S T M \}$ - gated cell used for GGNN (only part of search space for GGNN).   
+• num heads $\in \ \{ 4 , 8 \}$ - number of attention heads used for R-GAT (only part of search space for R-GAT).

parse/train/HJe4Cp4KwH/HJe4Cp4KwH_content_list.json

@@ -0,0 +1,1396 @@
+[
+    {
+        "type": "text",
+        "text": "GNN-FILM: GRAPH NEURAL NETWORKS WITH FEATURE-WISE LINEAR MODULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper presents a new Graph Neural Network (GNN) type using feature-wise linear modulation (FiLM). Many standard GNN variants propagate information along the edges of a graph by computing “messages” based only on the representation of the source of each edge. In GNN-FiLM, the representation of the target node of an edge is additionally used to compute a transformation that can be applied to all incoming messages, allowing feature-wise modulation of the passed information. ",
+        "bbox": [
+            233,
+            263,
+            764,
+            361
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Results of experiments comparing different GNN architectures on three tasks from the literature are presented, based on re-implementations of baseline methods. Hyperparameters for all methods were found using extensive search, yielding somewhat surprising results: differences between baseline models are smaller than reported in the literature. Nonetheless, GNN-FiLM outperforms baseline methods on a regression task on molecular graphs and performs competitively on other tasks. ",
+        "bbox": [
+            233,
+            363,
+            764,
+            459
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            482,
+            336,
+            498
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning from graph-structured data has seen explosive growth over the last few years, as graphs are a convenient formalism to model the broad class of data that has objects (treated as vertices) with some known relationships (treated as edges). Example usages include reasoning about physical and biological systems, knowledge bases, computer programs, and relational reasoning in computer vision tasks. This graph construction is a highly complex form of feature engineering, mapping the knowledge of a domain expert into a graph structure which can be consumed and exploited by high-capacity neural network models. ",
+        "bbox": [
+            174,
+            513,
+            825,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many neural graph learning methods can be summarised as neural message passing (Gilmer et al., 2017): nodes are initialised with some representation and then exchange information by transforming their current state (in practice with a single linear layer) and sending it as a message to all neighbours in the graph. At each node, messages are aggregated in some way and then used to update the associated node representation. In this setting, the message is entirely determined by the source node (and potentially the edge type) and the target node is not taken into consideration. A (partial) exception to this is the family of Graph Attention Networks (Velickovi ˇ c et al., 2018), where ´ the agreement between source and target representation of an edge is used to determine the weight of the message in an attention architecture. However, this weight is applied to all dimensions of the message at the same time. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A simple consequence of this observation may be to simply compute messages from the pair of source and target node state. However, the linear layer commonly used to compute messages would only allow additive interactions between the representations of source and target nodes. More complex transformation functions are often impractical, as computation in GNN implementations is dominated by the message transformation function. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "However, this need for non-trivial interaction between different information sources is a common problem in neural network design. A recent trend has been the use of hypernetworks (Ha et al., 2017), neural networks that compute the weights of other networks. In this setting, interaction between two signal sources is achieved by using one of them as the input to a hypernetwork and the other as input to the computed network. While an intellectually pleasing approach, it is often impractical because the prediction of weights of non-trivial neural networks is computationally expensive. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Approaches to mitigate this exist (e.g., Wu et al. (2019) handle this in natural language processing), but are often domain-specific. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A more general mitigation method is to restrict the structure of the computed network. Recently, “feature-wise linear modulations” (FiLM) were introduced in the visual question answering domain (Perez et al., 2017). Here, the hypernetwork is fed with an encoding of a question and produces an element-wise affine function that is applied to the features extracted from a picture. This can be adapted to the graph message passing domain by using the representation of the target node to compute the affine function. This compromise between expressiveness and computational feasibility has been very effective in some domains and the results presented in this article indicate that it is also a good fit for the graph domain. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This article explores the use of hypernetworks in learning on graphs. Sect. 2 first reviews existing GNN models from the related work to identify commonalities and differences. This involves generalising a number of existing formalisms to new formulations that are able to handle graphs with different types of edges, which are often used to model different relationship between vertices. Then, two new formalisms are introduced: Relational Graph Dynamic Convolutional Networks (RGDCN), which dynamically compute the neural message passing function as a linear layer, and Graph Neural Networks with Feature-wise Linear Modulation (GNN-FiLM), which combine learned message passing functions with dynamically computed element-wise affine transformations. In Sect. 3, a range of baselines are compared in extensive experiments on three tasks from the literature, spanning classification, regression and ranking tasks on small and large graphs. Experiments were performed on re-implementations of existing model architectures in the same framework and hyperparameter setting searches were performed with the same computational budgets across all architectures. The results show that differences between baselines are smaller than the literature suggests and that the new FiLM model performs well on a number of interesting tasks. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            450
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            470,
+            267,
+            487
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notation. Let $\\mathcal { L }$ be a finite (usually small) set of edge types. Then, a directed graph $\\mathcal { G } = ( \\nu , \\mathcal { E } )$ has nodes $\\nu$ and typed edges $\\mathcal { E } \\subseteq \\mathcal { V } \\times \\mathcal { L } \\times \\mathcal { V }$ , where $( u , \\ell , v ) \\in \\mathcal { E }$ denotes an edge from node $u$ to node $v$ of type $\\ell$ , usually written as $u \\xrightarrow { \\ell _ { \\setminus } } v$ . ",
+        "bbox": [
+            174,
+            501,
+            825,
+            544
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks. As discussed above, Graph Neural Networks operate by propagating information along the edges of a given graph. Concretely, each node $v$ is associated with an initial representation $\\boldsymbol { h } _ { v } ^ { ( 0 ) }$ (for example obtained from the label of that node, or by some other model component). Then, a GNN layer updates the node representations using the node representations of its neighbours in the graph, yielding representations $\\pmb { h } _ { v } ^ { ( 1 ) }$ . This process can be unrolled through time by repeatedly applying the same update function, yielding representations $h _ { v } ^ { ( 2 ) } \\ldots h _ { v } ^ { ( T ) }$ . Alternatively, several GNN layers can be stacked, which is intuitively similar to unrolling through time, but increases the GNN capacity by using different parameters for each timestep. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Gated Graph Neural Networks (GGNN) (Li et al., 2016), the update rule uses one linear layer $W _ { \\ell }$ per edge type $\\ell$ to compute messages and combines the aggregated messages with the current representation of a node using a recurrent unit $r$ (e.g., GRU or LSTM cells), yielding the following definition. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ac22ee49891d5a6910f1a12eb1465cb919147e8d13a4eaba451f4314192de153.jpg",
+        "text": "$$\n\\pmb { h } _ { v } ^ { ( t + 1 ) } = r ( \\pmb { h } _ { v } ^ { ( t ) } , \\sum _ { u  v \\in \\mathcal { E } } W _ { \\ell } \\pmb { h } _ { u } ^ { ( t ) } ; \\pmb { \\theta } _ { r } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            739,
+            633,
+            782
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The learnable parameters of the model are the edge-type-dependent weights $W _ { \\ell }$ and the recurrent cell parameters $\\pmb { \\theta } _ { r }$ . ",
+        "bbox": [
+            176,
+            785,
+            823,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Relational Graph Convolutional Networks (R-GCN) (Schlichtkrull et al., 2018), the gated unit is replaced by a simple non-linearity $\\sigma$ (e.g., the hyperbolic tangent). ",
+        "bbox": [
+            173,
+            819,
+            821,
+            848
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/98613de1a57b3356ebec7c067ceb267b3d7d92a86cbf8594e94194616fd5442b.jpg",
+        "text": "$$\n\\pmb { h } _ { v } ^ { ( t + 1 ) } = \\sigma \\left( \\sum _ { u \\not \\in \\mathcal { E } } \\frac { 1 } { c _ { v , \\ell } } \\cdot W _ { \\ell } \\pmb { h } _ { u } ^ { ( t ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            851,
+            620,
+            893
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, $c _ { v , \\ell }$ is a normalisation factor usually set to the number of edges of type $\\ell$ ending in $v$ . The learnable parameters of the model are the edge-type-dependent weights $W _ { \\ell }$ . It is important to note that in this setting, the edge type set $\\mathcal { L }$ is assumed to contain a special edge type 0 for self-loops $v \\xrightarrow { 0 } v$ , allowing state associated with a node to be kept. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Graph Attention Networks (GAT) (Velickovi ˇ c et al., 2018), new node representations are com- ´ puted from a weighted sum of neighbouring node representations. The model can be generalised from the original definitional to support different edge types as follows (we will call this R-GAT below).1 ",
+        "bbox": [
+            174,
+            138,
+            823,
+            194
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d2f8e637d482c5c94b2cca1059ac92e1d67c781135f212141a5d706cb31f9fca.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\boldsymbol { e } _ { u , \\ell , v } = \\mathrm { L e a k y R e L U } ( \\boldsymbol { \\alpha } _ { \\ell } \\cdot ( W _ { \\ell } \\boldsymbol { h } _ { u } ^ { ( t ) } \\| W _ { \\ell } \\boldsymbol { h } _ { v } ^ { ( t ) } ) ) } \\\\ & { \\qquad \\boldsymbol { a } _ { v } = \\mathrm { s o f t m a x } ( \\boldsymbol { e } _ { u , \\ell , v } \\mid \\boldsymbol { u } \\xrightarrow { \\ell } \\boldsymbol { v } \\in \\mathcal { E } ) } \\\\ & { \\quad \\boldsymbol { h } _ { v } ^ { ( t + 1 ) } = \\sigma \\left( \\displaystyle \\sum _ { u \\xrightarrow { \\ell } v \\in \\mathcal { E } } ( \\boldsymbol { a } _ { v } ) _ { u \\xrightarrow { \\ell } v } \\cdot W _ { \\ell } \\boldsymbol { h } _ { u } ^ { ( t ) } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            199,
+            656,
+            282
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\pmb { \\alpha } _ { \\ell }$ is a learnable row vector used to weigh different feature dimensions in the computation of an attention (“relevance”) score of the node representations, $\\mathbf { \\Delta x } \\Vert \\mathbf { \\Delta y }$ is the concatenation of vectors $_ { \\textbf { \\em x } }$ and $\\textbf {  { y } }$ , and $( \\pmb { a } _ { v } ) _ { u } \\mathcal { L } _ { v }$ refers to the weight computed by the softmax for that edge. The learnable parameters of the model are the edge-type-dependent weights $W _ { \\ell }$ and the attention parameters $\\pmb { \\alpha } _ { \\ell }$ . In practice, GATs usually employ several attention heads that independently implement the mechanism above in parallel, using separate learnable parameters. The results of the different attention heads are then concatenated after each propagation round to yield the value of $h _ { v } ^ { ( t + 1 ) }$ . ",
+        "bbox": [
+            173,
+            286,
+            825,
+            387
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "More recently, $\\mathrm { X u }$ et al. (2019) analysed the expressiveness of different GNN types, comparing their ability to distinguish similar graphs with the Weisfeiler-Lehman (WL) graph isomorphism test. Their results show that GCNs and the GraphSAGE model Hamilton et al. (2017) are strictly weaker than the WL test and hence they developed Graph Isomorphism Networks (GIN) (Xu et al., 2019), which are indeed as powerful as the WL test. While the GIN definition is limited to a single edge type, Corollary 6 of $\\mathrm { X u }$ et al. (2019) shows that using the definition ",
+        "bbox": [
+            173,
+            392,
+            825,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a03cf7f7c80881532122955a09daad1c554de0c323e57384bdb74375d8b1a500.jpg",
+        "text": "$$\n\\pmb { h } _ { v } ^ { ( t + 1 ) } = \\varphi ( ( 1 + \\epsilon ) \\cdot f ( \\pmb { h } _ { v } ^ { ( t ) } ) + \\sum _ { u  v \\in \\mathcal { E } } f ( \\pmb { h } _ { u } ^ { ( t ) } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            482,
+            668,
+            525
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "there are choices for $\\epsilon$ , $\\varphi$ and $f$ such that the node representation update is sufficient for the overall network to be as powerful as the WL test. In the setting of different edge types, the function $f$ in the sum over neighbouring nodes needs to reflect different edge types to distinguish graphs such as $v \\ \\bot \\rangle \\ u \\ \\ll \\ w$ and $v \\ \\bar { 2 } \\gg \\ u \\ \\ll \\ w$ from each other. Using different functions $f _ { \\ell }$ for different edge types makes it possible to unify the use of the current node representation $h _ { v } ^ { ( t ) }$ with the use of neighbouring node representations by again using a fresh edge type 0 for self-loops $v \\ a \\ $ . In that setting, the factor $( 1 + \\epsilon )$ can be integrated into $f _ { 0 }$ . Finally, following an argument similar to $\\mathrm { X u }$ et al. (2019), $\\varphi$ and $f$ at subsequent layers can be “merged” into a single function which can be approximated by a multilayer perceptron (MLP), yielding the final R-GIN definition ",
+        "bbox": [
+            173,
+            530,
+            825,
+            659
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2d0a51e6aabe2f776331d64d345e9baa07cb80ff3f464e4104e424703768563.jpg",
+        "text": "$$\n\\pmb { h } _ { v } ^ { ( t + 1 ) } = \\sigma \\left( \\sum _ { u \\downarrow v \\in \\mathcal { E } } M L P ( \\pmb { h } _ { u } ^ { ( t ) } ; \\pmb { \\theta } _ { \\ell } ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            662,
+            635,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The learnable parameters here are the edge-specific weights $\\pmb { \\theta } _ { \\ell }$ . Note that Eq. (4) is very similar to the definition of R-GCNs (Eq. (2)), only dropping the normalisation factor $\\frac { \\hat { \\mathbf { 1 } } } { c _ { v , \\ell } }$ and replacing linear layers by an MLP. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "While many more GNN variants exist, the four formalisms above are broadly representative of general trends. It is notable that in all of these models, the information passed from one node to another is based on the learned weights and the representation of the source of an edge. In contrast, the representation of the target of an edge is only updated (in the GGNN case Eq. (1)), treated as another incoming message (in the R-GCN case Eq. (2) and the R-GIN case Eq. (4)), or used to weight the relevance of an edge (in the R-GAT case Eq. (3)). Sometimes unnamed GNN variants of the above are used (e.g., by Selsam et al. (2019); Paliwal et al. (2019)), replacing the linear layers to compute the messages for each edge by MLPs applied to the concatenation of the representations of source and target nodes. In the experiments, this will be called GNN-MLP, formally defined as follows.2 ",
+        "bbox": [
+            173,
+            762,
+            825,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            102,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ca55904beb3ea3bc06f0d79e51bfaa64a5eae35025b4106bcc9e8a00440bb84a.jpg",
+        "text": "$$\n\\pmb { h } _ { v } ^ { ( t + 1 ) } = \\sigma \\left( \\sum _ { u \\xrightarrow [ ] { \\ell } v \\in \\mathcal { E } } \\frac { 1 } { c _ { v , \\ell } } \\cdot M L P \\left( \\pmb { h } _ { u } ^ { ( t ) } \\| \\pmb { h } _ { v } ^ { ( t ) } \\ ; \\ \\pmb { \\theta } _ { \\ell } \\right) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            133,
+            674,
+            176
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Below, we will instantiate the $M L P$ with a single linear layer to obtain what we call GNN-MLP0, which only differs from R-GCNs (Eq. (2)) in that the message passing function is applied to the concatenation of source and target state. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            224
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 GRAPH HYPERNETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            239,
+            398,
+            253
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Hypernetworks (i.e., neural networks computing the parameters of another neural network) (Ha et al., 2017) have been successfully applied to a number of different tasks; naturally raising the question if they are also applicable in the graph domain. ",
+        "bbox": [
+            174,
+            265,
+            823,
+            309
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, a hypernetwork corresponds to a higher-order function, i.e., it can be viewed as a function computing another function. Hence, a natural idea would be to use the target of a message propagation step to compute the function computing the message; essentially allowing it to focus on features that are especially relevant for the update of the target node representation. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            372
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Relational Graph Dynamic Convolutional Networks (RGDCN) A first attempt would be to adapt (2) to replace the learnable message transformation $W _ { \\ell }$ by the result of some learnable function $f$ that operates on the target representation: ",
+        "bbox": [
+            173,
+            385,
+            825,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e50ddd34ffca3a0d42397fbdd7f5fd99cb048a51e4ffd1624d1b7c8014cb867d.jpg",
+        "text": "$$\n\\pmb { h } _ { v } ^ { ( t + 1 ) } = \\sigma \\left( \\sum _ { u \\downarrow v \\in \\mathcal { E } } f ( \\pmb { h } _ { v } ^ { ( t ) } ; \\pmb { \\theta } _ { f , \\ell } ) \\pmb { h } _ { u } ^ { ( t ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            361,
+            433,
+            635,
+            476
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, for a representation size $D$ , $f$ would need to produce a matrix of size $D ^ { 2 }$ from $D$ inputs. Hence, if implemented as a simple linear layer, $f$ would have on the order of $\\mathcal { O } ( D ^ { 3 } )$ parameters, quickly making it impractical in most contexts. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This can be somewhat mitigated by splitting the node representations $h _ { v } ^ { ( t ) }$ into $C$ “chunks” $h _ { v , c } ^ { ( t ) }$ of dimension $\\begin{array} { r } { K = { \\frac { D } { C } } } \\end{array}$ : ",
+        "bbox": [
+            174,
+            531,
+            823,
+            566
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/684053b46a790f29830f9dd0179f152cfe1a4b0b9ece7c0a76571c3c99d38956.jpg",
+        "text": "$$\n\\begin{array} { r l } & { W _ { \\ell , t , v , c } = f ( \\pmb { h } _ { v } ^ { ( t ) } ; \\pmb { \\theta } _ { f , \\ell , c } ) } \\\\ & { \\qquad \\mathbf { h } _ { v } ^ { ( t + 1 ) } = \\displaystyle \\operatorname* { l i } _ { 1 \\leq c \\leq C } \\sigma \\left( \\sum _ { u } \\pounds _ { v \\in \\mathcal { E } } W _ { \\ell , t , v , c } \\pmb { h } _ { u , c } ^ { ( t ) } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            352,
+            569,
+            645,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The number of parameters of the model can now be reduced by tying the value of some instances of $\\theta _ { f , \\ell , c }$ . For example, the update function for a chunk $c$ can be computed using only the corresponding chunk of the node representation $h _ { v , c } ^ { ( t ) }$ , or the same update function can be applied to all “chunks” by setting $\\pmb { \\theta } _ { f , \\ell , 1 } = . . . = \\pmb { \\theta } _ { f , \\ell , C }$ . The learnable parameters of the model are only the hypernetwork parameters $\\theta _ { f , \\ell , c }$ . This is somewhat less desirable than the related idea of Wu et al. (2019), which operates on sequences, where sharing between neighbouring elements of the sequence has an intuitive interpretation that is not applicable in the general graph setting. ",
+        "bbox": [
+            173,
+            638,
+            826,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks with Feature-wise Linear Modulation (GNN-FiLM) In (6), the message passing layer is a linear transformation conditioned on the target node representation, focusing on separate chunks of the node representation at a time. In the extreme case in which the dimension of each chunk is 1, this method coincides with the ideas of Perez et al. (2017), who propose to use layers of element-wise affine transformations to modulate feature maps in the visual question answering setting; there, a natural language question is the input used to compute the affine transformation applied to the features extracted from a picture. ",
+        "bbox": [
+            173,
+            755,
+            825,
+            853
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the graph setting, we can use each node’s representation as an input that determines an elementwise affine transformation of incoming messages, allowing the model to dynamically up-weight and down-weight features based on the information present at the target node of an edge. This yields the following update rule, using a learnable function $g$ to compute the parameters of the affine transformation. ",
+        "bbox": [
+            176,
+            859,
+            820,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/80793c00acef7fba9ee3395f0dc3beb76f2bc9ec5bd5046c4bc3c5a3274f1380.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\beta _ { \\ell , v } ^ { ( t ) } , \\gamma _ { \\ell , v } ^ { ( t ) } = g ( \\pmb { h } _ { v } ^ { ( t ) } ; \\pmb { \\theta } _ { g , \\ell } ) } \\\\ & { \\quad \\pmb { h } _ { v } ^ { ( t + 1 ) } = \\sigma \\left( \\displaystyle \\sum _ { u \\in \\mathcal { E } } \\gamma _ { \\ell , v } ^ { ( t ) } \\odot W _ { \\ell } \\pmb { h } _ { u } ^ { ( t ) } + \\beta _ { \\ell , v } ^ { ( t ) } \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            143,
+            658,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The learnable parameters of the model are both the hypernetwork parameters $\\theta _ { g , \\ell }$ and the weights $W _ { \\ell }$ . In practice, implementing $g$ as a single linear layer works well. ",
+        "bbox": [
+            171,
+            213,
+            821,
+            242
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the case of using a single linear layer, the resulting message passing function is bilinear in source and target node representation, as the message computation is centred around $( W _ { g } \\pmb { h } _ { v } ^ { ( t ) } ) \\odot ( W _ { \\ell } \\pmb { h } _ { u } ^ { ( t ) } )$ . This is the core difference to the (linear) interaction of source and target node representations in models that use $W _ { \\ell } ( \\pmb { h } _ { u } ^ { ( t ) } | | \\pmb { h } _ { v } ^ { ( t ) } )$ . ",
+        "bbox": [
+            173,
+            248,
+            825,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A simple toy example may illustrate the usefulness of such a mechanism: assuming a graph of nodes $\\nu _ { A }$ and $\\gamma _ { B }$ and edge types 1 and 2, a task may involve counting the number of 1-neighbours of $\\nu _ { A }$ nodes and of 2-neighbours of $\\gamma _ { B }$ nodes. By setting $\\gamma _ { 1 , v _ { a } } = 1$ , $\\gamma _ { 2 , v _ { a } } = 0$ for $v _ { a } \\in \\mathcal { V } _ { A }$ and $\\gamma _ { 1 , v _ { b } } = 0$ , $\\gamma _ { 2 , v _ { b } } = 1$ for $v _ { b } \\in \\mathcal { V } _ { B }$ , GNN-FiLM can solve this in a single layer. Simpler approaches can solve this by counting $A / 1 , A / 2 , B / 1$ and $B / 2$ neighbours separately in one layer and then projecting to the correct counter, but require more feature dimensions and layers for this. As this toy example illustrates, a core capability of GNN-FiLM is to learn to ignore graph edges based on the representation of target nodes. ",
+        "bbox": [
+            173,
+            315,
+            825,
+            428
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the featurewise modulation can also be viewed of an extension of the gating mechanism of GRU or LSTM cells used in GGNNs. Concretely, the “forgetting” of memories in a GRU/LSTM is similar to down-weighting messages computed for the self-loop edges and the gating of the cell input is similar to the modulation of other incoming messages. However, GGNNs apply this gating to the sum of all incoming messages (cf. Eq. (1), wheras in GNN-FiLM the modulation additionally depends on the edge type, allowing for a more fine-grained gating mechanism. ",
+        "bbox": [
+            173,
+            434,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, a small implementation bug brought focus to the fact that applying the non-linearity $\\sigma$ after summing up messages from neighbouring nodes can make it harder to perform tasks such as counting the number of neighbours with a certain feature. In experiments, applying the non-linearity before aggregation as in the following update rule improved performance. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            582
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/862ad11681ccb9203d2773bd28d5888bea6fc2f16ea5c5f0df2ce6b965777b98.jpg",
+        "text": "$$\n\\pmb { h } _ { v } ^ { ( t + 1 ) } = l \\left( \\sum _ { u \\downarrow } \\sigma _ { v \\in \\mathcal { E } } \\sigma \\left( \\gamma _ { \\ell , v } ^ { ( t ) } \\odot W _ { \\ell } \\pmb { h } _ { u } ^ { ( t ) } + \\beta _ { \\ell , v } ^ { ( t ) } \\right) ; \\pmb { \\theta } _ { l } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            316,
+            583,
+            679,
+            626
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, this means that the magnitude of node representations is now dependent on the degree of nodes in the handled graph. This can sometimes lead to instability during training, which can in turn be controlled by adding an additional layer $l$ after message passing, which can be a simple bounded nonlinearity (e.g. tanh), a fully connected layer, or layer normalisation (Ba et al., 2016), or any combination of these. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            717,
+            315,
+            733
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 GNN BENCHMARK TASKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            747,
+            400,
+            762
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Due to the versatile nature of the GNN modelling formalism, many fundamentally different tasks are studied in the research area and it should be noted that good results on one task often do not transfer over to other tasks. This is due to the widely varying requirements of different tasks, as the following summary of tasks from the literature should illustrate. ",
+        "bbox": [
+            176,
+            773,
+            825,
+            830
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Cora/Citeseer/Pubmed (Sen et al., 2008): Each task consists of a single graph of $\\sim 1 0 0 0 0$ nodes corresponding to documents and undirected (sic!) edges corresponding to references. The sparse $\\sim 1 0 0 0$ node features are a bag of words representation of the corresponding documents. The goal is to assign a subset of nodes to a small number of classes. State of the art performance on these tasks is achieved with two propagation steps along graph edges. ",
+        "bbox": [
+            217,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• PPI (Zitnik & Leskovec, 2017): A protein-protein interaction dataset consisting of 24 graphs of $\\sim \\ 2 5 0 0$ nodes corresponding to different human tissues. Each node has 50 features selected by domain experts and the goal is node-level classification, where each node may belong to several of the 121 classes. State of the art performance on this task requires three propagation steps. QM9 property prediction (Ramakrishnan et al., 2014): $\\sim 1 3 0 0 0 0$ graphs of $\\sim 8$ nodes represent molecules, where nodes are heavy atoms and undirected, typed edges are bonds between these atoms, different edge types indicating single/double/etc. bonds. The goal is to regress each graph to a number of quantum chemical properties. State of the art performance on these tasks requires at least four propagation steps. VarMisuse (Allamanis et al., 2018): $\\sim 2 3 5 0 0 0$ graphs of $\\sim 2 5 0 0$ nodes each represent program fragments, where nodes are tokens in the program text and different edge types represent the program’s abstract syntax tree, data flow between variables, etc. The goal is to select one of a set of candidate nodes per graph. State of the art performance requires at least six propagation steps. ",
+        "bbox": [
+            215,
+            103,
+            825,
+            323
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Hence, tasks differ in the complexity of edges (from undirected and untyped to directed and manytyped), the size of the considered graphs, the size of the dataset, the importance of node-level vs. graph-level representations, and the number of required propagation steps. ",
+        "bbox": [
+            178,
+            334,
+            825,
+            377
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This article includes results on the PPI, QM9 and VarMisuse tasks. Preliminary experiments on the citation network data showed results that were at best comparable to the baseline methods, but changes of a random seed led to substantial fluctuations (mirroring the problems with evaluation on these tasks reported by Shchur et al. (2018)). ",
+        "bbox": [
+            176,
+            383,
+            825,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 IMPLEMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            341,
+            470
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To allow for a wider comparison, the implementation of GNN-FiLM is accompanied by implementations of a range of baseline methods. These include GGNN (Li et al., 2016) (see Eq. (1)), R-GCN (Schlichtkrull et al., 2018) (see Eq. (2)), R-GAT (Velickovi ˇ c et al., 2018) (see Eq. ´ (3)), and R-GIN (Hamilton et al., 2017) (see Eq. (4))3. Additionally, GNN-MLP0 is a variant of R-GCN using a single linear layer to compute the edge message from both source and target state (i.e., Eq. (5) instantiated with an “MLP” without hidden layers), and GNN-MLP1 is the same with a single hidden layer. The baseline methods were re-implemented in TensorFlow and individually tested to reach performance equivalent to results reported in their respective source papers. All code for the implementation of these GNNs is released on https://revealed/after/double/blind/ lifted, together with implementations of all tasks and scripts necessary to reproduce the results reported in this paper. This includes the hyperparameter settings found by search, which are stored in tasks/default hypers/ and are selected by default on the respective tasks. The code is designed to facilitate testing new GNN types on existing tasks and easily adding new tasks, allowing for rapid evaluation of new architectures. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Early on in the experiments, it became clear that the RGDCN approach (Eq. (6)) as presented is infeasible. It is extremely sensitive to the parameter initialisation and hence changes to the random seed lead to wild swings in the target metrics. Hence, no experimental results are reported for it in the following. It is nonetheless included in the article (and the implementation) to show the thought process leading to GNN-FiLM, as well as to allow other researchers to build upon this. In the following, GNN-FiLM refers to the formulation of Eq. (8), which performed better than the variant of Eq. (7) across all experiments. Somewhat surprisingly, the same trick (of moving the non-linearity before the message aggregation step) did not help the other GNN types. For all models, using each layer only for a single propagation step performed better than using fewer layers with several propagation steps. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In all experiments, models were trained until the target metric did not improve anymore for some additional epochs (25 for PPI and QM9, 5 for VarMisuse). The reported results on the held-out test data are averaged across the results of a number of training runs, each starting from different random parameter initializations. ",
+        "bbox": [
+            174,
+            830,
+            825,
+            886
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            392,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 PROTEIN-PROTEIN INTERACTIONS (PPI) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            131,
+            509,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The models are first evaluated on the node-level classification PPI task (Zitnik & Leskovec, 2017), following the dataset split from earlier papers. Training hence used a set of 20 graphs and validation and test sets of two separate graphs each. The graphs use two edge types: the dataset-provided untyped edges as well as a fresh “self-loop” edge type to allows nodes to keep state across propagation steps. ",
+        "bbox": [
+            174,
+            156,
+            825,
+            228
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters for all models were selected based on results from earlier papers and a small grid search of a number of author-selected hyperparameter ranges (see App. A for details). This resulted in three (R-GAT), four (GGNN, GNN-FiLM, GNN-MLP1, R-GCN), or five (GNN-MLP0, R-GIN) layers (propagation steps) and a node representation size of 256 (GNN-MLP0, R-GIN) or 320 (all others). All models use dropout on the node representations before all GNN layers, with a keep ratio of 0.9. After selecting hyperparameters, all models were trained ten times with different random seeds on a NVidia V100. ",
+        "bbox": [
+            174,
+            233,
+            825,
+            330
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Tab. 1 shows the micro-averaged F1 score on the classification task on the test graphs, with standard deviations and training times in seconds computed over the ten runs. The results for all re-implemented models are better than the results reported by Velickovi ˇ c et al. (2018) ´ for the GAT model (without edge types). A cursory exploration of the reasons yielded three factors. First, the generalisation to different edge types (cf. Eq. (3)) and the subsequent use of a special self-loop edge type helps R-GAT (and all other models) significantly. Second, using dropout between layers significantly im",
+        "bbox": [
+            174,
+            339,
+            483,
+            518
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/3a61de3ab3d709469f54f95ec13196280c16e1756c167b4306364c50f275a18c.jpg",
+        "table_caption": [
+            "Table 1: GNN results on PPI task. $\\mathrm { G A T ^ { * } }$ result taken from Velickovi ˇ c et al. (2018). ´ "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Avg. Micro-F1</td><td>Time (s)</td></tr><tr><td>GAT*</td><td>0.973 ±0.002</td><td>n/a</td></tr><tr><td>GGNN</td><td>0.990 ±0.001</td><td>432.6</td></tr><tr><td>R-GCN</td><td>0.989 ±0.000</td><td>759.0</td></tr><tr><td>R-GAT</td><td>0.989 ±0.001</td><td>782.3</td></tr><tr><td>R-GIN</td><td>0.991 ±0.001</td><td>704.8</td></tr><tr><td>GNN-MLP0</td><td>0.992±0.000</td><td>556.9</td></tr><tr><td>GNN-MLP1</td><td>0.992±0.001</td><td>479.2</td></tr><tr><td>GNN-FiLM</td><td>0.992±0.000</td><td>308.1</td></tr></table>",
+        "bbox": [
+            519,
+            368,
+            802,
+            508
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "proved the results. Third, the larger node representation sizes (compared to 256 used by Velickovi ˇ c´ et al. (2018)) improved the results again. However, the new GNN-FiLM improves slightly over these four baselines from the literature, while converging substantially faster than all baselines, mainly because it converges in significantly fewer training steps (approx. 240 epochs compared to 400-600 epochs for the other models). ",
+        "bbox": [
+            174,
+            518,
+            825,
+            588
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3.2 QUANTUM CHEMISTRY (QM9) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            608,
+            444,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All models were additionally evaluated on graph-level regression tasks on the QM9 molecule data set (Ramakrishnan et al., 2014), considering thirteen different quantum chemical properties. The ${ \\sim } 1 3 0 k$ molecular graphs in the dataset were split into training, validation and test data by randomly selecting 10 000 graphs for the latter two sets. Additionally, another data split without a test set was used for the hyperparameter search (see below). The graphs use five edge types: the datasetprovided typed edges (single, double, triple and aromatic bonds between atoms) as well as a fresh “self-loop” edge type that allows nodes to keep state across propagation steps. The evaluation differs from the setting reported by Gilmer et al. (2017), as no additional molecular information is encoded as edge features, nor are the graphs augmented by master nodes or additional edges.4 ",
+        "bbox": [
+            174,
+            633,
+            825,
+            760
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters for all models were found using a staged search process. First, 500 hyperparameter configurations were sampled from an author-provided search space (see App. A for details) and run on the first three regression tasks. The top three configurations for each of these three tasks were then run on all thirteen tasks and the final configuration was chosen as the one with the lowest average mean absolute error across all properties, as evaluated on the validation data of that dataset split. This process led to eight layers / propagation steps for all models but GGNN and R-GIN, which showed best performance with six layers. Furthermore, all models used residual connections connecting every second layer and GGNN, R-GCN, GNN-FiLM and GNN-MLP0 additionally used layer normalisation (as in Eq. (8)). ",
+        "bbox": [
+            174,
+            766,
+            825,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/48f53a8f8558d0db1faa39f5f9d8a208e4d345602586bbdbea16dd344dfc9679.jpg",
+        "table_caption": [
+            "Table 2: GNN average error rates and standard deviations on QM9 target values. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Property</td><td>GGNN</td><td>R-GCN</td><td>R-GAT</td><td>R-GIN</td><td>GNN-MLP0</td><td>GNN-MLP1</td><td>GNN-FiLM</td></tr><tr><td>mu</td><td>3.85 ±0.16</td><td>3.21 ±0.06</td><td>2.68 ±0.06</td><td>2.64 ±0.11</td><td>2.36 ±0.04</td><td>2.44 ±0.12</td><td>2.38 ±0.13</td></tr><tr><td>alpha</td><td>5.22 ±0.86</td><td>4.22 ±0.45</td><td>4.65 ±0.44</td><td>4.67 ±0.52</td><td>4.27 ±0.36</td><td>4.63 ±0.54</td><td>3.75 ±0.11</td></tr><tr><td>HOMO</td><td>1.67 ±0.07</td><td>1.45 ±0.01</td><td>1.48 ±0.03</td><td>1.42 ±0.01</td><td>1.25 ±0.04</td><td>1.29 ±0.06</td><td>1.22 ±0.07</td></tr><tr><td>LUMO</td><td>1.74 ±0.06</td><td>1.62 ±0.04</td><td>1.53 ±0.07</td><td>1.50 ±0.09</td><td>1.35 ±0.04</td><td>1.50 ±0.19</td><td>1.30 ±0.05</td></tr><tr><td>gap</td><td>2.60 ±0.06</td><td>2.42 ±0.14</td><td>2.31 ±0.06</td><td>2.27 ±0.09</td><td>2.04 ±0.05</td><td>2.06 ±0.10</td><td>1.96 ±0.06</td></tr><tr><td>R2</td><td>35.94 ±35.68</td><td>16.38 ±0.49</td><td>52.39 ±42.58</td><td>15.63 ±1.40</td><td>14.86 ±1.62</td><td>15.81 ±1.42</td><td>15.59 ±1.38</td></tr><tr><td>ZPVE</td><td>17.84 ±3.61</td><td>17.40 ±3.56</td><td>14.87 ±2.88</td><td>12.93 ±1.81</td><td>12.00 ±1.66</td><td>14.12 ±1.10</td><td>11.00 ±0.74</td></tr><tr><td>UO</td><td>8.65 ±2.46</td><td>7.82 ±0.80</td><td>7.61 ±0.46</td><td>5.88 ±1.01</td><td>5.55 ±0.38</td><td>6.94 ±0.64</td><td>5.43 ±0.96</td></tr><tr><td>U</td><td>9.24 ±2.26</td><td>8.24 ±1.25</td><td>6.86 ±0.53</td><td>18.71 ±23.36</td><td>6.20 ±0.88</td><td>7.00 ±1.06</td><td>5.95 ±0.46</td></tr><tr><td>H</td><td>9.35 ±0.96</td><td>9.05 ±1.21</td><td>7.64 ±0.92</td><td>5.62 ±0.81</td><td>5.96 ±0.45</td><td>7.98 ±0.88</td><td>5.59 ±0.57</td></tr><tr><td>G</td><td>7.14 ±1.15</td><td>7.00 ±1.51</td><td>6.54 ±0.36</td><td>5.38±0.75</td><td>5.09 ±0.57</td><td>7.14 ±0.51</td><td>5.17 ±1.13</td></tr><tr><td>Cv</td><td>8.86 ±9.07</td><td>3.93 ±0.48</td><td>4.11 ±0.27</td><td>3.53 ±0.37</td><td>3.38 ±0.20</td><td>4.60 ±0.74</td><td>3.46 ±0.21</td></tr><tr><td>Omega</td><td>1.57 ±0.53</td><td>1.02 ±0.05</td><td>1.48 ±0.87</td><td>1.05 ±0.11</td><td>0.84±0.02</td><td>5.60 ±8.82</td><td>0.98 ±0.06</td></tr></table>",
+        "bbox": [
+            176,
+            127,
+            821,
+            294
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/dd11906b1fced7d02e34ad81ece2c25a291a6b99fc894e7992fd960827d8333f.jpg",
+        "table_caption": [
+            "Table 3: Accuracy on VarMisuse task. GGNN∗ result taken from appendix of Allamanis et al. (2018). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>TRAIN</td><td>VALID</td><td>SEENPROJTEST</td><td>UNSEENPROJTEST</td></tr><tr><td>GGNN*</td><td>n/a</td><td>n/a</td><td>84.0 n/a</td><td>74.1 n/a</td></tr><tr><td>GGNN</td><td>87.5±1.8%</td><td>82.1±0.9%</td><td>85.7 ±0.5%</td><td>79.3 ±1.2%</td></tr><tr><td>R-GCN</td><td>88.7±3.1%</td><td>85.7±1.6%</td><td>87.2±1.5%</td><td>81.4±2.3%</td></tr><tr><td>R-GAT</td><td>90.4±3.9%</td><td>84.2±1.0%</td><td>86.9 ±0.7%</td><td>81.2 ±0.9%</td></tr><tr><td>R-GIN</td><td>93.4±1.8%</td><td>84.2±1.0%</td><td>87.1 ±0.1%</td><td>81.1 ±0.9%</td></tr><tr><td>GNN-MLP0</td><td>95.3±2.4%</td><td>83.4±0.3%</td><td>86.5 ±0.2%</td><td>80.5 ±1.4%</td></tr><tr><td>GNN-MLP1</td><td>94.7±1.2%</td><td>84.4±0.4%</td><td>86.9 ±0.3%</td><td>81.4±0.7%</td></tr><tr><td>GNN-FiLM</td><td>94.3±1.0%</td><td>84.6±0.6%</td><td>87.0 ±0.2%</td><td>81.3 ±0.9%</td></tr></table>",
+        "bbox": [
+            186,
+            342,
+            808,
+            483
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Each model was trained for each of the properties separately five times using different random seeds on compute nodes with NVidia P100 cards. The average results of the five runs are reported in Tab. 2, with their respective standard deviations.5 The results indicate that the new GNN-FiLM model outperforms the standard baselines on all tasks and the usually not considered GNN-MLP variants on the majority of tasks. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            584
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.3.3 VARIABLE USAGE IN PROGRAMS (VARMISUSE) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            560,
+            614
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, the models were evaluated on the VarMisuse task of Allamanis et al. (2018). This task requires to process a graph representing an abstraction of a program fragment and then select one of a few candidate nodes (representing program variables) based on the representation of another node (representing the location to use a variable in). The experiments are performed using the released split of the dataset, which contains $\\sim 1 3 0 k$ training graphs, $\\sim 2 0 k$ validation graphs and two test sets: SEENPROJTEST, which contains $\\sim 5 5 k$ graphs extracted from open source projects that also contributed data to the training and validation sets, and UNSEENPROJTEST, which contains $\\sim 3 0 k$ graphs extracted from completely unseen projects. ",
+        "bbox": [
+            174,
+            623,
+            825,
+            736
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Due to the inherent cost of training models on this dataset (Balog et al. (2019) provide an in-depth performance analysis), a limited hyperparameter grid search was performed, with only $\\sim 3 0$ candidate configurations for each model (see App. A for details). For each model, the configuration yielding the best results on the validation data set fold was selected. This led to six layers for GGNN and R-GIN, eight layers for R-GAT and GNN-MLP0, and ten layers for the remaining models. Graph node hidden sizes were 128 for all models but GGNN and R-GAT, which performed better with 96 dimensions. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            839
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results, shown in Tab. 3, are somewhat surprising, as they indicate a different ranking of model architectures as the results on PPI and QM9, with R-GCN performing best. All re-implemented baselines beat the results reported by Allamanis et al. (2018), who also reported that R-GCN and GGNN show very similar performance. This is in spite of a simpler implementation of the task than in the original paper, as it only uses the string labels of nodes for the representation and does not use the additional type information provided in the dataset. However, the re-implementation of the task uses the insights from Cvitkovic et al. (2019), who use character CNNs to encode node labels and furthermore introduce extra nodes for subtokens appearing in labels of different nodes, connecting them to their sources (e.g., nodes labelled openWullfrax and closeWullfrax are both connected to a fresh Wullfrax node). ",
+        "bbox": [
+            176,
+            847,
+            821,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A deeper investigation results showed that the more complex models seem to suffer from significant overfitting to the training data, as can be seen in the results for training and validation accuracy reported in Tab. 3. A brief exploration of more aggressive regularisation methods (more dropout, weight decay) showed no improvement and a deeper understanding of the cause of these results remains for future work. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, the large variance in results on the validation set (especially for R-GCN) makes it likely that the hyperparameter grid search with only one training run per configuration did not yield the best configuration for each model. ",
+        "bbox": [
+            174,
+            299,
+            825,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION & CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            361,
+            459,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "After a review of existing graph neural network architectures, the idea of using hypernetworkinspired models in the graph setting was explored. This led to two models, Graph Dynamic Convolutional Networks and GNNs with feature-wise linear modulation, were presented. While GDCNs seem to be impractical to train, experiments show that GNN-FiLM is competitive with or improving on baseline models on three tasks from the literature. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            462
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The extensive experiments also show that a number of results from the literature could benefit from more substantial hyperparameter search and are often missing comparisons to a number of obvious baselines: ",
+        "bbox": [
+            176,
+            469,
+            825,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• The results in Tab. 1 indicate that GATs have no advantage over GGNNs or R-GCNs on the PPI task, which does not match the findings by Velickovi ˇ c et al. (2018). ´ • The results in Tab. 3 indicate that R-GCNs are outperforming GGNNs substantially on the VarMisuse task, contradicting the findings of Allamanis et al. (2018). • The GNN-MLP models are obvious extensions that are often alluded to, but are not part of the usually considered set of baseline models. Nonetheless, experiments across all three tasks have shown that these methods outperform better-published techniques such as GGNNs, R-GCNs and GATs, without a substantial runtime penalty. ",
+        "bbox": [
+            215,
+            523,
+            825,
+            645
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "These results indicate that there is substantial value in independent reproducibility efforts and comparisons that include “obvious” baselines, matching the experiences from other areas of machine learning as well as earlier work by Shchur et al. (2018) on reproducing experimental results for GNNs on citation network tasks. ",
+        "bbox": [
+            176,
+            657,
+            823,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. Learning to represent programs with graphs. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            174,
+            125,
+            823,
+            154
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lei Jimmy Ba, Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. CoRR, abs/1607.06450, 2016. ",
+        "bbox": [
+            173,
+            160,
+            821,
+            189
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matej Balog, Bart van Merrienboer, Subhodeep Moitra, Yujia Li, and Daniel Tarlow. Fast training ¨ of sparse graph neural networks on dense hardware. CoRR, abs/1906.11786, 2019. ",
+        "bbox": [
+            173,
+            196,
+            820,
+            226
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Busbridge, Dane Sherburn, Pietro Cavallo, and Nils Y. Hammerla. Relational graph attention networks. CoRR, abs/1904.05811, 2019. ",
+        "bbox": [
+            174,
+            233,
+            820,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Milan Cvitkovic, Badal Singh, and Anima Anandkumar. Open vocabulary learning on source code with a graph-structured cache. In International Conference on Machine Learning (ICML), 2019. ",
+        "bbox": [
+            173,
+            270,
+            821,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            174,
+            305,
+            823,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Ha, Andrew M. Dai, and Quoc V. Le. HyperNetworks. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            171,
+            354,
+            823,
+            385
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "William L Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems (NeurIPS), 2017. ",
+        "bbox": [
+            173,
+            391,
+            821,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            173,
+            428,
+            821,
+            458
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aditya Paliwal, Sarah M. Loos, Markus N. Rabe, Kshitij Bansal, and Christian Szegedy. Graph representations for higher-order logic and theorem proving. CoRR, abs/1905.10006, 2019. ",
+        "bbox": [
+            173,
+            463,
+            823,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. FiLM: Visual reasoning with a general conditioning layer. In AAAI Conference on Artificial Intelligence, 2017. ",
+        "bbox": [
+            176,
+            500,
+            823,
+            542
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raghunathan Ramakrishnan, Pavlo O. Dral, Matthias Rupp, and O. Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific Data, 1, 2014. ",
+        "bbox": [
+            173,
+            550,
+            823,
+            580
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional network. In Extended Semantic Web Conference (ESWC), 2018. ",
+        "bbox": [
+            173,
+            587,
+            823,
+            630
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Selsam, Matthew Lamm, Benedikt Bunz, Percy Liang, Leonardo de Moura, and David L. ¨ Dill. Learning a SAT solver from single-bit supervision. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            174,
+            636,
+            823,
+            679
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29, 2008. ",
+        "bbox": [
+            174,
+            685,
+            823,
+            717
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Gunnemann. Pitfalls ¨ of graph neural network evaluation. CoRR, abs/1811.05868, 2018. ",
+        "bbox": [
+            173,
+            722,
+            823,
+            752
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Li ´ o, and Yoshua \\` Bengio. Graph Attention Networks. In International Conference on Learning Representations (ICLR), 2018. ",
+        "bbox": [
+            173,
+            758,
+            825,
+            801
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Felix Wu, Angela Fan, Alexei Baevski, Yann Dauphin, and Michael Auli. Pay less attention with lightweight and dynamic convolutions. In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            171,
+            808,
+            823,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            173,
+            858,
+            821,
+            888
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marinka Zitnik and Jure Leskovec. Predicting multicellular function through multi-layer tissue networks. Bioinformatics, 33, 2017. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A HYPERPARAMETER SEARCH SPACES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            511,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 PPI ",
+        "bbox": [
+            174,
+            132,
+            246,
+            148
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For all models, a full grid search considering all combinations of the following parameters was performed: ",
+        "bbox": [
+            173,
+            159,
+            825,
+            188
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• hidden siz $\\textsf { e } \\in \\{ 1 9 2 , 2 5 6 , 3 2 0 \\}$ - size of per-node representations. • graph num layers $\\in \\{ 2 , 3 , 4 , 5 \\}$ - number of propagation steps / layers. • graph layer input dropout keep prob $\\in \\ \\{ 0 . 8 , 0 . 9 , 1 . 0 \\}$ - dropout applied before propagation steps. ",
+        "bbox": [
+            215,
+            198,
+            825,
+            267
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.2 QM9 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            282,
+            256,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For all models, 500 configurations were considered, sampling hyperparameter settings uniformly from the following options: ",
+        "bbox": [
+            174,
+            308,
+            823,
+            338
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• hidden siz $\\textsf { e } \\in \\{ 6 4 , 9 6 , 1 2 8 \\}$ - size of per-node representations.   \n• graph num layers $\\in \\{ 4 , 6 , 8 \\}$ - number of propagation steps / layers.   \n• graph layer input dropout keep prob $\\in \\ \\{ 0 . 8 , 0 . 9 , 1 . 0 \\}$ - dropout applied before propagation steps.   \n• layer norm $\\in \\{ T r u e , F a l s e \\}$ - decided if layer norm is applied after each propagation step.   \n• dense layers $\\in \\{ 1 , 2 , 3 2 \\}$ - insert a fully connected layer applied to node representations between every dense layers propagation steps. (32 effectively turns this off) res connection $\\in \\quad \\{ 1 , 2 , 3 2 \\}$ - insert a residual connection between every res connection propagation steps. (32 effectively turns this off)   \n• graph activation function $\\in$ {relu, leaky relu, elu, gelu, tanh} - non-linearity applied after message passing.   \n• optimizer $\\in \\{ R M S P r o p , A d a m \\}$ - optimizer used (with TF 1.13.1 default parameters).   \n• $\\mathtt { l r } \\in [ 0 . 0 0 0 5 , 0 . 0 0 1 ]$ - learning rate.   \n• $\\mathsf { c e l 1 } \\in \\{ R N N , G R U , L S T M \\}$ - gated cell used for GGNN (only part of search space for GGNN).   \n• num heads $\\in \\{ 4 , 8 , 1 6 \\}$ - number of attention heads used for R-GAT (only part of search space for R-GAT). ",
+        "bbox": [
+            214,
+            348,
+            825,
+            651
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.3 VARMISUSE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            666,
+            305,
+            681
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For all models, a full grid search considering all combinations of the following parameters was performed: ",
+        "bbox": [
+            173,
+            691,
+            823,
+            720
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "• hidden si $z \\in \\{ 6 4 , 9 6 , 1 2 8 \\}$ - size of per-node representations.   \n• graph num layers $\\in \\{ 6 , 8 , 1 0 \\}$ - number of propagation steps / layers. graph layer input dropout keep prob $\\in \\ \\{ 0 . 8 , 0 . 9 , 1 . 0 \\}$ - dropout applied before propagation steps.   \n$\\mathsf { c e l 1 } \\in \\mathsf { \\Omega } \\{ G R U , L S T M \\}$ - gated cell used for GGNN (only part of search space for GGNN).   \n• num heads $\\in \\ \\{ 4 , 8 \\}$ - number of attention heads used for R-GAT (only part of search space for R-GAT). ",
+        "bbox": [
+            215,
+            731,
+            825,
+            864
+        ],
+        "page_idx": 10
+    }
+]

parse/train/HWX5j6Bv_ih/HWX5j6Bv_ih.md

@@ -0,0 +1,394 @@
+# CROSS-NODE FEDERATED GRAPH NEURAL NETWORK FOR SPATIO-TEMPORAL DATA MODELING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Vast amount of data generated from networks of sensors, wearables, and the Internet of Things (IoT) devices underscores the need for advanced modeling techniques that leverage the spatio-temporal structure of decentralized data due to the need for edge computation and licensing (data access) issues. While federated learning (FL) has emerged as a framework for model training without requiring direct data sharing and exchange, effectively modeling the complex spatiotemporal dependencies to improve forecasting capabilities still remains an open problem. On the other hand, state-of-the-art spatio-temporal forecasting models assume unfettered access to the data, neglecting constraints on data sharing. To bridge this gap, we propose a federated spatio-temporal model – Cross-Node Federated Graph Neural Network (CNFGNN) – which explicitly encodes the underlying graph structure using graph neural network (GNN)-based architecture under the constraint of cross-node federated learning, which requires that data in a network of nodes is generated locally on each node and remains decentralized. CNFGNN operates by disentangling the temporal dynamics modeling on devices and spatial dynamics on the server, utilizing alternating optimization to reduce the communication cost, facilitating computations on the edge devices. Experiments on the traffic flow forecasting task show that CNFGNN achieves the best forecasting performance in both transductive and inductive learning settings with no extra computation cost on edge devices, while incurring modest communication cost.
+
+# 1 INTRODUCTION
+
+Modeling the dynamics of spatio-temporal data generated from networks of edge devices or nodes (e.g. sensors, wearable devices and the Internet of Things (IoT) devices) is critical for various applications including traffic flow prediction (Li et al., 2018; Yu et al., 2018), forecasting (Seo et al., 2019; Azencot et al., 2020), and user activity detection (Yan et al., 2018; Liu et al., 2020). While existing works on spatio-temporal dynamics modeling (Battaglia et al., 2016; Kipf et al., 2018; Battaglia et al., 2018) assume that the model is trained with centralized data gathered from all devices, the volume of data generated at these edge devices precludes the use of such centralized data processing, and calls for decentralized processing where computations on the edge can lead to significant gains in improving the latency. In addition, in case of spatio-temporal forecasting, the edge devices need to leverage the complex inter-dependencies to improve the prediction performance. Moreover, with increasing concerns about data privacy and its access restrictions due to existing licensing agreements, it is critical for spatio-temporal modeling to utilize decentralized data, yet leveraging the underlying relationships for improved performance.
+
+Although recent works in federated learning (FL) (Kairouz et al., 2019) provides a solution for training a model with decentralized data on multiple devices, these works either do not consider the inherent spatio-temporal dependencies (McMahan et al., 2017; Li et al., 2020b; Karimireddy et al., 2020) or only model it implicitly by imposing the graph structure in the regularization on model weights (Smith et al., 2017), the latter of which suffers from the limitation of regularization based methods due to the assumption that graphs only encode similarity of nodes (Kipf & Welling, 2017), and cannot operate in settings where only a fraction of devices are observed during training (inductive learning setting). As a result, there is a need for an architecture for spatio-temporal data modeling which enables reliable computation on the edge, while maintaining the data decentralized.
+
+To this end, leveraging recent works on federated learning (Kairouz et al., 2019), we introduce the cross-node federated learning requirement to ensure that data generated locally at a node remains decentralized. Specifically, our architecture – Cross-Node Federated Graph Neural Network (CNFGNN), aims to effectively model the complex spatio-temporal dependencies under the cross-node federated learning constraint. For this, CNFGNN decomposes the modeling of temporal and spatial dependencies using an encoder-decoder model on each device to extract the temporal features with local data, and a Graph Neural Network (GNN) based model on the server to capture spatial dependencies among devices.
+
+As compared to existing federated learning techniques that rely on regularization to incorporate spatial relationships, CNFGNN leverages an explicit graph structure using a graph neural networkbased (GNNs) architecture, which leads to performance gains. However, the federated learning (data sharing) constraint means that the GNN cannot be trained in a centralized manner, since each node can only access the data stored on itself. To address this, CNFGNN employs Split Learning (Singh et al., 2019) to train the spatial and temporal modules. Further, to alleviate the associated high communication cost incurred by Split Learning, we propose an alternating optimization-based training procedure of these modules, which incurs only half the communication overhead as compared to a comparable Split Learning architecture. Here, we also use Federated Averaging (FedAvg) (McMahan et al., 2017) to train a shared temporal feature extractor for all nodes, which leads to improved empirical performance.
+
+Our main contributions are as follows :
+
+1. We propose Cross-Node Federated Graph Neural Network (CNFGNN), a GNN-based federated learning architecture that captures complex spatio-temporal relationships among multiple nodes while ensuring that the data generated locally remains decentralized at no extra computation cost at the edge devices.   
+2. Our modeling and training procedure enables GNN-based architectures to be used in federated learning settings. We achieve this by disentangling the modeling of local temporal dynamics on edge devices and spatial dynamics on the central server, and leverage an alternating optimization-based procedure for updating the spatial and temporal modules using Split Learning and Federated Averaging to enable effective GNN-based federated learning.   
+3. We demonstrate that CNFGNN achieves the best prediction performance (both in transductive and inductive settings) at no extra computation cost on edge devices with modest communication cost, as compared to the related techniques on a traffic flow prediction task.
+
+# 2 RELATED WORK
+
+Our method derives elements from graph neural networks, federated learning and privacy-preserving graph learning, we now discuss related works in these areas in relation to our work.
+
+Graph Neural Networks (GNNs). GNNs have shown their superior performance on various learning tasks with graph-structured data, including graph embedding (Hamilton et al., 2017), node classification (Kipf & Welling, 2017), spatio-temporal data modeling (Yan et al., 2018; Li et al., 2018; Yu et al., 2018) and multi-agent trajectory prediction (Battaglia et al., 2016; Kipf et al., 2018; Li et al., 2020a). Recent GNN models (Hamilton et al., 2017; Ying et al., 2018; You et al., 2019; Huang et al., 2018) also have sampling strategies and are able to scale on large graphs. While GNNs enjoy the benefit from strong inductive bias (Battaglia et al., 2018; Xu et al., 2019), most works require centralized data during the training and the inference processes.
+
+Federated Learning (FL). Federated learning is a machine learning setting where multiple clients train a model in collaboration with decentralized training data (Kairouz et al., 2019). It requires that the raw data of each client is stored locally without any exchange or transfer. However, the decentralized training data comes at the cost of less utilization due to the heterogeneous distributions of data on clients and the lack of information exchange among clients. Various optimization algorithms have been developed for federated learning on non-IID and unbalanced data (McMahan et al., 2017; Li et al., 2020b; Karimireddy et al., 2020). Smith et al. (2017) propose a multi-task learning framework that captures relationships amongst data. While the above works mitigate the caveat of missing neighbors’ information to some extent, they are not as effective as GNN models and still suffer from the absence of feature exchange and aggregation.
+
+Alternating Optimization. Alternating optimization is a popular choice in non-convex optimization (Agarwal et al., 2014; Arora et al., 2014; 2015; Jain & Kar, 2017). In the context of Federated Learning, Liang et al. (2020) uses alternating optimization for learning a simple global model and reduces the number of communicated parameters, and He et al. (2020) uses alternating optimization for knowledge distillation from server models to edge models. In our work, we utilize alternating optimization to effectively train on-device modules and the server module jointly, which captures temporal and spatial relationships respectively.
+
+Privacy-Preserving Graph Learning. Suzumura et al. (2019) and Mei et al. (2019) use statistics of graph structures instead of node information exchange and aggregation to avoid the leakage of node information. Recent works have also incorporated graph learning models with privacypreserving techniques such as Differential Privacy (DP), Secure Multi-Party Computation (MPC) and Homomorphic Encryption (HE). Zhou et al. (2020) utilize MPC and HE when learning a GNN model for node classification with vertically split data to preserve silo-level privacy instead of nodelevel privacy. Sajadmanesh & Gatica-Perez (2020) preprocesses the input raw data with DP before feeding it into a GNN model. Composing privacy-preserving techniques for graph learning can help build federated learning systems following the privacy-in-depth principle, wherein the privacy properties degrade as gracefully as possible if one technique fails (Kairouz et al., 2019).
+
+# 3 CROSS-NODE FEDERATED GRAPH NEURAL NETWORK
+
+# 3.1 PROBLEM FORMULATION
+
+Given a dataset with a graph $\mathcal { G } = ( \nu , \mathcal { E } )$ , a feature tensor $\pmb { \mathsf { X } } \in \mathbb { R } ^ { | \mathcal { V } | \times \hdots }$ and a label tensor ${ \pmb { \mathsf { Y } } } \in { }$ $\mathbb { R } ^ { | \nu | \times \dots }$ , we consider learning a model under the cross-node federated learning constraint: node feature $\pmb { x } _ { i } = \pmb { \mathrm { X } } _ { i , \dots }$ , node label $\begin{array} { r } { \mathbf { { y } } _ { i } = \mathbf { { Y } } _ { i , \dots } } \end{array}$ , and model output $\hat { y } _ { i }$ are only visible to the node $i$ .
+
+One typical task that requires the cross-node federated learning constraint is the prediction of spatiotemporal data generated by a network of sensors. In such a scenario, $\nu$ is the set of sensors and $\mathcal { E }$ describes relations among sensors (e.g. $e _ { i j } \in \mathcal { E }$ if and only if the distance between $v _ { i }$ and $v _ { j }$ is below some threshold). The feature tensor $\pmb { x } _ { i } \in \mathbb { R } ^ { m \times D }$ represents the $i$ -th sensor’s records in the $D$ -dim space during the past $m$ time steps, and the label $\dot { \boldsymbol { y } } _ { i } \in \mathbb { R } ^ { n \times D }$ represents the $i$ -th sensor’s records in the future $n$ time steps. Since records collected on different sensors owned by different users/organizations may not be allowed to be shared due to the need for edge computation or licensing issues on data access, it is necessary to design an algorithm modeling the spatio-temporal relation without any direct exchange of node-level data.
+
+# 3.2 PROPOSED METHOD
+
+We now introduce our proposed Cross-Node Federated Graph Neural Network (CNFGNN) model. Here, we begin by disentangling the modeling of node-level temporal dynamics and server-level spatial dynamics as follows: (i) (Figure 1c) on each node, an encoder-decoder model extracts temporal features from data on the node and makes predictions; (ii) (Figure 1b) on the central server, a Graph Network (GN) (Battaglia et al., 2018) propagates extracted node temporal features and outputs node embeddings, which incorporate the relationship information amongst nodes. (i) has access to the not shareable node data and is executed on each node locally. (ii) only involves the upload and download of smashed features and gradients instead of the raw data on nodes. This decomposition enables the exchange and aggregation of node information under the cross-node federated learning constraint.
+
+# 3.2.1 MODELING OF NODE-LEVEL TEMPORAL DYNAMICS
+
+We modify the Gated Recurrent Unit (GRU) based encoder-decoder architecture in (Cho et al., 2014) for the modeling of node-level temporal dynamics on each node. Given an input sequence $\pmb { x } _ { i } \in \mathbb { R } ^ { m \times D }$ on the $i$ -th node, an encoder sequentially reads the whole sequence and outputs the
+
+![](images/3e1ee05691630c734f899149db2febff1d255fd4582f0392794764cdcc1a7efa.jpg)
+
+(a) Overview of the training procedure.
+
+![](images/3c494966c931cf3054784bdb0199663996cfa83e3d4629a910fe32c657d23c87.jpg)
+
+(b) Server-side Graph Network (GN).
+
+![](images/e452c68aab769bc52637ce4deba79a253af6ae7d1c8558c060fc7ee48848f040.jpg)  
+(c) Encoder-decoder on the $_ { i }$ -th node.   
+Figure 1: Cross-Node Federated Graph Neural Network. (a) In each round of training, we alternately train models on nodes and the model on the server. More specifically, we sequentially execute: (1) Federated learning of on-node models. (2) Temporal encoding update. (3) Split Learning of GN. (4) On-node graph embedding update. (b) Detailed view of the server-side GN model for modeling spatial dependencies in data. (c) Detailed view of the encoder-decoder model on the $i$ -th node.
+
+hidden state $h _ { c , i }$ as the summary of the input sequence according to Equation 1.
+
+$$
+\begin{array} { r } { \pmb { h } _ { c , i } = E n c o d e r _ { i } ( \pmb { x } _ { i } , \pmb { h } _ { c , i } ^ { ( 0 ) } ) , } \end{array}
+$$
+
+where ${ h } _ { c , i } ^ { ( 0 ) }$ is a zero-valued initial hidden state vector.
+
+To incorporate the spatial dynamics into the prediction model of each node, we concatenate $h _ { c , i }$ with the node embedding $h _ { G , c , i }$ generated from the procedure described in 3.2.2, which contains spatial information, as the initial state vector of the decoder. The decoder generates the prediction $\hat { y } _ { i }$ in an auto-regressive way starting from the last frame of the input sequence $x _ { i , m }$ with the concatenated hidden state vector.
+
+$$
+\hat { \pmb { y } } _ { i } = D e c o d e r _ { i } ( x _ { i , m } , [ \pmb { h } _ { c , i } ; \pmb { h } _ { G , c , i } ] ) .
+$$
+
+We choose the mean squared error (MSE) between the prediction and the ground truth values as the loss function, which is evaluated on each node locally.
+
+# 3.2.2 MODELING OF SPATIAL DYNAMICS
+
+To capture the complex spatial dynamics, we adopt Graph Networks (GNs) proposed in (Battaglia et al., 2018) to generate node embeddings containing the relational information of all nodes. The central server collects the hidden state from all nodes $\{ h _ { c , i } \mid i \in \mathcal { V } \}$ as the input to the GN. Each layer of GN updates the input features as follows:
+
+$$
+\begin{array} { r l r } & { { \mathbf e } _ { k } ^ { \prime } = \phi ^ { e } \left( { \mathbf e } _ { k } , { \mathbf v } _ { r _ { k } } , { \mathbf v } _ { s _ { k } } , { \mathbf u } \right) } & { \overline { { { \mathbf e } } } _ { i } ^ { \prime } = \rho ^ { e \to v } \left( E _ { i } ^ { \prime } \right) } \\ & { { \mathbf v } _ { i } ^ { \prime } = \phi ^ { v } \left( \overline { { { \mathbf e } } } _ { i } ^ { \prime } , { \mathbf v } _ { i } , { \mathbf u } \right) } & { \overline { { { \mathbf e } } } ^ { \prime } = \rho ^ { e \to u } \left( E ^ { \prime } \right) } \\ & { { \mathbf u } ^ { \prime } = \phi ^ { u } \left( \overline { { { \mathbf e } } } ^ { \prime } , \overline { { { \mathbf v } } } ^ { \prime } , { \mathbf u } \right) } & { \overline { { { \mathbf v } } } ^ { \prime } = \rho ^ { v \to u } \left( V ^ { \prime } \right) } \end{array} ,
+$$
+
+# Algorithm 1 Training algorithm of CNFGNN on the server side.
+
+# Server executes:
+
+1: Initialize server-side GN weights θ GN , client model weigh ts θ¯(0)c {θ¯(0),encc , $\{ \bar { \bar { \theta } } _ { c } ^ { ( 0 ) , e n c } , \bar { \theta } _ { c } ^ { ( 0 ) , d e c } \} _ { . }$ .   
+2: for each node $i \in \mathcal V$ in parallel do   
+3: Initialize client model θ(0)c,i ${ \pmb \theta } _ { c , i } ^ { ( 0 ) } = \bar { \pmb \theta } _ { c } ^ { ( 0 ) }$ = θ¯(0)c .   
+4: raph encoding. on node $h _ { G , c , i } = h _ { G , c , i } ^ { ( 0 ) }$ end for   
+6: for global round $r _ { g } = 1 , 2 , \ldots , R _ { g }$ do   
+7: // (1) Federated learning of on-node models.   
+8: for each client $i \in \nu$ in parallel do   
+9: $\theta _ { c , i } \gets$ ClientUpdate $( i )$ .   
+11: 10: end for $\begin{array} { r } { \bar { \pmb { \theta } } _ { c }  \sum _ { i \in \mathcal { V } } \frac { N _ { i } } { N } \pmb { \theta } _ { c , i } } \end{array}$ .   
+12: for each client $i \in \nu$ in parallel do   
+13: Initialize client model: $\theta _ { c , i } ^ { ( 0 ) } = \bar { \theta } _ { c }$   
+14: end for   
+15: // (2) Temporal encoding update.   
+16: for each client $i \in \nu$ in parallel do   
+17: $h _ { c , i } \gets$ ClientEncode $( i )$ .   
+18: end for   
+19: // (3) Split Learning of GN.   
+20: Initialize $\pmb { \theta } _ { G N } ^ { ( r _ { g } , 0 ) } = \pmb { \theta } _ { G N } ^ { ( r _ { g } - 1 ) }$   
+21: for server round $r _ { s } = 1 , 2 , \ldots , R _ { s }$ do   
+22: $\{ h _ { G , c , i } | i ~ \in ~ \mathcal { V } \} ~  ~ G N ( \{ h _ { c , i } | i ~ \in ~$   
+23 $\mathcal { V } \rbrace ; \pmb { \theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } )$ . in prale o $i \in \nu$   
+24: $\nabla _ { h _ { G , c , i } } \ell _ { i } \gets$ ClientBackward( $_ { i , h _ { G , c , i } ) }$ .backward(   
+25: $\nabla _ { \pmb { \theta } ^ { ( r _ { g } , r _ { s } - 1 ) } } \ell _ { i } \gets \pmb { h } _ { G , c , i }$ $\overset { \scriptscriptstyle \mathrm { G } } { \nabla } _ { h _ { G , c , i } } \ell _ { i } )$ .   
+26: end for   
+27: $\begin{array} { r l } & { \nabla _ { \pmb { \theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } } \ell  \sum _ { i \in \mathcal { V } } \nabla _ { \pmb { \theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } } \ell _ { i } . } \\ & { \pmb { \theta } _ { G N } ^ { ( r _ { g } , r _ { s } ) }  \pmb { \theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } } \\ & { \qquad - \eta _ { s } \nabla _ { \pmb { \theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } } \ell . } \end{array}$   
+28:   
+29: end for   
+30: ${ \pmb \theta } _ { G N } ^ { ( r _ { g } ) }  { \pmb \theta } _ { G N } ^ { ( r _ { g } , R _ { s } ) }$   
+31: // (4) On-node graph embedding update.   
+32: $\begin{array} { r l } & { \{ h _ { G , c , i } | i \in \mathcal { V } \}  } \\ & { \quad G N ( \{ h _ { c , i } | i \in \mathcal { V } \} ; \theta _ { G N } ^ { ( r _ { g } ) } ) . } \end{array}$   
+33: for each client $i \in \mathcal V$ in parallel do   
+34: Set graph encoding on client as hG,c,i.   
+35: end for   
+36: end for
+
+# Algorithm 2 Training algorithm of CNFGNN on the client side.
+
+# ClientUpdate(i):
+
+1: for client round $r _ { c } = 1 , 2 , \ldots , R _ { c } \ : _ { }$ do   
+2: $\pmb { h } _ { c , i } ^ { ( r _ { c } ) } \gets E n c o d e r _ { i } ( \pmb { x } _ { i } ; \pmb { \theta } _ { c , i } ^ { ( r _ { c } - 1 ) , e n c } )$   
+3: $\hat { \pmb { y } } _ { i }  D e c o d e r _ { i }$ (   
+$x _ { i , m } , [ { h _ { c , i } ^ { ( r _ { c } ) } } ; { h _ { G , c , i } } ] ; \theta _ { c , i } ^ { ( r _ { c } - 1 ) , d e c } ) .$   
+4: 5: θ(rc)c,i ← θ(rc−1)c,i − ηc∇θ(rc−1)c,i \`i. $\ell _ { i } \gets \ell ( \hat { \pmb y } _ { i } , \pmb y )$ .
+
+6: end for
+
+7: θc,i = θ(Rc).   
+8: return $\theta _ { c , i }$ to server.   
+ClientEncode $\mathbf { \rho } ( i )$ :   
+1: return $\begin{array} { r c l } { { { h } } _ { { c } , i } } & { = } & { { E n c o d e r } _ { i } ( { \bf { x } } _ { i } ; { \bf { \bf { \theta } } } _ { c , i } ^ { e n c } ) } \end{array}$ to server.   
+ClientBackward $( i , h _ { G , c , i } )$ :   
+1: $\hat { \pmb { y } } _ { i }  D e c o d e r _ { i } ( x _ { i , m } , [ h _ { c , i } ; h _ { G , c , i } ] ; \pmb { \theta } _ { c , i } ^ { d e c } )$ . 2: $\ell _ { i } \gets \ell ( \hat { \pmb y } _ { i } , \pmb y )$ .   
+3: return $\nabla _ { \boldsymbol { h } _ { G , c , i } } \ell _ { i }$ to server.
+
+where $\mathbf { e } _ { k } , \mathbf { v } _ { i } , \mathbf { u }$ are edge features, node features and global features respectively. $\phi ^ { e } , \phi ^ { v } , \phi ^ { u }$ are neural networks. $\rho ^ { e  v } , \rho ^ { e  u } , \rho ^ { v  u }$ are aggregation functions such as summation. As shown in Figure 1b, we choose a 2-layer GN with residual connections for all experiments. We set $\mathbf { v } _ { i } = h _ { c , i }$ , $\mathbf { e } _ { k } = W _ { r _ { k } , s _ { k } }$ $\cdot$ is the adjacency matrix) , and assign the empty vector to u as the input of the first GN layer. The server-side GN outputs embeddings $\{ h _ { G , c , i } \mid i \in \mathcal { V } \}$ for all nodes, and sends the embedding of each node correspondingly.
+
+# 3.2.3 ALTERNATING TRAINING OF NODE-LEVEL AND SPATIAL MODELS
+
+One challenge brought about by the cross-node federated learning requirement and the server-side GN model is the high communication cost in the training stage. Since we distribute different parts of the model on different devices, Split Learning proposed by (Singh et al., 2019) is a potential solution for training, where hidden vectors and gradients are communicated among devices. However, when we simply train the model end-to-end via Split Learning, the central server needs to receive hidden states from all nodes and to send node embeddings to all nodes in the forward propagation, then it must receive gradients of node embeddings from all nodes and send back gradients of hidden states to all nodes in the backward propagation. Assume all hidden states and node embeddings have the same size $S$ , the total amount of data transmitted in each training round of the GN model is $4 | \nu | S$ .
+
+Table 1: Statistics of datasets PEMS-BAY and METR-LA.   
+
+<table><tr><td>Dataset</td><td>#Nodes</td><td># Directed Edges</td><td># Train Seq</td><td># Val Seq</td><td># Test Seq</td></tr><tr><td>PEMS-BAY</td><td>325</td><td>2369</td><td>36465</td><td>5209</td><td>10419</td></tr><tr><td>METR-LA</td><td>207</td><td>1515</td><td>23974</td><td>3425</td><td>6850</td></tr></table>
+
+To alleviate the high communication cost in the training stage, we instead alternately train models on nodes and the GN model on the server. More specifically, in each round of training, we (1) fix the node embedding $h _ { G , c , i }$ and optimize the encoder-decoder model for $R _ { c }$ rounds, then (2) we optimize the GN model while fixing all models on nodes. Since models on nodes are fixed, $h _ { c , i }$ stays constant during the training of the GN model, and the server only needs to fetch $h _ { c , i }$ from nodes before the training of GN starts and only to communicate node embeddings and gradients. Therefore, the average amount of data transmitted in each round for $R s$ rounds of training of the GN model reduces to $\frac { 2 + \overline { { 2 } } R _ { s } } { R _ { s } } | \mathcal { V } | S$ . We provide more details of the training procedure in Algorithm 1 and Algorithm 2.
+
+To more effectively extract temporal features from each node, we also train the encoder-decoder models on nodes with the FedAvg algorithm proposed in (McMahan et al., 2017). This enables all nodes to share the same feature extractor and thus share a joint hidden space of temporal features, which avoids the potential overfitting of models on nodes and demonstrates faster convergence and better prediction performance empirically.
+
+# 4 EXPERIMENTS
+
+We evaluate the performance of CNFGNN and all baseline methods on the traffic forecasting task, which is an important application for spatio-temporal data modeling. We reuse the following two real-world large-scale datasets in (Li et al., 2018) and follow the same preprocessing procedures: (1) PEMS-BAY: This dataset contains the traffic speed readings from 325 sensors in the Bay Area over 6 months from Jan 1st, 2017 to May 31st, 2017. (2) METR-LA: This dataset contains the traffic speed readings from 207 loop detectors installed on the highway of Los Angeles County over 4 months from Mar 1st, 2012 to Jun 30th, 2012.
+
+For both datasets, we construct the adjacency matrix of sensors using the Gaussian kernel with a threshold: $W _ { i , j } = d _ { i , j }$ if $d _ { i , j } > = \kappa$ else 0, where $\begin{array} { r } { d _ { i , j } = \exp { ( - \frac { \mathrm { d i s t } ( v _ { i } , v _ { j } ) ^ { 2 } } { \sigma ^ { 2 } . } ) } , } \end{array}$ $\mathrm { d i s t } ( v _ { i } , v _ { j } )$ is the road network distance from sensor $v _ { i }$ to sensor $v _ { j }$ , $\sigma$ is the standard deviation of distances and $\kappa$ is the threshold. We set $\kappa = 0 . 1$ for both datasets.
+
+We aggregate traffic speed readings in both datasets into 5-minute windows and truncate the whole sequence to multiple sequences with length 24. The forecasting task is to predict the traffic speed in the following 12 steps of each sequence given the first 12 steps. We show the statistics of both datasets in Table 1.
+
+# 4.1 SPATIO-TEMPORAL DATA MODELING: TRAFFIC FLOW FORECASTING
+
+Baselines We compare CNFGNN with the following baselines. (1) GRU (centralized): a Gated Recurrent Unit (GRU) model trained with centralized sensor data. (2) $\_$ (centralized): a model directly combining GRU and GN trained with centralized data, whose architecture is similar to CNFGNN but all GRU modules on nodes always share the same weights. We see its performance as the upper bound of the performance of CNFGNN. (3) GRU (local): for each node we train a GRU model with only the local data on it. (4) GRU $^ +$ FedAvg: a GRU model trained with the Federated Averaging algorithm (McMahan et al., 2017). (5) $\mathbf { G R U + F M T L }$ : for each node we train a GRU model using the federated multi-task learning (FMTL) with cluster regularization (Smith et al., 2017) given by the adjacency matrix. For each baseline, we have 2 variants of the GRU model to show the effect of on-device model complexity: one with 63K parameters and the other with 727K parameters. For CNFGNN, the encoder-decoder model on each node has 64K parameters and the GN model has 1M parameters.
+
+Table 3: Comparison of the computation cost on edge devices and the communication cost. We use the amount of floating point operations (FLOPS) to measure the computational cost of models on edge devices. We also show the total size of data/parameters transmitted in the training stage (Train Comm Cost) until the model reaches its lowest validation error.   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">Comp Cost On Device (GFLOPS)</td><td colspan="2">PEMS-BAY</td><td colspan="2">METR-LA</td></tr><tr><td>RMSE</td><td>Train Comm Cost (GB)</td><td>RMSE</td><td>Train Comm Cost (GB)</td></tr><tr><td>GRU (63K)+FMTL</td><td>0.159</td><td>3.961</td><td>57.823</td><td>11.548</td><td>99.201</td></tr><tr><td>GRU (727K) + FMTL</td><td>1.821</td><td>3.955</td><td>359.292</td><td>11.570</td><td>722.137</td></tr><tr><td>CNFGNN (64K + 1M)</td><td>0.162</td><td>3.822</td><td>237.654</td><td>11.487</td><td>222.246</td></tr></table>
+
+Discussion Table 2 shows the comparison of forecasting performance and Table 3 shows the comparison of computation cost on device and communication cost of CNFGNN and baselines. We make the following observations. Firstly, when we compare the best forecasting performance of each baseline over the 2 GRU variants, GRU trained with FedAvg performs the worst in terms of forecasting performance compared to GRU trained with centralized data and GRU trained with local data (4.432 vs 4.010/4.124 on PEMS-BAY and 12.058 vs 11.730/11.801 on METRLA), showing that the data distributions on different nodes are highly heterogeneous, and training one single model ignoring the heterogeneity is suboptimal.
+
+Table 2: Comparison of performance on the traffic flow forecasting task. We use the Rooted Mean Squared Error (RMSE) to evaluate the forecasting performance.   
+
+<table><tr><td>Method</td><td>PEMS-BAY</td><td>METR-LA</td></tr><tr><td>GRU (centralized, 63K)</td><td>4.124</td><td>11.730</td></tr><tr><td>GRU (centralized, 727K) GRU + GN</td><td>4.128</td><td>11.787</td></tr><tr><td>(centralized, 64K + 1M)</td><td>3.816</td><td>11.471</td></tr><tr><td>GRU (local, 63K)</td><td>4.010</td><td>11.801</td></tr><tr><td>GRU (local, 727K)</td><td>4.152</td><td>12.224</td></tr><tr><td>GRU (63K) + FedAvg</td><td>4.512</td><td>12.132</td></tr><tr><td>GRU (727K) + FedAvg</td><td>4.432</td><td>12.058</td></tr><tr><td>GRU (63K)+FMTL</td><td>3.961</td><td>11.548</td></tr><tr><td>GRU (727K) + FMTL</td><td>3.955</td><td>11.570</td></tr><tr><td>CNFGNN (64K + 1M)</td><td>3.822</td><td>11.487</td></tr></table>
+
+Secondly, both the $\mathrm { G R U + F M T L }$ baseline and CNFGNN consider the spatial relations among nodes and show better forecasting performance than baselines without relation information. This shows that the modeling of spatial dependencies is critical for the forecasting task.
+
+Lastly, CNFGNN achieves the lowest forecasting error on both datasets. The baselines that increases the complexity of on-device models (GRU $( 7 2 7 \mathrm { K } ) + \mathrm { F M T L }$ ) gains slight or even no improvement at the cost of higher computation cost on edge devices and larger communication cost. However, due to its effective modeling of spatial dependencies in data, CNFGNN not only has the largest improvement of forecasting performance, but also keeps the computation cost on devices almost unchanged and maintains modest communication cost compared to baselines increasing the model complexity on devices.
+
+# 4.2 INDUCTIVE LEARNING ON UNSEEN NODES
+
+Set-up Another advantage of CNFGNN is that it can conduct inductive learning and generalize to larger graphs with nodes unobserved during the training stage. We evaluate the performance of CNFGNN under the following inductive learning setting: for each dataset, we first sort all sensors based on longitudes, then use the subgraph on the first $\eta \%$ of sensors to train the model and evaluate the trained model on the entire graph. For each dataset we select $\eta \% = 2 5 \%$ , $5 0 \%$ , $7 5 \%$ . Over all baselines following the cross-node federated learning constraint, GRU (local) and $\mathrm { G R U + F M T L }$ requires training new models on unseen nodes and only GRU $^ +$ FedAvg is applicable to the inductive learning setting.
+
+Table 4: Inductive learning performance measured with rooted mean squared error (RMSE).   
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">PEMS-BAY</td><td colspan="3">METR-LA</td></tr><tr><td>25%</td><td>50%</td><td>75%</td><td>25%</td><td>50%</td><td>75%</td></tr><tr><td>GRU (63K) + FedAvg</td><td>4.863</td><td>4.847</td><td>4.859</td><td>11.993</td><td>12.104</td><td>12.014</td></tr><tr><td>CNFGNN (64K + 1M)</td><td>4.541</td><td>4.598</td><td>4.197</td><td>12.013</td><td>11.815</td><td>11.676</td></tr></table>
+
+![](images/43859867fa889cd71a153f132f5e85593bfc311ff2369e88c13a34e041c3045c.jpg)  
+Figure 2: Validation loss during the training stage of different training strategies.
+
+Discussion Table 4 shows the performance of inductive learning of CNFGNN and GRU $^ +$ FedAvg baseline on both datasets. We observe that under most settings, CNFGNN outperforms the $\mathrm { G R U + }$ FedAvg baseline (except on the METR-LA dataset with $2 5 \%$ nodes observed in training, where both models perform similarly), showing that CNFGNN has the stronger ability of generalization.
+
+4.3 ABLATION STUDY: EFFECT OF ALTERNATING TRAINING AND FEDAVG ON NODE-LEVEL AND SPATIAL MODELS
+
+Baselines We compare the effect of different training strategies of CNFGNN: (1) Centralized: CNFGNN trained with centralized data where all nodes share one single encoder-decoder. (2)
+
+Table 5: Comparison of test error (RMSE) and the communication cost during training of different training strategies of CNFGNN.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">PEMS-BAY</td><td colspan="2">METR-LA</td></tr><tr><td>RMSE</td><td>Train Comm Cost (GB)</td><td>RMSE</td><td>Train Comm Cost (GB)</td></tr><tr><td>Centralized</td><td>3.816</td><td></td><td>11.471</td><td></td></tr><tr><td>SL</td><td>3.914</td><td>350.366</td><td>12.186</td><td>307.627</td></tr><tr><td>SL + FedAvg</td><td>4.383</td><td>80.200</td><td>11.631</td><td>343.031</td></tr><tr><td>AT, w/o FedAvg</td><td>4.003</td><td>5221.576</td><td>11.912</td><td>2434.985</td></tr><tr><td>AT +FedAvg</td><td>3.822</td><td>237.654</td><td>11.487</td><td>222.246</td></tr></table>
+
+Split Learning (SL): CNFGNN trained with split learning (Singh et al., 2019), where models on nodes and the model on the server are jointly trained by exchanging hidden vectors and gradients. (3) Split
+
+Learning $^ +$ FedAvg $\mathrm { \bf S L + }$ FedAvg): A variant of SL that synchronizes the weights of encoderdecoder modules periodically with FedAvg. (4) Alternating training without Federated Averaging of models on nodes (AT, w/o FedAvg). (5) Alternating training with Federated Averaging on nodes described in Section 3.2.3 $\mathbf { \Delta A T } + \mathbf { F e d A v g }$ ).
+
+Discussion Figure 2 shows the validation loss during training of different training strategies on PEMS-BAY and METR-LA datasets, and Table 5 shows their prediction performance and the communication cost in training. We notice that (1) SL suffers from suboptimal prediction performance and high communication costs on both datasets; SL $^ +$ FedAvg does not have consistent results on both datasets and its performance is always inferior to AT $\cdot$ FedAvg. AT $\cdot$ FedAvg consistently outperforms other baselines on both datasets, including its variant without FedAvg. (2) AT $^ +$ FedAvg has the lowest communication cost on METR-LA and the 2nd lowest communication cost on PEMS-BAY, on which the baseline with the lowest communication cost ( $\mathrm { S L } +$ FedAvg) has a much higher prediction error (4.383 vs 3.822). Both illustrate that our proposed training strategy, $\mathrm { S L } +$ FedAvg, achieves the best prediction performance as well as low communication cost compared to other baseline strategies.
+
+# 4.4 ABLATION STUDY: EFFECT OF CLIENT ROUNDS AND SERVER ROUNDS
+
+Set-up We further investigate the effect of different compositions of the number of client rounds $( R _ { s } )$ in Algorithm 2 and the number of server rounds $( R _ { c } )$ in Algorithm 1. To this end, we vary both $R _ { c }$ and $R _ { s }$ over [1,10,20].
+
+Discussion Figure 3 shows the forecasting performance (measured with RMSE) and the total communication cost in the training of CNFGNN under all compositions of $( R _ { c }$ , $R _ { s }$ ) on the METR-LA dataset. We observe that: (1) Models with lower ${ \cal R } _ { c } / { \cal R } _ { s }$ ratios $( R _ { c } / R _ { s } ~ < ~ 0 . 5 )$ tend to have lower forecasting errors while models with higher ${ \cal R } _ { c } / { \cal R } _ { s }$ ratios $( R _ { c } / R _ { s } > 2 )$ have lower communication cost in training. This is because the lower ratio of ${ \cal R } _ { c } / { \cal R } _ { s }$ encourages more frequent exchange of node information at the expense of higher communication cost, while the higher ratio of ${ \cal R } _ { c } / { \cal R } _ { s }$ acts in the opposite way. (2) Models with similar ${ \cal R } _ { c } / { \cal R } _ { s }$ ratios have similar communication costs, while those with lower
+
+![](images/aeed15dde9053561a6b6271b85b07c237441559b0d5bbb78fa4218bcae933a69.jpg)  
+Figure 3: Effect of client rounds and server rounds $( R _ { c } , R _ { s } )$ on forecasting performance and communication cost.
+
+$R _ { c }$ values perform better, corroborating our observation in (1) that frequent node information exchange improves the forecasting performance.
+
+# 5 CONCLUSION
+
+We propose Cross-Node Federated Graph Neural Network (CNFGNN), which bridges the gap between modeling complex spatio-temporal data and decentralized data processing by enabling the use of graph neural networks (GNNs) in the federated learning setting. We accomplish this by decoupling the learning of local temporal models and the server-side spatial model using alternating optimization of spatial and temporal modules based on split learning and federated averaging. Our experimental results on traffic flow prediction on two real-world datasets show superior performance as compared to competing techniques. Our future work includes applying existing GNN models with sampling strategies and integrating them into CNFGNN for large-scale graphs, extending CNFGNN to a fully decentralized framework, and incorporating existing privacy-preserving methods for graph learning to CNFGNN, to enhance federated learning of spatio-temporal dynamics.
+
+# REFERENCES
+
+Alekh Agarwal, Animashree Anandkumar, Prateek Jain, Praneeth Netrapalli, and Rashish Tandon. Learning sparsely used overcomplete dictionaries. In Conference on Learning Theory, pp. 123– 137, 2014.
+
+Sanjeev Arora, Rong Ge, and Ankur Moitra. New algorithms for learning incoherent and overcomplete dictionaries. In Conference on Learning Theory, pp. 779–806, 2014.
+
+Sanjeev Arora, Rong Ge, Tengyu Ma, and Ankur Moitra. Simple, efficient, and neural algorithms for sparse coding. 2015.
+
+Omri Azencot, N Benjamin Erichson, Vanessa Lin, and Michael W Mahoney. Forecasting sequential data using consistent koopman autoencoders. In ICML, 2020.
+
+Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, et al. Interaction networks for learning about objects, relations and physics. In Advances in neural information processing systems, pp. 4502–4510, 2016.
+
+Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018.
+
+Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1724–1734, 2014.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in neural information processing systems, pp. 1024–1034, 2017.
+
+Chaoyang He, Salman Avestimehr, and Murali Annavaram. Group knowledge transfer: Collaborative training of large cnns on the edge. arXiv preprint arXiv:2007.14513, 2020.
+
+Wenbing Huang, Tong Zhang, Yu Rong, and Junzhou Huang. Adaptive sampling towards fast graph representation learning. In Advances in neural information processing systems, pp. 4558–4567, 2018.
+
+Prateek Jain and Purushottam Kar. Non-convex optimization for machine learning. Foundations and Trends $\textsuperscript { \textregistered }$ in Machine Learning, 10(3-4):142–363, 2017. ISSN 1935-8237. doi: 10.1561/ 2200000058. URL http://dx.doi.org/10.1561/2200000058.
+
+Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurelien Bellet, Mehdi Bennis, Arjun Nitin ´ Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019.
+
+Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank J Reddi, Sebastian U Stich, and Ananda Theertha Suresh. Scaffold: Stochastic controlled averaging for federated learning. In Proceedings of the 37th International Conference on Machine Learning, 2020.
+
+Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017.
+
+Thomas N Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard S Zemel. Neural relational inference for interacting systems. In ICML, 2018.
+
+Max Guangyu Li, Bo Jiang, Hao Zhu, Zhengping Che, and Yan Liu. Generative attention networks for multi-agent behavioral modeling. In AAAI, 2020a.
+
+Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. Federated optimization in heterogeneous networks. In Proceedings of the 3rd MLSys Conference, 2020b.
+
+Yaguang Li, Rose Yu, Cyrus Shahabi, and Yan Liu. Diffusion convolutional recurrent neural network: Data-driven traffic forecasting. In International Conference on Learning Representations (ICLR ’18), 2018.
+
+Paul Pu Liang, Terrance Liu, Liu Ziyin, Ruslan Salakhutdinov, and Louis-Philippe Morency. Think locally, act globally: Federated learning with local and global representations. arXiv preprint arXiv:2001.01523, 2020.
+
+Ziyu Liu, Hongwen Zhang, Zhenghao Chen, Zhiyong Wang, and Wanli Ouyang. Disentangling and unifying graph convolutions for skeleton-based action recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 143–152, 2020.
+
+Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial Intelligence and Statistics, pp. 1273–1282. PMLR, 2017.
+
+Guangxu Mei, Ziyu Guo, Shijun Liu, and Li Pan. Sgnn: A graph neural network based federated learning approach by hiding structure. In 2019 IEEE International Conference on Big Data (Big Data), pp. 2560–2568. IEEE, 2019.
+
+Sina Sajadmanesh and Daniel Gatica-Perez. When differential privacy meets graph neural networks. arXiv preprint arXiv:2006.05535, 2020.
+
+Sungyong Seo, Chuizheng Meng, and Yan Liu. Physics-aware difference graph networks for sparsely-observed dynamics. In International Conference on Learning Representations, 2019.
+
+Abhishek Singh, Praneeth Vepakomma, Otkrist Gupta, and Ramesh Raskar. Detailed comparison of communication efficiency of split learning and federated learning. arXiv preprint arXiv:1909.09145, 2019.
+
+Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet S Talwalkar. Federated multi-task learning. In Advances in Neural Information Processing Systems, pp. 4424–4434, 2017.
+
+Toyotaro Suzumura, Yi Zhou, Natahalie Barcardo, Guangnan Ye, Keith Houck, Ryo Kawahara, Ali Anwar, Lucia Larise Stavarache, Daniel Klyashtorny, Heiko Ludwig, et al. Towards federated graph learning for collaborative financial crimes detection. arXiv preprint arXiv:1909.12946, 2019.
+
+Keyulu Xu, Jingling Li, Mozhi Zhang, Simon S Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. What can neural networks reason about? In International Conference on Learning Representations (ICLR), 2019.
+
+Sijie Yan, Yuanjun Xiong, and Dahua Lin. Spatial temporal graph convolutional networks for skeleton-based action recognition. In AAAI, 2018.
+
+Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 974– 983, 2018.
+
+Jiaxuan You, Rex Ying, and Jure Leskovec. Position-aware graph neural networks. In Proceedings of the 36th International Conference on Machine Learning, 2019.
+
+Bing Yu, Haoteng Yin, and Zhanxing Zhu. Spatio-temporal graph convolutional networks: A deep learning framework for traffic forecasting. In Proceedings of the 27th International Joint Conference on Artificial Intelligence (IJCAI), 2018.
+
+Jun Zhou, Chaochao Chen, Longfei Zheng, Xiaolin Zheng, Bingzhe Wu, Ziqi Liu, and Li Wang. Privacy-preserving graph neural network for node classification. arXiv preprint arXiv:2005.11903, 2020.
+
+# A APPENDIX
+
+A.1 DETAILED EXPERIMENT SETTINGS
+
+Unless noted otherwise, all models are optimized using the Adam optimizer with the learning rate 1e-3.
+
+GRU (centralized) : Gated Recurrent Unit (GRU) model trained with centralized sensor data. The GRU model with 63K parameters is a 1-layer GRU with hidden dimension 100, and the GRU model with 727K parameters is a 2-layer GRU with hidden dimension 200.
+
+GRU (local) We train one GRU model for each node with the local data only.
+
+GRU $^ +$ FedAvg We train a single GRU model with Federated Averaging (McMahan et al., 2017).   
+We select 1 as the number of local epochs.
+
+$\mathbf { G R U } + \mathbf { F M T L }$ We train one GRU model for each node using the federated multi-task learning (FMTL) with cluster regularization (Smith et al., 2017) given by the adjacency matrix. More specifically, the cluster regularization (without the L2-norm regularization term) takes the following form:
+
+$$
+\mathcal { R } ( W , \mathfrak { L } ) = \lambda \mathrm { t r } ( W \Omega W ^ { T } ) .
+$$
+
+Given the constructed adjacency matrix $\pmb { A }$ , $\begin{array} { r } { \pmb { \Omega } = \frac { 1 } { | \mathcal { V } | } ( \pmb { D } - \pmb { A } ) = \frac { 1 } { | \mathcal { V } | } \pmb { L } } \end{array}$ , where $_ { D }$ is the degree matrix and $\pmb { L }$ is the Laplacian matrix. Equation A1 can be reformulated as:
+
+$$
+\begin{array} { r l } {  { \mathcal { R } ( W , \pmb { \Omega } ) = \lambda \mathrm { t r } ( W \pmb { \Omega } W ^ { T } ) = \frac { \lambda } { | \mathcal { V } | } \mathrm { t r } ( W \pmb { L } W ^ { T } ) } } \\ & { = \frac { \lambda } { | \mathcal { V } | } \mathrm { t r } ( \displaystyle \sum _ { i \in \mathcal { V } } \pmb { w } _ { i } \displaystyle \sum _ { j \not = i } a _ { i j } \pmb { w } _ { i } ^ { T } - \displaystyle \sum _ { j \not = i } \pmb { w } _ { i } a _ { i j } \pmb { w } _ { j } ^ { T } ) } \\ & { = \lambda _ { 1 } ( \displaystyle \sum _ { i \in \mathcal { V } } \displaystyle \sum _ { j \not = i } \alpha _ { i , j } \langle \pmb { w } _ { i } , \pmb { w } _ { i } - \pmb { w } _ { j } \rangle ) . } \end{array}
+$$
+
+We implement the cluster regularization via sharing model weights between each pair of nodes connected by an edge and select $\lambda _ { 1 } = 0 . 1$ .
+
+CNFGNN We use a GRU-based encoder-decoder model as the model on nodes, which has 1 GRU layer and hidden dimension 64. We use a 2-layer Graph Network (GN) with residual connections as the Graph Neural Network model on the server side. We use the same network architecture for the edge/node/global update function in each GN layer: a multi-layer perceptron (MLP) with 3 hidden layers, whose sizes are [256, 256, 128] respectively. We choose $R _ { c } = 1 , R _ { s } = 2 0$ for experiments on PEMS-BAY, and $R _ { c } = 1 , R _ { s } = 1$ for METR-LA.
+
+# A.2 CALCULATION OF COMMUNICATION COST
+
+We denote $R$ as the number of communication rounds for one model to reach the lowest validation error in the training stage.
+
+$\mathbf { G R U + F M T L }$ Using Equation A2, in each communication round, each pair of nodes exchange their model weights, thus the total communicated data amount is calculated as:
+
+$$
+R \times \# \mathrm { n o n s e l f ~ d i r e c t e d ~ e d g e s } \times \mathrm { s i z e ~ o f ~ n o d e ~ m o d e l ~ w e i g h t s } .
+$$
+
+CNFGNN (AT $^ +$ FedAvg) In each communication round, the central server fetches and sends back model weights to each node for Federated Averaging, and transmits hidden vectors and gradients for Split Learning. The total communicated data amount is calculated as:
+
+$$
+\begin{array} { r l } & { R \times ( \mathrm { \# n o d e s } \times \mathrm { s i z e ~ o f ~ n o d e ~ m o d e l ~ w e i g h t s } \times 2 } \\ & { \quad + ( 1 + 2 * \mathrm { s e r v e r ~ r o u n d } + 1 ) \times \mathrm { \# n o d e s } \times \mathrm { h i d d e n ~ s t a t e ~ s i z e } ) . } \end{array}
+$$
+
+CNFGNN (SL) In each communication round, each node sends and fetches hidden vectors and graidents twice (one for encoder, the other for decoder) and the total communicated data amount is:
+
+$$
+-
+$$
+
+CNFGNN $\mathrm { \bf { S L + } }$ FedAvg) Compared to CNFGNN (SL), the method has extra communcation cost for FedAvg in each round, thus the total communicated data amount is:
+
+$$
+-
+$$
+
+CNFGNN (AT, w/o FedAvg) Compared to CNFGNN (AT $^ +$ FedAvg), there is no communcation cost for the FedAvg part, thus the total communcated data amount is:
+
+$$
+-
+$$
+
+Table A1: Parameters used for calculating the communication cost of $\mathrm { G R U + F M T L }$ .   
+
+<table><tr><td colspan="2">Method</td><td colspan="2">GRU (63K) + FMTL GRU (727K) + FMTL</td></tr><tr><td colspan="2">Node Model Weights Size (GB)</td><td>2.347E-4</td><td>2.708E-3</td></tr><tr><td rowspan="3">PEMS-BAY</td><td>#Nonself Directed Edges</td><td>2369</td><td></td></tr><tr><td>R</td><td>104</td><td>56</td></tr><tr><td>Train Comm Cost (GB)</td><td>57.823</td><td>359.292</td></tr><tr><td rowspan="3">METR-LA</td><td>#Nonself Directed Edges</td><td></td><td>1515</td></tr><tr><td>R</td><td>279</td><td>176</td></tr><tr><td>Train Comm ( Cost (GB)</td><td>99.201</td><td>722.137</td></tr></table>
+
+Table A2: Parameters used for calculating the communication cost of CNFGNN (AT $\cdot$ FedAvg).   
+
+<table><tr><td>Node Model Weights Size (GB)</td><td colspan="2">2.384E-4</td></tr><tr><td rowspan="3">PEMS-BAY</td><td>#Nodes</td><td>325</td></tr><tr><td>Hidden State Size (GB) Server Round</td><td>2.173E-3 20</td></tr><tr><td>R</td><td>2</td></tr><tr><td rowspan="3">METR-LA</td><td>Train Comm Cost (GB) #Nodes</td><td>237.654 207</td></tr><tr><td>Hidden State Size (GB)</td><td>1.429E-3</td></tr><tr><td>Server Round R</td><td>1 46</td></tr></table>
+
+# A.3 INDUCTIVE LEARNING
+
+We have added results using $\cdot$ and $5 \%$ data on both datasets and we show the table of inductive learning results as Table A6. We observe that: (1) With the portion of visible nodes in the training stage increasing, the prediction error of CNFGNN decreases drastically. However, the increase of the portion of visible nodes has negligible contribution to the performance of GRU $\cdot$ FedAvg after the portion surpasses $\cdot$ . Since increasing the ratio of seen nodes in training introduces more complex relationships among nodes to the training data, the difference of performance illustrates that CNFGNN has a stronger capability of capturing complex spatial relationships. (2) When the ratio of visible nodes in training is extremely low $\cdot$ , there is not enough spatial relationship information in the training data to train the GN module in CNFGNN, and the performance of CNFGNN may not be ideal. We visualize the subgraphs visible in training under different ratios in Figure A1. However, as long as the training data covers a moderate portion of the spatial information of the whole graph, CNFGNN can still leverage the learned spatial connections among nodes effectively and outperforms GRU $+$ FedAvg. We empirically show that the necessary ratio can vary for different datasets ( $2 5 \%$ for PEMS-BAY and $\cdot$ for METR-LA).
+
+Table A3: Parameters used for calculating the communication cost of CNFGNN (SL).   
+
+<table><tr><td rowspan="2">PEMS-BAY</td><td>#Nodes Hidden State Size (GB) R</td><td>325 2.173E-3 31</td></tr><tr><td>Train Comm Cost (GB)</td><td>350.366</td></tr><tr><td rowspan="3">METR-LA</td><td>#Nodes Hidden State Size (GB)</td><td>207 1.429E-3</td></tr><tr><td>R</td><td>65</td></tr><tr><td>Train Comm Cost (GB)</td><td>307.627</td></tr></table>
+
+Table A4: Parameters used for calculating the communication cost of CNFGNN (SL $^ +$ FedAvg).   
+Table A5: Parameters used for calculating the communication cost of CNFGNN (AT, w/o FedAvg).   
+
+<table><tr><td>Node Model Weights Size (GB)</td><td colspan="2">2.384E-4</td></tr><tr><td>PEMS-BAY</td><td>#Nodes Hidden State Size (GB) R Train Comm Cost (GB)</td><td>325 2.173E-3 7 80.200</td></tr><tr><td>METR-LA</td><td>#Nodes Hidden State Size (GB) R Train Comm Cost (GB)</td><td>207 1.429E-3 71 343.031</td></tr></table>
+
+![](images/82218b6d5ed79cf9fb8faba82ec055c2f31115267be423b485d38a1203e54314.jpg)  
+Figure A1: Visualization of subgraphs visible in training under different ratios.
+
+Table A6: Inductive learning performance measured with rooted mean squared error (RMSE).   
+
+<table><tr><td rowspan="2">Method</td><td colspan="5">PEMS-BAY</td><td colspan="5">METR-LA</td></tr><tr><td>5%</td><td>25%</td><td>50%</td><td>75%</td><td>90%</td><td>5%</td><td>25%</td><td>50%</td><td>75%</td><td>90%</td></tr><tr><td>GRU (63K)+ FedAvg</td><td>5.087</td><td>4.863</td><td>4.847</td><td>4.859</td><td>4.866</td><td>12.128</td><td>11.993</td><td>12.104</td><td>12.014</td><td>12.016</td></tr><tr><td>CNFGNN (64K + 1M)</td><td>5.869</td><td>4.541</td><td>4.598</td><td>4.197</td><td>3.942</td><td>13.931</td><td>12.013</td><td>11.815</td><td>11.676</td><td>11.629</td></tr></table>
+
+# A.4 THE HISTOGRAMS OF DATA ON DIFFERENT NODES
+
+We show the histograms of traffic speed on different nodes of PEMS-BAY and METR-LA in Figure A2. For each dataset, we only show the first 100 nodes ranked by their IDs for simplicity. The histograms show that the data distribution varies with nodes, thus data on different nodes are not independent and identically distributed.
+
+![](images/fbb9448d998bae68ee364eb978642afeeb3a587536740eb8563d4983ca31138b.jpg)  
+Figure A2: The histograms of data on the first 100 nodes ranked by ID.

parse/train/HWX5j6Bv_ih/HWX5j6Bv_ih_content_list.json

@@ -0,0 +1,1860 @@
+[
+    {
+        "type": "text",
+        "text": "CROSS-NODE FEDERATED GRAPH NEURAL NETWORK FOR SPATIO-TEMPORAL DATA MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vast amount of data generated from networks of sensors, wearables, and the Internet of Things (IoT) devices underscores the need for advanced modeling techniques that leverage the spatio-temporal structure of decentralized data due to the need for edge computation and licensing (data access) issues. While federated learning (FL) has emerged as a framework for model training without requiring direct data sharing and exchange, effectively modeling the complex spatiotemporal dependencies to improve forecasting capabilities still remains an open problem. On the other hand, state-of-the-art spatio-temporal forecasting models assume unfettered access to the data, neglecting constraints on data sharing. To bridge this gap, we propose a federated spatio-temporal model – Cross-Node Federated Graph Neural Network (CNFGNN) – which explicitly encodes the underlying graph structure using graph neural network (GNN)-based architecture under the constraint of cross-node federated learning, which requires that data in a network of nodes is generated locally on each node and remains decentralized. CNFGNN operates by disentangling the temporal dynamics modeling on devices and spatial dynamics on the server, utilizing alternating optimization to reduce the communication cost, facilitating computations on the edge devices. Experiments on the traffic flow forecasting task show that CNFGNN achieves the best forecasting performance in both transductive and inductive learning settings with no extra computation cost on edge devices, while incurring modest communication cost. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            578,
+            336,
+            593
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Modeling the dynamics of spatio-temporal data generated from networks of edge devices or nodes (e.g. sensors, wearable devices and the Internet of Things (IoT) devices) is critical for various applications including traffic flow prediction (Li et al., 2018; Yu et al., 2018), forecasting (Seo et al., 2019; Azencot et al., 2020), and user activity detection (Yan et al., 2018; Liu et al., 2020). While existing works on spatio-temporal dynamics modeling (Battaglia et al., 2016; Kipf et al., 2018; Battaglia et al., 2018) assume that the model is trained with centralized data gathered from all devices, the volume of data generated at these edge devices precludes the use of such centralized data processing, and calls for decentralized processing where computations on the edge can lead to significant gains in improving the latency. In addition, in case of spatio-temporal forecasting, the edge devices need to leverage the complex inter-dependencies to improve the prediction performance. Moreover, with increasing concerns about data privacy and its access restrictions due to existing licensing agreements, it is critical for spatio-temporal modeling to utilize decentralized data, yet leveraging the underlying relationships for improved performance. ",
+        "bbox": [
+            174,
+            611,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although recent works in federated learning (FL) (Kairouz et al., 2019) provides a solution for training a model with decentralized data on multiple devices, these works either do not consider the inherent spatio-temporal dependencies (McMahan et al., 2017; Li et al., 2020b; Karimireddy et al., 2020) or only model it implicitly by imposing the graph structure in the regularization on model weights (Smith et al., 2017), the latter of which suffers from the limitation of regularization based methods due to the assumption that graphs only encode similarity of nodes (Kipf & Welling, 2017), and cannot operate in settings where only a fraction of devices are observed during training (inductive learning setting). As a result, there is a need for an architecture for spatio-temporal data modeling which enables reliable computation on the edge, while maintaining the data decentralized. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To this end, leveraging recent works on federated learning (Kairouz et al., 2019), we introduce the cross-node federated learning requirement to ensure that data generated locally at a node remains decentralized. Specifically, our architecture – Cross-Node Federated Graph Neural Network (CNFGNN), aims to effectively model the complex spatio-temporal dependencies under the cross-node federated learning constraint. For this, CNFGNN decomposes the modeling of temporal and spatial dependencies using an encoder-decoder model on each device to extract the temporal features with local data, and a Graph Neural Network (GNN) based model on the server to capture spatial dependencies among devices. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            214
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As compared to existing federated learning techniques that rely on regularization to incorporate spatial relationships, CNFGNN leverages an explicit graph structure using a graph neural networkbased (GNNs) architecture, which leads to performance gains. However, the federated learning (data sharing) constraint means that the GNN cannot be trained in a centralized manner, since each node can only access the data stored on itself. To address this, CNFGNN employs Split Learning (Singh et al., 2019) to train the spatial and temporal modules. Further, to alleviate the associated high communication cost incurred by Split Learning, we propose an alternating optimization-based training procedure of these modules, which incurs only half the communication overhead as compared to a comparable Split Learning architecture. Here, we also use Federated Averaging (FedAvg) (McMahan et al., 2017) to train a shared temporal feature extractor for all nodes, which leads to improved empirical performance. ",
+        "bbox": [
+            174,
+            222,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are as follows : ",
+        "bbox": [
+            176,
+            382,
+            429,
+            396
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We propose Cross-Node Federated Graph Neural Network (CNFGNN), a GNN-based federated learning architecture that captures complex spatio-temporal relationships among multiple nodes while ensuring that the data generated locally remains decentralized at no extra computation cost at the edge devices.   \n2. Our modeling and training procedure enables GNN-based architectures to be used in federated learning settings. We achieve this by disentangling the modeling of local temporal dynamics on edge devices and spatial dynamics on the central server, and leverage an alternating optimization-based procedure for updating the spatial and temporal modules using Split Learning and Federated Averaging to enable effective GNN-based federated learning.   \n3. We demonstrate that CNFGNN achieves the best prediction performance (both in transductive and inductive settings) at no extra computation cost on edge devices with modest communication cost, as compared to the related techniques on a traffic flow prediction task. ",
+        "bbox": [
+            212,
+            409,
+            825,
+            587
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            607,
+            344,
+            623
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our method derives elements from graph neural networks, federated learning and privacy-preserving graph learning, we now discuss related works in these areas in relation to our work. ",
+        "bbox": [
+            176,
+            640,
+            823,
+            667
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs). GNNs have shown their superior performance on various learning tasks with graph-structured data, including graph embedding (Hamilton et al., 2017), node classification (Kipf & Welling, 2017), spatio-temporal data modeling (Yan et al., 2018; Li et al., 2018; Yu et al., 2018) and multi-agent trajectory prediction (Battaglia et al., 2016; Kipf et al., 2018; Li et al., 2020a). Recent GNN models (Hamilton et al., 2017; Ying et al., 2018; You et al., 2019; Huang et al., 2018) also have sampling strategies and are able to scale on large graphs. While GNNs enjoy the benefit from strong inductive bias (Battaglia et al., 2018; Xu et al., 2019), most works require centralized data during the training and the inference processes. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            796
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Federated Learning (FL). Federated learning is a machine learning setting where multiple clients train a model in collaboration with decentralized training data (Kairouz et al., 2019). It requires that the raw data of each client is stored locally without any exchange or transfer. However, the decentralized training data comes at the cost of less utilization due to the heterogeneous distributions of data on clients and the lack of information exchange among clients. Various optimization algorithms have been developed for federated learning on non-IID and unbalanced data (McMahan et al., 2017; Li et al., 2020b; Karimireddy et al., 2020). Smith et al. (2017) propose a multi-task learning framework that captures relationships amongst data. While the above works mitigate the caveat of missing neighbors’ information to some extent, they are not as effective as GNN models and still suffer from the absence of feature exchange and aggregation. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Alternating Optimization. Alternating optimization is a popular choice in non-convex optimization (Agarwal et al., 2014; Arora et al., 2014; 2015; Jain & Kar, 2017). In the context of Federated Learning, Liang et al. (2020) uses alternating optimization for learning a simple global model and reduces the number of communicated parameters, and He et al. (2020) uses alternating optimization for knowledge distillation from server models to edge models. In our work, we utilize alternating optimization to effectively train on-device modules and the server module jointly, which captures temporal and spatial relationships respectively. ",
+        "bbox": [
+            174,
+            150,
+            823,
+            247
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Privacy-Preserving Graph Learning. Suzumura et al. (2019) and Mei et al. (2019) use statistics of graph structures instead of node information exchange and aggregation to avoid the leakage of node information. Recent works have also incorporated graph learning models with privacypreserving techniques such as Differential Privacy (DP), Secure Multi-Party Computation (MPC) and Homomorphic Encryption (HE). Zhou et al. (2020) utilize MPC and HE when learning a GNN model for node classification with vertically split data to preserve silo-level privacy instead of nodelevel privacy. Sajadmanesh & Gatica-Perez (2020) preprocesses the input raw data with DP before feeding it into a GNN model. Composing privacy-preserving techniques for graph learning can help build federated learning systems following the privacy-in-depth principle, wherein the privacy properties degrade as gracefully as possible if one technique fails (Kairouz et al., 2019). ",
+        "bbox": [
+            174,
+            266,
+            825,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 CROSS-NODE FEDERATED GRAPH NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            428,
+            660,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            392,
+            476
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given a dataset with a graph $\\mathcal { G } = ( \\nu , \\mathcal { E } )$ , a feature tensor $\\pmb { \\mathsf { X } } \\in \\mathbb { R } ^ { | \\mathcal { V } | \\times \\hdots }$ and a label tensor ${ \\pmb { \\mathsf { Y } } } \\in { }$ $\\mathbb { R } ^ { | \\nu | \\times \\dots }$ , we consider learning a model under the cross-node federated learning constraint: node feature $\\pmb { x } _ { i } = \\pmb { \\mathrm { X } } _ { i , \\dots }$ , node label $\\begin{array} { r } { \\mathbf { { y } } _ { i } = \\mathbf { { Y } } _ { i , \\dots } } \\end{array}$ , and model output $\\hat { y } _ { i }$ are only visible to the node $i$ . ",
+        "bbox": [
+            174,
+            487,
+            823,
+            532
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One typical task that requires the cross-node federated learning constraint is the prediction of spatiotemporal data generated by a network of sensors. In such a scenario, $\\nu$ is the set of sensors and $\\mathcal { E }$ describes relations among sensors (e.g. $e _ { i j } \\in \\mathcal { E }$ if and only if the distance between $v _ { i }$ and $v _ { j }$ is below some threshold). The feature tensor $\\pmb { x } _ { i } \\in \\mathbb { R } ^ { m \\times D }$ represents the $i$ -th sensor’s records in the $D$ -dim space during the past $m$ time steps, and the label $\\dot { \\boldsymbol { y } } _ { i } \\in \\mathbb { R } ^ { n \\times D }$ represents the $i$ -th sensor’s records in the future $n$ time steps. Since records collected on different sensors owned by different users/organizations may not be allowed to be shared due to the need for edge computation or licensing issues on data access, it is necessary to design an algorithm modeling the spatio-temporal relation without any direct exchange of node-level data. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            666
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 PROPOSED METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            356,
+            700
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now introduce our proposed Cross-Node Federated Graph Neural Network (CNFGNN) model. Here, we begin by disentangling the modeling of node-level temporal dynamics and server-level spatial dynamics as follows: (i) (Figure 1c) on each node, an encoder-decoder model extracts temporal features from data on the node and makes predictions; (ii) (Figure 1b) on the central server, a Graph Network (GN) (Battaglia et al., 2018) propagates extracted node temporal features and outputs node embeddings, which incorporate the relationship information amongst nodes. (i) has access to the not shareable node data and is executed on each node locally. (ii) only involves the upload and download of smashed features and gradients instead of the raw data on nodes. This decomposition enables the exchange and aggregation of node information under the cross-node federated learning constraint. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            838
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 MODELING OF NODE-LEVEL TEMPORAL DYNAMICS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            593,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We modify the Gated Recurrent Unit (GRU) based encoder-decoder architecture in (Cho et al., 2014) for the modeling of node-level temporal dynamics on each node. Given an input sequence $\\pmb { x } _ { i } \\in \\mathbb { R } ^ { m \\times D }$ on the $i$ -th node, an encoder sequentially reads the whole sequence and outputs the ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/3e1ee05691630c734f899149db2febff1d255fd4582f0392794764cdcc1a7efa.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            109,
+            401,
+            227
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(a) Overview of the training procedure. ",
+        "bbox": [
+            174,
+            232,
+            401,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c494966c931cf3054784bdb0199663996cfa83e3d4629a910fe32c657d23c87.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            434,
+            102,
+            821,
+            227
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(b) Server-side Graph Network (GN). ",
+        "bbox": [
+            516,
+            232,
+            738,
+            246
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/e452c68aab769bc52637ce4deba79a253af6ae7d1c8558c060fc7ee48848f040.jpg",
+        "image_caption": [
+            "(c) Encoder-decoder on the $_ { i }$ -th node. ",
+            "Figure 1: Cross-Node Federated Graph Neural Network. (a) In each round of training, we alternately train models on nodes and the model on the server. More specifically, we sequentially execute: (1) Federated learning of on-node models. (2) Temporal encoding update. (3) Split Learning of GN. (4) On-node graph embedding update. (b) Detailed view of the server-side GN model for modeling spatial dependencies in data. (c) Detailed view of the encoder-decoder model on the $i$ -th node. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            252,
+            823,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "hidden state $h _ { c , i }$ as the summary of the input sequence according to Equation 1. ",
+        "bbox": [
+            171,
+            587,
+            696,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b92b597aa6085d9ff1cd2388c82f99cec8a2e76f53e72c5d9a3997dc9317f434.jpg",
+        "text": "$$\n\\begin{array} { r } { \\pmb { h } _ { c , i } = E n c o d e r _ { i } ( \\pmb { x } _ { i } , \\pmb { h } _ { c , i } ^ { ( 0 ) } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            608,
+            584,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ h } _ { c , i } ^ { ( 0 ) }$ is a zero-valued initial hidden state vector. ",
+        "bbox": [
+            173,
+            638,
+            529,
+            656
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To incorporate the spatial dynamics into the prediction model of each node, we concatenate $h _ { c , i }$ with the node embedding $h _ { G , c , i }$ generated from the procedure described in 3.2.2, which contains spatial information, as the initial state vector of the decoder. The decoder generates the prediction $\\hat { y } _ { i }$ in an auto-regressive way starting from the last frame of the input sequence $x _ { i , m }$ with the concatenated hidden state vector. ",
+        "bbox": [
+            173,
+            664,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a23697176af852cadac1bc9df3688a53af0e61e1ef17e11898da2580112888aa.jpg",
+        "text": "$$\n\\hat { \\pmb { y } } _ { i } = D e c o d e r _ { i } ( x _ { i , m } , [ \\pmb { h } _ { c , i } ; \\pmb { h } _ { G , c , i } ] ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            732,
+            620,
+            750
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We choose the mean squared error (MSE) between the prediction and the ground truth values as the loss function, which is evaluated on each node locally. ",
+        "bbox": [
+            171,
+            752,
+            823,
+            780
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2.2 MODELING OF SPATIAL DYNAMICS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            795,
+            473,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To capture the complex spatial dynamics, we adopt Graph Networks (GNs) proposed in (Battaglia et al., 2018) to generate node embeddings containing the relational information of all nodes. The central server collects the hidden state from all nodes $\\{ h _ { c , i } \\mid i \\in \\mathcal { V } \\}$ as the input to the GN. Each layer of GN updates the input features as follows: ",
+        "bbox": [
+            173,
+            819,
+            825,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f844065df565e1a132d4f5272263ff3b12fda16233dd100f4868142e0054c922.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { { \\mathbf e } _ { k } ^ { \\prime } = \\phi ^ { e } \\left( { \\mathbf e } _ { k } , { \\mathbf v } _ { r _ { k } } , { \\mathbf v } _ { s _ { k } } , { \\mathbf u } \\right) } & { \\overline { { { \\mathbf e } } } _ { i } ^ { \\prime } = \\rho ^ { e \\to v } \\left( E _ { i } ^ { \\prime } \\right) } \\\\ & { { \\mathbf v } _ { i } ^ { \\prime } = \\phi ^ { v } \\left( \\overline { { { \\mathbf e } } } _ { i } ^ { \\prime } , { \\mathbf v } _ { i } , { \\mathbf u } \\right) } & { \\overline { { { \\mathbf e } } } ^ { \\prime } = \\rho ^ { e \\to u } \\left( E ^ { \\prime } \\right) } \\\\ & { { \\mathbf u } ^ { \\prime } = \\phi ^ { u } \\left( \\overline { { { \\mathbf e } } } ^ { \\prime } , \\overline { { { \\mathbf v } } } ^ { \\prime } , { \\mathbf u } \\right) } & { \\overline { { { \\mathbf v } } } ^ { \\prime } = \\rho ^ { v \\to u } \\left( V ^ { \\prime } \\right) } \\end{array} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            881,
+            655,
+            928
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Training algorithm of CNFGNN on the server side. ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            598,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Server executes: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            140,
+            289,
+            152
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: Initialize server-side GN weights θ GN , client model weigh ts θ¯(0)c {θ¯(0),encc , $\\{ \\bar { \\bar { \\theta } } _ { c } ^ { ( 0 ) , e n c } , \\bar { \\theta } _ { c } ^ { ( 0 ) , d e c } \\} _ { . }$ .   \n2: for each node $i \\in \\mathcal V$ in parallel do   \n3: Initialize client model θ(0)c,i ${ \\pmb \\theta } _ { c , i } ^ { ( 0 ) } = \\bar { \\pmb \\theta } _ { c } ^ { ( 0 ) }$ = θ¯(0)c .   \n4: raph encoding. on node $h _ { G , c , i } = h _ { G , c , i } ^ { ( 0 ) }$ end for   \n6: for global round $r _ { g } = 1 , 2 , \\ldots , R _ { g }$ do   \n7: // (1) Federated learning of on-node models.   \n8: for each client $i \\in \\nu$ in parallel do   \n9: $\\theta _ { c , i } \\gets$ ClientUpdate $( i )$ .   \n11: 10: end for $\\begin{array} { r } { \\bar { \\pmb { \\theta } } _ { c }  \\sum _ { i \\in \\mathcal { V } } \\frac { N _ { i } } { N } \\pmb { \\theta } _ { c , i } } \\end{array}$ .   \n12: for each client $i \\in \\nu$ in parallel do   \n13: Initialize client model: $\\theta _ { c , i } ^ { ( 0 ) } = \\bar { \\theta } _ { c }$   \n14: end for   \n15: // (2) Temporal encoding update.   \n16: for each client $i \\in \\nu$ in parallel do   \n17: $h _ { c , i } \\gets$ ClientEncode $( i )$ .   \n18: end for   \n19: // (3) Split Learning of GN.   \n20: Initialize $\\pmb { \\theta } _ { G N } ^ { ( r _ { g } , 0 ) } = \\pmb { \\theta } _ { G N } ^ { ( r _ { g } - 1 ) }$   \n21: for server round $r _ { s } = 1 , 2 , \\ldots , R _ { s }$ do   \n22: $\\{ h _ { G , c , i } | i ~ \\in ~ \\mathcal { V } \\} ~  ~ G N ( \\{ h _ { c , i } | i ~ \\in ~$   \n23 $\\mathcal { V } \\rbrace ; \\pmb { \\theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } )$ . in prale o $i \\in \\nu$   \n24: $\\nabla _ { h _ { G , c , i } } \\ell _ { i } \\gets$ ClientBackward( $_ { i , h _ { G , c , i } ) }$ .backward(   \n25: $\\nabla _ { \\pmb { \\theta } ^ { ( r _ { g } , r _ { s } - 1 ) } } \\ell _ { i } \\gets \\pmb { h } _ { G , c , i }$ $\\overset { \\scriptscriptstyle \\mathrm { G } } { \\nabla } _ { h _ { G , c , i } } \\ell _ { i } )$ .   \n26: end for   \n27: $\\begin{array} { r l } & { \\nabla _ { \\pmb { \\theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } } \\ell  \\sum _ { i \\in \\mathcal { V } } \\nabla _ { \\pmb { \\theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } } \\ell _ { i } . } \\\\ & { \\pmb { \\theta } _ { G N } ^ { ( r _ { g } , r _ { s } ) }  \\pmb { \\theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } } \\\\ & { \\qquad - \\eta _ { s } \\nabla _ { \\pmb { \\theta } _ { G N } ^ { ( r _ { g } , r _ { s } - 1 ) } } \\ell . } \\end{array}$   \n28:   \n29: end for   \n30: ${ \\pmb \\theta } _ { G N } ^ { ( r _ { g } ) }  { \\pmb \\theta } _ { G N } ^ { ( r _ { g } , R _ { s } ) }$   \n31: // (4) On-node graph embedding update.   \n32: $\\begin{array} { r l } & { \\{ h _ { G , c , i } | i \\in \\mathcal { V } \\}  } \\\\ & { \\quad G N ( \\{ h _ { c , i } | i \\in \\mathcal { V } \\} ; \\theta _ { G N } ^ { ( r _ { g } ) } ) . } \\end{array}$   \n33: for each client $i \\in \\mathcal V$ in parallel do   \n34: Set graph encoding on client as hG,c,i.   \n35: end for   \n36: end for ",
+        "bbox": [
+            178,
+            155,
+            491,
+            496
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            503,
+            137,
+            836,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 Training algorithm of CNFGNN on the client side. ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            535,
+            594,
+            550
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ClientUpdate(i): ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            571,
+            290,
+            585
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1: for client round $r _ { c } = 1 , 2 , \\ldots , R _ { c } \\ : _ { }$ do   \n2: $\\pmb { h } _ { c , i } ^ { ( r _ { c } ) } \\gets E n c o d e r _ { i } ( \\pmb { x } _ { i } ; \\pmb { \\theta } _ { c , i } ^ { ( r _ { c } - 1 ) , e n c } )$   \n3: $\\hat { \\pmb { y } } _ { i }  D e c o d e r _ { i }$ (   \n$x _ { i , m } , [ { h _ { c , i } ^ { ( r _ { c } ) } } ; { h _ { G , c , i } } ] ; \\theta _ { c , i } ^ { ( r _ { c } - 1 ) , d e c } ) .$   \n4: 5: θ(rc)c,i ← θ(rc−1)c,i − ηc∇θ(rc−1)c,i \\`i. $\\ell _ { i } \\gets \\ell ( \\hat { \\pmb y } _ { i } , \\pmb y )$ . ",
+        "bbox": [
+            179,
+            588,
+            468,
+            691
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "6: end for ",
+        "bbox": [
+            181,
+            690,
+            254,
+            704
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "7: θc,i = θ(Rc).   \n8: return $\\theta _ { c , i }$ to server.   \nClientEncode $\\mathbf { \\rho } ( i )$ :   \n1: return $\\begin{array} { r c l } { { { h } } _ { { c } , i } } & { = } & { { E n c o d e r } _ { i } ( { \\bf { x } } _ { i } ; { \\bf { \\bf { \\theta } } } _ { c , i } ^ { e n c } ) } \\end{array}$ to server.   \nClientBackward $( i , h _ { G , c , i } )$ :   \n1: $\\hat { \\pmb { y } } _ { i }  D e c o d e r _ { i } ( x _ { i , m } , [ h _ { c , i } ; h _ { G , c , i } ] ; \\pmb { \\theta } _ { c , i } ^ { d e c } )$ . 2: $\\ell _ { i } \\gets \\ell ( \\hat { \\pmb y } _ { i } , \\pmb y )$ .   \n3: return $\\nabla _ { \\boldsymbol { h } _ { G , c , i } } \\ell _ { i }$ to server. ",
+        "bbox": [
+            504,
+            568,
+            825,
+            714
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { e } _ { k } , \\mathbf { v } _ { i } , \\mathbf { u }$ are edge features, node features and global features respectively. $\\phi ^ { e } , \\phi ^ { v } , \\phi ^ { u }$ are neural networks. $\\rho ^ { e  v } , \\rho ^ { e  u } , \\rho ^ { v  u }$ are aggregation functions such as summation. As shown in Figure 1b, we choose a 2-layer GN with residual connections for all experiments. We set $\\mathbf { v } _ { i } = h _ { c , i }$ , $\\mathbf { e } _ { k } = W _ { r _ { k } , s _ { k } }$ $\\cdot$ is the adjacency matrix) , and assign the empty vector to u as the input of the first GN layer. The server-side GN outputs embeddings $\\{ h _ { G , c , i } \\mid i \\in \\mathcal { V } \\}$ for all nodes, and sends the embedding of each node correspondingly. ",
+        "bbox": [
+            173,
+            755,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2.3 ALTERNATING TRAINING OF NODE-LEVEL AND SPATIAL MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            856,
+            689,
+            871
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "One challenge brought about by the cross-node federated learning requirement and the server-side GN model is the high communication cost in the training stage. Since we distribute different parts of the model on different devices, Split Learning proposed by (Singh et al., 2019) is a potential solution for training, where hidden vectors and gradients are communicated among devices. However, when we simply train the model end-to-end via Split Learning, the central server needs to receive hidden states from all nodes and to send node embeddings to all nodes in the forward propagation, then it must receive gradients of node embeddings from all nodes and send back gradients of hidden states to all nodes in the backward propagation. Assume all hidden states and node embeddings have the same size $S$ , the total amount of data transmitted in each training round of the GN model is $4 | \\nu | S$ . ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/5427f65e31a59e870639ba0799d96cb6e8c5eeb2c63b3aea492a28a7cb6ed5f3.jpg",
+        "table_caption": [
+            "Table 1: Statistics of datasets PEMS-BAY and METR-LA. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>#Nodes</td><td># Directed Edges</td><td># Train Seq</td><td># Val Seq</td><td># Test Seq</td></tr><tr><td>PEMS-BAY</td><td>325</td><td>2369</td><td>36465</td><td>5209</td><td>10419</td></tr><tr><td>METR-LA</td><td>207</td><td>1515</td><td>23974</td><td>3425</td><td>6850</td></tr></table>",
+        "bbox": [
+            222,
+            126,
+            777,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            210,
+            825,
+            295
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To alleviate the high communication cost in the training stage, we instead alternately train models on nodes and the GN model on the server. More specifically, in each round of training, we (1) fix the node embedding $h _ { G , c , i }$ and optimize the encoder-decoder model for $R _ { c }$ rounds, then (2) we optimize the GN model while fixing all models on nodes. Since models on nodes are fixed, $h _ { c , i }$ stays constant during the training of the GN model, and the server only needs to fetch $h _ { c , i }$ from nodes before the training of GN starts and only to communicate node embeddings and gradients. Therefore, the average amount of data transmitted in each round for $R s$ rounds of training of the GN model reduces to $\\frac { 2 + \\overline { { 2 } } R _ { s } } { R _ { s } } | \\mathcal { V } | S$ . We provide more details of the training procedure in Algorithm 1 and Algorithm 2. ",
+        "bbox": [
+            174,
+            301,
+            825,
+            430
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To more effectively extract temporal features from each node, we also train the encoder-decoder models on nodes with the FedAvg algorithm proposed in (McMahan et al., 2017). This enables all nodes to share the same feature extractor and thus share a joint hidden space of temporal features, which avoids the potential overfitting of models on nodes and demonstrates faster convergence and better prediction performance empirically. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            507
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            326,
+            544
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the performance of CNFGNN and all baseline methods on the traffic forecasting task, which is an important application for spatio-temporal data modeling. We reuse the following two real-world large-scale datasets in (Li et al., 2018) and follow the same preprocessing procedures: (1) PEMS-BAY: This dataset contains the traffic speed readings from 325 sensors in the Bay Area over 6 months from Jan 1st, 2017 to May 31st, 2017. (2) METR-LA: This dataset contains the traffic speed readings from 207 loop detectors installed on the highway of Los Angeles County over 4 months from Mar 1st, 2012 to Jun 30th, 2012. ",
+        "bbox": [
+            173,
+            559,
+            825,
+            657
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For both datasets, we construct the adjacency matrix of sensors using the Gaussian kernel with a threshold: $W _ { i , j } = d _ { i , j }$ if $d _ { i , j } > = \\kappa$ else 0, where $\\begin{array} { r } { d _ { i , j } = \\exp { ( - \\frac { \\mathrm { d i s t } ( v _ { i } , v _ { j } ) ^ { 2 } } { \\sigma ^ { 2 } . } ) } , } \\end{array}$ $\\mathrm { d i s t } ( v _ { i } , v _ { j } )$ is the road network distance from sensor $v _ { i }$ to sensor $v _ { j }$ , $\\sigma$ is the standard deviation of distances and $\\kappa$ is the threshold. We set $\\kappa = 0 . 1$ for both datasets. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            724
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We aggregate traffic speed readings in both datasets into 5-minute windows and truncate the whole sequence to multiple sequences with length 24. The forecasting task is to predict the traffic speed in the following 12 steps of each sequence given the first 12 steps. We show the statistics of both datasets in Table 1. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            786
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SPATIO-TEMPORAL DATA MODELING: TRAFFIC FLOW FORECASTING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            694,
+            814
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines We compare CNFGNN with the following baselines. (1) GRU (centralized): a Gated Recurrent Unit (GRU) model trained with centralized sensor data. (2) $\\_$ (centralized): a model directly combining GRU and GN trained with centralized data, whose architecture is similar to CNFGNN but all GRU modules on nodes always share the same weights. We see its performance as the upper bound of the performance of CNFGNN. (3) GRU (local): for each node we train a GRU model with only the local data on it. (4) GRU $^ +$ FedAvg: a GRU model trained with the Federated Averaging algorithm (McMahan et al., 2017). (5) $\\mathbf { G R U + F M T L }$ : for each node we train a GRU model using the federated multi-task learning (FMTL) with cluster regularization (Smith et al., 2017) given by the adjacency matrix. For each baseline, we have 2 variants of the GRU model to show the effect of on-device model complexity: one with 63K parameters and the other with 727K parameters. For CNFGNN, the encoder-decoder model on each node has 64K parameters and the GN model has 1M parameters. ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a2b131fec79a37cf1ec47b21bd581f2b95462cd61f1b7abb74395542a23dcf69.jpg",
+        "table_caption": [
+            "Table 3: Comparison of the computation cost on edge devices and the communication cost. We use the amount of floating point operations (FLOPS) to measure the computational cost of models on edge devices. We also show the total size of data/parameters transmitted in the training stage (Train Comm Cost) until the model reaches its lowest validation error. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">Comp Cost On Device (GFLOPS)</td><td colspan=\"2\">PEMS-BAY</td><td colspan=\"2\">METR-LA</td></tr><tr><td>RMSE</td><td>Train Comm Cost (GB)</td><td>RMSE</td><td>Train Comm Cost (GB)</td></tr><tr><td>GRU (63K)+FMTL</td><td>0.159</td><td>3.961</td><td>57.823</td><td>11.548</td><td>99.201</td></tr><tr><td>GRU (727K) + FMTL</td><td>1.821</td><td>3.955</td><td>359.292</td><td>11.570</td><td>722.137</td></tr><tr><td>CNFGNN (64K + 1M)</td><td>0.162</td><td>3.822</td><td>237.654</td><td>11.487</td><td>222.246</td></tr></table>",
+        "bbox": [
+            183,
+            255,
+            815,
+            362
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Discussion Table 2 shows the comparison of forecasting performance and Table 3 shows the comparison of computation cost on device and communication cost of CNFGNN and baselines. We make the following observations. Firstly, when we compare the best forecasting performance of each baseline over the 2 GRU variants, GRU trained with FedAvg performs the worst in terms of forecasting performance compared to GRU trained with centralized data and GRU trained with local data (4.432 vs 4.010/4.124 on PEMS-BAY and 12.058 vs 11.730/11.801 on METRLA), showing that the data distributions on different nodes are highly heterogeneous, and training one single model ignoring the heterogeneity is suboptimal. ",
+        "bbox": [
+            174,
+            382,
+            419,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/579e4a3003545305cea74154102ab98d7d967faee222e5fd976195783070821d.jpg",
+        "table_caption": [
+            "Table 2: Comparison of performance on the traffic flow forecasting task. We use the Rooted Mean Squared Error (RMSE) to evaluate the forecasting performance. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>PEMS-BAY</td><td>METR-LA</td></tr><tr><td>GRU (centralized, 63K)</td><td>4.124</td><td>11.730</td></tr><tr><td>GRU (centralized, 727K) GRU + GN</td><td>4.128</td><td>11.787</td></tr><tr><td>(centralized, 64K + 1M)</td><td>3.816</td><td>11.471</td></tr><tr><td>GRU (local, 63K)</td><td>4.010</td><td>11.801</td></tr><tr><td>GRU (local, 727K)</td><td>4.152</td><td>12.224</td></tr><tr><td>GRU (63K) + FedAvg</td><td>4.512</td><td>12.132</td></tr><tr><td>GRU (727K) + FedAvg</td><td>4.432</td><td>12.058</td></tr><tr><td>GRU (63K)+FMTL</td><td>3.961</td><td>11.548</td></tr><tr><td>GRU (727K) + FMTL</td><td>3.955</td><td>11.570</td></tr><tr><td>CNFGNN (64K + 1M)</td><td>3.822</td><td>11.487</td></tr></table>",
+        "bbox": [
+            444,
+            450,
+            808,
+            646
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Secondly, both the $\\mathrm { G R U + F M T L }$ baseline and CNFGNN consider the spatial relations among nodes and show better forecasting performance than baselines without relation information. This shows that the modeling of spatial dependencies is critical for the forecasting task. ",
+        "bbox": [
+            176,
+            680,
+            821,
+            723
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lastly, CNFGNN achieves the lowest forecasting error on both datasets. The baselines that increases the complexity of on-device models (GRU $( 7 2 7 \\mathrm { K } ) + \\mathrm { F M T L }$ ) gains slight or even no improvement at the cost of higher computation cost on edge devices and larger communication cost. However, due to its effective modeling of spatial dependencies in data, CNFGNN not only has the largest improvement of forecasting performance, but also keeps the computation cost on devices almost unchanged and maintains modest communication cost compared to baselines increasing the model complexity on devices. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            827
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 INDUCTIVE LEARNING ON UNSEEN NODES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            847,
+            514,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Set-up Another advantage of CNFGNN is that it can conduct inductive learning and generalize to larger graphs with nodes unobserved during the training stage. We evaluate the performance of CNFGNN under the following inductive learning setting: for each dataset, we first sort all sensors based on longitudes, then use the subgraph on the first $\\eta \\%$ of sensors to train the model and evaluate the trained model on the entire graph. For each dataset we select $\\eta \\% = 2 5 \\%$ , $5 0 \\%$ , $7 5 \\%$ . Over all baselines following the cross-node federated learning constraint, GRU (local) and $\\mathrm { G R U + F M T L }$ requires training new models on unseen nodes and only GRU $^ +$ FedAvg is applicable to the inductive learning setting. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/12f44181d87c6f4f48b916cc6e36328dd6d687d01a55c6c01d7b73c4c0640b0a.jpg",
+        "table_caption": [
+            "Table 4: Inductive learning performance measured with rooted mean squared error (RMSE). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"3\">PEMS-BAY</td><td colspan=\"3\">METR-LA</td></tr><tr><td>25%</td><td>50%</td><td>75%</td><td>25%</td><td>50%</td><td>75%</td></tr><tr><td>GRU (63K) + FedAvg</td><td>4.863</td><td>4.847</td><td>4.859</td><td>11.993</td><td>12.104</td><td>12.014</td></tr><tr><td>CNFGNN (64K + 1M)</td><td>4.541</td><td>4.598</td><td>4.197</td><td>12.013</td><td>11.815</td><td>11.676</td></tr></table>",
+        "bbox": [
+            240,
+            127,
+            758,
+            205
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/43859867fa889cd71a153f132f5e85593bfc311ff2369e88c13a34e041c3045c.jpg",
+        "image_caption": [
+            "Figure 2: Validation loss during the training stage of different training strategies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            219,
+            812,
+            373
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            415,
+            825,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Discussion Table 4 shows the performance of inductive learning of CNFGNN and GRU $^ +$ FedAvg baseline on both datasets. We observe that under most settings, CNFGNN outperforms the $\\mathrm { G R U + }$ FedAvg baseline (except on the METR-LA dataset with $2 5 \\%$ nodes observed in training, where both models perform similarly), showing that CNFGNN has the stronger ability of generalization. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            544
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 ABLATION STUDY: EFFECT OF ALTERNATING TRAINING AND FEDAVG ON NODE-LEVEL AND SPATIAL MODELS ",
+        "bbox": [
+            176,
+            560,
+            728,
+            589
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Baselines We compare the effect of different training strategies of CNFGNN: (1) Centralized: CNFGNN trained with centralized data where all nodes share one single encoder-decoder. (2) ",
+        "bbox": [
+            173,
+            602,
+            354,
+            712
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/11fb50f7e5ddfd6f52755ef1959f9f94b005b0b0a253152894714e71b65f29d6.jpg",
+        "table_caption": [
+            "Table 5: Comparison of test error (RMSE) and the communication cost during training of different training strategies of CNFGNN. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"2\">PEMS-BAY</td><td colspan=\"2\">METR-LA</td></tr><tr><td>RMSE</td><td>Train Comm Cost (GB)</td><td>RMSE</td><td>Train Comm Cost (GB)</td></tr><tr><td>Centralized</td><td>3.816</td><td></td><td>11.471</td><td></td></tr><tr><td>SL</td><td>3.914</td><td>350.366</td><td>12.186</td><td>307.627</td></tr><tr><td>SL + FedAvg</td><td>4.383</td><td>80.200</td><td>11.631</td><td>343.031</td></tr><tr><td>AT, w/o FedAvg</td><td>4.003</td><td>5221.576</td><td>11.912</td><td>2434.985</td></tr><tr><td>AT +FedAvg</td><td>3.822</td><td>237.654</td><td>11.487</td><td>222.246</td></tr></table>",
+        "bbox": [
+            372,
+            657,
+            818,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Split Learning (SL): CNFGNN trained with split learning (Singh et al., 2019), where models on nodes and the model on the server are jointly trained by exchanging hidden vectors and gradients. (3) Split ",
+        "bbox": [
+            173,
+            713,
+            354,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Learning $^ +$ FedAvg $\\mathrm { \\bf S L + }$ FedAvg): A variant of SL that synchronizes the weights of encoderdecoder modules periodically with FedAvg. (4) Alternating training without Federated Averaging of models on nodes (AT, w/o FedAvg). (5) Alternating training with Federated Averaging on nodes described in Section 3.2.3 $\\mathbf { \\Delta A T } + \\mathbf { F e d A v g }$ ). ",
+        "bbox": [
+            173,
+            824,
+            825,
+            880
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Discussion Figure 2 shows the validation loss during training of different training strategies on PEMS-BAY and METR-LA datasets, and Table 5 shows their prediction performance and the communication cost in training. We notice that (1) SL suffers from suboptimal prediction performance and high communication costs on both datasets; SL $^ +$ FedAvg does not have consistent results on both datasets and its performance is always inferior to AT $\\cdot$ FedAvg. AT $\\cdot$ FedAvg consistently outperforms other baselines on both datasets, including its variant without FedAvg. (2) AT $^ +$ FedAvg has the lowest communication cost on METR-LA and the 2nd lowest communication cost on PEMS-BAY, on which the baseline with the lowest communication cost ( $\\mathrm { S L } +$ FedAvg) has a much higher prediction error (4.383 vs 3.822). Both illustrate that our proposed training strategy, $\\mathrm { S L } +$ FedAvg, achieves the best prediction performance as well as low communication cost compared to other baseline strategies. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 ABLATION STUDY: EFFECT OF CLIENT ROUNDS AND SERVER ROUNDS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            247,
+            705,
+            262
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Set-up We further investigate the effect of different compositions of the number of client rounds $( R _ { s } )$ in Algorithm 2 and the number of server rounds $( R _ { c } )$ in Algorithm 1. To this end, we vary both $R _ { c }$ and $R _ { s }$ over [1,10,20]. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Discussion Figure 3 shows the forecasting performance (measured with RMSE) and the total communication cost in the training of CNFGNN under all compositions of $( R _ { c }$ , $R _ { s }$ ) on the METR-LA dataset. We observe that: (1) Models with lower ${ \\cal R } _ { c } / { \\cal R } _ { s }$ ratios $( R _ { c } / R _ { s } ~ < ~ 0 . 5 )$ tend to have lower forecasting errors while models with higher ${ \\cal R } _ { c } / { \\cal R } _ { s }$ ratios $( R _ { c } / R _ { s } > 2 )$ have lower communication cost in training. This is because the lower ratio of ${ \\cal R } _ { c } / { \\cal R } _ { s }$ encourages more frequent exchange of node information at the expense of higher communication cost, while the higher ratio of ${ \\cal R } _ { c } / { \\cal R } _ { s }$ acts in the opposite way. (2) Models with similar ${ \\cal R } _ { c } / { \\cal R } _ { s }$ ratios have similar communication costs, while those with lower ",
+        "bbox": [
+            174,
+            334,
+            419,
+            611
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/aeed15dde9053561a6b6271b85b07c237441559b0d5bbb78fa4218bcae933a69.jpg",
+        "image_caption": [
+            "Figure 3: Effect of client rounds and server rounds $( R _ { c } , R _ { s } )$ on forecasting performance and communication cost. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            436,
+            358,
+            816,
+            537
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "$R _ { c }$ values perform better, corroborating our observation in (1) that frequent node information exchange improves the forecasting performance. ",
+        "bbox": [
+            174,
+            612,
+            821,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            661,
+            318,
+            678
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose Cross-Node Federated Graph Neural Network (CNFGNN), which bridges the gap between modeling complex spatio-temporal data and decentralized data processing by enabling the use of graph neural networks (GNNs) in the federated learning setting. We accomplish this by decoupling the learning of local temporal models and the server-side spatial model using alternating optimization of spatial and temporal modules based on split learning and federated averaging. Our experimental results on traffic flow prediction on two real-world datasets show superior performance as compared to competing techniques. Our future work includes applying existing GNN models with sampling strategies and integrating them into CNFGNN for large-scale graphs, extending CNFGNN to a fully decentralized framework, and incorporating existing privacy-preserving methods for graph learning to CNFGNN, to enhance federated learning of spatio-temporal dynamics. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            834
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            857,
+            285,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alekh Agarwal, Animashree Anandkumar, Prateek Jain, Praneeth Netrapalli, and Rashish Tandon. Learning sparsely used overcomplete dictionaries. In Conference on Learning Theory, pp. 123– 137, 2014. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Rong Ge, and Ankur Moitra. New algorithms for learning incoherent and overcomplete dictionaries. In Conference on Learning Theory, pp. 779–806, 2014. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sanjeev Arora, Rong Ge, Tengyu Ma, and Ankur Moitra. Simple, efficient, and neural algorithms for sparse coding. 2015. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Omri Azencot, N Benjamin Erichson, Vanessa Lin, and Michael W Mahoney. Forecasting sequential data using consistent koopman autoencoders. In ICML, 2020. ",
+        "bbox": [
+            173,
+            176,
+            823,
+            205
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Battaglia, Razvan Pascanu, Matthew Lai, Danilo Jimenez Rezende, et al. Interaction networks for learning about objects, relations and physics. In Advances in neural information processing systems, pp. 4502–4510, 2016. ",
+        "bbox": [
+            174,
+            213,
+            823,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018. ",
+        "bbox": [
+            173,
+            263,
+            826,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Hol- ¨ ger Schwenk, and Yoshua Bengio. Learning phrase representations using rnn encoder–decoder for statistical machine translation. In Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 1724–1734, 2014. ",
+        "bbox": [
+            173,
+            329,
+            825,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in neural information processing systems, pp. 1024–1034, 2017. ",
+        "bbox": [
+            176,
+            392,
+            820,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chaoyang He, Salman Avestimehr, and Murali Annavaram. Group knowledge transfer: Collaborative training of large cnns on the edge. arXiv preprint arXiv:2007.14513, 2020. ",
+        "bbox": [
+            173,
+            429,
+            821,
+            459
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wenbing Huang, Tong Zhang, Yu Rong, and Junzhou Huang. Adaptive sampling towards fast graph representation learning. In Advances in neural information processing systems, pp. 4558–4567, 2018. ",
+        "bbox": [
+            174,
+            467,
+            823,
+            510
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prateek Jain and Purushottam Kar. Non-convex optimization for machine learning. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Machine Learning, 10(3-4):142–363, 2017. ISSN 1935-8237. doi: 10.1561/ 2200000058. URL http://dx.doi.org/10.1561/2200000058. ",
+        "bbox": [
+            174,
+            517,
+            821,
+            560
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurelien Bellet, Mehdi Bennis, Arjun Nitin ´ Bhagoji, Keith Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al. Advances and open problems in federated learning. arXiv preprint arXiv:1912.04977, 2019. ",
+        "bbox": [
+            174,
+            568,
+            823,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sai Praneeth Karimireddy, Satyen Kale, Mehryar Mohri, Sashank J Reddi, Sebastian U Stich, and Ananda Theertha Suresh. Scaffold: Stochastic controlled averaging for federated learning. In Proceedings of the 37th International Conference on Machine Learning, 2020. ",
+        "bbox": [
+            173,
+            618,
+            825,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            669,
+            820,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard S Zemel. Neural relational inference for interacting systems. In ICML, 2018. ",
+        "bbox": [
+            174,
+            705,
+            820,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Guangyu Li, Bo Jiang, Hao Zhu, Zhengping Che, and Yan Liu. Generative attention networks for multi-agent behavioral modeling. In AAAI, 2020a. ",
+        "bbox": [
+            171,
+            742,
+            823,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. Federated optimization in heterogeneous networks. In Proceedings of the 3rd MLSys Conference, 2020b. ",
+        "bbox": [
+            174,
+            780,
+            823,
+            823
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yaguang Li, Rose Yu, Cyrus Shahabi, and Yan Liu. Diffusion convolutional recurrent neural network: Data-driven traffic forecasting. In International Conference on Learning Representations (ICLR ’18), 2018. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            873
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Paul Pu Liang, Terrance Liu, Liu Ziyin, Ruslan Salakhutdinov, and Louis-Philippe Morency. Think locally, act globally: Federated learning with local and global representations. arXiv preprint arXiv:2001.01523, 2020. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ziyu Liu, Hongwen Zhang, Zhenghao Chen, Zhiyong Wang, and Wanli Ouyang. Disentangling and unifying graph convolutions for skeleton-based action recognition. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 143–152, 2020. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. Communication-efficient learning of deep networks from decentralized data. In Artificial Intelligence and Statistics, pp. 1273–1282. PMLR, 2017. ",
+        "bbox": [
+            178,
+            155,
+            820,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Guangxu Mei, Ziyu Guo, Shijun Liu, and Li Pan. Sgnn: A graph neural network based federated learning approach by hiding structure. In 2019 IEEE International Conference on Big Data (Big Data), pp. 2560–2568. IEEE, 2019. ",
+        "bbox": [
+            174,
+            207,
+            823,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sina Sajadmanesh and Daniel Gatica-Perez. When differential privacy meets graph neural networks. arXiv preprint arXiv:2006.05535, 2020. ",
+        "bbox": [
+            173,
+            257,
+            821,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sungyong Seo, Chuizheng Meng, and Yan Liu. Physics-aware difference graph networks for sparsely-observed dynamics. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            171,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Abhishek Singh, Praneeth Vepakomma, Otkrist Gupta, and Ramesh Raskar. Detailed comparison of communication efficiency of split learning and federated learning. arXiv preprint arXiv:1909.09145, 2019. ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Virginia Smith, Chao-Kai Chiang, Maziar Sanjabi, and Ameet S Talwalkar. Federated multi-task learning. In Advances in Neural Information Processing Systems, pp. 4424–4434, 2017. ",
+        "bbox": [
+            173,
+            385,
+            823,
+            415
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Toyotaro Suzumura, Yi Zhou, Natahalie Barcardo, Guangnan Ye, Keith Houck, Ryo Kawahara, Ali Anwar, Lucia Larise Stavarache, Daniel Klyashtorny, Heiko Ludwig, et al. Towards federated graph learning for collaborative financial crimes detection. arXiv preprint arXiv:1909.12946, 2019. ",
+        "bbox": [
+            173,
+            422,
+            825,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Jingling Li, Mozhi Zhang, Simon S Du, Ken-ichi Kawarabayashi, and Stefanie Jegelka. What can neural networks reason about? In International Conference on Learning Representations (ICLR), 2019. ",
+        "bbox": [
+            174,
+            488,
+            823,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sijie Yan, Yuanjun Xiong, and Dahua Lin. Spatial temporal graph convolutional networks for skeleton-based action recognition. In AAAI, 2018. ",
+        "bbox": [
+            169,
+            539,
+            823,
+            569
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L Hamilton, and Jure Leskovec. Graph convolutional neural networks for web-scale recommender systems. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 974– 983, 2018. ",
+        "bbox": [
+            173,
+            577,
+            825,
+            633
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiaxuan You, Rex Ying, and Jure Leskovec. Position-aware graph neural networks. In Proceedings of the 36th International Conference on Machine Learning, 2019. ",
+        "bbox": [
+            169,
+            642,
+            823,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bing Yu, Haoteng Yin, and Zhanxing Zhu. Spatio-temporal graph convolutional networks: A deep learning framework for traffic forecasting. In Proceedings of the 27th International Joint Conference on Artificial Intelligence (IJCAI), 2018. ",
+        "bbox": [
+            174,
+            680,
+            823,
+            723
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jun Zhou, Chaochao Chen, Longfei Zheng, Xiaolin Zheng, Bingzhe Wu, Ziqi Liu, and Li Wang. Privacy-preserving graph neural network for node classification. arXiv preprint arXiv:2005.11903, 2020. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            775
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 DETAILED EXPERIMENT SETTINGS ",
+        "bbox": [
+            176,
+            133,
+            460,
+            148
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Unless noted otherwise, all models are optimized using the Adam optimizer with the learning rate 1e-3. ",
+        "bbox": [
+            174,
+            159,
+            823,
+            186
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "GRU (centralized) : Gated Recurrent Unit (GRU) model trained with centralized sensor data. The GRU model with 63K parameters is a 1-layer GRU with hidden dimension 100, and the GRU model with 727K parameters is a 2-layer GRU with hidden dimension 200. ",
+        "bbox": [
+            174,
+            202,
+            823,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "GRU (local) We train one GRU model for each node with the local data only. ",
+        "bbox": [
+            173,
+            260,
+            692,
+            275
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "GRU $^ +$ FedAvg We train a single GRU model with Federated Averaging (McMahan et al., 2017).   \nWe select 1 as the number of local epochs. ",
+        "bbox": [
+            174,
+            290,
+            820,
+            319
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { G R U } + \\mathbf { F M T L }$ We train one GRU model for each node using the federated multi-task learning (FMTL) with cluster regularization (Smith et al., 2017) given by the adjacency matrix. More specifically, the cluster regularization (without the L2-norm regularization term) takes the following form: ",
+        "bbox": [
+            173,
+            334,
+            825,
+            377
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04f3335e068d20564d0db98938598be7fcbc4c25669ed5da9c5cf6be4b3b0854.jpg",
+        "text": "$$\n\\mathcal { R } ( W , \\mathfrak { L } ) = \\lambda \\mathrm { t r } ( W \\Omega W ^ { T } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            383,
+            598,
+            402
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Given the constructed adjacency matrix $\\pmb { A }$ , $\\begin{array} { r } { \\pmb { \\Omega } = \\frac { 1 } { | \\mathcal { V } | } ( \\pmb { D } - \\pmb { A } ) = \\frac { 1 } { | \\mathcal { V } | } \\pmb { L } } \\end{array}$ , where $_ { D }$ is the degree matrix and $\\pmb { L }$ is the Laplacian matrix. Equation A1 can be reformulated as: ",
+        "bbox": [
+            174,
+            407,
+            825,
+            440
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb7c5daaf87cef8304e2f9568af7901debcc9d582a75d522926f2130132fc909.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\mathcal { R } ( W , \\pmb { \\Omega } ) = \\lambda \\mathrm { t r } ( W \\pmb { \\Omega } W ^ { T } ) = \\frac { \\lambda } { | \\mathcal { V } | } \\mathrm { t r } ( W \\pmb { L } W ^ { T } ) } } \\\\ & { = \\frac { \\lambda } { | \\mathcal { V } | } \\mathrm { t r } ( \\displaystyle \\sum _ { i \\in \\mathcal { V } } \\pmb { w } _ { i } \\displaystyle \\sum _ { j \\not = i } a _ { i j } \\pmb { w } _ { i } ^ { T } - \\displaystyle \\sum _ { j \\not = i } \\pmb { w } _ { i } a _ { i j } \\pmb { w } _ { j } ^ { T } ) } \\\\ & { = \\lambda _ { 1 } ( \\displaystyle \\sum _ { i \\in \\mathcal { V } } \\displaystyle \\sum _ { j \\not = i } \\alpha _ { i , j } \\langle \\pmb { w } _ { i } , \\pmb { w } _ { i } - \\pmb { w } _ { j } \\rangle ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            251,
+            445,
+            745,
+            558
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We implement the cluster regularization via sharing model weights between each pair of nodes connected by an edge and select $\\lambda _ { 1 } = 0 . 1$ . ",
+        "bbox": [
+            173,
+            563,
+            823,
+            590
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "CNFGNN We use a GRU-based encoder-decoder model as the model on nodes, which has 1 GRU layer and hidden dimension 64. We use a 2-layer Graph Network (GN) with residual connections as the Graph Neural Network model on the server side. We use the same network architecture for the edge/node/global update function in each GN layer: a multi-layer perceptron (MLP) with 3 hidden layers, whose sizes are [256, 256, 128] respectively. We choose $R _ { c } = 1 , R _ { s } = 2 0$ for experiments on PEMS-BAY, and $R _ { c } = 1 , R _ { s } = 1$ for METR-LA. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            690
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.2 CALCULATION OF COMMUNICATION COST ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            707,
+            516,
+            722
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We denote $R$ as the number of communication rounds for one model to reach the lowest validation error in the training stage. ",
+        "bbox": [
+            173,
+            732,
+            823,
+            762
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { G R U + F M T L }$ Using Equation A2, in each communication round, each pair of nodes exchange their model weights, thus the total communicated data amount is calculated as: ",
+        "bbox": [
+            171,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b396ba77e4d62589b2647972bcc574adf18279067e6a3185a6cb9b9c14fc0a6c.jpg",
+        "text": "$$\nR \\times \\# \\mathrm { n o n s e l f ~ d i r e c t e d ~ e d g e s } \\times \\mathrm { s i z e ~ o f ~ n o d e ~ m o d e l ~ w e i g h t s } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            813,
+            705,
+            829
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "CNFGNN (AT $^ +$ FedAvg) In each communication round, the central server fetches and sends back model weights to each node for Federated Averaging, and transmits hidden vectors and gradients for Split Learning. The total communicated data amount is calculated as: ",
+        "bbox": [
+            174,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/86179e2cfe1f3af68fed3c6e5b3cd6fbc9d44870beabf26434d26f54f38a87b9.jpg",
+        "text": "$$\n\\begin{array} { r l } & { R \\times ( \\mathrm { \\# n o d e s } \\times \\mathrm { s i z e ~ o f ~ n o d e ~ m o d e l ~ w e i g h t s } \\times 2 } \\\\ & { \\quad + ( 1 + 2 * \\mathrm { s e r v e r ~ r o u n d } + 1 ) \\times \\mathrm { \\# n o d e s } \\times \\mathrm { h i d d e n ~ s t a t e ~ s i z e } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            892,
+            717,
+            929
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "CNFGNN (SL) In each communication round, each node sends and fetches hidden vectors and graidents twice (one for encoder, the other for decoder) and the total communicated data amount is: ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e37c5d1dd6ae0dead5332a3f9be3a01b29f1ee973ab27a7e7578835df53a5f23.jpg",
+        "text": "$$\n-\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            140,
+            642,
+            156
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CNFGNN $\\mathrm { \\bf { S L + } }$ FedAvg) Compared to CNFGNN (SL), the method has extra communcation cost for FedAvg in each round, thus the total communicated data amount is: ",
+        "bbox": [
+            171,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6dd4d0454c9e5d1d141ca3310dab20abee4c9fe48201a3f5b1c679909e392f31.jpg",
+        "text": "$$\n-\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            228,
+            794,
+            244
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CNFGNN (AT, w/o FedAvg) Compared to CNFGNN (AT $^ +$ FedAvg), there is no communcation cost for the FedAvg part, thus the total communcated data amount is: ",
+        "bbox": [
+            171,
+            286,
+            823,
+            315
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4fcef62a6c5f963db3fb727165a418098db90ce36b28c66adb7e152dd4d3c29b.jpg",
+        "text": "$$\n-\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            321,
+            705,
+            339
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/9270a2aa17865f403dd1787a3c63a8b0c3b35b467205705a99a3b2ff29952d05.jpg",
+        "table_caption": [
+            "Table A1: Parameters used for calculating the communication cost of $\\mathrm { G R U + F M T L }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Method</td><td colspan=\"2\">GRU (63K) + FMTL GRU (727K) + FMTL</td></tr><tr><td colspan=\"2\">Node Model Weights Size (GB)</td><td>2.347E-4</td><td>2.708E-3</td></tr><tr><td rowspan=\"3\">PEMS-BAY</td><td>#Nonself Directed Edges</td><td>2369</td><td></td></tr><tr><td>R</td><td>104</td><td>56</td></tr><tr><td>Train Comm Cost (GB)</td><td>57.823</td><td>359.292</td></tr><tr><td rowspan=\"3\">METR-LA</td><td>#Nonself Directed Edges</td><td></td><td>1515</td></tr><tr><td>R</td><td>279</td><td>176</td></tr><tr><td>Train Comm ( Cost (GB)</td><td>99.201</td><td>722.137</td></tr></table>",
+        "bbox": [
+            204,
+            397,
+            794,
+            537
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/a96f6681567494bf93eeba203f3ff8524c5df2c261093780dfd0f868da2a0f36.jpg",
+        "table_caption": [
+            "Table A2: Parameters used for calculating the communication cost of CNFGNN (AT $\\cdot$ FedAvg). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Node Model Weights Size (GB)</td><td colspan=\"2\">2.384E-4</td></tr><tr><td rowspan=\"3\">PEMS-BAY</td><td>#Nodes</td><td>325</td></tr><tr><td>Hidden State Size (GB) Server Round</td><td>2.173E-3 20</td></tr><tr><td>R</td><td>2</td></tr><tr><td rowspan=\"3\">METR-LA</td><td>Train Comm Cost (GB) #Nodes</td><td>237.654 207</td></tr><tr><td>Hidden State Size (GB)</td><td>1.429E-3</td></tr><tr><td>Server Round R</td><td>1 46</td></tr></table>",
+        "bbox": [
+            308,
+            583,
+            691,
+            773
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.3 INDUCTIVE LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            800,
+            379,
+            814
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We have added results using $\\cdot$ and $5 \\%$ data on both datasets and we show the table of inductive learning results as Table A6. We observe that: (1) With the portion of visible nodes in the training stage increasing, the prediction error of CNFGNN decreases drastically. However, the increase of the portion of visible nodes has negligible contribution to the performance of GRU $\\cdot$ FedAvg after the portion surpasses $\\cdot$ . Since increasing the ratio of seen nodes in training introduces more complex relationships among nodes to the training data, the difference of performance illustrates that CNFGNN has a stronger capability of capturing complex spatial relationships. (2) When the ratio of visible nodes in training is extremely low $\\cdot$ , there is not enough spatial relationship information in the training data to train the GN module in CNFGNN, and the performance of CNFGNN may not be ideal. We visualize the subgraphs visible in training under different ratios in Figure A1. However, as long as the training data covers a moderate portion of the spatial information of the whole graph, CNFGNN can still leverage the learned spatial connections among nodes effectively and outperforms GRU $+$ FedAvg. We empirically show that the necessary ratio can vary for different datasets ( $2 5 \\%$ for PEMS-BAY and $\\cdot$ for METR-LA). ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/38fc25f544b3e968ff7c6b0cdf90d166cd581fee8f3b4d6b4348e7fa15ac0f4d.jpg",
+        "table_caption": [
+            "Table A3: Parameters used for calculating the communication cost of CNFGNN (SL). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">PEMS-BAY</td><td>#Nodes Hidden State Size (GB) R</td><td>325 2.173E-3 31</td></tr><tr><td>Train Comm Cost (GB)</td><td>350.366</td></tr><tr><td rowspan=\"3\">METR-LA</td><td>#Nodes Hidden State Size (GB)</td><td>207 1.429E-3</td></tr><tr><td>R</td><td>65</td></tr><tr><td>Train Comm Cost (GB)</td><td>307.627</td></tr></table>",
+        "bbox": [
+            328,
+            132,
+            668,
+            261
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/9269dd3b99e9cfbaad78a980ecc4ccb2686c31076292de1652ad38e20db8b213.jpg",
+        "table_caption": [
+            "Table A4: Parameters used for calculating the communication cost of CNFGNN (SL $^ +$ FedAvg). ",
+            "Table A5: Parameters used for calculating the communication cost of CNFGNN (AT, w/o FedAvg). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Node Model Weights Size (GB)</td><td colspan=\"2\">2.384E-4</td></tr><tr><td>PEMS-BAY</td><td>#Nodes Hidden State Size (GB) R Train Comm Cost (GB)</td><td>325 2.173E-3 7 80.200</td></tr><tr><td>METR-LA</td><td>#Nodes Hidden State Size (GB) R Train Comm Cost (GB)</td><td>207 1.429E-3 71 343.031</td></tr></table>",
+        "bbox": [
+            308,
+            305,
+            691,
+            467
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/82218b6d5ed79cf9fb8faba82ec055c2f31115267be423b485d38a1203e54314.jpg",
+        "image_caption": [
+            "Figure A1: Visualization of subgraphs visible in training under different ratios. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            511,
+            823,
+            888
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/c18a8970ce8052869bf6af904c2732e732fccb5161433b8647d83e33970190c6.jpg",
+        "table_caption": [
+            "Table A6: Inductive learning performance measured with rooted mean squared error (RMSE). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"5\">PEMS-BAY</td><td colspan=\"5\">METR-LA</td></tr><tr><td>5%</td><td>25%</td><td>50%</td><td>75%</td><td>90%</td><td>5%</td><td>25%</td><td>50%</td><td>75%</td><td>90%</td></tr><tr><td>GRU (63K)+ FedAvg</td><td>5.087</td><td>4.863</td><td>4.847</td><td>4.859</td><td>4.866</td><td>12.128</td><td>11.993</td><td>12.104</td><td>12.014</td><td>12.016</td></tr><tr><td>CNFGNN (64K + 1M)</td><td>5.869</td><td>4.541</td><td>4.598</td><td>4.197</td><td>3.942</td><td>13.931</td><td>12.013</td><td>11.815</td><td>11.676</td><td>11.629</td></tr></table>",
+        "bbox": [
+            232,
+            127,
+            766,
+            185
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            210,
+            825,
+            308
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.4 THE HISTOGRAMS OF DATA ON DIFFERENT NODES ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            325,
+            575,
+            339
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We show the histograms of traffic speed on different nodes of PEMS-BAY and METR-LA in Figure A2. For each dataset, we only show the first 100 nodes ranked by their IDs for simplicity. The histograms show that the data distribution varies with nodes, thus data on different nodes are not independent and identically distributed. ",
+        "bbox": [
+            173,
+            351,
+            825,
+            407
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/fbb9448d998bae68ee364eb978642afeeb3a587536740eb8563d4983ca31138b.jpg",
+        "image_caption": [
+            "Figure A2: The histograms of data on the first 100 nodes ranked by ID. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            825,
+            892
+        ],
+        "page_idx": 15
+    }
+]

parse/train/RHY_9ZVcTa_/RHY_9ZVcTa_.md

@@ -0,0 +1,467 @@
+# ON LINEAR IDENTIFIABILITY OF LEARNED REPRESENTATIONS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Identifiability is a desirable property of a statistical model: it implies that the true model parameters may be estimated to any desired precision, given sufficient computational resources and data. We study identifiability in the context of representation learning: discovering nonlinear data representations that are optimal with respect to some downstream task. When parameterized as deep neural networks, such representation functions lack identifiability in parameter space, because they are overparameterized by design. In this paper, building on recent advances in nonlinear Independent Components Analysis, we aim to rehabilitate identifiability by showing that a large family of discriminative models are in fact identifiable in function space, up to a linear indeterminacy. Many models for representation learning in a wide variety of domains have been identifiable in this sense, including text, images and audio, state-of-the-art at time of publication. We derive sufficient conditions for linear identifiability and provide empirical support for the result on both simulated and real-world data.
+
+# 1 INTRODUCTION
+
+An increasingly common methodology in machine learning is to improve performance on a primary down-stream task by first learning a high-dimensional representation of the data on a related, proxy task. In this paradigm, training a model reduces to fine-tuning the learned representations for optimal performance on a particular sub-task (Erhan et al., 2010). Deep neural networks (DNNs), as flexible function approximators, have been surprisingly successful in discovering effective high-dimensional representations for use in downstream tasks such as image classification (Sharif Razavian et al., 2014), text generation (Radford et al., 2018; Devlin et al., 2018), and sequential decision making (Oord et al., 2018).
+
+When learning representations for downstream tasks, it would be useful if the representations were reproducible, in the sense that every time a network relearns the representation function on the same data distribution, they were approximately the same, regardless of small deviations in the initialization of the parameters or the optimization procedure. In some applications, such as learning real-world causal relationships from data, such reproducible learned representations are crucial for accurate and robust inference (Johansson et al., 2016; Louizos et al., 2017). A rigorous way to achieve reproducibility is to choose a model whose representation function is identifiable in function space. Informally speaking, identifiability in function space is achieved when, in the limit of infinite data, there exists a single, global optimum in function space. Interestingly, Figure 1 exhibits learned representation functions that appear to be the same up to a linear transformation, even on finite data and optimized without convergence guarantees (see Appendix A.1 for training details).
+
+In this paper, we account for Figure 1 by making precise the relationship it exemplifies. We prove that a large class of discriminative and autoregressive models are identifiable in function space, up to a linear transformation. Our results extend recent advances in the theory of nonlinear Independent Components Analysis (ICA), which have recently provided strong identifiability results for generative models of data (Hyvärinen et al., 2018; Khemakhem et al., 2019; 2020; Sorrenson et al., 2020). Our key contribution is to bridge the gap between these results and discriminative models, commonly used for representation learning (e.g., (Hénaff et al., 2019; Brown et al., 2020)).
+
+The rest of the paper is organized as follows. In Section 2, we describe a general discriminative model family, defined by its canonical mathematical form, which generalizes many supervised, selfsupervised, and contrastive learning frameworks. In Section 3, we prove that learned representations in this family have an asymptotic property desirable for representation learning: equality up to a linear transformation. In Section 4, we show that this family includes a number of highly performant models, state-of-the-art at publication for their problem domains, including CPC (Oord et al., 2018), BERT (Devlin et al., 2018), and GPT-2 and GPT-3 (Radford et al., 2018; 2019; Brown et al., 2020). Section 5 investigates the actually realizable regime of finite data and partial optimization, showing that representations learned by members of the identifiable model family approach equality up to a linear transformation as a function of dataset size, neural network capacity, and optimization progress.
+
+![](images/d6a3113bbeed129e0a21ecfef6c9065bb07fca469ea52e4866e6213f0c68bc18.jpg)  
+Figure 1: Left and Middle: Two learned DNN representation functions ${ \bf f } _ { \pmb { \theta } _ { 1 } } ( { \boldsymbol { B } } )$ , $\cdot$ visualized on held-out data $\boldsymbol { B }$ . The DNNs are word embedding models Mnih and Teh (2012) trained on the Billion Word Dataset (Chelba et al., 2013) (see Appendix A.1 for code release and training details). Right: $A \mathbf { f } _ { \pmb { \theta } _ { 1 } } ( B )$ and $\cdot$ , where $\pmb { A }$ is a linear transformation learned after training. The overlap exhibits linear identifiability (see Section 3): different representation functions, learned on the same data distribution, live within linear transformations of each other in function space.
+
+# 2 MODEL FAMILY AND DATA DISTRIBUTION
+
+The learned embeddings of a DNN are a function not only of the parameters, but also the network architecture and size of dataset (viewed as a sample from the underlying data distribution). This renders any analysis in full generality challenging. To make such an analysis tractable, in this section, we begin by specifying a set of assumptions about the underlying data distribution and model family that must hold for the learned representations to be similar up to a linear transformation. These assumptions are, in fact, satisfied by a number of already published, highly performant models. We establish definitions in this section, and discuss these existing approaches in depth in Section 4.
+
+Data Distribution We assume the existence of a generalized dataset in the form of an empirical distribution $p _ { \mathcal { D } } ( \mathbf { x } , \mathbf { y } , \mathbf { S } )$ over random variables $\mathbf { x }$ , y and S with the following properties:
+
+• The random variable $\mathbf { x }$ is an input variable, typically high-dimensional, such as text or an image.   
+• The random variable y is a target variable whose value the model predicts. In case of object classification, this would be some semantically meaningful class label. However, in our model family, y may also be a high-dimensional context variable, such a text, image, or sentence fragment.   
+• S is a set containing the possible values of y given x, so $p _ { \mathcal { D } } ( \mathbf { y } | \mathbf { x } , \mathbf { S } ) > 0 \iff \mathbf { y } \in \mathbf { S } .$
+
+Note that the set of labels S is not fixed, but a random variable. This allows supervised, contrastive, and self-supervised learning frameworks to be analyzed together: the meaning of S encodes the task. For supervised classification, S is deterministic and contains class labels. For self-supervised pretraining, S contains randomly-sampled high-dimensional variables such as image embeddings. For deep metric learning (Hoffer and Ailon, 2015; Sohn, 2016), the set S contains one positive and $k$ negative samples of the class to which $\mathbf { x }$ belongs.
+
+Canonical Discriminative Form Given a data distribution as above, a generalized discriminative model family may be defined by its parameterization of the probability of a target variable $\mathbf { y }$ conditioned on an observed variable x and a set S that contains not only the true target label $\mathbf { y }$ , but
+
+also a collection of distractors $\mathbf { y } ^ { \prime }$ :
+
+$$
+p _ { \theta } ( \mathbf { y } \vert \mathbf { x } , \mathbf { S } ) = \frac { \exp ( \mathbf { f } _ { \theta } ( \mathbf { x } ) ^ { \top } \mathbf { g } _ { \theta } ( \mathbf { y } ) ) } { \sum _ { \mathbf { y } ^ { \prime } \in \mathbf { S } } \exp ( \mathbf { f } _ { \theta } ( \mathbf { x } ) ^ { \top } \mathbf { g } _ { \theta } ( \mathbf { y } ^ { \prime } ) ) } ,
+$$
+
+The codomain of the functions $\mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } )$ and $\mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } )$ is $\mathbb { R } ^ { M }$ , and the domains vary according to modelling task. For notational convenience both are parameterized by $\pmb \theta \in \Theta$ , but f and $\mathbf { g }$ may use disjoint parts of $\pmb { \theta }$ , meaning that they do not necessarily share parameters.
+
+With $\mathcal { F }$ and $\mathcal { G }$ we denote the function spaces of $\mathbf { f } _ { \theta }$ and $\mathbf { g } _ { \pmb { \theta } }$ respectively. Our primary domain of interest is when $\mathbf { f } _ { \theta }$ and $\mathbf { g } _ { \theta }$ are highly flexible function approximators, such as DNNs. This brings certain analytical challenges. In neural networks, different choices of parameters $\pmb \theta$ can result in the same functions $\mathbf { f } _ { \pmb { \theta } }$ and $\mathbf { g } _ { \theta }$ , hence the map $\Theta \to { \mathcal { F } } \times { \mathcal { G } }$ is many-to-one. In the context of representation learning, the function $\mathbf { f } _ { \theta }$ is typically viewed as a nonlinear feature extractor, e.g., the learned representation of the input data. While other choices meet the membership conditions for the family defined by the canonical form of Equation (1), in the remainder, we will focus on DNNs in the remainder. We next present a definition of identifiability suitable for DNNs, and prove that members of the above family satisfy it under additional assumptions.
+
+# 3 MODEL IDENTIFIABILITY
+
+In this section, we derive identifiability conditions for models in the family defined in Section 2.
+
+# 3.1 IDENTIFIABILITY IN PARAMETER SPACE
+
+Identifiability analysis answers the question of whether it is theoretically possible to learn the parameters of a statistical model exactly. Specifically, given some estimator $\pmb { \theta } ^ { \prime }$ for model parameters $\pmb { \theta } ^ { * }$ , identifiability is the property that, for any $\{ \theta ^ { \prime } , \theta ^ { \ast } \} \subset \Theta$ ,
+
+$$
+p _ { \pmb { \theta } ^ { \prime } } = p _ { \pmb { \theta } ^ { * } } \quad \Longrightarrow \quad \pmb { \theta } ^ { \prime } = \pmb { \theta } ^ { * } .
+$$
+
+Models that do not have this property are said to be non-identifiable. This happens when different values $\{ \theta ^ { \prime } , \theta ^ { \ast } \} \subset \Theta$ can give rise to the same model distribution $p _ { \pmb { \theta } ^ { \prime } } ( \mathbf { y } | \mathbf { x } , \bar { \mathbf { S } } ) = p _ { \pmb { \theta } ^ { * } } ( \mathbf { y } | \mathbf { x } , \mathbf { S } )$ . In such a case, observing an empirical distribution $p _ { \pmb { \theta } ^ { * } } ( \mathbf { y } | \mathbf { x } , \mathbf { S } )$ , and fitting a model $p _ { \pmb { \theta } ^ { \prime } } ( \mathbf { y } | \mathbf { x } , \mathbf { S } )$ to it perfectly does not guarantee that $\pmb { \theta } ^ { \prime } = \pmb { \theta } ^ { * }$ .
+
+Neural networks exhibit various symmetries in parameter space such that there is almost always a many-to-one correspondence between a choice of $\pmb { \theta }$ and resulting probability function $p _ { \pmb { \theta } }$ . A simple example in neural networks is that one can swap the (incoming and outgoing) connections of two neurons in a hidden layer. This changes the value of the parameters, but does not change the network’s function. Thus, when representation functions $\mathbf { f } _ { \theta }$ or $\mathbf { g } _ { \pmb { \theta } }$ are parameterized as DNNs, equation 2 is not satisfiable.
+
+# 3.2 IDENTIFIABILITY IN FUNCTION SPACE
+
+For reliable and efficient representation learning, we want learned representations $\mathbf { f } _ { \theta }$ from two identifiable models to be sufficiently similar for interchangeable use in downstream tasks. The most general property we wish to preserve among learned representations is their ability to discriminate among statistical patterns corresponding to categorical groupings. In the model family defined in Section 2, the data and context functions $\mathbf { f } _ { \theta }$ and $\mathbf { g } _ { \pmb { \theta } }$ parameterize $p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { x } , \mathbf { S } )$ , the probability of label assignment, through a normalized inner product. This induces a hyperplane boundary, for discrimination, in a joint space of learned representations for data $\mathbf { x }$ and context $\mathbf { y }$ . Therefore, in the following, we will derive identifiability conditions up to a linear transformation, using a notion of similarity in parameter space inspired by Hyvärinen et al. (2018).
+
+Definition 1. Let $\overset { L } { \sim }$ be a pairwise relation on $\Theta$ defined as:
+
+$$
+\begin{array} { r } { \pmb { \theta } ^ { \prime } \stackrel { L } { \sim } \pmb { \theta } ^ { * } \iff \mathbf { f } _ { \pmb { \theta } ^ { \prime } } ( \mathbf { x } ) = A \mathbf { f } _ { \pmb { \theta } ^ { * } } ( \mathbf { x } ) } \\ { \mathbf { g } _ { \pmb { \theta } ^ { \prime } } ( \mathbf { y } ) = B \mathbf { g } _ { \pmb { \theta } ^ { * } } ( \mathbf { y } ) } \end{array}
+$$
+
+where $\pmb { A }$ and $\textbf {  { B } }$ are invertible $M \times M$ matrices. See Appendix $\mathbf { B }$ for proof that $\stackrel { \mathrm { L } } { \sim }$ is an equivalence relation. In the remainder, we refer to identifiability up to the equivalence relation $\stackrel { \mathrm { L } } { \sim }$ as $\overset { L } { \sim }$ -identifiable or linearly identifiable.
+
+# 3.3 LINEAR IDENTIFIABILITY OF LEARNED REPRESENTATIONS
+
+We next present a simple derivation of the $\stackrel { \mathrm { L } } { \sim }$ -identifiability of members of the generalized discriminative family defined in Section 2. This result reveals sufficient conditions under which a discriminative probabilistic model $p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { x } , \mathbf { S } )$ has a useful property: the learned representations of the input $\mathbf { x }$ and target random variables $\mathbf { y }$ for any two pairs of parameters $( \theta ^ { \prime } , \theta ^ { * } )$ are related as $\theta ^ { \prime } \stackrel { \triangledown } { \sim } \theta ^ { * }$ , that is, $\mathbf { f } _ { \pmb { \theta } ^ { \prime } } ( \mathbf { x } ) = A \mathbf { f } _ { \pmb { \theta } ^ { * } } ( \mathbf { x } )$ and $\mathbf { g } _ { \pmb { \theta } ^ { \prime } } ( \mathbf { y } ) = \mathbf { \bar { \phi } } B \mathbf { g } _ { \pmb { \theta } ^ { \ast } } ( \mathbf { \bar { y } } )$ .
+
+We first review the notation for the proof, which is introduced in detail in Section 2. We then highlight an important requirement on the diversity of the data distribution, which must be satisfied for the proof statement to hold. We prove the result immediately after.
+
+Notation. The target random variables $\mathbf { y }$ , associated with input random variables x, may be class labels (as in supervised classification), or they could be stochastically generated from datapoints x as, e.g., perturbed image patches (as in self-supervised learning). We account for this additional stochasticity as a set-valued random variable S, containing all possible values of $\mathbf { y }$ conditioned on some $\mathbf { x }$ . For brevity, we will use shorthands that drop the parameters $\pmb { \theta }$ : $p ^ { \prime } : = p _ { \pmb { \theta } ^ { \prime } } , p ^ { * } : = p _ { \pmb { \theta } ^ { * } }$ , $\mathbf { f } ^ { * } : = \mathbf { f } _ { \theta ^ { * } } , \mathbf { f } ^ { \prime } : = \mathbf { f } _ { \theta ^ { \prime } } , \mathbf { g } ^ { \prime } : = \mathbf { g } _ { \theta ^ { \prime } }$ .
+
+Diversity condition. We assume that for any $( \theta ^ { \prime } , \theta ^ { * } )$ for which it holds that $p ^ { \prime } = p ^ { * }$ , and for any distinct tuples given $\mathbf { x }$ , by repeated sampling $\{ ( \mathbf { y } _ { A } ^ { ( i ) } , \mathbf { y } _ { B } ^ { ( i ) } ) \} _ { i = 1 } ^ { M }$ $\mathbf { S } \sim p _ { \mathcal { D } } ( \mathbf { S } | \mathbf { x } )$ such that the matrices and picking $\mathbf { L } ^ { \prime }$ $\mathbf { y } _ { A } , \mathbf { y } _ { B } \in \mathbf { S }$ and $\mathbf { L } ^ { \ast }$ are invertible, where , we can construct a set of $\mathbf { L } ^ { \prime }$ consists $M$ of columns $( \mathbf { g } ^ { \prime } ( \mathbf { y } _ { A } ^ { ( i ) } ) - \mathbf { g } ^ { \prime } ( \mathbf { y } _ { B } ^ { ( i ) } ) )$ , and $\mathbf { L } ^ { \ast }$ consists of columns $\mathbf { g } ^ { * } ( \mathbf { y } _ { A } ^ { ( i ) } ) - \mathbf { g } ^ { * } ( \mathbf { y } _ { B } ^ { ( i ) } )$ , $i \in \{ 1 , \ldots , M \}$ . See Section 3.4 for detailed discussion.
+
+Theorem 1. Under the diversity condition, models in the family defined by Equation (1) are linearly identifiable. That is, for any $\theta ^ { \prime } , \theta ^ { \ast } \in \Theta$ , and $\mathbf { f } ^ { * } , \mathbf { f } ^ { \prime } , \mathbf { g } ^ { * } , \mathbf { g } ^ { \prime } , p ^ { * } , \bar { p ^ { \prime } }$ defined as in Section 2,
+
+$$
+p ^ { \prime } = p ^ { * } \implies \pmb { \theta } ^ { \prime } \stackrel { \perp } { \sim } \pmb { \theta } ^ { * } .
+$$
+
+To establish the result, we proceed by directly constructing an invertible linear transformation that satisfies Definition 1. Consider $\mathbf { y } _ { A } , \mathbf { y } _ { B } \in \mathbf { S }$ . The likelihood ratios for these points
+
+$$
+\frac { p ^ { \prime } ( \mathbf { y } _ { A } | \mathbf { x } , \mathbf { S } ) } { p ^ { \prime } ( \mathbf { y } _ { B } | \mathbf { x } , \mathbf { S } ) } = \frac { p ^ { * } ( \mathbf { y } _ { A } | \mathbf { x } , \mathbf { S } ) } { p ^ { * } ( \mathbf { y } _ { B } | \mathbf { x } , \mathbf { S } ) }
+$$
+
+are equal. Substituting our model definition from equation (1), we find:
+
+$$
+\frac { \exp ( \mathbf { f } ^ { \prime } ( \mathbf { x } ) ^ { \top } \mathbf { g } ^ { \prime } ( \mathbf { y } _ { A } ) ) } { \exp ( \mathbf { f } ^ { \prime } ( \mathbf { x } ) ^ { \top } \mathbf { g } ^ { \prime } ( \mathbf { y } _ { B } ) ) } = \frac { \exp ( \mathbf { f } ^ { * } ( \mathbf { x } ) ^ { \top } \mathbf { g } ^ { * } ( \mathbf { y } _ { A } ) ) } { \exp ( \mathbf { f } ^ { * } ( \mathbf { x } ) ^ { \top } \mathbf { g } ^ { * } ( \mathbf { y } _ { B } ) ) } ,
+$$
+
+where the normalizing constants cancelled out on the left- and right-hand sides. Taking the logarithm, this simplifies to:
+
+$$
+( \mathbf { g } ^ { \prime } ( \mathbf { y } _ { A } ) - \mathbf { g } ^ { \prime } ( \mathbf { y } _ { B } ) ) ^ { \top } \mathbf { f } ^ { \prime } ( \mathbf { x } ) = ( \mathbf { g } ^ { * } ( \mathbf { y } _ { A } ) - \mathbf { g } ^ { * } ( \mathbf { y } _ { B } ) ) ^ { \top } \mathbf { f } ^ { * } ( \mathbf { x } ) .
+$$
+
+Note that this equation is true for any triple $\left( \mathbf { x } , \mathbf { y } _ { A } , \mathbf { y } _ { B } \right)$ for which $p _ { \mathcal { D } } ( \mathbf { x } , \mathbf { y } _ { B } , \mathbf { y } _ { B } ) > 0$ .
+
+We next collect $M$ distinct tuples $( \mathbf { y } _ { A } ^ { ( i ) } , \mathbf { y } _ { B } ^ { ( i ) } )$ so that by repeating Equation (7) $M$ times and by the diversity condition noted above, the resulting difference vectors are linearly independent. We collect these vectors together as the columns of $( M \times M )$ -dimensional matrices $\mathbf { L } ^ { \prime }$ and $\mathbf { L } ^ { \ast }$ , forming the following system of $M$ linear equations:
+
+$$
+\mathbf { L ^ { \prime } } ^ { \top } \mathbf { f ^ { \prime } } ( \mathbf { x } ) = \mathbf { L ^ { * } } ^ { \top } \mathbf { f ^ { * } } ( \mathbf { x } ) .
+$$
+
+Since $\mathbf { L } ^ { \prime }$ and $\mathbf { L } ^ { \ast }$ are invertible, we rearrange:
+
+$$
+\mathbf { f } ^ { \prime } ( \mathbf { x } ) = ( \mathbf { L } ^ { * } \mathbf { L } ^ { \prime - 1 } ) ^ { \top } \mathbf { f } ^ { * } ( \mathbf { x } ) .
+$$
+
+Hence, $\mathbf { f } ^ { \prime } ( \mathbf { x } ) = \mathbf { A } \mathbf { f } ^ { * } ( \mathbf { x } )$ where $\mathbf { A } = ( \mathbf { L } ^ { * } \mathbf { L } ^ { \prime - 1 } )$ . This completes the first half of the proof. See Appendix $\textrm { C }$ for the second half of the proof, which is similar, and handles the function g.
+
+# 3.4 DISCUSSION: WHEN DOES THE DIVERSITY CONDITION HOLD?
+
+Theorem 1 is a constructive proof of existence that exhibits invertible $( M \times M )$ matrices $\mathbf { L } ^ { \prime }$ and $\mathbf { L } ^ { \ast }$ . We require the diversity condition to hold in order to guarantee invertibility. Such a requirement is similar to the conditions in earlier work on nonlinear ICA such as (Hyvärinen et al., 2018), as discussed in Section 6. Informally, this means that there needs to be a sufficient number of possible values $\mathbf { y } \in \mathbf { S }$ . In the case of supervised classification with $K$ classes, S is fixed and of size $K$ . Then, we need $K \ge M + 1$ in order to generate $M$ difference vectors $\mathbf { g } _ { \theta } ( \mathbf { y } ^ { ( 1 ) } ) - \mathbf { g } _ { \theta } ( \mathbf { y } ^ { ( j ) } )$ , $j = 2 , \ldots , M + 1$ . In case of self-supervised or deep metric learning, where $\mathbf { S }$ and y may be algorithmically generated from $\mathbf { x }$ , this requirement is easy to satisfy, as there will typically be a diversity of values of y. The same holds for language models with large vocabularies. However, for supervised classification with a small number of classes, this requirement on the size of S may be restrictive, as we discuss further in Section 4.
+
+Note that by placing the diversity requirement on the number of classes $K$ , we implicitly assumed that the context representation function $\mathbf { g } _ { \theta }$ has the following property: the $M$ difference vectors span the range of $\mathbf { g } _ { \theta }$ . This is a mild assumption in the context of DNNs: for random initialization and iterative weight updates, this property follows from the stochasticity of the distribution used to initialize the network. Briefly, a set of $M + 1$ unique points $\mathbf { y } ^ { ( j ) }$ such that the $M$ vectors $\mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } ^ { ( 1 ) } ) - \mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } ^ { ( j ) } ) , j = 2 , \dots , M + 1$ are not linearly independent has measure zero. For other choices of $\mathbf { g } _ { \pmb { \theta } }$ , care must be taken to ensure this condition is satisfied.
+
+What can be said when $\mathbf { L } ^ { \prime }$ and $\mathbf { L } ^ { \ast }$ are ill-conditioned, that is, the ratio between maximum and minimum singular value $\frac { \sigma _ { \mathrm { m a x } } ( \mathbf { L } ) } { \sigma _ { \mathrm { m i n } } ( \mathbf { L } ) }$ (dropping superscripts when a statement apply to both) is large? In the context of a data representation matrix such as $\mathbf { L }$ , this implies that there exists at least one column $\ell _ { j }$ of $\mathbf { L }$ and constants $\lambda _ { k }$ for $k \neq j$ such that $\begin{array} { r } { \| \ell _ { j } - \sum _ { k \neq j } \bar { \lambda } _ { k } \ell _ { k } \| _ { 2 } < \varepsilon } \end{array}$ for small $\varepsilon$ . In other words, sometuple $( \mathbf { y } ^ { ( k ) } , \mathbf { y } ^ { ( i ) } )$ early a linear combination of the others. T such that the resulting difference vector $\ell _ { j } = \dot { \mathbf { g } } _ { \pmb { \theta } } ( \mathbf { y } _ { A } ^ { ( k ) } ) - \mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } _ { B } ^ { ( i ) } )$ ere exists somecan nearly (in the sense above) be written as a linear combination of the other columns. Such near singularity is in this case a function of the choice of samples $\mathbf { y }$ that yield the difference vectors. The issue could be handled by resampling different data points until the condition number of the matrices is satisfactory. This amounts to strengthening the diversity condition. We leave more detailed analysis to future work, as the result will depend on the choice of architectures for f and $\mathbf { g }$ .
+
+# 4 EXAMPLES OF LINEARLY IDENTIFIABLE MODELS
+
+The form of Equation (1) is already used as a general approach for a variety of machine learning problems. We present a non-exhaustive sample of such publications, chosen to exhibit the range of applications. Many of these approaches were state-of-the-art at the time of their release: Contrastive Predictive Coding (Hénaff et al., 2019), BERT (Devlin et al., 2018), GPT-2 and GPT-3 (Radford et al., 2018; 2019; Brown et al., 2020), XLNET (Yang et al., 2019), and the triplet loss for deep metric learning (Sohn, 2016). In this section, we discuss how to interpret the functional components of these frameworks with respect to the generalized data distribution of Section 2 and canonical parameterization of Equation (1). See Appendix D for reductions to the canonical form of Equation (1).
+
+Supervised Classification. Although the scope of this paper is identifiable representation learning, under certain conditions, standard supervised classifiers can learn identifiable representations as well. In this case, the number of classes must be strictly greater than the feature dimension, as noted in Section 3.4. We simulate such a model in Section 5.1 to show evidence of its linear identifiability. We stress that representation learning as pretraining for classification is a way to ensure that the conditions on label diversity are met, rather than relying on the supervised classifier itself to generate identifiable representations. This paradigm is discussed in the next subsection.
+
+Representations learned during supervised classification can be linearly identifiable under the following model specification. The input random variables $\mathbf { x }$ represent some data domain to be classified, such as images or word embeddings. The target variables $\mathbf { y }$ represent label assignments for $\mathbf { x }$ typically semantically meaningful. These are often encoded these as the standard basis vectors $\mathbf { e _ { y } }$ a “one-hot encoding." The set $\mathbf { S }$ contains all $K$ possible values of $\mathbf { y }$ . In this case, notice that S is not stochastic: the empirical distribution $p _ { \mathcal { D } } ( \mathbf { S } | \mathbf { x } )$ is modelled as a Dirac measure with all probability mass on the set $\mathbf { S } = \{ 0 , \ldots , K - 1 \}$ (using integers, here, to represent distinct labels) . The representation function $\mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } )$ of a classifier is often implemented as DNN that maps from the input layer to the layer just prior to the model logits. The context map $\mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } )$ is given by the weights in the final, linear projection layer, which outputs unnormalized logits. Concretely, $\mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } ) = \mathbf { W } \mathbf { e } _ { \mathbf { y } }$ , where $\mathbf { W } \in \mathbb { R } ^ { M \times M }$ is a learnable weight matrix. In order satisfy the diversity condition, the dimension $M$ of the number of classes $K$ must be strictly greater than the dimension of the learned representation $M$ , that is, $| \mathbf { S } | \geq M + 1$ . Finally, the output of the final, linear projection layer is normalized through a Softmax function, yielding the parameterization of Equation (1).
+
+Self-Supervised Pretraining for Image Classification. Self-supervised learning is a framework that first pretrains a DNN before deploying it on some other, related task. The pretraining task often takes the form of Equation (1) and meets the sufficient conditions to be linearly identifiable. A paradigmatic example is Contrastive Predictive Coding (CPC) (Oord et al., 2018). CPC is a general pretraining framework, but we focus for the sake of clarity on its use in image models here. CPC as applied to images involves: (1) preprocessing an image into augmented patches, (2) assigning labels according to which image the patch came from, and then (3) predicting the representations of the patches whether below, to the right, to the left, or above a certain level (Oord et al., 2018).
+
+The context function of CPC, $\mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } )$ , encodes a particular position in the sequence of patches, and the representation function, $\mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } )$ , is an autoregressive function of the previous $k$ patches, according to some predefined patch ordering. Given some $\mathbf { x }$ , the collection of all patches from the sequence, from a given minibatch of images, is the set $\mathbf { S } \sim p _ { \mathit { D } } ( \mathbf { S } | \mathbf { x } )$ , where the randomness enters via the patch preprocessing algorithm. Since the preprocessing phase is part of the algorithm design, it is straightforward to make it sufficiently diverse (enough transformations of enough patches) so as to meet the requirements for the model to be linearly identifiable.
+
+Multi-task Pretraining for Natural Language Generation. Autoregressive language models, such as (Mikolov et al., 2010; Dai and Le, 2015) and more recently GPT-2 and GPT-3 (Radford et al., 2018; 2019; Brown et al., 2020), are typically also instances of the model family of Equation 1. Data points $\mathbf { x }$ are the past tokens, $\mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } )$ is a nonlinear representation of the past estimated by either an LSTM (Hochreiter and Schmidhuber, 1997) or an autoregressive Transformer model (Vaswani et al., 2017), y is the next token, and $\mathbf { w } _ { i } = \mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } = i )$ is a learned representation of the next token, often implemented as a simple look-up table, as in supervised classification.
+
+BERT (Devlin et al., 2018) is also a member of the linearly identifiable family. This model pretrains word embeddings through a denoising autoencoder-like (Vincent et al., 2008) architecture. For a given sequence of tokenized text, some fixed percentage of the symbols are extracted and set aside, and their original values set to a special null symbol, “corrupting" the original sequence. The pretraining task in BERT is to learn a continuous representation of the extracted symbols conditioned on the remainder of the text. A transformer (Vaswani et al., 2017) function approximator is used to map from the corrupted sequence into a continuous space. The transformer network is the $\mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } )$ function of Equation 1. The context map $\mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } )$ is a lookup map into the learned basis vector for each token.
+
+# 5 EXPERIMENTS
+
+The derivation in Section 3 shows that, for models in the general discriminative family defined in Section 2, the functions $\mathbf { f } _ { \theta }$ and $\mathbf { g } _ { \theta }$ are identifiable up to a linear transformation given unbounded data and assuming model convergence. The question remains as to how close a model trained on finite data and without convergence guarantees will approach this limit. One subtle issue is that poor architecture choices (such as too few hidden units, or inadequate inductive priors) or insufficient data samples when training can interfere with model estimation and thereby linear identifiability of the learned representations, due to underfitting. In this section, we study this issue over a range of models, from low-dimensional language embedding and supervised classification (Figures 1 and 2 respectively) to GPT-2 (Radford et al., 2019), an approximately $1 . 5 * 1 0 ^ { 9 }$ -parameter generative model of natural language (Figure 4). See Appendix A and the code release for details needed to reproduce.
+
+Through these experiments, we show that (1) in the small dimensional, large data regime, linearly identifiable models yield learned representations that lie approximately within a linear transformation of each other (Figures 1 and 2) as predicted by Theorem 1; and (2) in the high dimensional, large data regime, linearly identifiable models yield learned representations that exhibit a strong trend towards linear identifiability. The learned representations approach a linear transformation of each other monotonically, as a function of dataset sample size, neural network capacity (number of hidden units), and optimization progress. In the case of GPT-2, which has benefited from substantial tuning by engineers to improve model estimation, we find strong evidence of linear identifiability.
+
+Measuring linear similarity between learned representations. How can we measure whether pairs of learned representations live within a linear transformation of each other in function space? We adapt Canonical Correlation Analysis (CCA) (Hotelling, 1936) for this purpose, which finds the optimal linear transformations to maximize correlation among two random vectors. On a randomly selected held-out subset $B \subset D$ of the training data we compute $\mathbf { f } _ { \pmb { \theta } _ { 1 } } ( \pmb { \cal { B } } )$ and $\mathbf { f } _ { \pmb { \theta } _ { 2 } } ( { \pmb { \cal { B } } } )$ for two models with parameters $\pmb { \theta } _ { 1 }$ and $\pmb { \theta } _ { 2 }$ respectively. Assume without loss of generality that $\mathbf { f } _ { \pmb { \theta } _ { 1 } } ( \pmb { \cal { B } } )$ and $\mathbf { f } _ { \pmb { \theta } _ { 2 } } ( { \pmb { \cal { B } } } )$ are centered. CCA finds the optimal linear transformations $C$ and $_ { D }$ such that the pairwise correlations $\rho _ { i }$ between the $i ^ { t h }$ columns of $C ^ { \top } \mathbf { f } _ { \pmb { \theta } _ { 1 } } ( B )$ and $D ^ { \top } \mathbf { f } _ { \theta _ { 2 } } ( B )$ are maximized. We collect correlations together in $\rho$ . If after linear transformation the two matrices are aligned, the mean of $\rho$ will be 1; if they are instead uncorrelated, then the mean of $\rho$ will be 0. We use the mean of $\rho$ as a proxy for the existence of a linear transformation between $\mathbf { f } _ { \pmb { \theta } _ { 1 } } ( \pmb { \cal { B } } )$ and $\mathbf { f } _ { \pmb { \theta } _ { 2 } } ( { \pmb { \cal { B } } } )$ . For DNNs, it is a well known phenomenon that most of the variability in a learned representation tends to concentrate in a low-dimensional subspace, leaving many noisy, random dimensions (Morcos et al., 2018). Such random noise can result in spurious high correlations in CCA. A solution to this problem is to apply Principal Components Analysis (PCA) (Pearson, 1901) to each of the two matrices ${ \bf \dot { f } } _ { \pmb { \theta } _ { 2 } } ( B )$ and ${ \bf f } _ { \pmb { \theta } _ { 1 } } ( { \pmb { \cal { B } } } )$ , projecting onto their top- $k$ principal components, before applying CCA. This technique is known as SVCCA (Raghu et al., 2017).
+
+![](images/2d4cb868dd22dc59ee9ae0da08d44517998df81059fa0342bf5bca962e146720.jpg)  
+Figure 2: Deep Supervised Classification. (a) Data distribution for a linearly identifiable K-way classification problem. (b) Mean (centered) CCA between the learned representations over the course of training. After approx. 4000 iterations, CCA finds a linear transformation that rotate the learned representations into alignment, up to optimization error. (c) Learned representations after transformation via optimal linear transformation. The first dimension of the first model’s feature space is plotted against the first dimension of second. The learned representations have a nearly linear relationship, modulo estimation noise.
+
+We report first on a simulation study of linearly identifiable $K$ -way classification, where all assumptions and sufficient conditions of Theorem 1 are guaranteed to be met. We generated a synthetic data distribution with the properties required by Section 2, and chose DNNs that had sufficient capacity to learn a specified nonlinear relationship between inputs $\mathbf { x }$ and targets y. In short, the data distribution $p _ { \mathcal { D } } ( \mathbf { x } , \mathbf { y } , \mathbf { S } )$ consists of inputs $\mathbf { x }$ sampled from a 2-D Gaussian with $\sigma = 3$ . The targets $\mathbf { y }$ were assigned among $K = 1 8$ classes according to their radial position (angle swept out by a ray fixed at the origin). The number of classes $K$ was chosen to ensure $K \geq \mathrm { d i m } [ { \bf f } _ { \theta } ( { \bf \bar { x } } ) ] + 1$ , the diversity condition. See Appendix D.1 for more details.
+
+To evaluate linear similarity, we trained two randomly initialized models of $p _ { \mathcal { D } } ( \mathbf { y } \vert \mathbf { x } , \mathbf { S } )$ . Plots show $\mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } )$ , the data representation function, on random $\mathbf { x }$ . Figure 2b shows that the mean CCA increases to its maximum value over training, demonstrating that the feature spaces converge to the same solution up to a linear transformation modulo model estimation noise. Similarly, Figure 2c shows that the learned representations exhibit a strongly linear relationship.
+
+![](images/76ae7e18d21d886cff12f4e1e12baa0dc100b27ba33fcaae511558cdc38dc139.jpg)  
+Figure 3: Self-Supervised Representation Learning. Error bars are computed over 5 pairs of models. (a) Input data. Two patches are taken (one from top half, and one from the bottom half) of an image at random. Using a contrastive loss, we predict the identity of the bottom patch encoding from the top. (b) Linear similarity of learned representations at checkpoints (see legend). As models converge, linear similarity increases. (c) Linear similarity as we increase the amount of data for $\mathbf { f } _ { \pmb { \theta } }$ and $\mathbf { g } _ { \theta }$ . Error bars are computed over 5 pairs of models. (d) As we increase model size, linear similarity after convergence increases for both $\mathbf { f } _ { \theta }$ and $\mathbf { g } _ { \pmb { \theta } }$ .
+
+![](images/54d8c98b0aec6fd34702d4f5ad8ccd6c87908a0105b64d122896df5365a635f7.jpg)  
+Figure 4: Text Embeddings by GPT-2. GPT-2 results. Representations of the last hidden layer (which is identifiable), in addition to three earlier layers (not necessarily identifiable) for four GPT-2 models. For each representation layer, SVCCA is computed over to all pairs of models, over which correlation coefficients were averaged. SVCCA was applied with 16, 64, 256 and 768 principal components. The learned representations in the last, identifiable layer more correlated than representations learned in preceding layers.
+
+We next investigate high-dimensional, self-supervised representation learning on CIFAR-10 (Krizhevsky et al., 2009) using CPC (Oord et al., 2018; Hénaff et al., 2019). For a given input image, this model predicts the identity of a bottom image patch representation given a top patch representation (Figure 3a.) Here, S comprises the true patch with a set of distractor patches from across the current minibatch. For each model we define both $\mathbf { f } _ { \pmb { \theta } ^ { \prime } }$ and $\mathbf { g } _ { \pmb { \theta } ^ { \prime } }$ as a 3-layer MLP with 256 units per layer (except where noted otherwise) and fix output dimensionality of 64.
+
+In Figure 3b, CCA coefficients are plotted over the course of training. As training progresses, alignment between the learned representations increases. In Figure 3c, we artificially limited the size of the dataset, and plot mean correlation after training and convergence. This shows that increasing availability of data correlates with closer alignment. In Figure 3d, we fix dataset size and artificially limit the model capacity (number hidden units) to investigate the effect of model size on the learned representations, varying the number of hidden units from 64 to 8192. This show that increasing model capacity correlates with increase in alignment of learned representations.
+
+# 5.3 GPT-2
+
+Finally, we report on a study of GPT-2 (Radford et al., 2019), a massive-scale language model. The identifiable representation is the set of features just before the last linear layer of the model. We use pretrained models from HuggingFace (Wolf et al., 2019). HuggingFace provides four different versions of the GPT-2: gpt2, gpt2-medium, gpt2-large and $\mathtt { g p t 2 - x 1 }$ , which differ mainly in the hyper-parameters that determine the width and depth of the neural network layers. For approximately 2000 input sentences, per timestep, for each model, we extracted representations at the last layer (which is identifiable) in addition to the representations per timestep given by three earlier layers in the model. Then, we performed SVCCA on each possible pair of models, on each of the four representations. SVCCA was performed with 16, 64, 256 and 768 principal components, computed by applying SVD separately for each representations of each model. We chose 768 as the largest number of principal components, since that is the representation size for the smallest model in the repository (gpt2). We then averaged the CCA correlation coefficients across the pairs of models. Figure 4 shows the results. The results align well with our theory, namely that the representations at the last layer are more linearly related than the representations at other layers of the model.
+
+# 5.4 INTERPRETATION AND SUMMARY
+
+Theorem 1 establishes linear identifiability as an asymptotic property of a model that holds in the limit of infinite data and exact estimation. The experiments of this section have shown that for linear identifiable models, when the dimensionality is small relative to dataset size (Figures 1 and 2), the learned embeddings are closely linearly related, up to noise. Problems of model estimation and sufficient dataset size are more pronounced in high dimensions. Nevertheless, in GPT2, representations among different trained models do in fact approach a mean correlation coefficient of 1.0 after training (Figure 4, blue line), providing strong evidence of linear identifiability.
+
+# 6 RELATED WORKS
+
+Prior to Hyvärinen and Morioka (2016), identifiability analysis was uncommon in deep learning. We build on advances in the theory of nonlinear ICA (Hyvärinen and Morioka, 2016; Hyvärinen et al., 2018; Khemakhem et al., 2019). In this section, we carefully distinguish our results from prior and concurrent works. Our diversity assumption is similar to diversity assumptions in these earlier works, while differing on certain conditions. The main difference is that their results apply to related but distinct families of models compared to the general discriminative family outlined in this paper. Arguably most related is Theorem 3 of Hyvärinen et al. (2018) and its proof, which shows that a class of contrastive discriminative models will estimate, up to an affine transformation, the true latent variables of a nonlinear ICA model. The main difference with our result is that they additionally assume: (1) that the mapping between observed variables and latent representations is invertible; and (2) that the discriminative model is binary logistic regression exhibiting universal approximation (Hornik et al., 1989), estimated with a contrastive objective. In addition, (Hyvärinen et al., 2018) does not present conditions for affine identifiability for their version of the context representation function g. It should be noted that Theorem 1 in (Hyvärinen et al., 2018) provides a potential avenue for further generalization of our theorem 1 to discriminative models with non-linear interaction between f and g.
+
+Concurrent work (Khemakhem et al., 2020) has expanded the theory of identifiable nonlinear ICA to a class of conditional energy-based models (EBMs) with universal density approximation capability, therefore imposing milder assumptions than previous nonlinear ICA results. Their version of affine identifiability is similar to our result of linear identifiability in Section 3.2. The main differences are that Khemakhem et al. (2020) focus in both theory and experiment on EBMs. This allows for alternative versions of the diversity condition, assuming that the Jacobians of their versions of f or g are full rank. This is only possible if $\mathbf { x }$ or y are assumed continuous-valued; note that we do not make such an assumption. Khemakhem et al. (2020) also presents an architecture for which the conditions provably hold, in addition to sufficient conditions for identifiability up to element-wise scaling, which we did not explore in this work. While we build on these earlier results, we are, to the best of our knowledge, the first to apply identifiability analysis to state-of-the-art discriminative and autoregressive generative models.
+
+# 7 CONCLUSION
+
+We have shown that representations learned by a large family of discriminative models are identifiable up to a linear transformation, providing a novel perspective on representation learning using DNNs. Since identifiability is a property of a model class, and identification is realized in the asymptotic limit of data and compute, we perform experiments in the more realistic setting with finite datasets and finite compute. Our empirical results show that as the representational capacity of the model and dataset size increases, learned representations indeed tend towards solutions that are equal up to only a linear transformation.
+
+REFERENCES   
+J. Bradbury, R. Frostig, P. Hawkins, M. J. Johnson, C. Leary, D. Maclaurin, and S. Wandermanmilne. Jax: Composable transformations of Python+NumPy programs, 2018. URL Http: //Github.Com/Google/Jax.   
+T. B. Brown, B. Mann, N. Ryder, M. Subbiah, J. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell, and Others. Language Models are Few-Shot Learners. Arxiv Preprint Arxiv:2005.14165, 2020.   
+C. Chelba, T. Mikolov, M. Schuster, Q. Ge, T. Brants, P. Koehn, and t. Robinson. One Billion Word Benchmark for Measuring Progress in Statistical Language Modeling. Arxiv Preprint Arxiv:1312.3005, 2013.   
+A. M. Dai and Q. V. Le. Semi-Supervised Sequence Learning. In Advances in Neural information Processing Systems, pages 3079–3087, 2015.   
+J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. Arxiv Preprint Arxiv:1810.04805, 2018.   
+D. Erhan, Y. Bengio, A. Courville, P.-A. Manzagol, P. Vincent, and S. Bengio. Why Does Unsupervised Pre-training Help Deep Learning? Journal of Machine Learning Research, 11(Feb):625–660, 2010.   
+O. J. Hénaff, A. Razavi, C. Doersch, S. Eslami, and A. V. D. Oord. Data-Efficient Image Recognition with Contrastive Predictive Coding. Arxiv Preprint Arxiv:1905.09272, 2019.   
+S. Hochreiter and J. Schmidhuber. Long Short-Term Memory. Neural Computation, 9(8):1735–1780, 1997.   
+E. Hoffer and N. Ailon. Deep Metric Learning Using Triplet Network. In International Workshop On Similarity-Based Pattern Recognition, pages 84–92. Springer, 2015.   
+K. Hornik, M. Stinchcombe, and H. White. Multilayer Feedforward Networks are Universal Approximators. Neural Networks, 2(5):359–366, 1989.   
+H. Hotelling. Relations Between Two Sets of Variates. Biometrika, 28(3/4):321–377, 1936.   
+A. Hyvärinen and H. Morioka. Unsupervised Feature Extraction by Time-Contrastive Learning and Nonlinear ICA. In Advances in Neural information Processing Systems, pages 3765–3773, 2016.   
+A. Hyvärinen, H. Sasaki, and R. E. Turner. Nonlinear ICA Using Auxiliary Variables and Generalized Contrastive Learning. Arxiv Preprint Arxiv:1805.08651, 2018.   
+F. Johansson, U. Shalit, and D. Sontag. Learning representations for counterfactual inference. In International conference on machine learning, pages 3020–3029, 2016.   
+I. Khemakhem, D. P. Kingma, and A. Hyvärinen. Variational Autoencoders and Nonlinear ICA: A Unifying Framework. Arxiv Preprint Arxiv:1907.04809, 2019.   
+I. Khemakhem, R. P. Monti, D. P. Kingma, and A. Hyvärinen. ICE-BeeM: Identifiable Conditional Energy-based Deep Models. Arxiv Preprint Arxiv:2002.11537, 2020.   
+D. P. Kingma and J. Ba. Adam: A Method for Stochastic Optimization. Arxiv Preprint Arxiv:1412.6980, 2014.   
+A. Krizhevsky, G. Hinton, and Others. Learning Multiple Layers of Features from Tiny Images. 2009.   
+P. J. Liu, M. Saleh, E. Pot, B. Goodrich, R. Sepassi, L. Kaiser, and N. Shazeer. Generating Wikipedia by Summarizing Long Sequences. Arxiv Preprint Arxiv:1801.10198, 2018.   
+C. Louizos, U. Shalit, J. M. Mooij, D. Sontag, R. Zemel, and M. Welling. Causal effect inference with deep latent-variable models. In Advances in Neural Information Processing Systems, pages 6446–6456, 2017.   
+Under review as a conference paper at ICLR 2021   
+T. Mikolov, M. Karafiát, L. Burget, J. Cernock ˇ y, and S. Khudanpur. Recurrent Neural Network Based \` Language Model. In Eleventh Annual Conference of The international Speech Communication Association, 2010.   
+T. Mikolov, I. Sutskever, K. Chen, G. S. Corrado, and J. Dean. Distributed Representations of Words and Phrases and their Compositionality. In Advances in Neural information Processing Systems, pages 3111–3119, 2013.   
+A. Mnih and G. E. Hinton. A Scalable Hierarchical Distributed Language Model. In Advances in Neural information Processing Systems, pages 1081–1088, 2009.   
+A. Mnih and Y. W. Teh. A Fast and Simple Algorithm for Training Neural Probabilistic Language Models. Arxiv Preprint Arxiv:1206.6426, 2012.   
+A. S. Morcos, M. Raghu, and S. Bengio. Insights on Representational Similarity in Neural Networks with Canonical Correlation, 2018.   
+A. V. D. Oord, Y. Li, and O. Vinyals. Representation Learning with Contrastive Predictive Coding. Arxiv Preprint Arxiv:1807.03748, 2018.   
+K. Pearson. LIII. On Lines and Planes of Closest Fit to Systems of Points in Space. The London, Edinburgh, and Dublin Philosophical Magazine and Journal of Science, 2(11):559–572, 1901.   
+A. Radford, K. Narasimhan, T. Salimans, and I. Sutskever. Improving Language Understanding by Generative Pre-training. 2018.   
+A. Radford, J. Wu, R. Child, D. Luan, D. Amodei, and I. Sutskever. Language Models are Unsupervised Multitask Learners. Openai Blog, 1(8), 2019.   
+M. Raghu, J. Gilmer, J. Yosinski, and J. Sohl-Dickstein. SVCCA: Singular Vector Canonical Correlation Analysis for Deep Learning Dynamics and interpretability. In Advances in Neural information Processing Systems, pages 6076–6085, 2017.   
+A. Sharif Razavian, H. Azizpour, J. Sullivan, and S. Carlsson. CNN Features Off-the-Shelf: An Astounding Baseline for Recognition. In Proceedings of The Ieee Conference On Computer Vision and Pattern Recognition Workshops, pages 806–813, 2014.   
+K. Sohn. Improved Deep Metric Learning with Multi-class N-Pair Loss Objective. In Advances in Neural information Processing Systems, pages 1857–1865, 2016.   
+P. Sorrenson, C. Rother, and U. Köthe. Disentanglement by Nonlinear ICA with General Incompressible-flow Networks (Gin). Arxiv:2001.04872 [Cs, Stat], Jan. 2020.   
+A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin. Attention is All You Need. In Advances in Neural information Processing Systems, pages 5998– 6008, 2017.   
+P. Vincent, H. Larochelle, Y. Bengio, and P.-A. Manzagol. Extracting and Composing Robust Features with Denoising Autoencoders. In Proceedings of The 25th international Conference On Machine Learning, pages 1096–1103, 2008.   
+T. Wolf, L. Debut, V. Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowicz, and J. Brew. Huggingface’s Transformers: State-of-the-art Natural Language Processing. Arxiv, Abs/1910.03771, 2019.   
+Z. Yang, Z. Dai, Y. Yang, J. Carbonell, R. Salakhutdinov, and Q. V. Le. XLNET: Generalized Autoregressive Pretraining for Language Understanding. Arxiv Preprint Arxiv:1906.08237, 2019.
+
+# A REPRODUCING EXPERIMENTS AND FIGURES
+
+In this section, we present training and optimization details needed to reproduce our empirical validation of Theorem 1. We also published notebooks and check-pointed weights for two crucial experiments that investigate the result in the small and massive scale regimes, for Figure 1 and GPT-2 (ANONYMIZED).
+
+# A.1 FIGURE 1
+
+We provide a Jupyter notebook and model checkpoints for reproducing Figure 1. Please refer to this for hyperparameter settings. In short, we implemented a model (Mnih and Teh, 2012) in the family of Section 2 and trained it on the Billion Word dataset (Chelba et al., 2013). This is illustrative of the property of Theorem 1 because the relatively modest size of the parameter space (see notebook) and massive dataset minimizes model convergence and data availability restrictions, e.g., approaches the asymptotic regime.
+
+The word embedding space is 2-D for ease of visualization. We randomly selected a subset of words, mapped them into their learned embeddings, and visualized them as points in the left and middle panes. We then regress pane one onto pane two in order to learn the best linear transformation between them. Note that if the two are linear transformations of each other, regression will recover that transformation exactly.
+
+# A.2 SIMULATION STUDY: CLASSIFICATION BY DNNS
+
+For this experiment, we want to ensure that the chosen model can fit the data distribution exactly. Controlling this removes one possible factor that could prevent linear identifiability of learned representations despite the model formally having that property. We do this by making sure that the process that generates the dataset matches the model chosen to learn the relationships between inputs and labels.
+
+This is achieved through the following algorithm. We first randomly assign initialization labels based on angular position, then fit two neural networks $f _ { \theta ^ { \star } }$ and $g _ { \pmb { \theta } ^ { \star } }$ to predict the final labels, using the discriminative model of Equation (1) and Appendix D.1. Both $f _ { \theta ^ { \star } }$ and $g _ { \pmb { \theta } ^ { \star } }$ 4-hidden-layer MLPs with two 64 unit layers and one 2-D bottle neck layer. After training these representation functions to convergence, generated new batch of points $\mathbf { x }$ , and used the trained networks to predict the ground truth labels y.
+
+Finally, to conduct experiments, we chose $\mathbf { f } _ { \theta ^ { \prime } }$ and $\mathbf { g } _ { \pmb { \theta } ^ { \prime } }$ to be the same architecture as $\mathbf { f } _ { \theta ^ { \star } }$ and $\mathbf { g } _ { \pmb { \theta } ^ { \star } }$ . This ensures that the supervised classifier we attempted to learn would using the function approximators $\mathbf { f } _ { \pmb { \theta } ^ { \prime } }$ and $\mathbf { g } _ { \pmb { \theta } ^ { \prime } }$ would be able to capture the true data generating process, e.g, would not fail due to too few hidden units, or too complex a relationship between targets and inputs.
+
+Remaining training details are as follows. We optimize weights using Adam with a learning rate of $1 0 ^ { - 4 }$ for $5 * 1 0 ^ { 4 }$ iterations. To make the classification problem more challenging, we additionally add 20 input dimensions of random noise to the data. The Adam optimizer Kingma and Ba (2014) with a learning rate of $3 \cdot 1 0 ^ { - 4 }$ is used.
+
+# A.3 SELF-SUPERVISED LEARNING FOR IMAGE CLASSIFICATION
+
+To compute linear similarity between representations, we train two independent models in parallel. For each model we define both $\mathbf { f } _ { \pmb { \theta } }$ and $\mathbf { g } _ { \theta }$ as a 3-layer fully connected neural network with $\bar { 2 } ^ { 8 }$ units per layer and a fixed output dimensionality of $2 ^ { 6 }$ . We define our model following Equation (1), where $S$ is the set of the other image patches from the current minibatch and optimize the objective of (Hénaff et al., 2019). We augment both sampled patches independently with randomized brightness, saturation, hue, and contrast adjustments, following the recipe of (Hénaff et al., 2019). We train on the CIFAR10 dataset (Krizhevsky et al., 2009) with batchsize $2 ^ { 8 }$ , using the Adam optimizer with a learning rate of $1 0 ^ { - 4 }$ and the JAX (Bradbury et al., 2018) software package. For each model, we early stop based on a validation loss failing to improve further.
+
+Additional details about the experiments that generated Figure 3:
+
+Figure 3 a. Patches are sampled randomly from training images.
+
+Figure 3 b. For each model, we train for at most $3 * 1 0 ^ { 4 }$ iterations, early stopping when necessary based on validation loss.
+
+Figure $_ { 3 \mathrm { ~ c ~ } }$ . For each model, we train for at most $3 * 1 0 ^ { 4 }$ iterations, early stopping when necessary based on validation loss.
+
+Figure 3 d. Error bars show standard error computed over 5 pairs of models after $1 . 5 * 1 0 ^ { 4 }$ training iterations.
+
+# A.4 GPT-2
+
+We include all details through a notebook in the code release. Pretrained GPT-2 weights as specified in the main text are publicly available from HuggingFace Wolf et al. (2019).
+
+# A.5 REMARK ON EFFECT OF INITIALIZATION AND HYPERPARAMETERS OF MODELS
+
+One question that may be of interest is whether initialization affects whether learned representations will be within a linear transformation of each other. This depends on whether the optimization routines (like Adam, AdaGrad, etc.) are robust to wider initialization within a certain range. If so, model convergence will be unaffected. However, this cannot make up for poor initialization or poor optimization: just as in any deep neural network, a poor initialization and inadequate optimizer will interfere with learning the model parameters. In the case of a linearly identifiable model, means that the learned representations would not live within a linear transformation of each other (up to noise from model fitting), since the models have failed to converge to a reasonable solution for the task at hand.
+
+When the hyperparameters of a DNN are changed, this changes the class of functions that the network can represent (i.e., the size and stride of convolution filters will change which input pixels could be correlated in deeper layers). Typically, hyperparameters are carefully tuned using cross validation based on held-out data. We did so in our experiments also. We expect that such a tuning procedure would yield hyperparameters that are as good as possible for the model to be optimized, allowing sufficient optimization so that the linear identifiability of the learned representations is realized. If the hyperparameters are sufficiently bad and optimization suffers, this will interfere with model fitting, and with linear identifiability of the learned representations also.
+
+# B PROOF THAT LINEAR SIMILARITY IS AN EQUIVALENCE RELATION
+
+We claim that $\stackrel { \mathrm { L } } { \sim }$ is an equivalence relation. It suffices to show that it is reflexive, transitive, and symmetric.
+
+Proof. Consider some function $\mathbf { g } _ { \pmb { \theta } }$ and some $\pmb { \theta } ^ { \prime } , \pmb { \theta } ^ { \star } , \pmb { \theta } ^ { \dagger } \subset \Theta$ . Suppose $\theta ^ { \prime } \stackrel { \scriptscriptstyle \perp } { \sim } \theta ^ { \star }$ . Then, there exists an invertible matrix $\mathbf { B }$ such that $\mathbf { g } _ { \pmb { \theta } ^ { \prime } } ( \mathbf { x } ) = \mathbf { B } \mathbf { g } _ { \pmb { \theta } ^ { \star } } ( \mathbf { x } )$ . Since ${ \bf g } _ { \pmb { \theta } ^ { \star } } ( { \bf x } ) = { \bf B } ^ { - 1 } { \bf g } _ { \pmb { \theta } ^ { \prime } } ( { \bf x } )$ , $\stackrel { \mathrm { L } } { \sim }$ is symmetric. Reflexivity follows from setting $\mathbf { g } _ { \pmb { \theta } ^ { \star } }$ to $\mathbf { g } _ { \pmb { \theta } ^ { \prime } }$ and $\mathbf { B }$ to the identity matrix. To show transitivity, suppose also that $\smash { \theta ^ { \star } \stackrel { \scriptscriptstyle \perp } { \sim } \theta ^ { \dagger } }$ . Then, there exists an invertible $\mathbf { C }$ such that $\mathbf { g } _ { \pmb { \theta } ^ { \star } } ( \mathbf { x } ) = \mathbf { C } \mathbf { g } _ { \pmb { \theta } ^ { \dagger } } ( \mathbf { x } )$ . Since $\mathbf { g } _ { \pmb { \theta } ^ { \prime } } \overset { \mathtt { L } } { \sim } \mathbf { g } _ { \pmb { \theta } ^ { \star } }$ , $\mathbf { B } ^ { - 1 } \mathbf { g } _ { \pmb { \theta } ^ { \prime } } ( \mathbf { x } ) = \mathbf { C } \mathbf { g } _ { \pmb { \theta } ^ { \dagger } } ( \mathbf { x } )$ . Rearranging terms, ${ \bf g } _ { \theta ^ { \prime } } ( { \bf x } ) = { \bf B } { \bf C } { \bf g } _ { \theta ^ { \dagger } } ( { \bf x } )$ , so that $\pmb { \theta } ^ { \prime } \sim \pmb { \theta } ^ { \dagger }$ as required.
+
+# C SECTION 3.2 CONTINUED: CASE OF CONTEXT REPRESENTATION FUNCTION g
+
+Our derivation of identifiability of $\mathbf { g } _ { \theta }$ is similar to the derivation of $\mathbf { f } _ { \pmb { \theta } }$ . The primary difference is that the normalizing constants in Equation (6) do not cancel out. First, note that we can rewrite Equation 1 as:
+
+$$
+p _ { \pmb { \theta } } ( \mathbf { y } | \mathbf { x } , \mathbf { S } ) = \exp ( \widetilde { \mathbf { f } _ { \pmb { \theta } } } ( \mathbf { x } , \mathbf { S } ) ^ { \top } \widetilde { \mathbf { g } } _ { \pmb { \theta } } ( \mathbf { y } ) )
+$$
+
+where:
+
+$$
+\begin{array} { r l } & { \displaystyle \widetilde { \mathbf { f } _ { \theta } } ( \mathbf { x } , \mathbf { S } ) = \left[ - Z ( \mathbf { x } , \mathbf { S } ) ; \mathbf { f } _ { \theta } ( \mathbf { x } ) \right] } \\ & { \quad \widetilde { \mathbf { g } _ { \theta } } ( \mathbf { y } ) = \left[ 1 ; \mathbf { g } _ { \theta } ( \mathbf { y } ) \right] } \\ & { \displaystyle Z ( \mathbf { x } , \mathbf { S } ) = \log \sum _ { \mathbf { y } ^ { \prime } \in \mathbf { S } } \exp ( \mathbf { f } _ { \theta } ( \mathbf { x } ) ^ { \top } \mathbf { g } _ { \theta } ( \mathbf { y } ^ { \prime } ) ) . } \end{array}
+$$
+
+Below, we will show that for the model family defined in Section 2,
+
+$$
+\begin{array} { r } { p _ { \pmb { \theta } ^ { \prime } } = p _ { \pmb { \theta } ^ { * } } \quad \Longrightarrow \quad \mathbf { g } _ { \pmb { \theta } ^ { \prime } } ( \mathbf { y } ) = \mathbf { B } \mathbf { g } _ { \pmb { \theta } ^ { \star } } ( \mathbf { y } ) , } \end{array}
+$$
+
+where $\mathbf { B }$ is an invertible $( M \times M )$ -dimensional matrix, concluding the proof of the linear identifiability of models in the family defined by Equation (1). We adopt the same shorthands as in the main text.
+
+# C.1 DIVERSITY CONDITION
+
+We assume that for any $( \theta ^ { \prime } , \theta ^ { \ast } ) \subset \Theta$ for which it holds that $p ^ { \prime } = p ^ { * }$ , and for any given $\mathbf { y }$ , there exist $M + 1$ tuples $\{ ( \mathbf { x } ^ { ( i ) } , \mathbf { S } ^ { ( i ) } ) \} _ { i = 0 } ^ { M }$ , such that $p _ { \mathcal { D } } ( \mathbf { x } ^ { ( i ) } , \mathbf { y } , \mathbf { S } ^ { ( i ) } ) > 0$ , and such that the $( ( M + 1 ) \times ( M + 1 ) )$ matrices $\mathbf { M } ^ { \prime }$ and $\mathbf { M } ^ { \ast }$ are invertible, where $\mathbf { M } ^ { \prime }$ consists of columns $\widetilde { \mathbf { f } } ^ { \prime } ( \mathbf { x } ^ { ( i ) } , \mathbf { S } ^ { ( i ) } )$ , and $\mathbf { M } ^ { * }$ consists of columns $\widetilde { \mathbf { f } } ^ { * } ( \mathbf { x } ^ { ( i ) } , \mathbf { S } ^ { ( i ) } )$ .
+
+This is similar to the diversity condition of Section 3.2 but milder, since a typical dataset will have multiple $\mathbf { x }$ for each $\mathbf { y }$ .
+
+# C.2 PROOF
+
+With the data distribution $p _ { \mathcal { D } } ( \mathbf { x } , \mathbf { y } , \mathbf { S } )$ , for a given $\mathbf { y }$ , there exists a conditional distribution $p _ { \mathcal { D } } ( \mathbf { x } , \mathbf { S } | \mathbf { y } )$ Let $( \mathbf { x } , \mathbf { S } )$ be a sample from this distribution. From equation 1 and the statement to prove, it follows that:
+
+$$
+p ^ { \prime } ( \mathbf { y } | \mathbf { x } , \mathbf { S } ) = p ^ { * } ( \mathbf { y } | \mathbf { x } , \mathbf { S } )
+$$
+
+Substituting in the definition of our model from equation (9), we find:
+
+$$
+\exp ( \widetilde { \mathbf { f } } ^ { \prime } ( \mathbf { x } , \mathbf { S } ) ^ { \top } \widetilde { \mathbf { g } } ^ { \prime } ( \mathbf { y } ) ) = \exp ( \widetilde { \mathbf { f } } ^ { * } ( \mathbf { x } , \mathbf { S } ) ^ { \top } \widetilde { \mathbf { g } } ^ { * } ( \mathbf { y } ) ) ,
+$$
+
+which, evaluating logarithms, becomes
+
+$$
+\widetilde { \mathbf { f } } ^ { \prime } ( \mathbf { x } , \mathbf { S } ) ^ { \top } \widetilde { \mathbf { g } } ^ { \prime } ( \mathbf { y } ) = \widetilde { \mathbf { f } } ^ { * } ( \mathbf { x } , \mathbf { S } ) ^ { \top } \widetilde { \mathbf { g } } ^ { * } ( \mathbf { y } ) ,
+$$
+
+which is true for any triple $( \mathbf { x } , \mathbf { y } , \mathbf { S } )$ where $p _ { \mathcal { D } } ( \mathbf { y } | \mathbf { x } , \mathbf { S } ) > 0$ .
+
+From $\mathbf { M } ^ { \prime }$ and $\mathbf { M } ^ { * }$ (Section C.1) and equation 16 we form a linear system of equations, collecting the $M + 1$ relationships together:
+
+$$
+\begin{array} { r } { \mathbf { M ^ { \prime } } ^ { \top } \widetilde { \mathbf { g } } ^ { \prime } ( \mathbf { y } ) = \mathbf { M ^ { * } } ^ { \top } \widetilde { \mathbf { g } } ^ { * } ( \mathbf { y } ) } \\ { \widetilde { \mathbf { g } } ^ { \prime } ( \mathbf { y } ) = \mathbf { A } \widetilde { \mathbf { g } } ^ { * } ( \mathbf { y } ) , \quad } \end{array}
+$$
+
+where $\mathbf { A } = ( \mathbf { M } ^ { * } \mathbf { M } ^ { \prime - 1 } ) ^ { \top }$ , an invertible $( M + 1 ) \times ( M + 1 )$ matrix.
+
+It remains to show the existence of an invertible $M \times M$ matrix $\mathbf { B }$ such that
+
+$$
+\mathbf { g } ^ { \prime } ( \mathbf { y } ) = \mathbf { B } \mathbf { g } ^ { * } ( \mathbf { y } ) .
+$$
+
+We proceed by constructing $\mathbf { B }$ from A. Since A is invertible, there exist $j$ elementary matrices $\{ \mathbf { E } _ { 1 } , \hdots , \mathbf { E } _ { j } \}$ such that their action $\mathbf { R } = \mathbf { E } _ { j } \mathbf { E } _ { j - 1 } \ldots \mathbf { E } _ { 1 }$ converts $\mathbf { A }$ to a (non-unique) row echelon form. Without loss of generality, we build $\mathbf { R }$ such that the $^ { a _ { 1 , 1 } }$ entry of $\mathbf { A }$ is the first pivot, leading to the particular row echelon form:
+
+$$
+\mathbf { R A } = \left[ \begin{array} { c c c c c c } { a _ { 1 , 1 } } & { a _ { 1 , 2 } } & { a _ { 1 , 3 } } & { . . . } & { a _ { 1 , m \times 1 } } \\ { 0 } & { \tilde { a } _ { 2 , 2 } } & { \tilde { a } _ { 2 , 3 } } & { . . . } & { \tilde { a } _ { 2 , m \times 1 } } \\ { 0 } & { 0 } & { \tilde { a } _ { 3 , 3 } } & { . . . } & { \tilde { a } _ { 2 , m \times 1 } } \\ { \vdots } & { \vdots } & { \vdots } & { \ddots } & { \vdots } \\ { 0 } & { 0 } & { . . . } & { 0 } & { \tilde { a } _ { m \times 1 , m \times 1 } } \end{array} \right] ,
+$$
+
+where $\tilde { a } _ { i , j }$ indicates that the corresponding entry in RA may differ from A due to the action of $\mathbf { R }$ Applying $\mathbf { R }$ to Equation (17), we have
+
+$$
+\mathbf { R } \widetilde { \mathbf { g } } ^ { \prime } ( \mathbf { y } ) = \mathbf { R } \mathbf { A } \widetilde { \mathbf { g } } ^ { * } ( \mathbf { y } ) .
+$$
+
+We now show that removing the first row and column of RA and $\mathbf { R }$ generates matrices of rank $M$ . Let $\overline { { \mathbf { R A } } }$ and $\overline { { \mathbf { R } } }$ denote the $( M \times M )$ submatrices formed by removing the first row and column of RA and $\mathbf { R }$ respectively.
+
+Equation (20) shows that $\overline { { { \bf R } { \bf A } } }$ has a pivot in each column, and thus has rank $M$ . To show that $\overline { { \mathbf { R } } }$ is invertible, we must show that removing the first row and column reduces the rank of $\mathbf { R } = \mathbf { E } _ { j } \mathbf { E } _ { j - 1 } \ldots \mathbf { E } _ { 1 }$ by exactly 1. Clearly, each $\mathbf { E } _ { k }$ is invertible, and their composition is invertible. We must show the same for the composition of $\overline { { \mathbf { E } _ { k } } }$ .
+
+There are three cases to consider, corresponding to the three unique types of elementary matrices. Each elementary matrix acts on A by either (1) swapping rows $i$ and $j$ , (2) replacing row $j$ by a multiple $m$ of itself, or (3) adding a multiple $m$ of row $i$ to row $j$ . We denote elementary matrix types by superscripts.
+
+In Case (1), $\mathbf { E } _ { k } ^ { 1 }$ is an identity matrix with row $i$ and row $j$ swapped. For Case (2), $\mathbf { E } _ { l } ^ { 2 }$ is an identity matrix with the $j , j ^ { t h }$ entry replaced by some $m$ . For each $\mathbf { E } _ { k } ^ { 1 }$ and $\mathbf { E } _ { l } ^ { 2 }$ in $\mathbf { R }$ , where $1 \leq k , l \leq j$ , we know that the indices $i , j \geq 2$ , because we chose the first entry of the first row of $\mathbf { A }$ to be the pivot, and hence do not swap the first row, or replace the first row by itself multiplied by a constant. This implies that removing the first row and column of $\mathbf { E } _ { k } ^ { 1 }$ and $\mathbf { E } _ { l } ^ { \bar { 2 } }$ removes a pivot entry 1 in the $( 1 , 1 )$ position, and removes zeros elsewhere. Hence, the $( M \times M )$ submatrices $\overline { { \mathbf { E } _ { k } ^ { 1 } } }$ and $\overline { { \mathbf { E } _ { l } ^ { 2 } } }$ are elementary matrices with rank $M$ .
+
+For Case (3), $\mathbf { E } _ { k } ^ { 3 }$ has some value $m \in \mathbb { R }$ in the $j , i ^ { t h }$ entry, and 1s along the diagonal. In this case, we may find a non-zero entry in some $\mathbf { E } _ { k } ^ { 3 }$ , so that, e.g., the second row has a pivot at position $( 2 , 2 )$ . Without loss of generality, suppose $i = 1$ , $j = 2$ and let $m$ be some nonzero constant. Removing the first row and column of ${ \bf E } _ { 1 } ^ { 3 }$ removes this $m$ also. Nevertheless, $\overline { { \mathbf { E } _ { 1 } ^ { 3 } } } = \mathbf { I } _ { M }$ , the rank $M$ identity matrix. For any other $\mathbf { E } _ { k } ^ { 3 } \ 1 < i \leq M + 1$ , $j \geq 2$ because we chose $^ { a _ { 1 , 1 } }$ as the first pivot, and hence do not swap the first row, or replace the first row by itself multiplied by a constant. In both cases, removing the first row and first column creates an $\overline { { \mathbf { E } _ { k } ^ { 3 } } }$ that is a rank $M$ elementary matrix.
+
+We have shown by the above that $\overline { { \mathbf { R } } }$ is a composition of rank $M$ matrices. We now construct the matrix $\mathbf { B }$ by removing the first entries of $\widetilde { \mathbf { g } } ^ { \prime }$ and $\widetilde { \mathbf { g } } ^ { \star }$ , and removing the first row and first column of $\mathbf { R }$ e eand RA in Equation (equation 21). Then, we have
+
+$$
+\begin{array} { r l } & { \overline { { { \bf R } } } { \bf g } ^ { \prime } ( { \bf y } ) = \overline { { { \bf R } { \bf A } } } { \bf g } ^ { * } ( { \bf y } ) , } \\ & { { \bf g } ^ { \prime } ( { \bf y } ) = \overline { { { \bf R } } } ^ { - 1 } \overline { { { \bf R } { \bf A } } } { \bf g } ^ { * } ( { \bf y } ) . } \end{array}
+$$
+
+Choosing ${ \bf B } = \overline { { { \bf R } } } ^ { - 1 } \overline { { { \bf R } { \bf A } } }$ proves the result.
+
+# D REDUCTIONS TO CANONICAL FORM OF EQUATION (1)
+
+In the following, we show membership in the model family of Equation 1 using the mathematical notation of the papers under discussion in Section 4. Note that each subsection will change notation to match the papers under discussion, which varies quite widely. We employ the following colour-coding scheme to aid in clarity:
+
+$$
+\log p _ { \theta } ( \mathbf { y } \vert \mathbf { x } , \mathbf { S } ) = \mathbf { f } _ { \theta } ( \mathbf { x } ) ^ { \top } \mathbf { g } _ { \theta } ( \mathbf { y } ) - \log \sum _ { \mathbf { y } ^ { \prime } \in \mathbf { S } } \exp ( \mathbf { f } _ { \theta } ( \mathbf { x } ) ^ { \top } \mathbf { g } _ { \theta } ( \mathbf { y } ^ { \prime } ) ) ,
+$$
+
+where $\mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } )$ is generalized to a data representation function, $\mathbf { g } _ { \boldsymbol { \theta } } ( \mathbf { y } )$ is generalized to a context representation function, and $\begin{array} { r } { \sum _ { \mathbf { y } ^ { \prime } \in \mathbf { S } } \exp ( \mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } ) ^ { \top } \mathbf { g } _ { \pmb { \theta } } ( \mathbf { y } ^ { \prime } ) ) } \end{array}$ is some constant.
+
+# D.1 SUPERVISED CLASSIFICATION
+
+Supervised classifiers commonly employ a neural network feature extractor followed by a linear projection of the output of this network into a space of unnormalized logits. All the layers prior to the logits are the representation function $\mathbf { f } _ { \theta }$ , and the final projection layer is the context map $\mathbf { g } _ { \pmb { \theta } } ( y = i ) = \mathbf { w } _ { i }$ , where $\mathbf { w } _ { i }$ is the $i$ -th column of a weight matrix W. The set S in this case contains human-chosen labels and has no stochasticity. The loss function is the negative log-likelihood of the data under a categorical distribution with a softmax parameterization:
+
+$$
+\log p _ { \pmb { \theta } } ( y = i | \mathbf { x } ; \mathbf { S } ) = \mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } ) ^ { \top } \pmb { w } _ { i } - \varinjlim \sum _ { j = 1 } ^ { | \mathbf { S } | } \exp ( \mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } ) ^ { \top } \pmb { w } _ { j } )
+$$
+
+Supervised classification is thus an member of the family defined in Section 2. It exhibits the simplest functional form for the $\mathbf { g }$ function while allowing f to be arbitrarily complicated.
+
+# D.2 CPC
+
+Consider a sequence of points $\mathbf { x } _ { t }$ . We wish to learn the parameters $\phi$ to maximize the $k$ -step ahead predictive distribution $p ( \mathbf { x } _ { t + k } | \mathbf { x } _ { t } , \phi )$ . In the image patch example, each patch center $i , j$ is indexed by $t$ . Each $\mathbf { x } _ { t }$ is mapped to a sequence of feature vectors $z _ { t } = f _ { \theta } ( \mathbf { x } _ { t } )$ An autoregressive model, already updated with the previous latent representations $z _ { \leq t - 1 }$ , transforms the ${ \boldsymbol { z } } _ { t }$ into a “context" latent representation ${ \bf c } _ { t } = g _ { A R } ( z _ { \leq t } )$ . Instead of predicting future observations $k$ steps ahead, $\mathbf { x } _ { t + k }$ , directly through a generative model $\dot { p } _ { k } \big ( \mathbf { x } _ { t + k } | \mathbf { c } _ { t } \big )$ , Oord et al. (2018) model a density ratio in order to preserve the mutual information between $\mathbf { x } _ { t + k }$ and $\mathbf { c } _ { t }$ .
+
+Objective Let $\mathbf { X } = \{ \mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { N } \}$ be a set of $N$ random samples containing one positive sample from $p ( \mathbf { x } _ { t + k } | \mathbf { c } _ { t } )$ and $N - 1$ samples from the proposal distribution $p ( \mathbf { x } _ { t + k } )$ . Oord et al. (2018) define the following link function: $l _ { k } ( \mathbf { x } _ { t + k } , \mathbf { c } _ { t } ) \triangleq \exp \left( \mathbf { z } _ { t + k } ^ { \intercal } \mathbf { W } _ { k } \mathbf { c } _ { t } \right)$ . Then, CPC optimizes
+
+$$
+- \mathbb { E } _ { \mathbf { X } } \left[ \log \frac { l _ { k } ( \mathbf { x } _ { t + k } , \mathbf { c } _ { t } ) } { \sum _ { x _ { j } \in X } l _ { k } ( \mathbf { x } _ { j } , \mathbf { c } _ { t } ) } \right] = - \mathbb { E } _ { \mathbf { X } } \left[ \log \frac { \exp \left( \mathbf { z } _ { t + k } \mathbf { \Xi } ^ { \top } \mathbf { W } _ { k } \mathbf { c } _ { t } \right) } { \sum _ { \mathbf { x } _ { j } \in \mathbf { X } } \exp \left( \mathbf { z } _ { j } ^ { \top } \mathbf { W } _ { k } \mathbf { c } _ { t } \right) } \right] .
+$$
+
+Substituting in the definition of $l _ { k }$ makes equation (24) identical to the model family (Equation 1).
+
+D.3 AUTOREGRESSIVE LANGUAGE MODELS (E.G. GPT-2)
+
+Let ${ \mathcal { U } } = \{ u _ { 1 } , \ldots , u _ { n } \}$ be a corpus of tokens. Autoregressive language models maximize a loglikelihood $\begin{array} { r } { \dot { L } ( \mathcal { U } ) = \sum _ { i = 1 } ^ { n } \log P ( u _ { i } | u _ { i - k } , \dots , u _ { i - 1 } ; \Theta ) } \end{array}$ , Concretely, the conditional density is modelled as
+
+$$
+\begin{array} { r } { \log P ( u _ { i } | u _ { i - k : i - 1 } ; \Theta ) \qquad } \\ { = \mathbf { W } _ { i : } \mathbf { h } _ { i } - \log \displaystyle \sum _ { j } \exp ( \mathbf { W } _ { j : } \mathbf { h } _ { i } ) , } \end{array}
+$$
+
+where $\mathbf { h } _ { i }$ is the $m \times 1$ output of a function approximator (e.g. a Transformer decoder (Liu et al., 2018)), and $\mathbf { W } _ { i }$ : is the $i$ ’th row of the $| \mathcal { U } | \times m$ token embedding matrix.
+
+# D.4 BERT
+
+Consider a sequence of text $\mathbf x = [ x _ { 1 } , \dots , x _ { T } ]$ . Some proportion of the symbols in $\mathbf { x }$ are extracted into a vector $\bar { \bf x }$ , and then set in $\mathbf { x }$ to a special null symbol, “corrupting" the original sequence. This operation generates the corrupted sequence $\mathbf { \underline { { x } } }$ . The representational learning task is to predict $\bar { \bf x }$ conditioned on $\mathbf { \underline { { x } } }$ , that is, to maximize w.r.t. $\pmb { \theta }$ ¯:
+
+$$
+\log p _ { \theta } ( \bar { \mathbf { x } } | \mathbf { x } ) \approx \sum _ { t = 1 } ^ { T } m _ { t } \log p _ { \theta } ( x _ { t } | \mathbf { x } ) = \sum _ { t = 1 } ^ { T } m _ { t } \Biggl ( \overline { { H _ { \theta } ( \mathbf { x } ) _ { t } } } ^ { \top } e ( x _ { t } ) - \log \sum _ { x ^ { \prime } } \exp \left( H _ { \theta } ( \mathbf { x } ) _ { t } ^ { \top } e ( x ^ { \prime } ) \right) \Biggr ) ,
+$$
+
+where $H$ is a transformer, $e$ is a lookup table, and $m _ { t } = 1$ if symbol $x _ { t }$ is masked. That is, corrupted symbols are “reconstructed" by the model, meaning that their index is predicted. As noted in Yang et al. (2019), BERT models the joint conditional probability $p ( { \bar { \mathbf { x } } } | \mathbf { x } )$ as factorized so that each masked token is separately reconstructed. This means that the log likelihood is approximate instead of exact.
+
+# D.5 QUICKTHOUGHT VECTORS
+
+Let f and $\mathbf { g }$ be functions that take a sentence as input and encode it into an fixed length vector. Let $s$ be a given sentence, and $S _ { c t x t }$ be the set of sentences appearing in the context of $s$ for a fixed context size. Let $S _ { c a n d }$ be the set of candidate sentences considered for a given context sentence $s _ { c t x t } \in S _ { c t x t }$ . Then, $S _ { c a n d }$ contains a valid context sentence $s _ { c t x t }$ as well as many other non-context sentences. $S _ { c a n d }$ is used for the classification objective. For any given sentence position in the context of $s$ (for example, the preceding sentence), the probability that a candidate sentence $s _ { c a n d } \in S _ { c a n d }$ is the correct sentence for that position is given by
+
+$$
+\log p ( s _ { c a n d } | s , S _ { c a n d } ) = f _ { \theta } ( s ) ^ { \top } \underline { { { g } _ { \theta } ( s _ { c a n d } ) ) } } - \log \sum _ { s ^ { \prime } \in S _ { c a n d } } \exp \left( f _ { \theta } ( s ) ^ { \top } g _ { \theta } ( s _ { c a n d } ^ { \prime } ) \right) .
+$$
+
+# D.6 DEEP METRIC LEARNING
+
+The multi-class N-pair loss in Sohn (2016) is proportional to
+
+$$
+\log N - \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \log \left( 1 + \sum _ { j \neq i } \exp \{ \mathbf { f } _ { \theta } ( { x _ { i } } ) ^ { \top } \mathbf { f } _ { \theta } ( y _ { j } ) - \mathbf { f } _ { \theta } ( { x _ { i } } ) ^ { \top } \mathbf { f } _ { \theta } ( y _ { i } ) ) \} \right) ,
+$$
+
+which can be simplified as
+
+$$
+\begin{array} { l } { { \displaystyle - \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \log \left( \frac { 1 } { K } \sum _ { j = 1 } ^ { K } \exp \{ \mathbf { f } _ { \theta } ( x _ { i } ) ^ { \top } \mathbf { f } _ { \theta } ( y _ { j } ) - \mathbf { f } _ { \theta } ( x _ { i } ) ^ { \top } \mathbf { f } _ { \theta } ( y _ { i } ) \} \right) } } \\ { { \displaystyle = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \log \left( \frac { 1 } { \frac { 1 } { K } \sum _ { j = 1 } ^ { K } \exp \{ \mathbf { f } _ { \theta } ( x _ { i } ) ^ { \top } \mathbf { f } _ { \theta } ( y _ { j } ) - \mathbf { f } _ { \theta } ( x _ { i } ) ^ { \top } \mathbf { f } _ { \theta } ( y _ { i } ) \} } \right) } } \\ { { \displaystyle = \frac { 1 } { N } \sum _ { i = 1 } ^ { N } \log \left( \frac { \exp \{ \mathbf { f } _ { \theta } ( x _ { i } ) ^ { \top } \mathbf { f } _ { \theta } ( y _ { i } ) \} } { \frac { 1 } { K } \sum _ { j = 1 } ^ { K } \exp \{ \mathbf { f } _ { \theta } ( x _ { i } ) ^ { \top } \mathbf { f } _ { \theta } ( y _ { j } ) \} } \right) . } } \end{array}
+$$
+
+Setting $\mathbf { N }$ to 1 and evaluating the log gives
+
+$$
+\mathbf { f } _ { \pmb { \theta } } ( x _ { i } ) ^ { \top } \mathbf { f } _ { \pmb { \theta } } ( y _ { i } ) - \frac { 1 } { K } \sum _ { j = 1 } ^ { K } \exp ( \mathbf { f } _ { \pmb { \theta } } ( x _ { i } ) ^ { \top } \mathbf { f } _ { \pmb { \theta } } ( y _ { j } ) ) ,
+$$
+
+which is Equation 1 where $\mathbf { f } _ { \theta } = \mathbf { g } _ { \theta }$
+
+# D.7 NEURAL PROBABILISTIC LANGUAGE MODELS (NPLMS)
+
+Figure 1 shows results from a neural probabilistic language model as proposed in Mnih and Teh (2012). Mnih and Teh (2012) propose using a log-bilinear model (Mnih and Hinton, 2009) which, given some context $h$ , learns a context word vectors $r _ { w }$ and target word vectors $q _ { w }$ . Two different embedding matrices are maintained, in other words: one to capture the embedding of the word and the other the context. The representation for the context vectorlinear combination of the context words and a context weight matrix $\hat { q }$ , is thenso that . $C _ { i }$ $\begin{array} { r } { \hat { q } = \bar { \sum } _ { i = 1 } ^ { n - 1 } C _ { i } r _ { w _ { i } } } \end{array}$ The score for the match between the context and the next word is computed as a dot product, e.g., $s _ { \theta } ( w , h ) = \hat { q } ^ { \top } \tilde { q } _ { w } { } ^ { 1 }$ and substituting into the definition of $P _ { \theta } ^ { h } ( w )$ , we see that
+
+$$
+\log P _ { \theta } ^ { h } ( w ) = \boldsymbol { \hat { q } } ^ { \top } \boldsymbol { \tilde { q } } _ { w } - \log \sum _ { w ^ { \prime } } \exp \left( \boldsymbol { \hat { q } } ^ { \top } \boldsymbol { \tilde { q } } _ { w ^ { \prime } } \right)
+$$
+
+shows that Mnih and Teh (2012) is a member of the model family.
+
+Interestingly, a touchstone work in the area of NPLMs, Word2Vec (Mikolov et al., 2013), does not fall under the model family due to an additional nonlinearity applied to the score of Mnih and Teh (2012).

parse/train/xCy9thPPTb_/xCy9thPPTb_.md

@@ -0,0 +1,247 @@
+# THE COMPACT SUPPORT NEURAL NETWORK
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Neural networks are popular and useful in many fields, but they have the problem of giving high confidence responses for examples that are away from the training data. This makes the neural networks very confident in their prediction while making gross mistakes, thus limiting their reliability for safety critical applications such as autonomous driving, space exploration, etc. In this paper, we present a neuron generalization that has the standard dot-product based neuron and the RBF neuron as two extreme cases of a shape parameter. Using ReLU as the activation function we obtain a novel neuron that compact support, which means its output is zero outside a bounded domain. We show how to avoid difficulties in training a neural network with such neurons, by starting with a trained standard neural network and gradually increasing the shape parameter to the desired value. Through experiments on standard benchmark datasets, we show the promise of the proposed approach, in that it can have good prediction on in-distribution samples, while being able to consistently detect and have low confidence on out of distribution samples.
+
+# 1 INTRODUCTION
+
+Neural networks have been proven to be extremely useful in all sorts of applications, including object detection, speech and handwriting recognition, medical imaging, etc. They have become the state of the art in these applications, and in some cases they even surpass human performance. However, neural networks have been observed to have a major disadvantage: they don’t know when they don’t know, i.e. don’t know when the input is far away from the type of data they have been trained on. Instead of saying “I don’t know”, they give some output with high confidence (Goodfellow et al., 2015; Nguyen et al., 2015). An explanation of why this is happening for ReLU based networks has been given in Hein et al. (2019). This issue is very important for safety-critical applications such as space exploration, autonomous driving, medical diagnosis, etc. In these cases it is important that the system know when the input data is outside its nominal range, to alert the human (e.g. driver for autonomous driving or radiologist for medical diagnostic) to take charge in such cases.
+
+In this paper we suspect that the root of this problem is actually the neuron design, and propose a different type of neuron to address what we think are its issues. The standard neuron can be written as $f ( x ) = \dot { \sigma } ( \mathbf { w } ^ { T } \mathbf { x } + b )$ , which can be regarded as a projection (dot product) $\mathbf { x } \to \mathbf { w } ^ { T } \mathbf { x } + b$ onto a direction w, followed by a nonlinearity $\tilde { \sigma } ( \cdot )$ . In this design, the neuron has a large response for vectors $\mathbf { x } \in \mathbb { R } ^ { p }$ that are in a half-space. This can be an advantage when training the NN since it creates high connectivity in the weight space and makes the neurons sensitive to far-away signals. However, it is a disadvantage when using the trained NN, since it can lead to the neurons unpredictably firing with high responses to far-away signals, which can result (with some probability) in high confidence responses of the whole network for examples that are far away from the training data.
+
+To address these problems, we use a type of radial basis function neuron (Broomhead & Lowe, 1988), $f ( \mathbf { x } ) = g ( \| \mathbf { x } - \mathbf { \bar { \mu } } \| ^ { 2 } )$ , which we modify to have a high response only for examples that are close to $\pmb { \mu }$ , and to have zero response at distance at least $R$ from $\pmb { \mu }$ . Therefore the neuron has compact support, and the same applies to a layer formed entirely of such neurons. Using one such compact support layer before the output layer we can guarantee that the space where the NN has a non-zero response is bounded, obtaining a more reliable neural network.
+
+In this formulation, the parameter vector $\pmb { \mu }$ is directly comparable to the neuron inputs $\mathbf { x }$ , thus $\pmb { \mu }$ has a simple and direct interpretation as a "template". A layer consisting of such neurons forms can be interpreted as a sparse coordinate system on the manifold containing the inputs of that layer.
+
+Because of the compact support, the loss function of such a compact support NN has many flat areas and it can be difficult to training it directly by backpropagation. However, we will show how to train such a NN, by starting with a trained regular NN and gradually bending the neuron decision boundaries to make them have smaller and smaller support.
+
+The contributions of this paper are the following:
+
+• We introduce a type of neuron formulation that generalizes the standard neuron and the RBF neuron as two extreme cases of a shape parameter. Moreover one can smoothly transition from a regular neuron to a RBF neuron by gradually changing this parameter. We introduce the RBF correspondent to a ReLU neuron and observe that it has compact support, i.e. its output is zero outside a bounded domain. The above construction allows us to smoothly bend the decision boundary of a standard ReLU based neuron, obtaining a compact support neuron. We use this idea to train a compact support neural network (CSNN) starting from a pre-trained regular neural network. We show through experiments on standard datasets that the proposed CSNN can achieve comparable test errors with regular CNNs, and at the same time it can detect and have low confidence on out-of-distribution data.
+
+# 1.1 RELATED WORK
+
+A common way to address the problem of high confidence predictions for out of distribution (OOD) examples is through ensembles (Lakshminarayanan et al., 2017), where multiple neural networks are trained with different random initializations and their outputs are averaged in some way. The reason why ensemble methods have low confidence on OOD samples is that the high-confidence domain of each NN is random outside the training data, and the common high-confidence domain is therefore shrunk by the averaging process. This reasoning works well when the representation space (the space of the NN before the output layer) is high dimensional, but it fails when this space is low dimensional (see van Amersfoort et al. (2020) for example).
+
+Another popular approach is adversarial training (Madry et al., 2018), where the training set is augmented with adversarial examples generated by maximizing the loss starting from slightly perturbed examples. This method is modified in adversarial confidence enhanced training (ACET) (Hein et al., 2019) where the adversarial samples are added through a hybrid loss function. However, we believe that training with out of distribution samples could be a computationally expensive if not hopeless endeavor, since the instance space is extremely vast when it is high dimensional. Consequently, a finite number of training examples can only cover an insignificant part of it and no matter how many out-of-distribution examples are used, there always will be other parts of the instance space that have not been explored. Other methods include the estimation of the uncertainty using dropout (Gal & Ghahramani, 2016), softmax calibration (Guo et al., 2017), and the detection of out-of-distribution inputs (Hendrycks & Gimpel, 2017). CutMix Yun et al. (2019) is a method to generate training samples with larger variability, which help improve generalization and OOD detection. All these methods are complementary to our approach and could be used together with our classifiers to improve accuracy and OOD detection.
+
+In Ren et al. (2019) are trained two auto-regressive models, one for the foreground in-distribution data and one for the background, and the likelihood ratio is used to decide for each observation whether it is OOD or not. This is a generative model, while our model is discriminative.
+
+A number of works assume that the distance in the representation space (the space of outputs of the last layer before the final classification layer) is meaningful. They will be reviewed next.
+
+Recently, Jiang et al. (2018) proposed a trust score that measures the agreement between a given classifier and a modified version of a $k$ -nearest neighbor classifier. While this approach does consider the distance of the test samples to the training set, it only does so to a certain extent since the $k$ -NN does not have a concept of “too far”, and is also computationally expensive.
+
+A simple method based on the Mahalanobis distance is presented in Lee et al. (2018). It assumes that the observations are normally distributed in the representation space, with a shared covariance matrix for all classes. While we also assume that the distance in the representation space is meaningful, we make a much weaker assumption that the observations for each class are clustered in a number of clusters, not necessarily Gaussian. In our representation, each class is usually covered by more than one compact support neuron, and each neuron could be involved in multiple classes. Furthermore, the method in Lee et al. (2018) simply replaces the last layer of the NN with their Mahalanobis measure and makes no attempt to further train the new model, while we can train our layers together with the whole network.
+
+![](images/c7b11b621b86f77faf4f46292c6a7bf7a8dc8bd8c59ec1ae6b0410e5b178460a.jpg)  
+Figure 1: The construction (3) smoothly interpolates between a standard neuron $( \alpha = 0$ ) and an RBF-type of neuron $( \alpha = 1$ ). Shown are the neuron decision boundaries for various values of $\alpha$ .
+
+The Generalized ODIN Hsu et al. (2020) decomposes the output prediction into the ratio of a classspecific function $h _ { i } ( x )$ and a common denominator $g ( x )$ , both defined over instances $x$ from the representation space. Good results are obtained using $h _ { i }$ based on the Euclidean distance or the cosine similarity. Again, this approach assumes that the observations are grouped in a single cluster for each class, which explains it uses very deep models (with 34-100 layers) that are more capable to obtain representations where this assumption is satisfied. Our method does not make the single cluster per class assumption, and can use deep or shallow models.
+
+The Deterministic Uncertainty Quantification (DUQ) (van Amersfoort et al., 2020) method uses an RBF network and a special gradient penalty to decrease the prediction confidence away from the training examples. The authors also propose a centroid updating scheme to handle the difficulties in training an RBF network. In contrast, our paper proposes a generalized neuron model that has the RBF neurons and the standard neurons as two extreme cases, and trains all models starting from a standard NN where the local minima are more well behaved.
+
+# 2 THE COMPACT SUPPORT NEURAL NETWORK
+
+The compact support neural network consists of a number of layers, where the last layer before the output layer contains only compact support neurons, which will be described next. The other layers could be regular neural network or convolutional neural network layers, or compact support layers. The final output layer is a regular linear layer without a bias term, so that it can output a vector of all zeros when appropriate.
+
+# 2.1 THE COMPACT SUPPORT NEURON
+
+We start with the radial basis function (RBF) neuron (Broomhead & Lowe, 1988),
+
+$$
+f _ { \mathbf { w } } ( \mathbf { x } ) = g ( \| \mathbf { x } - \mathbf { w } \| ^ { 2 } ) .
+$$
+
+The RBF neuron has $g ( u ) = \exp ( - \beta u )$ as the activation function, but in this paper we will use $g ( u ) = \operatorname* { m a x } ( R ^ { 2 } - u , \bar { 0 } )$ because it is related to the ReLU.
+
+A flexible representation. We can introduce an extra parameter $\alpha = 1$ and rewrite eq. (1) as
+
+$$
+f _ { \mathbf { w } } ( \mathbf { x } ) = g ( \mathbf { x } ^ { T } \mathbf { x } + \mathbf { w } ^ { t } \mathbf { w } - 2 \mathbf { w } ^ { T } \mathbf { x } ) = g ( \alpha ( \| \mathbf { x } \| ^ { 2 } + \| \mathbf { w } \| ^ { 2 } ) - 2 \mathbf { w } ^ { T } \mathbf { x } ) .
+$$
+
+Using the parameter $\alpha$ , we obtain a representation that smoothly changes between an RBF neuron when $\alpha = 1$ and a standard projection neuron when $\alpha = 0$ . However, starting with an RBF neuron with $g ( u ) = \exp ( - \beta u )$ , we obtain the projection neuron for $\alpha = 0$ as $f _ { \mathbf { w } } ( \mathbf { x } ) = \exp ( 2 \mathbf { w } ^ { T } \mathbf { x } )$ , which has an exponential activation function.
+
+The compact support neuron. We want to obtain a standard ReLU based neuron $f _ { \mathbf { w } } ( \mathbf { x } ) = \sigma ( \mathbf { w } ^ { T } \mathbf { x } )$ with $\sigma ( u ) = \operatorname* { m a x } ( u , 0 )$ for $\alpha = 0$ . For this purpose we will use $g ( u ) = \sigma ( R ^ { 2 } - \dot { u } )$ , and modify the above construction to obtain the compact support neuron:
+
+$$
+f _ { \mathbf { w } } ( \mathbf { x } ) = \sigma ( R ^ { 2 } - \mathbf { x } ^ { T } \mathbf { x } - \mathbf { w } ^ { T } \mathbf { w } + 2 \mathbf { w } ^ { T } \mathbf { x } ) = \sigma [ \alpha ( R ^ { 2 } - \| \mathbf { x } \| ^ { 2 } - \| \mathbf { w } \| ^ { 2 } - b ) + 2 \mathbf { w } ^ { T } \mathbf { x } + b ] ,
+$$
+
+![](images/4f4fba9ba6cebb9ff56d470944d1274f28dea0a59e233283cba4a0b94d59d6ae.jpg)  
+Figure 2: Left: Diagram of the compact support neural network (CSNN), with the CSN layer described in Eq. (6). Right: an example of the CSNN with normalized input from ResNet. Only the full arrows have backpropagation.
+
+where we also introduced a bias term $b$ for the standard neuron. We usually make $b = 0$ for simplicity.   
+The parameter $R$ defines the radius of the support of the neuron when $\alpha = 1$ .
+
+One can easily check that the support of $f _ { \mathbf { w } } ( \mathbf { x } )$ from eq. (3) (i.e. the domain where it takes nonzero values) is in a sphere of radius
+
+$$
+R _ { \alpha } ^ { 2 } = R ^ { 2 } + b ( 1 / \alpha - 1 ) + \| \mathbf { w } \| ^ { 2 } ( 1 / \alpha ^ { 2 } - 1 )
+$$
+
+centered at $\mathbf { w } _ { \alpha } = \mathbf { w } / \alpha$ . Therefore the neuron from eq. (3) has compact support for any $\alpha > 0$ and the larger the value of $\alpha$ , the smaller the support of the neuron will be. In Figure 1 is shown the support for several values of $\alpha \in [ 0 , 1 ]$ of the neuron (3) with $\mathbf { w } = ( 0 , 2 ) ^ { T } , b = \mathbf { \bar { 0 } }$ and $R = 1$ .
+
+Convolutional version. If one desires to make a compact support convolutional neuron, let w be its $k \times k$ matrix of weights. Then the convolutional version can be obtained by taking into consideration that each $k \times k$ patch of an image I is a candidate $\mathbf { x }$ in eq. (3). Therefore one can easily check that the convolutional compact support neuron should be:
+
+$$
+f _ { \mathbf { w } } ( { \mathbf { I } } ) = \sigma [ \alpha ( R ^ { 2 } - b - { \mathbf { I } } ^ { 2 } * { \mathbf { 1 } } - \| \mathbf { w } \| ^ { 2 } ) + 2 { \mathbf { I } } * { \mathbf { w } } + b ]
+$$
+
+where 1 is a $k \times k$ matrix of ones, $\mathbf { I } ^ { 2 }$ is done elementwise and $^ *$ is the convolution.
+
+# 2.2 THE COMPACT SUPPORT NEURAL NETWORK
+
+If we have a layer containing only compact support neurons (CSN), combining the weights into a matrix ${ \bf W } ^ { T } = \dot { ( } { \bf w } _ { 1 } , . . . , { \bf w } _ { K } \dot { ) }$ and the biases into a vector $\mathbf { b } = ( b _ { 1 } , . . . , b _ { K } )$ , we can write the CSN layer as:
+
+$$
+\mathbf { f } _ { \mathbf { W } } ( \mathbf { x } ) = \sigma ( \alpha [ R ^ { 2 } - \mathbf { b } - \mathbf { x } ^ { T } \mathbf { x } - \mathrm { T r } ( \mathbf { W } \mathbf { W } ^ { T } ) ] + 2 \mathbf { W } \mathbf { x } + \mathbf { b } ) .
+$$
+
+where $\mathbf { f _ { W } } ( \mathbf { x } ) = ( f _ { 1 } ( \mathbf { x } ) , . . . , f _ { K } ( \mathbf { x } ) ) ^ { T }$ is the vector of neuron outputs of that layer. This formulation enables the use of standard neural network machinery (e.g. PyTorch) to train a CSN. In practice we will have no bias term (i.e. $\mathbf { b } = 0$ ), except in low dimensional experiments.
+
+The simplest compact support neural network (CSNN) has two layers: a hidden layer containing compact support neurons (3) or their convolutional counterparts (5), and an output layer which is a standard fully connected layer without bias. It is illustrated in Figure 2, left.
+
+Normalization. For best results, all variables of the input data $\mathbf { x }$ should be on the same scale. For better control, it is also preferable that $\| \mathbf { x } \|$ be approximately 1 on the training examples. These goals√ can be achieved by standardizing the variables to have zero mean and standard deviation $1 / \sqrt { d }$ on the training examples (where $d$ is the dimension of $\mathbf { x }$ ). This way $\| \mathbf { x } \| ^ { 2 } \sim 1$ when the dimension $d$ is large (under assumptions of normality and independence of the variables of $\mathbf { x }$ ). Our experiments on three datasets indicate that indeed $\| \mathbf { x } \| \sim 1$ on real data when the inputs $\mathbf { x }$ are normalized as described above, as exemplified by the histograms of $\| \mathbf { x } \|$ from Figure 3.
+
+![](images/163b3dd0b3e49e18d2d13f933c6c4551e29ecb0c2dc6c102da09cd14ecebc0e7.jpg)  
+Figure 3: Histogram of the norms $\left\| \mathbf { v } _ { i } \right\|$ of the normalized input features $\mathbf { v } _ { i }$ to the CSN layer for the three datasets trained in our experiments.
+
+Training. Like the RBF network, training a neural network with such neurons with $\alpha = 1$ is difficult because the loss function has many local optima. To make matters even worse, the compact support neurons have small support when $\alpha$ is close to 1, and consequently the loss function has flat regions between the local minima.
+
+This is why we take another approach to training. Using equations (6) or (5) we can train a CSNN by first training a regular NN $( \alpha = 0$ ) and then gradually increasing the shape parameter $\alpha$ from 0 towards 1 while continuing to update the NN parameters. Observe that whenever $\alpha > 0$ the NN has compact support, but the support gets smaller as $\alpha$ gets closer to 1. The training procedure is described in detail in Algorithm 1.
+
+Algorithm 1 Compact Support Neural Network (CSNN) Training   
+
+<table><tr><td>Output: Trained CSNN.</td><td>Input: Training set T = {(xi, yi) ∈ RP × R}=1,</td><td></td><td></td></tr><tr><td></td><td></td><td>1: Train a regular CNN f(x) = Lo(2Wg(x) + b) where W,L are the last two layer weight</td><td></td></tr><tr><td></td><td>matrices and g(x) is the rest of the CNN.</td><td>2: Freeze g(x), compute ui = g(xi),i = 1,.,n, their mean μ and standard deviation o.</td><td></td></tr><tr><td>3:</td><td> Obtain normalized versions Vi of ui as Vi = (ui - μ)/√do,i = 1,., n.</td><td></td><td></td></tr><tr><td>4:</td><td>for e= 1 to Nepochs do</td><td></td><td></td></tr><tr><td>5:</td><td>Set α = e/Nepochs</td><td></td><td></td></tr><tr><td>6:</td><td> Use the examples (Vi, yi) to update (W,L,b) based on one epoch of</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td>f(ν)=Lσ(α[R²-vTv- Tr(WWT)-b]+ 2Wv +b)</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td>7:(optional) Remove any neurons Wj of WT = (w1,.*,Wk) that are dead,i.e. satisfy:</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td>σ(a[R²-||vill²-|/wjl²)-bj]+2wTνi+bj)=0,i=1,.,n</td><td></td><td></td></tr></table>
+
+8: end for
+
+In the synthetic experiment in Figure 4 we succeeded to bring the train and test errors close to 0 for $\alpha = 1$ using a carefully crafted schedule for increasing the $\alpha$ . However, in the real data applications, the training, test and validation errors might first decrease a little bit but ultimately increase as $\alpha$ approaches 1. For example one could see the test errors vs $\alpha$ for the synthetic dataset in Figure 6 and for the real datasets in Figure 9. For this reason, in practice we stop the training at an $\alpha < 1$ where the training and validation errors still take acceptable values, e.g. a validation error less than the validation error for $\alpha = 0$ . However, we noticed that the larger the value of $\alpha$ , the tighter the support around the training data and the better the generalization.
+
+It is worth noting that in contrast to the weights of a standard neuron, the weights of the compact support neuron exist in the same space as the neuron inputs and they can be regarded as templates. Thus they have more meaning, and one could easily visualize the type of responses that make them maximal, using standard neuron visualization techniques such as Zeiler & Fergus (2014). Furthermore, one can also obtain samples from the compact support neurons, e.g. for generative or GAN models.
+
+# 3 EXPERIMENTS
+
+In this section we first present an experiment on 2D data to showcase what can be achieved with the proposed compact support neural network, and then experiments on real datasets to show the power of the CSNN to model real data and how it can detect out-of-distribution samples.
+
+# 3.1 2D EXAMPLE
+
+We present a first experiment with the moons 2D dataset, where the data is organized on two intertwining half-circle like shapes, one containing the positives and one the negatives. The data is scaled so that all observations are in the interval $[ 0 , 1 ] ^ { \dot { 2 } }$ (shown as a white rectangle in Figure 4. As out of distribution data (OOD) we started with $1 0 0 \times 1 0 0 = 1 0 0 0 0$ samples on a grid spanning $[ - 0 . 5 , 1 . 5 ] ^ { 2 }$ and we removed all samples at distance at most 0.1 from the moons data, obtaining 8763 samples.
+
+We used a two layer CSNN, with the first layer having 128 CSNN neurons, and the second layer being a standard NN layer without bias, as illustrated in Figure 2, left. The second layer is used to integrate the evidence from the CSNN neurons into the class prediction. We used 200 training examples and trained the CSNN using Algorithm 1. We trained 2000 epochs with $R ^ { 2 }$ decreasing linearly from 0.04 to 0.01, and $\alpha$ increasing from 0 to 1 as $\alpha _ { i } = \operatorname* { m i n } ( 1 , \operatorname* { m a x } ( 0 , ( i ^ { 0 . 1 } - 1 . 5 ) / . 6 ) )$ , $i = 1 , . . . , 2 0 0 0$ . This way $\alpha$ increases slower as it gets closer to 1. Using this special training we avoided the training and test errors blowing up when $\alpha$ gets close to 1. As specified in line 7 of Algorithm 1, the NN nodes that had zero response on all training examples were eliminated. These neurons cannot be trained anymore and only give uncontrolled responses on unseen data. This way from the 128 neurons, only 73 were left at the end of training.
+
+![](images/f0ed37566c4e463b84591db9ea935cc99dd785929ad3663b924e1ea041c39021.jpg)  
+Figure 4: The confidence map (0.5 for white and 1 for black) of the trained CSNN on the moons dataset for different values of $\alpha \in [ 0 , 1 ]$ . Top: zoom out on the interval $[ - 5 , 6 ] ^ { 2 }$ . Bottom: zoom in view of the interval $[ - 0 . 5 , 1 . 5 ] ^ { 2 }$ .
+
+![](images/0b9c8c6dd4e1fc416ec92903d00f1372faf8c9ddd2df5d650f39ba511e70915b.jpg)  
+Figure 5: Example of activation pattern domains for $\alpha = 0$ and $\alpha ~ = ~ 0 . 8 2 5$ and the resulting confidence map (0.5 for white and 1 for black) for $\alpha = 0 . 8 2 5$ for a 32 neuron 2-layer CSNN.
+
+The training/test errors and the AUROC and NZ confidence measures for the OOD data described above vs. $\alpha$ are shown in Figure 6. Observe that the training and test errors for $\alpha = 0$ are quite large, because the standard NN with 128 neurons cannot fit the data well enough, and they decrease as the neuron support decreases and the model is better capable to fit the data.
+
+The confidence map for the obtained classifier is shown in Figure 4. We can see that the confidence is 0.5 (white) almost everywhere except close to the training data, where it is close to 1 (black). This gives us an insight that the method works as expected, shrinking the support of the neurons to a small domain around the training data. We also see that the support is already reasonably small for $\alpha = 0 . 6$ and it gets tighter and tighter as $\alpha$ gets closer to 1.
+
+![](images/9d5e97c1bb2e292effd8e47c9118422de96af1861d74126ed5bb59b31adcae74.jpg)  
+Figure 6: CSNN train and test errors, AUROC and percent nonzero outputs (NZ) vs. $\alpha$ for the moons data.
+
+It is known Croce & Hein (2018); Hein et al. (2019) that the output of a ReLU-based neural network is piecewise linear and the domains of linearity are given by the activation pattern of the neurons. The activation pattern of the neurons consists of the domains where the set of neurons that are active (i.e. their output is positive) does not change. These activation pattern domains are polytopes, as shown in in Figure 5, left, for a two-layer NN with 32 neurons. The activation domains for a CSNN are intersections of circles, as illustrated in Figure 5, middle, with the domain where all neurons are inactive shown in white. The corresponding confidence map is shown in Figure 5, right.
+
+In real data applications we don’t need to go all the way to $\alpha =$ 1 since even for smaller $\alpha$ the support is still bounded and if the instance space is high dimensional (e.g. 512 to 1024 in the real data experiments below), the volume of the support of the CNN will be very small compared to the instance space, making it unlikely to have high confidence on out-of-distribution data.
+
+The role of pruning dead neurons. Due to the random initialization of the neurons, there might exist neurons that have zero response on all the training observations. These neurons are dead in the sense that they are not updated in the back-propagation, since their response is always zero. We have observed that in some cases these dead neurons will produce some small high confidence regions far away from the training examples (see Fig. 7). This problem can be eliminated by removing these neurons during training, which is done by line 7 of Algorithm 1.
+
+![](images/d6acabc6bfd51c9b56e29d682d1c93eab60c24247e4a4853209a72a34efec83c.jpg)  
+Figure 7: Confidence map without pruning, $\alpha = 0 . 9 8 5$ .
+
+![](images/5853098c38710f2d8261c9a369a5635256653dac968d9254e11a70ced307af4a.jpg)  
+Figure 8: The CSNN-F with LeNet backbone, where all layers are trained by backpropagation.
+
+# 3.2 REAL DATA EXPERIMENTS
+
+We conduct experiments by training on three different datasets: MNIST (LeCun & Cortes, 2010), CIFAR-10 and CIFAR-100 (Krizhevsky et al., 2009). We evaluate the confidence on in-sample and out-of-sample data, by testing them on their respective test sets (in-sample) and on other datasets as shown in Table 1, including the test sets of EMNIST (Cohen et al.), FashionMNIST (Xiao et al., 2017) and SVHN (Netzer et al., 2011), and the validation set of ImageNet (Deng et al., 2009). For MNIST we also tested on a grayscale version of CIFAR-10, obtained by converting the 10,000 test images to gray-scale and resizing them to $2 8 \times 2 8$ .
+
+CNN architecture. For MNIST we use a 4-layer LeNet CNN as backbone, with two $5 \times 5$ convolution layers with 32 and 64 filters respectively, followed by ReLU and $2 \times 2$ max pooling, and two fully connected layers with 256 and 10 neurons. For the other two datasets, we used as backbone a ResNet-18 architecture (He et al., 2016) with 4 residual blocks with 64, 128, 256 and 512 filters respectively. After the backbone CNN has been trained, the FC layers were removed and only the convolutional layers were kept, as illustrated in Figure 2, right and Figure 8.
+
+For the CSNN we will experiment with two architectures, illustrated in Figure 2 and Figure 8. The first is a small one (called CSNN) that takes as input the output of the last convolutional layer of the backbone, normalized as described in Section 2.2. The normalization of the CSNN input can also be achieved using a batch normalization layer without any learnable affine parameters. The second one is a full network (called CSNN-F), illustrated in Figure 8, where the backbone (LeNet or ResNet) is part of the backpropagation and a batch normalization layer (BN) without any learnable parameters has been introduced between the backbone and the CSN layer.
+
+Training details. For all datasets we used data augmentation with padding (3 pixels for MNIST, 4 pixels for the rest) and random cropping to train the backbones. For CIFAR-100 we also used random rotation up to 15 degrees.We used no data augmentation when training the CSNN and CSNN-F.
+
+The training/test data was passed though the backbone without the FC layers, and the output was normalized. A CSNN without bias term was trained for 510 epochs with $R = 0 . 1$ , of which 10 epochs at $\alpha = 0$ . For the CSNN training we used the Adam optimizer with learning rate 0.001 and weight decay 0.0001. We also tried SGD and obtained similar results. The CSNN-F was trained with SGD with a learning rate of 0.001 and weight decay 0.0005. Its layers were initialized with the trained backbone and the trained CSNN. Then $\alpha$ was kept fixed for two epochs and increased by 0.005 every epoch for 4 more epochs.
+
+![](images/2fecf33cc6072abb3692e728485b4933f30675a06e928fe55d9a7841f8e931db.jpg)  
+Figure 9: Train and test errors, Area under ROC Curve (AUROC) and percent nonzero outputs (NZ) vs $\alpha$ for CSNN classifiers trained on three real datasets. These results are obtained from one training run.
+
+Training the CSNN from $\alpha = 0$ to $\alpha = 1$ for 510 epochs takes less than an hour on a MSI GS-60 Core I7 laptop with 16Gb RAM and Nvidia GTX 970M GPU. Each epoch of the CSNN-F took less than a minute with the LeNet backbone and about 3 minutes with the ResNet-18 backbone.
+
+OOD detection. The out of distribution (OOD) detection is performed similarly to the way it is done in a standard CNN. For any observation, the maximum value of CSNN raw outputs is used as the OOD score for predicting whether the observation is OOD or not. If the observation is in-distribution, its score will usually be large, and if it is OOD, it will be usually close to zero or even zero. The ROC curve based on these scores for the test set of the in-distribution data (as class 0) and one OOD dataset (as class 1) will give us the AUROC. If the two distributions are not separable (have concept overlap), some of the OOD scores will be large, but for the OOD observations that are away from the area of overlap they will be small or even zero.
+
+In Figure 9 are shown the train/test errors vs $\alpha$ for the CSNN on the three datasets. Also shown are the Area under the ROC curve (AUROC) for OOD detection on CIFAR-10 or CIFAR-100 and the percentage of OOD samples with nonzero outputs (NZ). Observe that all curves on the real data are very smooth, even though they are obtained from one run, not averaged. We see that the training and test errors stay flat for a while then they start increasing from a certain $\alpha$ that depends on the dataset. At the same time, the AUROC stays flat and slightly increases, and there is a range of values of $\alpha$ where the test error is low and the AUROC is large. Looking in more detail at the CIFAR-10 dataset (middle plot in Figure 9), we see that for $\alpha = 0 . 7$ the NZ-CIFAR100 is about 0.6, which means that about $40 \%$ of the CIFAR-100 observations have all 0 CSNN outputs, therefore an OOD score of 0. Combined with the scores of the other observations and the fact that at most $10 \%$ of the CIFAR-10 test observations have an OOD score of 0 (because the test error is less than 0.1) it results in a slight increase in AUROC.
+
+In practice, $\alpha$ should be chosen as large as possible where an acceptable validation error is still obtained, to have the smallest support possible. For example one could choose the largest $\alpha$ such that the validation error at $\alpha$ is less then or equal to the validation error at $\alpha = 0$ . However, for better comparison with the other methods, for each dataset we chose the CSNN classifier corresponding to the largest $\alpha$ where the test error takes a value comparable to the other methods compared, and reported the AUROC values in Table 1. The CSNN-F was obtained by merging the corresponding CSNN head with the ResNet or LeNet backbone and training them together for 6 epochs.
+
+Methods compared. We compare our results with the Adversarial Confidence Enhanced Training (ACET) (Hein et al., 2019), Deterministic Uncertainty Quantification (DUQ) (van Amersfoort et al., 2020), a standard CNN, and an ensemble of five or 10 CNNs trained with different random initializations. The ACET results are taken directly from Hein et al. (2019), and the DUQ, CNN and ensemble results were obtained using the DUQ authors’ code. For DUQ we trained multiple models with various combinations of the length scales $\sigma \in \{ 0 . 0 5 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 5 , 1 . 0 \}$ and gradient penalty $\lambda \in \{ 0 , 0 . 0 5 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 5 , 1 . 0 \}$ and selected the combination with the best test error-AUROC trade-off.
+
+<table><tr><td>Train on MNIST</td><td>CNN 0.53% (.05)</td><td>ACET 0.66</td><td>DUQ 0.57 (.04)</td><td>5Ens 0.50 (.02)</td><td>10 Ens 0.51 (.03)</td><td>CSNN 0.52 (.01)</td><td>CSNN-F 0.50 (0.02)</td></tr><tr><td>EMNIST</td><td>0.983 (.001)</td><td>0.912</td><td>0.988 (.001)</td><td>0.985 (.001)</td><td>0.985 (.001)</td><td>0.992 (.001)</td><td>0.990 (.002)</td></tr><tr><td>FashionMNIST</td><td>0.989 (.001)</td><td>0.998</td><td>0.998 (.001)</td><td>0.992 (.001)</td><td>0.992 (.001)</td><td>0.998 (.001)</td><td>0.997 (.001)</td></tr><tr><td>grayCIFAR-10</td><td>0.995 (.001)</td><td>1.000</td><td>0.978 (.005)</td><td>0.992 (.003)</td><td>0.992 (.002)</td><td>1.000 (.0001)</td><td>1.000 (.0001)</td></tr><tr><td>Average</td><td>0.9897.005)</td><td>0.970</td><td>0.988(.009)</td><td>0.9907.004)</td><td>0.990 (.004)</td><td>0.996(.003)</td><td>0.996 (.004)</td></tr><tr><td>Train on CIFAR-10</td><td>5.99% (.09)</td><td>8.44</td><td>6.88 (.40)</td><td>4.83 (.16)</td><td>4.59 (.08)</td><td>7.28 (.06)</td><td>6.18 (.09)</td></tr><tr><td>CIFAR-100</td><td>0.860 (.001)</td><td>0.852</td><td>0.827 (.016)</td><td>0.891(.001)</td><td>0.897 (.001)</td><td>0.865 (.001)</td><td>0.882(.003)</td></tr><tr><td>SVHN</td><td>0.899 (.012)</td><td>0.981</td><td>0.912 (.031)</td><td>0.917 (.006)</td><td>0.924 (.002)</td><td>0.908 (.001)</td><td>0.900 (.013)</td></tr><tr><td>ImageNet</td><td>0.834 (.002)</td><td>0.859</td><td>0.816 (.021)</td><td>0.863 (.001)</td><td>0.869 (.001)</td><td>0.848 (.001)</td><td>0.854 (.004)</td></tr><tr><td>Average</td><td>0.8657.029)</td><td>0.897</td><td>0.852 (.050)</td><td>0.8907.023)</td><td>0.897 (.023)</td><td>0.874(.026)</td><td>0.879(.021)</td></tr><tr><td>Train on CIFAR100</td><td>26.18% (.28)</td><td>32.24</td><td>31.14(.23)</td><td>22.43 (.20)</td><td>21.86 (.11)</td><td>30.89 (0.10)</td><td>24.46 (.12)</td></tr><tr><td>CIFAR-10</td><td>0.750 (.002)</td><td>0.720</td><td>0.722 (.008)</td><td>0.781(.001)</td><td>0.786 (.001)</td><td>0.783 (.001)</td><td>0.762 (.002)</td></tr><tr><td>SVHN</td><td>0.781 (.035)</td><td>0.912</td><td>0.774 (.006)</td><td>0.832 (.013)</td><td>0.834 (.009)</td><td>0.872 (.001)</td><td>0.860 (.006)</td></tr><tr><td>ImageNet</td><td>0.766 (.002)</td><td>0.752</td><td>0.742 (.006)</td><td>0.798 (.001)</td><td>0.803 (.001)</td><td>0.755 (.001)</td><td>0.793 (.001)</td></tr><tr><td>Average</td><td>0.7667.023)</td><td>0.795</td><td>0.746(.024)</td><td>0.8047.022)</td><td>0.808 (.021)</td><td>0.804(.050)</td><td>0.805 (.042)</td></tr></table>
+
+Table 1: OOD detection comparison in terms of Area under the ROC curve (AUROC) for models trained and tested on several datasets. For each model the test error in $\%$ is shown in the "Train on" row. The ACET results are taken from Hein et al. (2019). All other results are averaged over 10 runs and the standard deviation is shown in parentheses.
+
+Results. The results are shown in Table 1. All results except the ACET results are averaged over 10 runs and the standard deviation is shown in parentheses. From Table 1 we observe that our methods obtain the best results on MNIST and the 10-ensemble obtains the best results on the other two datasets. The test errors of the CSNN-F approach are smaller than the CSNN, and the AUROCs are comparable. Compared to ACET both CSNN and CSNN-F obtain smaller test errors on all three dataset and better average AUROC on two out of three datasets. Compared to DUQ, the CSNN and CSNN-F obtain comparable test errors and better average AUROC on all three datasets. Compare to the 5-ensemble, the CSNN-F obtains comparable errors on two datasets and comparable or better AUROC on two datasets. Comparing the training time, both our methods are about 4 times faster than training a 5-ensemble, 8 times faster than a 10- ensemble and about 3 times faster than DUQ.
+
+# 4 CONCLUSION
+
+In this paper, we presented a generic neuron formulation that encompasses the standard projection based neuron and the RBF neuron as two extreme cases of a shape parameter $\alpha \in [ 0 , 1 ]$ . By using ReLU as the activation function we obtained a novel type of neuron that has compact support. We showed how to avoid the difficulties in training the compact support NN by training a standard neural network first $\alpha = 0$ ) and gradually shrinking the support by increasing $\alpha$ . We showed the advantages of the proposed compact support neural network in that it can still have good prediction on data coming from the same distribution, but it can detect out of distribution samples consistently well. This feature is important in safety critical applications such as autonomous driving, space exploration and medical imaging. Our results have been obtained without any adversarial training or ensembling, and adversarial training or ensembling could be used in our framework to obtain further improvements.
+
+In the real data applications we used a compact support layer as the last layer before the output layer. This ensures that the compact support is involved in the most relevant representation space of the CNN. However, because the CNN still has many projection-based layers to obtain this representation space, it means that the corresponding representation in the original image space does not have compact support and high confidence erroneous predictions are still possible. In the future we plan to study architectures with multiple compact support layers that have even smaller support in the image space.
+
+# REFERENCES
+
+David S Broomhead and David Lowe. Radial basis functions, multi-variable functional interpolation and adaptive networks. Technical report, Royal Signals and Radar Establishment Malvern (United Kingdom), 1988.
+
+Gregory Cohen, Saeed Afshar, Jonathan Tapson, and André van Schaik. Emnist: an extension of mnist to handwritten letters (2017). arXiv preprint arXiv:1702.05373.
+
+Francesco Croce and Matthias Hein. A randomized gradient-free attack on relu networks. In German Conference on Pattern Recognition, pp. 215–227. Springer, 2018.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255. Ieee, 2009.
+
+Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In ICML, pp. 1050–1059, 2016.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. ICLR, 2015.
+
+Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In ICML, pp. 1321–1330. JMLR. org, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.
+
+Matthias Hein, Maksym Andriushchenko, and Julian Bitterwolf. Why relu networks yield highconfidence predictions far away from the training data and how to mitigate the problem. In CVPR, pp. 41–50, 2019.
+
+Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. In ICLR, 2017.
+
+Yen-Chang Hsu, Yilin Shen, Hongxia Jin, and Zsolt Kira. Generalized odin: Detecting out-ofdistribution image without learning from out-of-distribution data. In CVPR, pp. 10951–10960, 2020.
+
+Heinrich Jiang, Been Kim, Melody Guan, and Maya Gupta. To trust or not to trust a classifier. In NeurIPS, pp. 5541–5552, 2018.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In NeurIPS, pp. 6402–6413, 2017.
+
+Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/.
+
+Kimin Lee, Kibok Lee, Honglak Lee, and Jinwoo Shin. A simple unified framework for detecting out-of-distribution samples and adversarial attacks. In NeurIPS, pp. 7167–7177, 2018.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NeurIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldl.stanford. edu/housenumbers/nips2011_housenumbers.pdf.
+
+Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In CVPR, pp. 427–436, 2015.
+
+Jie Ren, Peter J Liu, Emily Fertig, Jasper Snoek, Ryan Poplin, Mark Depristo, Joshua Dillon, and Balaji Lakshminarayanan. Likelihood ratios for out-of-distribution detection. In NeurIPS, pp. 14707–14718, 2019.
+
+Joost van Amersfoort, Lewis Smith, Yee Whye Teh, and Yarin Gal. Uncertainty estimation using a single deep deterministic neural network. In ICML, 2020.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017.
+
+Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In ICCV, pp. 6023–6032, 2019.
+
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, pp. 818–833. Springer, 2014.

parse/train/xCy9thPPTb_/xCy9thPPTb__content_list.json

@@ -0,0 +1,1346 @@
+[
+    {
+        "type": "text",
+        "text": "THE COMPACT SUPPORT NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            712,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            178,
+            145,
+            392,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            224
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks are popular and useful in many fields, but they have the problem of giving high confidence responses for examples that are away from the training data. This makes the neural networks very confident in their prediction while making gross mistakes, thus limiting their reliability for safety critical applications such as autonomous driving, space exploration, etc. In this paper, we present a neuron generalization that has the standard dot-product based neuron and the RBF neuron as two extreme cases of a shape parameter. Using ReLU as the activation function we obtain a novel neuron that compact support, which means its output is zero outside a bounded domain. We show how to avoid difficulties in training a neural network with such neurons, by starting with a trained standard neural network and gradually increasing the shape parameter to the desired value. Through experiments on standard benchmark datasets, we show the promise of the proposed approach, in that it can have good prediction on in-distribution samples, while being able to consistently detect and have low confidence on out of distribution samples. ",
+        "bbox": [
+            233,
+            246,
+            766,
+            439
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            470,
+            336,
+            486
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural networks have been proven to be extremely useful in all sorts of applications, including object detection, speech and handwriting recognition, medical imaging, etc. They have become the state of the art in these applications, and in some cases they even surpass human performance. However, neural networks have been observed to have a major disadvantage: they don’t know when they don’t know, i.e. don’t know when the input is far away from the type of data they have been trained on. Instead of saying “I don’t know”, they give some output with high confidence (Goodfellow et al., 2015; Nguyen et al., 2015). An explanation of why this is happening for ReLU based networks has been given in Hein et al. (2019). This issue is very important for safety-critical applications such as space exploration, autonomous driving, medical diagnosis, etc. In these cases it is important that the system know when the input data is outside its nominal range, to alert the human (e.g. driver for autonomous driving or radiologist for medical diagnostic) to take charge in such cases. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            652
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper we suspect that the root of this problem is actually the neuron design, and propose a different type of neuron to address what we think are its issues. The standard neuron can be written as $f ( x ) = \\dot { \\sigma } ( \\mathbf { w } ^ { T } \\mathbf { x } + b )$ , which can be regarded as a projection (dot product) $\\mathbf { x } \\to \\mathbf { w } ^ { T } \\mathbf { x } + b$ onto a direction w, followed by a nonlinearity $\\tilde { \\sigma } ( \\cdot )$ . In this design, the neuron has a large response for vectors $\\mathbf { x } \\in \\mathbb { R } ^ { p }$ that are in a half-space. This can be an advantage when training the NN since it creates high connectivity in the weight space and makes the neurons sensitive to far-away signals. However, it is a disadvantage when using the trained NN, since it can lead to the neurons unpredictably firing with high responses to far-away signals, which can result (with some probability) in high confidence responses of the whole network for examples that are far away from the training data. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            784
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address these problems, we use a type of radial basis function neuron (Broomhead & Lowe, 1988), $f ( \\mathbf { x } ) = g ( \\| \\mathbf { x } - \\mathbf { \\bar { \\mu } } \\| ^ { 2 } )$ , which we modify to have a high response only for examples that are close to $\\pmb { \\mu }$ , and to have zero response at distance at least $R$ from $\\pmb { \\mu }$ . Therefore the neuron has compact support, and the same applies to a layer formed entirely of such neurons. Using one such compact support layer before the output layer we can guarantee that the space where the NN has a non-zero response is bounded, obtaining a more reliable neural network. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this formulation, the parameter vector $\\pmb { \\mu }$ is directly comparable to the neuron inputs $\\mathbf { x }$ , thus $\\pmb { \\mu }$ has a simple and direct interpretation as a \"template\". A layer consisting of such neurons forms can be interpreted as a sparse coordinate system on the manifold containing the inputs of that layer. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Because of the compact support, the loss function of such a compact support NN has many flat areas and it can be difficult to training it directly by backpropagation. However, we will show how to train such a NN, by starting with a trained regular NN and gradually bending the neuron decision boundaries to make them have smaller and smaller support. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contributions of this paper are the following: ",
+        "bbox": [
+            174,
+            166,
+            495,
+            181
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We introduce a type of neuron formulation that generalizes the standard neuron and the RBF neuron as two extreme cases of a shape parameter. Moreover one can smoothly transition from a regular neuron to a RBF neuron by gradually changing this parameter. We introduce the RBF correspondent to a ReLU neuron and observe that it has compact support, i.e. its output is zero outside a bounded domain. The above construction allows us to smoothly bend the decision boundary of a standard ReLU based neuron, obtaining a compact support neuron. We use this idea to train a compact support neural network (CSNN) starting from a pre-trained regular neural network. We show through experiments on standard datasets that the proposed CSNN can achieve comparable test errors with regular CNNs, and at the same time it can detect and have low confidence on out-of-distribution data. ",
+        "bbox": [
+            217,
+            183,
+            825,
+            332
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1.1 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            340,
+            331,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A common way to address the problem of high confidence predictions for out of distribution (OOD) examples is through ensembles (Lakshminarayanan et al., 2017), where multiple neural networks are trained with different random initializations and their outputs are averaged in some way. The reason why ensemble methods have low confidence on OOD samples is that the high-confidence domain of each NN is random outside the training data, and the common high-confidence domain is therefore shrunk by the averaging process. This reasoning works well when the representation space (the space of the NN before the output layer) is high dimensional, but it fails when this space is low dimensional (see van Amersfoort et al. (2020) for example). ",
+        "bbox": [
+            173,
+            359,
+            825,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another popular approach is adversarial training (Madry et al., 2018), where the training set is augmented with adversarial examples generated by maximizing the loss starting from slightly perturbed examples. This method is modified in adversarial confidence enhanced training (ACET) (Hein et al., 2019) where the adversarial samples are added through a hybrid loss function. However, we believe that training with out of distribution samples could be a computationally expensive if not hopeless endeavor, since the instance space is extremely vast when it is high dimensional. Consequently, a finite number of training examples can only cover an insignificant part of it and no matter how many out-of-distribution examples are used, there always will be other parts of the instance space that have not been explored. Other methods include the estimation of the uncertainty using dropout (Gal & Ghahramani, 2016), softmax calibration (Guo et al., 2017), and the detection of out-of-distribution inputs (Hendrycks & Gimpel, 2017). CutMix Yun et al. (2019) is a method to generate training samples with larger variability, which help improve generalization and OOD detection. All these methods are complementary to our approach and could be used together with our classifiers to improve accuracy and OOD detection. ",
+        "bbox": [
+            174,
+            478,
+            825,
+            671
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Ren et al. (2019) are trained two auto-regressive models, one for the foreground in-distribution data and one for the background, and the likelihood ratio is used to decide for each observation whether it is OOD or not. This is a generative model, while our model is discriminative. ",
+        "bbox": [
+            174,
+            679,
+            821,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A number of works assume that the distance in the representation space (the space of outputs of the last layer before the final classification layer) is meaningful. They will be reviewed next. ",
+        "bbox": [
+            171,
+            728,
+            821,
+            756
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, Jiang et al. (2018) proposed a trust score that measures the agreement between a given classifier and a modified version of a $k$ -nearest neighbor classifier. While this approach does consider the distance of the test samples to the training set, it only does so to a certain extent since the $k$ -NN does not have a concept of “too far”, and is also computationally expensive. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            819
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A simple method based on the Mahalanobis distance is presented in Lee et al. (2018). It assumes that the observations are normally distributed in the representation space, with a shared covariance matrix for all classes. While we also assume that the distance in the representation space is meaningful, we make a much weaker assumption that the observations for each class are clustered in a number of clusters, not necessarily Gaussian. In our representation, each class is usually covered by more than one compact support neuron, and each neuron could be involved in multiple classes. Furthermore, the method in Lee et al. (2018) simply replaces the last layer of the NN with their Mahalanobis measure and makes no attempt to further train the new model, while we can train our layers together with the whole network. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/c7b11b621b86f77faf4f46292c6a7bf7a8dc8bd8c59ec1ae6b0410e5b178460a.jpg",
+        "image_caption": [
+            "Figure 1: The construction (3) smoothly interpolates between a standard neuron $( \\alpha = 0$ ) and an RBF-type of neuron $( \\alpha = 1$ ). Shown are the neuron decision boundaries for various values of $\\alpha$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            104,
+            694,
+            244
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            287,
+            821,
+            315
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Generalized ODIN Hsu et al. (2020) decomposes the output prediction into the ratio of a classspecific function $h _ { i } ( x )$ and a common denominator $g ( x )$ , both defined over instances $x$ from the representation space. Good results are obtained using $h _ { i }$ based on the Euclidean distance or the cosine similarity. Again, this approach assumes that the observations are grouped in a single cluster for each class, which explains it uses very deep models (with 34-100 layers) that are more capable to obtain representations where this assumption is satisfied. Our method does not make the single cluster per class assumption, and can use deep or shallow models. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The Deterministic Uncertainty Quantification (DUQ) (van Amersfoort et al., 2020) method uses an RBF network and a special gradient penalty to decrease the prediction confidence away from the training examples. The authors also propose a centroid updating scheme to handle the difficulties in training an RBF network. In contrast, our paper proposes a generalized neuron model that has the RBF neurons and the standard neurons as two extreme cases, and trains all models starting from a standard NN where the local minima are more well behaved. ",
+        "bbox": [
+            173,
+            426,
+            825,
+            511
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 THE COMPACT SUPPORT NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            527,
+            581,
+            545
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The compact support neural network consists of a number of layers, where the last layer before the output layer contains only compact support neurons, which will be described next. The other layers could be regular neural network or convolutional neural network layers, or compact support layers. The final output layer is a regular linear layer without a bias term, so that it can output a vector of all zeros when appropriate. ",
+        "bbox": [
+            173,
+            553,
+            825,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 THE COMPACT SUPPORT NEURON ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            641,
+            450,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We start with the radial basis function (RBF) neuron (Broomhead & Lowe, 1988), ",
+        "bbox": [
+            174,
+            665,
+            709,
+            681
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0fc31eaa8d797ce1d20d530ed4c19d93f448164bd6a9d98491f65c33b87b26a3.jpg",
+        "text": "$$\nf _ { \\mathbf { w } } ( \\mathbf { x } ) = g ( \\| \\mathbf { x } - \\mathbf { w } \\| ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            686,
+            580,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The RBF neuron has $g ( u ) = \\exp ( - \\beta u )$ as the activation function, but in this paper we will use $g ( u ) = \\operatorname* { m a x } ( R ^ { 2 } - u , \\bar { 0 } )$ because it is related to the ReLU. ",
+        "bbox": [
+            171,
+            713,
+            823,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A flexible representation. We can introduce an extra parameter $\\alpha = 1$ and rewrite eq. (1) as ",
+        "bbox": [
+            169,
+            746,
+            782,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/34746d6becf22a6d82975b1b3535749a10465aa6c07e6fa76c1c490f3b2e945e.jpg",
+        "text": "$$\nf _ { \\mathbf { w } } ( \\mathbf { x } ) = g ( \\mathbf { x } ^ { T } \\mathbf { x } + \\mathbf { w } ^ { t } \\mathbf { w } - 2 \\mathbf { w } ^ { T } \\mathbf { x } ) = g ( \\alpha ( \\| \\mathbf { x } \\| ^ { 2 } + \\| \\mathbf { w } \\| ^ { 2 } ) - 2 \\mathbf { w } ^ { T } \\mathbf { x } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            768,
+            725,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using the parameter $\\alpha$ , we obtain a representation that smoothly changes between an RBF neuron when $\\alpha = 1$ and a standard projection neuron when $\\alpha = 0$ . However, starting with an RBF neuron with $g ( u ) = \\exp ( - \\beta u )$ , we obtain the projection neuron for $\\alpha = 0$ as $f _ { \\mathbf { w } } ( \\mathbf { x } ) = \\exp ( 2 \\mathbf { w } ^ { T } \\mathbf { x } )$ , which has an exponential activation function. ",
+        "bbox": [
+            174,
+            795,
+            825,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The compact support neuron. We want to obtain a standard ReLU based neuron $f _ { \\mathbf { w } } ( \\mathbf { x } ) = \\sigma ( \\mathbf { w } ^ { T } \\mathbf { x } )$ with $\\sigma ( u ) = \\operatorname* { m a x } ( u , 0 )$ for $\\alpha = 0$ . For this purpose we will use $g ( u ) = \\sigma ( R ^ { 2 } - \\dot { u } )$ , and modify the above construction to obtain the compact support neuron: ",
+        "bbox": [
+            174,
+            856,
+            825,
+            898
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/64351adb596447fd3a3c847c6e5d28fcfb3a8e5a750429748dc523983201464b.jpg",
+        "text": "$$\nf _ { \\mathbf { w } } ( \\mathbf { x } ) = \\sigma ( R ^ { 2 } - \\mathbf { x } ^ { T } \\mathbf { x } - \\mathbf { w } ^ { T } \\mathbf { w } + 2 \\mathbf { w } ^ { T } \\mathbf { x } ) = \\sigma [ \\alpha ( R ^ { 2 } - \\| \\mathbf { x } \\| ^ { 2 } - \\| \\mathbf { w } \\| ^ { 2 } - b ) + 2 \\mathbf { w } ^ { T } \\mathbf { x } + b ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            191,
+            906,
+            785,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f4fba9ba6cebb9ff56d470944d1274f28dea0a59e233283cba4a0b94d59d6ae.jpg",
+        "image_caption": [
+            "Figure 2: Left: Diagram of the compact support neural network (CSNN), with the CSN layer described in Eq. (6). Right: an example of the CSNN with normalized input from ResNet. Only the full arrows have backpropagation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            95,
+            750,
+            200
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where we also introduced a bias term $b$ for the standard neuron. We usually make $b = 0$ for simplicity.   \nThe parameter $R$ defines the radius of the support of the neuron when $\\alpha = 1$ . ",
+        "bbox": [
+            173,
+            251,
+            823,
+            280
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One can easily check that the support of $f _ { \\mathbf { w } } ( \\mathbf { x } )$ from eq. (3) (i.e. the domain where it takes nonzero values) is in a sphere of radius ",
+        "bbox": [
+            173,
+            286,
+            823,
+            315
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e97f98977957dc623eefe3078e01876dbda267b48b68bd1824c40266490d382a.jpg",
+        "text": "$$\nR _ { \\alpha } ^ { 2 } = R ^ { 2 } + b ( 1 / \\alpha - 1 ) + \\| \\mathbf { w } \\| ^ { 2 } ( 1 / \\alpha ^ { 2 } - 1 )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            318,
+            647,
+            337
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "centered at $\\mathbf { w } _ { \\alpha } = \\mathbf { w } / \\alpha$ . Therefore the neuron from eq. (3) has compact support for any $\\alpha > 0$ and the larger the value of $\\alpha$ , the smaller the support of the neuron will be. In Figure 1 is shown the support for several values of $\\alpha \\in [ 0 , 1 ]$ of the neuron (3) with $\\mathbf { w } = ( 0 , 2 ) ^ { T } , b = \\mathbf { \\bar { 0 } }$ and $R = 1$ . ",
+        "bbox": [
+            173,
+            344,
+            825,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Convolutional version. If one desires to make a compact support convolutional neuron, let w be its $k \\times k$ matrix of weights. Then the convolutional version can be obtained by taking into consideration that each $k \\times k$ patch of an image I is a candidate $\\mathbf { x }$ in eq. (3). Therefore one can easily check that the convolutional compact support neuron should be: ",
+        "bbox": [
+            173,
+            392,
+            825,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d79fea881d3b74a09fc1d5494b4c5f0e98d33a1c16e8d6753aa62beea4eadde.jpg",
+        "text": "$$\nf _ { \\mathbf { w } } ( { \\mathbf { I } } ) = \\sigma [ \\alpha ( R ^ { 2 } - b - { \\mathbf { I } } ^ { 2 } * { \\mathbf { 1 } } - \\| \\mathbf { w } \\| ^ { 2 } ) + 2 { \\mathbf { I } } * { \\mathbf { w } } + b ]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            454,
+            679,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where 1 is a $k \\times k$ matrix of ones, $\\mathbf { I } ^ { 2 }$ is done elementwise and $^ *$ is the convolution. ",
+        "bbox": [
+            176,
+            479,
+            717,
+            496
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 THE COMPACT SUPPORT NEURAL NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            511,
+            527,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If we have a layer containing only compact support neurons (CSN), combining the weights into a matrix ${ \\bf W } ^ { T } = \\dot { ( } { \\bf w } _ { 1 } , . . . , { \\bf w } _ { K } \\dot { ) }$ and the biases into a vector $\\mathbf { b } = ( b _ { 1 } , . . . , b _ { K } )$ , we can write the CSN layer as: ",
+        "bbox": [
+            173,
+            536,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e14edd10f7ce2d3d3670e74e017c36e97f5b2d85e0e0f4924ab361467832096d.jpg",
+        "text": "$$\n\\mathbf { f } _ { \\mathbf { W } } ( \\mathbf { x } ) = \\sigma ( \\alpha [ R ^ { 2 } - \\mathbf { b } - \\mathbf { x } ^ { T } \\mathbf { x } - \\mathrm { T r } ( \\mathbf { W } \\mathbf { W } ^ { T } ) ] + 2 \\mathbf { W } \\mathbf { x } + \\mathbf { b } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            297,
+            574,
+            700,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { f _ { W } } ( \\mathbf { x } ) = ( f _ { 1 } ( \\mathbf { x } ) , . . . , f _ { K } ( \\mathbf { x } ) ) ^ { T }$ is the vector of neuron outputs of that layer. This formulation enables the use of standard neural network machinery (e.g. PyTorch) to train a CSN. In practice we will have no bias term (i.e. $\\mathbf { b } = 0$ ), except in low dimensional experiments. ",
+        "bbox": [
+            174,
+            597,
+            826,
+            641
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The simplest compact support neural network (CSNN) has two layers: a hidden layer containing compact support neurons (3) or their convolutional counterparts (5), and an output layer which is a standard fully connected layer without bias. It is illustrated in Figure 2, left. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            689
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Normalization. For best results, all variables of the input data $\\mathbf { x }$ should be on the same scale. For better control, it is also preferable that $\\| \\mathbf { x } \\|$ be approximately 1 on the training examples. These goals√ can be achieved by standardizing the variables to have zero mean and standard deviation $1 / \\sqrt { d }$ on the training examples (where $d$ is the dimension of $\\mathbf { x }$ ). This way $\\| \\mathbf { x } \\| ^ { 2 } \\sim 1$ when the dimension $d$ is large (under assumptions of normality and independence of the variables of $\\mathbf { x }$ ). Our experiments on three datasets indicate that indeed $\\| \\mathbf { x } \\| \\sim 1$ on real data when the inputs $\\mathbf { x }$ are normalized as described above, as exemplified by the histograms of $\\| \\mathbf { x } \\|$ from Figure 3. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/163b3dd0b3e49e18d2d13f933c6c4551e29ecb0c2dc6c102da09cd14ecebc0e7.jpg",
+        "image_caption": [
+            "Figure 3: Histogram of the norms $\\left\\| \\mathbf { v } _ { i } \\right\\|$ of the normalized input features $\\mathbf { v } _ { i }$ to the CSN layer for the three datasets trained in our experiments. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            797,
+            738,
+            904
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Training. Like the RBF network, training a neural network with such neurons with $\\alpha = 1$ is difficult because the loss function has many local optima. To make matters even worse, the compact support neurons have small support when $\\alpha$ is close to 1, and consequently the loss function has flat regions between the local minima. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This is why we take another approach to training. Using equations (6) or (5) we can train a CSNN by first training a regular NN $( \\alpha = 0$ ) and then gradually increasing the shape parameter $\\alpha$ from 0 towards 1 while continuing to update the NN parameters. Observe that whenever $\\alpha > 0$ the NN has compact support, but the support gets smaller as $\\alpha$ gets closer to 1. The training procedure is described in detail in Algorithm 1. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/b0a133f9cce0ecd56b09f715b387000b7c0a3aeb81ecdbd1605002917fba567a.jpg",
+        "table_caption": [
+            "Algorithm 1 Compact Support Neural Network (CSNN) Training "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Output: Trained CSNN.</td><td>Input: Training set T = {(xi, yi) ∈ RP × R}=1,</td><td></td><td></td></tr><tr><td></td><td></td><td>1: Train a regular CNN f(x) = Lo(2Wg(x) + b) where W,L are the last two layer weight</td><td></td></tr><tr><td></td><td>matrices and g(x) is the rest of the CNN.</td><td>2: Freeze g(x), compute ui = g(xi),i = 1,.,n, their mean μ and standard deviation o.</td><td></td></tr><tr><td>3:</td><td> Obtain normalized versions Vi of ui as Vi = (ui - μ)/√do,i = 1,., n.</td><td></td><td></td></tr><tr><td>4:</td><td>for e= 1 to Nepochs do</td><td></td><td></td></tr><tr><td>5:</td><td>Set α = e/Nepochs</td><td></td><td></td></tr><tr><td>6:</td><td> Use the examples (Vi, yi) to update (W,L,b) based on one epoch of</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td>f(ν)=Lσ(α[R²-vTv- Tr(WWT)-b]+ 2Wv +b)</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td>7:(optional) Remove any neurons Wj of WT = (w1,.*,Wk) that are dead,i.e. satisfy:</td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td></td><td>σ(a[R²-||vill²-|/wjl²)-bj]+2wTνi+bj)=0,i=1,.,n</td><td></td><td></td></tr></table>",
+        "bbox": [
+            179,
+            258,
+            823,
+            455
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "8: end for ",
+        "bbox": [
+            181,
+            450,
+            254,
+            464
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the synthetic experiment in Figure 4 we succeeded to bring the train and test errors close to 0 for $\\alpha = 1$ using a carefully crafted schedule for increasing the $\\alpha$ . However, in the real data applications, the training, test and validation errors might first decrease a little bit but ultimately increase as $\\alpha$ approaches 1. For example one could see the test errors vs $\\alpha$ for the synthetic dataset in Figure 6 and for the real datasets in Figure 9. For this reason, in practice we stop the training at an $\\alpha < 1$ where the training and validation errors still take acceptable values, e.g. a validation error less than the validation error for $\\alpha = 0$ . However, we noticed that the larger the value of $\\alpha$ , the tighter the support around the training data and the better the generalization. ",
+        "bbox": [
+            173,
+            477,
+            825,
+            589
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is worth noting that in contrast to the weights of a standard neuron, the weights of the compact support neuron exist in the same space as the neuron inputs and they can be regarded as templates. Thus they have more meaning, and one could easily visualize the type of responses that make them maximal, using standard neuron visualization techniques such as Zeiler & Fergus (2014). Furthermore, one can also obtain samples from the compact support neurons, e.g. for generative or GAN models. ",
+        "bbox": [
+            174,
+            595,
+            826,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            696,
+            328,
+            712
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section we first present an experiment on 2D data to showcase what can be achieved with the proposed compact support neural network, and then experiments on real datasets to show the power of the CSNN to model real data and how it can detect out-of-distribution samples. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 2D EXAMPLE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            782,
+            310,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We present a first experiment with the moons 2D dataset, where the data is organized on two intertwining half-circle like shapes, one containing the positives and one the negatives. The data is scaled so that all observations are in the interval $[ 0 , 1 ] ^ { \\dot { 2 } }$ (shown as a white rectangle in Figure 4. As out of distribution data (OOD) we started with $1 0 0 \\times 1 0 0 = 1 0 0 0 0$ samples on a grid spanning $[ - 0 . 5 , 1 . 5 ] ^ { 2 }$ and we removed all samples at distance at most 0.1 from the moons data, obtaining 8763 samples. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We used a two layer CSNN, with the first layer having 128 CSNN neurons, and the second layer being a standard NN layer without bias, as illustrated in Figure 2, left. The second layer is used to integrate the evidence from the CSNN neurons into the class prediction. We used 200 training examples and trained the CSNN using Algorithm 1. We trained 2000 epochs with $R ^ { 2 }$ decreasing linearly from 0.04 to 0.01, and $\\alpha$ increasing from 0 to 1 as $\\alpha _ { i } = \\operatorname* { m i n } ( 1 , \\operatorname* { m a x } ( 0 , ( i ^ { 0 . 1 } - 1 . 5 ) / . 6 ) )$ , $i = 1 , . . . , 2 0 0 0$ . This way $\\alpha$ increases slower as it gets closer to 1. Using this special training we avoided the training and test errors blowing up when $\\alpha$ gets close to 1. As specified in line 7 of Algorithm 1, the NN nodes that had zero response on all training examples were eliminated. These neurons cannot be trained anymore and only give uncontrolled responses on unseen data. This way from the 128 neurons, only 73 were left at the end of training. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0ed37566c4e463b84591db9ea935cc99dd785929ad3663b924e1ea041c39021.jpg",
+        "image_caption": [
+            "Figure 4: The confidence map (0.5 for white and 1 for black) of the trained CSNN on the moons dataset for different values of $\\alpha \\in [ 0 , 1 ]$ . Top: zoom out on the interval $[ - 5 , 6 ] ^ { 2 }$ . Bottom: zoom in view of the interval $[ - 0 . 5 , 1 . 5 ] ^ { 2 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            85,
+            820,
+            338
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b9c8c6dd4e1fc416ec92903d00f1372faf8c9ddd2df5d650f39ba511e70915b.jpg",
+        "image_caption": [
+            "Figure 5: Example of activation pattern domains for $\\alpha = 0$ and $\\alpha ~ = ~ 0 . 8 2 5$ and the resulting confidence map (0.5 for white and 1 for black) for $\\alpha = 0 . 8 2 5$ for a 32 neuron 2-layer CSNN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            395,
+            789,
+            554
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            607,
+            825,
+            718
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The training/test errors and the AUROC and NZ confidence measures for the OOD data described above vs. $\\alpha$ are shown in Figure 6. Observe that the training and test errors for $\\alpha = 0$ are quite large, because the standard NN with 128 neurons cannot fit the data well enough, and they decrease as the neuron support decreases and the model is better capable to fit the data. ",
+        "bbox": [
+            174,
+            726,
+            581,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The confidence map for the obtained classifier is shown in Figure 4. We can see that the confidence is 0.5 (white) almost everywhere except close to the training data, where it is close to 1 (black). This gives us an insight that the method works as expected, shrinking the support of the neurons to a small domain around the training data. We also see that the support is already reasonably small for $\\alpha = 0 . 6$ and it gets tighter and tighter as $\\alpha$ gets closer to 1. ",
+        "bbox": [
+            174,
+            813,
+            583,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/9d5e97c1bb2e292effd8e47c9118422de96af1861d74126ed5bb59b31adcae74.jpg",
+        "image_caption": [
+            "Figure 6: CSNN train and test errors, AUROC and percent nonzero outputs (NZ) vs. $\\alpha$ for the moons data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            599,
+            719,
+            821,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is known Croce & Hein (2018); Hein et al. (2019) that the output of a ReLU-based neural network is piecewise linear and the domains of linearity are given by the activation pattern of the neurons. The activation pattern of the neurons consists of the domains where the set of neurons that are active (i.e. their output is positive) does not change. These activation pattern domains are polytopes, as shown in in Figure 5, left, for a two-layer NN with 32 neurons. The activation domains for a CSNN are intersections of circles, as illustrated in Figure 5, middle, with the domain where all neurons are inactive shown in white. The corresponding confidence map is shown in Figure 5, right. ",
+        "bbox": [
+            173,
+            103,
+            826,
+            202
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In real data applications we don’t need to go all the way to $\\alpha =$ 1 since even for smaller $\\alpha$ the support is still bounded and if the instance space is high dimensional (e.g. 512 to 1024 in the real data experiments below), the volume of the support of the CNN will be very small compared to the instance space, making it unlikely to have high confidence on out-of-distribution data. ",
+        "bbox": [
+            173,
+            208,
+            619,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The role of pruning dead neurons. Due to the random initialization of the neurons, there might exist neurons that have zero response on all the training observations. These neurons are dead in the sense that they are not updated in the back-propagation, since their response is always zero. We have observed that in some cases these dead neurons will produce some small high confidence regions far away from the training examples (see Fig. 7). This problem can be eliminated by removing these neurons during training, which is done by line 7 of Algorithm 1. ",
+        "bbox": [
+            174,
+            295,
+            619,
+            364
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6acabc6bfd51c9b56e29d682d1c93eab60c24247e4a4853209a72a34efec83c.jpg",
+        "image_caption": [
+            "Figure 7: Confidence map without pruning, $\\alpha = 0 . 9 8 5$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            640,
+            205,
+            816,
+            332
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            366,
+            825,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5853098c38710f2d8261c9a369a5635256653dac968d9254e11a70ced307af4a.jpg",
+        "image_caption": [
+            "Figure 8: The CSNN-F with LeNet backbone, where all layers are trained by backpropagation. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            321,
+            406,
+            669,
+            506
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 REAL DATA EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            539,
+            401,
+            553
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments by training on three different datasets: MNIST (LeCun & Cortes, 2010), CIFAR-10 and CIFAR-100 (Krizhevsky et al., 2009). We evaluate the confidence on in-sample and out-of-sample data, by testing them on their respective test sets (in-sample) and on other datasets as shown in Table 1, including the test sets of EMNIST (Cohen et al.), FashionMNIST (Xiao et al., 2017) and SVHN (Netzer et al., 2011), and the validation set of ImageNet (Deng et al., 2009). For MNIST we also tested on a grayscale version of CIFAR-10, obtained by converting the 10,000 test images to gray-scale and resizing them to $2 8 \\times 2 8$ . ",
+        "bbox": [
+            173,
+            560,
+            826,
+            660
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CNN architecture. For MNIST we use a 4-layer LeNet CNN as backbone, with two $5 \\times 5$ convolution layers with 32 and 64 filters respectively, followed by ReLU and $2 \\times 2$ max pooling, and two fully connected layers with 256 and 10 neurons. For the other two datasets, we used as backbone a ResNet-18 architecture (He et al., 2016) with 4 residual blocks with 64, 128, 256 and 512 filters respectively. After the backbone CNN has been trained, the FC layers were removed and only the convolutional layers were kept, as illustrated in Figure 2, right and Figure 8. ",
+        "bbox": [
+            173,
+            661,
+            825,
+            746
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For the CSNN we will experiment with two architectures, illustrated in Figure 2 and Figure 8. The first is a small one (called CSNN) that takes as input the output of the last convolutional layer of the backbone, normalized as described in Section 2.2. The normalization of the CSNN input can also be achieved using a batch normalization layer without any learnable affine parameters. The second one is a full network (called CSNN-F), illustrated in Figure 8, where the backbone (LeNet or ResNet) is part of the backpropagation and a batch normalization layer (BN) without any learnable parameters has been introduced between the backbone and the CSN layer. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training details. For all datasets we used data augmentation with padding (3 pixels for MNIST, 4 pixels for the rest) and random cropping to train the backbones. For CIFAR-100 we also used random rotation up to 15 degrees.We used no data augmentation when training the CSNN and CSNN-F. ",
+        "bbox": [
+            174,
+            851,
+            825,
+            892
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The training/test data was passed though the backbone without the FC layers, and the output was normalized. A CSNN without bias term was trained for 510 epochs with $R = 0 . 1$ , of which 10 epochs at $\\alpha = 0$ . For the CSNN training we used the Adam optimizer with learning rate 0.001 and weight decay 0.0001. We also tried SGD and obtained similar results. The CSNN-F was trained with SGD with a learning rate of 0.001 and weight decay 0.0005. Its layers were initialized with the trained backbone and the trained CSNN. Then $\\alpha$ was kept fixed for two epochs and increased by 0.005 every epoch for 4 more epochs. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2fecf33cc6072abb3692e728485b4933f30675a06e928fe55d9a7841f8e931db.jpg",
+        "image_caption": [
+            "Figure 9: Train and test errors, Area under ROC Curve (AUROC) and percent nonzero outputs (NZ) vs $\\alpha$ for CSNN classifiers trained on three real datasets. These results are obtained from one training run. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            168,
+            85,
+            826,
+            228
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            290,
+            825,
+            361
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Training the CSNN from $\\alpha = 0$ to $\\alpha = 1$ for 510 epochs takes less than an hour on a MSI GS-60 Core I7 laptop with 16Gb RAM and Nvidia GTX 970M GPU. Each epoch of the CSNN-F took less than a minute with the LeNet backbone and about 3 minutes with the ResNet-18 backbone. ",
+        "bbox": [
+            176,
+            367,
+            823,
+            409
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "OOD detection. The out of distribution (OOD) detection is performed similarly to the way it is done in a standard CNN. For any observation, the maximum value of CSNN raw outputs is used as the OOD score for predicting whether the observation is OOD or not. If the observation is in-distribution, its score will usually be large, and if it is OOD, it will be usually close to zero or even zero. The ROC curve based on these scores for the test set of the in-distribution data (as class 0) and one OOD dataset (as class 1) will give us the AUROC. If the two distributions are not separable (have concept overlap), some of the OOD scores will be large, but for the OOD observations that are away from the area of overlap they will be small or even zero. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            527
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 9 are shown the train/test errors vs $\\alpha$ for the CSNN on the three datasets. Also shown are the Area under the ROC curve (AUROC) for OOD detection on CIFAR-10 or CIFAR-100 and the percentage of OOD samples with nonzero outputs (NZ). Observe that all curves on the real data are very smooth, even though they are obtained from one run, not averaged. We see that the training and test errors stay flat for a while then they start increasing from a certain $\\alpha$ that depends on the dataset. At the same time, the AUROC stays flat and slightly increases, and there is a range of values of $\\alpha$ where the test error is low and the AUROC is large. Looking in more detail at the CIFAR-10 dataset (middle plot in Figure 9), we see that for $\\alpha = 0 . 7$ the NZ-CIFAR100 is about 0.6, which means that about $40 \\%$ of the CIFAR-100 observations have all 0 CSNN outputs, therefore an OOD score of 0. Combined with the scores of the other observations and the fact that at most $10 \\%$ of the CIFAR-10 test observations have an OOD score of 0 (because the test error is less than 0.1) it results in a slight increase in AUROC. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In practice, $\\alpha$ should be chosen as large as possible where an acceptable validation error is still obtained, to have the smallest support possible. For example one could choose the largest $\\alpha$ such that the validation error at $\\alpha$ is less then or equal to the validation error at $\\alpha = 0$ . However, for better comparison with the other methods, for each dataset we chose the CSNN classifier corresponding to the largest $\\alpha$ where the test error takes a value comparable to the other methods compared, and reported the AUROC values in Table 1. The CSNN-F was obtained by merging the corresponding CSNN head with the ResNet or LeNet backbone and training them together for 6 epochs. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Methods compared. We compare our results with the Adversarial Confidence Enhanced Training (ACET) (Hein et al., 2019), Deterministic Uncertainty Quantification (DUQ) (van Amersfoort et al., 2020), a standard CNN, and an ensemble of five or 10 CNNs trained with different random initializations. The ACET results are taken directly from Hein et al. (2019), and the DUQ, CNN and ensemble results were obtained using the DUQ authors’ code. For DUQ we trained multiple models with various combinations of the length scales $\\sigma \\in \\{ 0 . 0 5 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 5 , 1 . 0 \\}$ and gradient penalty $\\lambda \\in \\{ 0 , 0 . 0 5 , 0 . 1 , 0 . 2 , 0 . 3 , 0 . 5 , 1 . 0 \\}$ and selected the combination with the best test error-AUROC trade-off. ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0d15ccb8ea7e501f096955a829664966b78e70eff2d3672667bbf0b1c7d2623.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Train on MNIST</td><td>CNN 0.53% (.05)</td><td>ACET 0.66</td><td>DUQ 0.57 (.04)</td><td>5Ens 0.50 (.02)</td><td>10 Ens 0.51 (.03)</td><td>CSNN 0.52 (.01)</td><td>CSNN-F 0.50 (0.02)</td></tr><tr><td>EMNIST</td><td>0.983 (.001)</td><td>0.912</td><td>0.988 (.001)</td><td>0.985 (.001)</td><td>0.985 (.001)</td><td>0.992 (.001)</td><td>0.990 (.002)</td></tr><tr><td>FashionMNIST</td><td>0.989 (.001)</td><td>0.998</td><td>0.998 (.001)</td><td>0.992 (.001)</td><td>0.992 (.001)</td><td>0.998 (.001)</td><td>0.997 (.001)</td></tr><tr><td>grayCIFAR-10</td><td>0.995 (.001)</td><td>1.000</td><td>0.978 (.005)</td><td>0.992 (.003)</td><td>0.992 (.002)</td><td>1.000 (.0001)</td><td>1.000 (.0001)</td></tr><tr><td>Average</td><td>0.9897.005)</td><td>0.970</td><td>0.988(.009)</td><td>0.9907.004)</td><td>0.990 (.004)</td><td>0.996(.003)</td><td>0.996 (.004)</td></tr><tr><td>Train on CIFAR-10</td><td>5.99% (.09)</td><td>8.44</td><td>6.88 (.40)</td><td>4.83 (.16)</td><td>4.59 (.08)</td><td>7.28 (.06)</td><td>6.18 (.09)</td></tr><tr><td>CIFAR-100</td><td>0.860 (.001)</td><td>0.852</td><td>0.827 (.016)</td><td>0.891(.001)</td><td>0.897 (.001)</td><td>0.865 (.001)</td><td>0.882(.003)</td></tr><tr><td>SVHN</td><td>0.899 (.012)</td><td>0.981</td><td>0.912 (.031)</td><td>0.917 (.006)</td><td>0.924 (.002)</td><td>0.908 (.001)</td><td>0.900 (.013)</td></tr><tr><td>ImageNet</td><td>0.834 (.002)</td><td>0.859</td><td>0.816 (.021)</td><td>0.863 (.001)</td><td>0.869 (.001)</td><td>0.848 (.001)</td><td>0.854 (.004)</td></tr><tr><td>Average</td><td>0.8657.029)</td><td>0.897</td><td>0.852 (.050)</td><td>0.8907.023)</td><td>0.897 (.023)</td><td>0.874(.026)</td><td>0.879(.021)</td></tr><tr><td>Train on CIFAR100</td><td>26.18% (.28)</td><td>32.24</td><td>31.14(.23)</td><td>22.43 (.20)</td><td>21.86 (.11)</td><td>30.89 (0.10)</td><td>24.46 (.12)</td></tr><tr><td>CIFAR-10</td><td>0.750 (.002)</td><td>0.720</td><td>0.722 (.008)</td><td>0.781(.001)</td><td>0.786 (.001)</td><td>0.783 (.001)</td><td>0.762 (.002)</td></tr><tr><td>SVHN</td><td>0.781 (.035)</td><td>0.912</td><td>0.774 (.006)</td><td>0.832 (.013)</td><td>0.834 (.009)</td><td>0.872 (.001)</td><td>0.860 (.006)</td></tr><tr><td>ImageNet</td><td>0.766 (.002)</td><td>0.752</td><td>0.742 (.006)</td><td>0.798 (.001)</td><td>0.803 (.001)</td><td>0.755 (.001)</td><td>0.793 (.001)</td></tr><tr><td>Average</td><td>0.7667.023)</td><td>0.795</td><td>0.746(.024)</td><td>0.8047.022)</td><td>0.808 (.021)</td><td>0.804(.050)</td><td>0.805 (.042)</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            821,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 1: OOD detection comparison in terms of Area under the ROC curve (AUROC) for models trained and tested on several datasets. For each model the test error in $\\%$ is shown in the \"Train on\" row. The ACET results are taken from Hein et al. (2019). All other results are averaged over 10 runs and the standard deviation is shown in parentheses. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Results. The results are shown in Table 1. All results except the ACET results are averaged over 10 runs and the standard deviation is shown in parentheses. From Table 1 we observe that our methods obtain the best results on MNIST and the 10-ensemble obtains the best results on the other two datasets. The test errors of the CSNN-F approach are smaller than the CSNN, and the AUROCs are comparable. Compared to ACET both CSNN and CSNN-F obtain smaller test errors on all three dataset and better average AUROC on two out of three datasets. Compared to DUQ, the CSNN and CSNN-F obtain comparable test errors and better average AUROC on all three datasets. Compare to the 5-ensemble, the CSNN-F obtains comparable errors on two datasets and comparable or better AUROC on two datasets. Comparing the training time, both our methods are about 4 times faster than training a 5-ensemble, 8 times faster than a 10- ensemble and about 3 times faster than DUQ. ",
+        "bbox": [
+            174,
+            372,
+            825,
+            512
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            527,
+            318,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we presented a generic neuron formulation that encompasses the standard projection based neuron and the RBF neuron as two extreme cases of a shape parameter $\\alpha \\in [ 0 , 1 ]$ . By using ReLU as the activation function we obtained a novel type of neuron that has compact support. We showed how to avoid the difficulties in training the compact support NN by training a standard neural network first $\\alpha = 0$ ) and gradually shrinking the support by increasing $\\alpha$ . We showed the advantages of the proposed compact support neural network in that it can still have good prediction on data coming from the same distribution, but it can detect out of distribution samples consistently well. This feature is important in safety critical applications such as autonomous driving, space exploration and medical imaging. Our results have been obtained without any adversarial training or ensembling, and adversarial training or ensembling could be used in our framework to obtain further improvements. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            691
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the real data applications we used a compact support layer as the last layer before the output layer. This ensures that the compact support is involved in the most relevant representation space of the CNN. However, because the CNN still has many projection-based layers to obtain this representation space, it means that the corresponding representation in the original image space does not have compact support and high confidence erroneous predictions are still possible. In the future we plan to study architectures with multiple compact support layers that have even smaller support in the image space. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            792
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            815,
+            285,
+            830
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David S Broomhead and David Lowe. Radial basis functions, multi-variable functional interpolation and adaptive networks. Technical report, Royal Signals and Radar Establishment Malvern (United Kingdom), 1988. ",
+        "bbox": [
+            176,
+            840,
+            823,
+            882
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gregory Cohen, Saeed Afshar, Jonathan Tapson, and André van Schaik. Emnist: an extension of mnist to handwritten letters (2017). arXiv preprint arXiv:1702.05373. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Francesco Croce and Matthias Hein. A randomized gradient-free attack on relu networks. In German Conference on Pattern Recognition, pp. 215–227. Springer, 2018. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In CVPR, pp. 248–255. Ieee, 2009. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. Dropout as a bayesian approximation: Representing model uncertainty in deep learning. In ICML, pp. 1050–1059, 2016. ",
+        "bbox": [
+            173,
+            181,
+            823,
+            210
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. ICLR, 2015. ",
+        "bbox": [
+            174,
+            219,
+            823,
+            248
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chuan Guo, Geoff Pleiss, Yu Sun, and Kilian Q Weinberger. On calibration of modern neural networks. In ICML, pp. 1321–1330. JMLR. org, 2017. ",
+        "bbox": [
+            174,
+            257,
+            821,
+            287
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016. ",
+        "bbox": [
+            174,
+            296,
+            823,
+            327
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthias Hein, Maksym Andriushchenko, and Julian Bitterwolf. Why relu networks yield highconfidence predictions far away from the training data and how to mitigate the problem. In CVPR, pp. 41–50, 2019. ",
+        "bbox": [
+            173,
+            335,
+            826,
+            378
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dan Hendrycks and Kevin Gimpel. A baseline for detecting misclassified and out-of-distribution examples in neural networks. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            388,
+            823,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yen-Chang Hsu, Yilin Shen, Hongxia Jin, and Zsolt Kira. Generalized odin: Detecting out-ofdistribution image without learning from out-of-distribution data. In CVPR, pp. 10951–10960, 2020. ",
+        "bbox": [
+            176,
+            426,
+            821,
+            469
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Heinrich Jiang, Been Kim, Melody Guan, and Maya Gupta. To trust or not to trust a classifier. In NeurIPS, pp. 5541–5552, 2018. ",
+        "bbox": [
+            173,
+            479,
+            825,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            518,
+            823,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Balaji Lakshminarayanan, Alexander Pritzel, and Charles Blundell. Simple and scalable predictive uncertainty estimation using deep ensembles. In NeurIPS, pp. 6402–6413, 2017. ",
+        "bbox": [
+            174,
+            542,
+            820,
+            573
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun and Corinna Cortes. MNIST handwritten digit database. 2010. URL http://yann. lecun.com/exdb/mnist/. ",
+        "bbox": [
+            176,
+            582,
+            823,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kimin Lee, Kibok Lee, Honglak Lee, and Jinwoo Shin. A simple unified framework for detecting out-of-distribution samples and adversarial attacks. In NeurIPS, pp. 7167–7177, 2018. ",
+        "bbox": [
+            174,
+            621,
+            823,
+            650
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            689
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y. Ng. Reading digits in natural images with unsupervised feature learning. In NeurIPS Workshop on Deep Learning and Unsupervised Feature Learning 2011, 2011. URL http://ufldl.stanford. edu/housenumbers/nips2011_housenumbers.pdf. ",
+        "bbox": [
+            173,
+            698,
+            826,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Anh Nguyen, Jason Yosinski, and Jeff Clune. Deep neural networks are easily fooled: High confidence predictions for unrecognizable images. In CVPR, pp. 427–436, 2015. ",
+        "bbox": [
+            169,
+            765,
+            825,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jie Ren, Peter J Liu, Emily Fertig, Jasper Snoek, Ryan Poplin, Mark Depristo, Joshua Dillon, and Balaji Lakshminarayanan. Likelihood ratios for out-of-distribution detection. In NeurIPS, pp. 14707–14718, 2019. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joost van Amersfoort, Lewis Smith, Yee Whye Teh, and Yarin Gal. Uncertainty estimation using a single deep deterministic neural network. In ICML, 2020. ",
+        "bbox": [
+            169,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms. arXiv preprint arXiv:1708.07747, 2017. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sangdoo Yun, Dongyoon Han, Seong Joon Oh, Sanghyuk Chun, Junsuk Choe, and Youngjoon Yoo. Cutmix: Regularization strategy to train strong classifiers with localizable features. In ICCV, pp. 6023–6032, 2019. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            145
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In ECCV, pp. 818–833. Springer, 2014. ",
+        "bbox": [
+            171,
+            155,
+            826,
+            184
+        ],
+        "page_idx": 10
+    }
+]