Original: NodeFormer: A Scalable Graph Structure Learning Transformer for Node Classification
Revised: NodeFormer: A Scalable Graph Structure Learning Transformer for Node Classification

Original: Abstract
Revised: Abstract

Original: Graph neural networks have been extensively studied for learning with interconnected data.
Revised: Graph neural networks have been extensively studied for learning with interconnected data.

Original: Despite this, recent evidence has revealed GNNs’ deficiencies related to over-squashing, heterophily, handling long-range dependencies, edge incompleteness and particularly, the absence of graphs altogether.
Revised: Despite this, recent evidence has revealed GNNs’ deficiencies related to over-squashing, heterophily, handling long-range dependencies, edge incompleteness and particularly, the absence of graphs altogether.

Original: While a plausible solution is to learn new adaptive topology for message passing, issues concerning quadratic complexity hinder simultaneous guarantees for scalability and precision in large networks.
Revised: While a plausible solution is to learn new adaptive topology for message passing, issues concerning quadratic complexity hinder simultaneous guarantees for scalability and precision in large networks.

Original: In this paper, we introduce a novel all-pair message passing scheme for efficiently propagating node signals between arbitrary nodes, as an important building block for a pioneering Transformer-style network for node classification on large graphs, dubbed as N ODE F ORMER .
Revised: In this paper, we introduce a novel all-pair message passing scheme for efficiently propagating node signals between arbitrary nodes, as an important building block for a pioneering Transformer-style network for node classification on large graphs, dubbed as N ODE F ORMER .

Original: Specifically, the efficient computation is enabled by a kernerlized Gumbel-Softmax operator that reduces the algorithmic complexity to linearity w.r.t.
Revised: Specifically, the efficient computation is enabled by a kernerlized Gumbel-Softmax operator that reduces the algorithmic complexity to linearity w.r.t.

Original: node numbers for learning latent graph structures from large, potentially fully-connected graphs in a differentiable manner.
Revised: node numbers for learning latent graph structures from large, potentially fully-connected graphs in a differentiable manner.

Original: We also provide accompanying theory as justification for our design.
Revised: We also provide accompanying theory as justification for our design.

Original: Extensive experiments demonstrate the promising efficacy of the method in various tasks including node classification on graphs (with up to 2M nodes) and graph-enhanced applications (e.g., image classification) where input graphs are missing.
Revised: Extensive experiments demonstrate the promising efficacy of the method in various tasks including node classification on graphs (with up to 2M nodes) and graph-enhanced applications (e.g., image classification) where input graphs are missing.

Original: The codes are available at https://github.com/qitianwu/NodeFormer .
Revised: The codes are available at https://github.com/qitianwu/NodeFormer .

Original:  Introduction
Revised:  Introduction

Original: Relational structure inter-connecting instance nodes as a graph is ubiquitous from social domains (e.g., citation networks) to natural science (protein-protein interaction), where graph neural networks (GNNs) [31, 19, 14, 36] have shown promising power for leveraging such data dependence as geometric priors.
Revised: Relational structure inter-connecting instance nodes as a graph is ubiquitous from social domains (e.g., citation networks) to natural science (protein-protein interaction), where graph neural networks (GNNs) [31, 19, 14, 36] have shown promising power for leveraging such data dependence as geometric priors.

Original: However, there arises increasing evidence challenging the core GNN hypothesis that propagating information along observed graph structures will necessarily produce better nodelevel representations for prediction on each individual instance node.
Revised: However, there arises increasing evidence challenging the core GNN hypothesis that propagating information along observed graph structures will necessarily produce better nodelevel representations for prediction on each individual instance node.

Original: Conflicts with this premise lead to commonly identified deficiencies with GNN message-passing rules w.r.t.
Revised: Conflicts with this premise lead to commonly identified deficiencies with GNN message-passing rules w.r.t.

Original: heterophily [52], over-squashing [2], long-range dependencies [8], and graph incompleteness [11], etc.
Revised: heterophily [52], over-squashing [2], long-range dependencies [8], and graph incompleteness [11], etc.

Original: Moreover, in graph-enhanced applications, e.g., text classification [45], vision navigation [12], physics simulation [29], etc., graph structures are often unavailable though individual instances are strongly inter-correlated.
Revised: Moreover, in graph-enhanced applications, e.g., text classification [45], vision navigation [12], physics simulation [29], etc., graph structures are often unavailable though individual instances are strongly inter-correlated.

Original: A common practice is to artificially construct a graph via some predefined rules (e.g., k -NN), which is agnostic to downstream tasks and may presumably cause the misspecification of
Revised: A common practice is to artificially construct a graph via some predefined rules (e.g., k -NN), which is agnostic to downstream tasks and may presumably cause the misspecification of

Original: GNNs’ inductive bias on input geometry (induced by the local feature propagation design).
Revised: GNNs’ inductive bias on input geometry (induced by the local feature propagation design).

Original: Natural solutions resort to organically combining learning optimal graph topology with message passing.
Revised: Natural solutions resort to organically combining learning optimal graph topology with message passing.

Original: However, one critical difficulty is the scalability issue with O ( N 2 ) (where N denotes
Revised: However, one critical difficulty is the scalability issue with O ( N 2 ) (where N denotes

Original: #nodes) computational complexity, which is prohibitive for large networks (with 10 K ∼ 1 M nodes).
Revised: #nodes) computational complexity, which is prohibitive for large networks (with 10 K ∼ 1 M nodes).

Original: Some existing approaches harness neighbor sampling [50], anchor-based adjacency surrogates [4] and hashing schemes [43] to reduce the overhead; however, these strategies may sacrifice model precision and still struggle to handle graphs with million-level nodes.
Revised: Some existing approaches harness neighbor sampling [50], anchor-based adjacency surrogates [4] and hashing schemes [43] to reduce the overhead; however, these strategies may sacrifice model precision and still struggle to handle graphs with million-level nodes.

Original: Another obstacle lies in the increased degrees of freedom due to at least an N × N all-pair similarity matrix, which may result in large combinatorial search space and vulnerability to over-fitting.
Revised: Another obstacle lies in the increased degrees of freedom due to at least an N × N all-pair similarity matrix, which may result in large combinatorial search space and vulnerability to over-fitting.

Original: In this work, we introduce a novel all-pair message passing scheme that can scale to large systems without compromising performance.
Revised: In this work, we introduce a novel all-pair message passing scheme that can scale to large systems without compromising performance.

Original: We develop a kernelized Gumbel-Softmax operator that seamlessly synthesizes random feature map [26] and approximated sampling strategy [16], for distilling latent structures among all the instance nodes and yielding moderate gradients through differentiable optimization.
Revised: We develop a kernelized Gumbel-Softmax operator that seamlessly synthesizes random feature map [26] and approximated sampling strategy [16], for distilling latent structures among all the instance nodes and yielding moderate gradients through differentiable optimization.

Original: Though such a combination of two operations involving randomness could potentially result in mutual distortion, we theoretically prove that the new operator can still guarantee a wellposed approximation for concrete variables (discrete structures) with the error bounded by feature dimensions.
Revised: Though such a combination of two operations involving randomness could potentially result in mutual distortion, we theoretically prove that the new operator can still guarantee a wellposed approximation for concrete variables (discrete structures) with the error bounded by feature dimensions.

Original: Furthermore, such a design can reduce the algorithmic complexity of learning new topology per layer to O ( N ) by avoiding explicit computation for the cumbersome all-pair similarity.
Revised: Furthermore, such a design can reduce the algorithmic complexity of learning new topology per layer to O ( N ) by avoiding explicit computation for the cumbersome all-pair similarity.

Original: The proposed module opens the door to a new class of graph networks, i.e., N ODE F ORMER ( Scalable
Revised: The proposed module opens the door to a new class of graph networks, i.e., N ODE F ORMER ( Scalable

Original: Transformers for Node Classification ), that is capable of efficiently propagating messages between arbitrary node pairs in flexible layer-specific latent graphs.
Revised: Transformers for Node Classification ), that is capable of efficiently propagating messages between arbitrary node pairs in flexible layer-specific latent graphs.

Original: And to accommodate input graphs (if any), we devise two simple techniques: a relational bias and an edge-level regularization loss, as guidance for properly learning adaptive structures.
Revised: And to accommodate input graphs (if any), we devise two simple techniques: a relational bias and an edge-level regularization loss, as guidance for properly learning adaptive structures.

Original: We evaluate our approach on diverse node classification tasks ranging from citation networks to images/texts.
Revised: We evaluate our approach on diverse node classification tasks ranging from citation networks to images/texts.

Original: The results show its promising power for tackling heterophily, long-range dependencies, large-scale graphs, graph incompleteness and the absence of input graphs.
Revised: The results show its promising power for tackling heterophily, long-range dependencies, large-scale graphs, graph incompleteness and the absence of input graphs.

Original: The contributions of this paper are summarized as follows:
Revised: The contributions of this paper are summarized as follows:

Original: • We develop a kernelized Gumbel-Softmax operator which is proven to serve as a well-posed approximation for concrete variables, particularly the discrete latent structure among data points.
Revised: • We develop a kernelized Gumbel-Softmax operator which is proven to serve as a well-posed approximation for concrete variables, particularly the discrete latent structure among data points.

Original: The new module can reduce the algorithmic complexity for learning new message-passing topology from quadratic to linear w.r.t.
Revised: The new module can reduce the algorithmic complexity for learning new message-passing topology from quadratic to linear w.r.t.

Original: node numbers, without sacrificing the precision.
Revised: node numbers, without sacrificing the precision.

Original: This serves as a pioneering model that successfully scales graph structure learning to large graphs with million-level nodes.
Revised: This serves as a pioneering model that successfully scales graph structure learning to large graphs with million-level nodes.

Original: • We further propose N ODE F ORMER , a new class of graph networks with layer-wise message passing as operated over latent graphs potentially connecting all nodes.
Revised: • We further propose N ODE F ORMER , a new class of graph networks with layer-wise message passing as operated over latent graphs potentially connecting all nodes.

Original: The latter are optimized in an end-to-end differentiable fashion through a new objective that essentially pursues sampling optimal topology from a posterior conditioned on node features and labels.
Revised: The latter are optimized in an end-to-end differentiable fashion through a new objective that essentially pursues sampling optimal topology from a posterior conditioned on node features and labels.

Original: To our knowledge, N ODE F ORMER is the first Transformer model that scales all-pair message passing to large node classification graphs.
Revised: To our knowledge, N ODE F ORMER is the first Transformer model that scales all-pair message passing to large node classification graphs.

Original: • We demonstrate the model’s efficacy by extensive experiments over a diverse set of datasets, including node classification benchmarks and image/text classification, where significant improvement over strong GNN models and SOTA structure learning methods is shown.
Revised: • We demonstrate the model’s efficacy by extensive experiments over a diverse set of datasets, including node classification benchmarks and image/text classification, where significant improvement over strong GNN models and SOTA structure learning methods is shown.

Original: Besides, it successfully scales to large graph datasets with up to 2M nodes where prior arts failed, and reduces the time/space consumption of the competitors by up to 93.1%/80.6% on moderate sized datasets.
Revised: Besides, it successfully scales to large graph datasets with up to 2M nodes where prior arts failed, and reduces the time/space consumption of the competitors by up to 93.1%/80.6% on moderate sized datasets.

Original:  Related Works
Revised:  Related Works

Original: Graph Neural Networks.
Revised: Graph Neural Networks.

Original: Building expressive GNNs is a fundamental problem in learning over graph data.
Revised: Building expressive GNNs is a fundamental problem in learning over graph data.

Original: With Graph Attention Networks (GAT) [36] as an early attempt, there are many follow-up works, e.g., [21, 42], considering weighting the edges in input graph for enhancing the expressiveness.
Revised: With Graph Attention Networks (GAT) [36] as an early attempt, there are many follow-up works, e.g., [21, 42], considering weighting the edges in input graph for enhancing the expressiveness.

Original: Other studies, e.g., [27, 51] focus on sparsifying input structures to promote robust representations.
Revised: Other studies, e.g., [27, 51] focus on sparsifying input structures to promote robust representations.

Original: There are also quite a few approaches that propose scalable GNNs through, e.g., subgraph sampling [47], linear feature mapping [39], and channel-wise transformation [48], etc.
Revised: There are also quite a few approaches that propose scalable GNNs through, e.g., subgraph sampling [47], linear feature mapping [39], and channel-wise transformation [48], etc.

Original: However, these works cannot learn new edges out of the scope of input geometry, which may limit the model’s receptive fields within local neighbors and neglect global information.
Revised: However, these works cannot learn new edges out of the scope of input geometry, which may limit the model’s receptive fields within local neighbors and neglect global information.

Original: Graph Structure Learning.
Revised: Graph Structure Learning.

Original: Going beyond observed topology, graph structure learning targets learning a new graph for message passing among all the instances [53].
Revised: Going beyond observed topology, graph structure learning targets learning a new graph for message passing among all the instances [53].

Original: One line of work is similaritydriven where the confidence of edges are reflected by some similarity functions between node pairs, e.g., Gaussian kernels [43], cosine similarity [4], attention networks [17], non-linear MLP [7] etc.
Revised: One line of work is similaritydriven where the confidence of edges are reflected by some similarity functions between node pairs, e.g., Gaussian kernels [43], cosine similarity [4], attention networks [17], non-linear MLP [7] etc.

Original: Another line of work optimizes the adjacency matrix.
Revised: Another line of work optimizes the adjacency matrix.

Original: Due to the increased optimization difficulties, some sophisticated training methods are introduced, such as bi-level optimization [11], variational
Revised: Due to the increased optimization difficulties, some sophisticated training methods are introduced, such as bi-level optimization [11], variational

Original: [Table] [Table]
Revised: [Table] [Table]

Original: approaches [10, 34]
Revised: approaches [10, 34]

Original: [Table]
Revised: [Table]

Original: Bayesian inference [50] and projected gradient descent [18].
Revised: Bayesian inference [50] and projected gradient descent [18].

Original: To push further the limits of structure learning
Revised: To push further the limits of structure learning

Original: [Table]
Revised: [Table]

Original: this paper proposes a new model N ODE F ORMER (for enabling scalable node-level Transformers) whose merits are highlighted via a high-level comparison in Table 1.
Revised: this paper proposes a new model N ODE F ORMER (for enabling scalable node-level Transformers) whose merits are highlighted via a high-level comparison in Table 1.

Original: In particular, N ODE F ORMER enables efficient structure learning in each layer, does not require input graphs and successfully scales to graphs with 2M nodes.
Revised: In particular, N ODE F ORMER enables efficient structure learning in each layer, does not require input graphs and successfully scales to graphs with 2M nodes.

Original: Node-Level v.s. Graph-Level Prediction.
Revised: Node-Level v.s. Graph-Level Prediction.

Original: We emphasize upfront that our focus is on node-level prediction tasks involving a single large graph such that scalability is paramount, especially if we are to consider arbitrary relationships across all nodes (each node is an instance with label and one can treat all the nodes non-i.i.d.
Revised: We emphasize upfront that our focus is on node-level prediction tasks involving a single large graph such that scalability is paramount, especially if we are to consider arbitrary relationships across all nodes (each node is an instance with label and one can treat all the nodes non-i.i.d.

Original: generated due to the inter-dependence) for structure-learning purposes.
Revised: generated due to the inter-dependence) for structure-learning purposes.

Original: Critically though, this scenario is quite distinct from graph-level classification tasks whereby each i.i.d.
Revised: Critically though, this scenario is quite distinct from graph-level classification tasks whereby each i.i.d.

Original: instance is itself a small graph and fully connecting nodes within each graph is computationally inexpensive.
Revised: instance is itself a small graph and fully connecting nodes within each graph is computationally inexpensive.

Original: While this latter scenario has been explored in the context of graph structure learning [38] and all-pair message passing design, e.g., graph Transformers [9], existing efforts do not scale to the large graphs endemic to node-level prediction.
Revised: While this latter scenario has been explored in the context of graph structure learning [38] and all-pair message passing design, e.g., graph Transformers [9], existing efforts do not scale to the large graphs endemic to node-level prediction.

Original:  N ODE F ORMER : A Transformer Graph Network at Scale
Revised:  N ODE F ORMER : A Transformer Graph Network at Scale

Original: Let G =
Revised: Let G =

Original: ( N , E ) denote a graph with N a node set ( |N| = N ) and E ⊆
Revised: ( N , E ) denote a graph with N a node set ( |N| = N ) and E ⊆

Original: N ×N an edge set ( |E| = E ).
Revised: N ×N an edge set ( |E| = E ).

Original: Each node u ∈ N is assigned with node features x u ∈ R D and a label y u .
Revised: Each node u ∈ N is assigned with node features x u ∈ R D and a label y u .

Original: We define an adjacency matrix A
Revised: We define an adjacency matrix A

Original: = { a uv } ∈ { 0 , 1 } N × N where a uv = 1 if edge ( u, v ) ∈ E and a uv
Revised: = { a uv } ∈ { 0 , 1 } N × N where a uv = 1 if edge ( u, v ) ∈ E and a uv

Original: = 0 otherwise.
Revised: = 0 otherwise.

Original: Without loss of generality,
Revised: Without loss of generality,

Original: E could be an empty set in case of no input structure.
Revised: E could be an empty set in case of no input structure.

Original: There are two common settings: transductive learning, where testing nodes are within the graph used for training, and inductive learning which handles new unseen nodes out of the training graph.
Revised: There are two common settings: transductive learning, where testing nodes are within the graph used for training, and inductive learning which handles new unseen nodes out of the training graph.

Original: The target is to learn a function for node-level prediction, i.e., estimate labels for unlabeled or new nodes in the graph.
Revised: The target is to learn a function for node-level prediction, i.e., estimate labels for unlabeled or new nodes in the graph.

Original: General Model and Key Challenges.
Revised: General Model and Key Challenges.

Original: We start with the observation that the input structures may not be the ideal one for propagating signals among nodes and instead there exist certain latent structures that could facilitate learning better node representations.
Revised: We start with the observation that the input structures may not be the ideal one for propagating signals among nodes and instead there exist certain latent structures that could facilitate learning better node representations.

Original: We thus consider the updating rule
Revised: We thus consider the updating rule

Original: [Equation]
Revised: [Equation]

Original: where Z ( l ) = { z ( l ) u } u ∈N and ˜ A ( l ) =
Revised: where Z ( l ) = { z ( l ) u } u ∈N and ˜ A ( l ) =

Original: { ˜ a ( l ) uv } u,v ∈N denotes the node representations and the estimated latent graph of the l -th layer, respectively, and g , h are both differentiable functions aiming at 1) structure estimation for a layer-specific latent graph
Revised: { ˜ a ( l ) uv } u,v ∈N denotes the node representations and the estimated latent graph of the l -th layer, respectively, and g , h are both differentiable functions aiming at 1) structure estimation for a layer-specific latent graph

Original: ˜ A ( l ) based on node representations and 2) feature propagation for updating node representations, respectively.
Revised: ˜ A ( l ) based on node representations and 2) feature propagation for updating node representations, respectively.

Original: The model defined by Eqn.
Revised: The model defined by Eqn.

Original: 1 follows the spirit of Transformers [35] (where in particular ˜
Revised: 1 follows the spirit of Transformers [35] (where in particular ˜

Original: A ( l ) can be seen as an attentive graph) that potentially enables message passing between any node pair in each layer, which, however, poses two challenges :
Revised: A ( l ) can be seen as an attentive graph) that potentially enables message passing between any node pair in each layer, which, however, poses two challenges :

Original: • (Scalability) : How to reduce the prohibitive quadratic complexity for learning new graphs?
Revised: • (Scalability) : How to reduce the prohibitive quadratic complexity for learning new graphs?

Original: • (Differentiability) :
Revised: • (Differentiability) :

Original: How to enable end-to-end differentiable optimization for discrete structures?
Revised: How to enable end-to-end differentiable optimization for discrete structures?

Original: Notice that the first challenge is non-trivial in node-level prediction tasks (the focus of our paper), since the latent graphs could potentially connect all the instance nodes (e.g., from thousands to millions, depending on dataset sizes), which is fairly hard to guarantee both precision and scalability.
Revised: Notice that the first challenge is non-trivial in node-level prediction tasks (the focus of our paper), since the latent graphs could potentially connect all the instance nodes (e.g., from thousands to millions, depending on dataset sizes), which is fairly hard to guarantee both precision and scalability.

Original: 3.1 Efficient Learning Discrete Structures
Revised: 3.1 Efficient Learning Discrete Structures

Original: We describe our new message-passing scheme with an efficient kernelized Gumbel-Softmax operator to resolve the aforementioned challenges.
Revised: We describe our new message-passing scheme with an efficient kernelized Gumbel-Softmax operator to resolve the aforementioned challenges.

Original: We assume z (0) u
Revised: We assume z (0) u

Original: = x u as the initial node representation.
Revised: = x u as the initial node representation.

Original: Kernelized Message Passing.
Revised: Kernelized Message Passing.

Original: We define a full-graph attentive network that estimates latent interactions among instance nodes and enables corresponding densely-connected message passing:
Revised: We define a full-graph attentive network that estimates latent interactions among instance nodes and enables corresponding densely-connected message passing:

Original: [Equation]
Revised: [Equation]

Original: where W ( l ) Q , W ( l ) K and W ( l ) V are learnable parameters in l -th layer.
Revised: where W ( l ) Q , W ( l ) K and W ( l ) V are learnable parameters in l -th layer.

Original: We omit non-linearity activation (after aggregation) for brevity.
Revised: We omit non-linearity activation (after aggregation) for brevity.

Original:  Eqn. 2 requires prohibitive O ( N 2 ) complexity.
Revised: The updating for N nodes in one layer using Eqn. 2 requires prohibitive O ( N 2 ) complexity.

Original: Also, given large N , the normalization in the denominator would shrink attention weights to zero and lead to gradient vanishing.
Revised: Also, given large N , the normalization in the denominator would shrink attention weights to zero and lead to gradient vanishing.

Original: We call this problem as over-normalizing .
Revised: We call this problem as over-normalizing .

Original: To accelerate the full-graph model, we observe that the dot-then-exponentiate operation in Eqn.
Revised: To accelerate the full-graph model, we observe that the dot-then-exponentiate operation in Eqn.

Original: 2 can be converted into a pairwise similarity function:
Revised: 2 can be converted into a pairwise similarity function:

Original: [Equation]
Revised: [Equation]

Original: where κ ( · , · ) : R d × R d → R is a positive-definite kernel measuring the pairwise similarity.
Revised: where κ ( · , · ) : R d × R d → R is a positive-definite kernel measuring the pairwise similarity.

Original: The kernel function can be further approximated by random features (RF) [26]which serves as an unbiased estimation via κ ( a , b ) = [Equation] Φ [Equation]
Revised: The kernel function can be further approximated by random features (RF) [26]which serves as an unbiased estimation via κ ( a , b ) = ⟨ Φ( a ) , Φ( b ) ⟩ V ≈ ϕ ( a ) ⊤ ϕ ( b ) , where the first equation is by Mercer’s theorem with Φ : R d → V a basis function and V a high-dimensional vector space, and ϕ ( · ) :

Original: a ) , Φ

Original: [Equation]

Original: b )

Original: [Equation]

Original: V

Original: ≈ ϕ

Original: ( a ) ⊤ ϕ ( b ) , where the first equation is by Mercer’s theorem with Φ : R d → V a basis function and V a high-dimensional vector space, and ϕ ( · ) :

Original: R d →
Revised: R d →

Original: R m is a low-dimensional feature map with random transformation.
Revised: R m is a low-dimensional feature map with random transformation.

Original: There are many potential choices for ϕ , e.g., Positive Random Features (PRF) [6]
Revised: There are many potential choices for ϕ , e.g., Positive Random Features (PRF) [6]

Original: [Equation]
Revised: [Equation]

Original: where w k ∼ N (0 , I d ) is i.i.d.
Revised: where w k ∼ N (0 , I d ) is i.i.d.

Original: sampled random transformation.
Revised: sampled random transformation.

Original: The RF converts dot-thenexponentiate operation into inner-product in vector space, which enables us to re-write Eqn.(assuming q u = W ( l ) Q z ( l ) u , k u = W ( l ) K z ( l ) u and v u = W ( l ) V z ( l ) u for simplicity):[Equation] l
Revised: The RF converts dot-thenexponentiate operation into inner-product in vector space, which enables us to re-write Eqn.(assuming q u = W ( l ) Q z ( l ) u , k u = W ( l ) K z ( l ) u and v u = W ( l ) V z ( l ) u for simplicity):

Original: [Equation]
Revised: [Equation]

Original: The key advantage of Eqn.
Revised: The key advantage of Eqn.

Original: 5 is that the two summations are shared by each u , so that one only needs to compute them once and re-used for others.
Revised: 5 is that the two summations are shared by each u , so that one only needs to compute them once and re-used for others.

Original: Such a property enables O ( N ) computational complexity for full-graph message passing, which paves the way for learning graph structures among large-scale instances.
Revised: Such a property enables O ( N ) computational complexity for full-graph message passing, which paves the way for learning graph structures among large-scale instances.

Original: Moreover, one can notice that Eqn.
Revised: Moreover, one can notice that Eqn.

Original: 5 avoids computing the N × N similarity matrix, i.e., { ˜ a ( l ) uv } N × N , required by Eqn. 2, thus also reducing the learning difficulties.
Revised: 5 avoids computing the N × N similarity matrix, i.e., { ˜ a ( l ) uv } N × N , required by Eqn. 2, thus also reducing the learning difficulties.

Original: Nevertheless, Eqn. 5 still suffers what we mentioned the over-normalizing issue.
Revised: Nevertheless, Eqn. 5 still suffers what we mentioned the over-normalizing issue.

Original: The crux is that the message passing is operated on a weighted fully-connected graph where, in fact, only partial edges are important.
Revised: The crux is that the message passing is operated on a weighted fully-connected graph where, in fact, only partial edges are important.

Original: Also, such a deterministic way of feature aggregation over all the instances may increase the risk for over-fitting, especially when N is large.
Revised: Also, such a deterministic way of feature aggregation over all the instances may increase the risk for over-fitting, especially when N is large.

Original: We next resolve the issues by distilling a sparse structure from the fully-connected graph.
Revised: We next resolve the issues by distilling a sparse structure from the fully-connected graph.

Original: Differentiable Stochastic Structure Learning.
Revised: Differentiable Stochastic Structure Learning.

Original: The difficultly lies in how to enable differentiable optimization for discrete graph structures.
Revised: The difficultly lies in how to enable differentiable optimization for discrete graph structures.

Original: The weight ˜ a ( l ) uv given by Eqn. 2 could be used to define a categorical distribution for generating latent edge e uv ∼ Cat ( π ( l ) u ) where π ( l ) u
Revised: The weight ˜ a ( l ) uv given by Eqn. 2 could be used to define a categorical distribution for generating latent edges from distribution Cat ( π ( l ) u ) where π ( l ) u

Original: [Equation] and π ( l ) uv = p ( v | u ) =
Revised: = { π ( l ) uv } Nv =1 and π ( l ) uv = p ( v | u ) =

Original: ˜ a ( l ) uv .
Revised: ˜ a ( l ) uv .

Original: Then in principle, we can sample over the categorical distribution multiple times for each node to obtain its neighbors.
Revised: Then in principle, we can sample over the categorical distribution multiple times for each node to obtain its neighbors.

Original: However, the sampling process would introduce discontinuity and hinders back-propagation.
Revised: However, the sampling process would introduce discontinuity and hinders back-propagation.

Original: Fortunately, we notice that the Eqn. 3 can be modified to incorporate the reparametrization trick [16] to allow differentiable learning:
Revised: Fortunately, we notice that the Eqn.can be modified to incorporate the reparametrization trick [16] to allow differentiable learning:

Original: [Equation]
Revised: [Equation]

Original: where g u is i.i.d.
Revised: where g u is i.i.d.

Original: sampled from Gumbel distribution and τ is a temperature coefficient.
Revised: sampled from Gumbel distribution and τ is a temperature coefficient.

Original: Eqn. 6 is a continuous relaxation of sampling  over Cat ( π ( l ) u ) and τ controls the closeness to hard discrete samples [22].
Revised: Eqn. 6 is a continuous relaxation of sampling one neighbored node for u over Cat ( π ( l ) u ) and τ controls the closeness to hard discrete samples [22].

Original: Following similar reasoning as Eqn. 3 and 5, we can yield z [Equation] l [Equation]
Revised: Following similar reasoning as Eqn. 3 and 5, we can yield z ( l +1) u

Original: [Equation]

Original: u

Original: [Equation]
Revised: [Equation]

Original: Eqn. 7 achieves message passing over a sampled latent graph (where we only sample once for each node) and still guarantees linear complexity as Eqn. 5.
Revised: Eqn. 7 achieves message passing over a sampled latent graph (where we only sample once for each node) and still guarantees linear complexity as Eqn. 5.

Original: In practice, we can sample K times (e.g., K = 5 ) for each node and take an average of the aggregated results.
Revised: In practice, we can sample K times (e.g., K = 5 ) for each node and take an average of the aggregated results.

Revised: Due to space limit, we defer more details concerning the differentiable sampling-based message passing to Appendix A. Besides, in Fig.

Original: In Fig.
Revised: 5 and Alg.

Original: 1  we present an illustration for node representation updating in each layer, from a matrix view that is  used for implementation.
Revised: 1 of Appendix A, we present an illustration for node embedding updating in each layer, from a matrix view that is practically used for implementation.

Original: Furthermore, Alg. 1 shows the detailed feed-forward process of N ODE F ORMER .

Original: 3.2 Well-posedness of the Kernelized Gumbel-Softmax Operator
Revised: 3.2 Well-posedness of the Kernelized Gumbel-Softmax Operator

Original: One reasonable concern for Eqn.
Revised: One reasonable concern for Eqn.

Original: 7 is whether the RF approximation for kernel functions maintains the well-posedness of Gumbel approximation for the target discrete variables.
Revised: 7 is whether the RF approximation for kernel functions maintains the well-posedness of Gumbel approximation for the target discrete variables.

Original: As a justification for the new message-passing function, we next answer two theoretical questions: 1) How is the approximation capability of RF for the original dot-then-exponentiate operation with Gumbel variables in Eqn.
Revised: As a justification for the new message-passing function, we next answer two theoretical questions: 1) How is the approximation capability of RF for the original dot-then-exponentiate operation with Gumbel variables in Eqn.

Original: Does Eqn.
Revised: Does Eqn.

Original: 7 still guarantee a continuous relaxation of the categorical distributions?
Revised: 7 still guarantee a continuous relaxation of the categorical distributions?

Original: We formulate the results as follows and defer proofs to Appendix A.
Revised: We formulate the results as follows and defer proofs to Appendix B.

Original: Theorem 1 (Approximation Error for Softmax-Kernel) .
Revised: Theorem 1 (Approximation Error for Softmax-Kernel) .

Original: Assume ∥
Revised: Assume ∥

Original: q u ∥ 2 and ∥ k v ∥ 2 are bounded by r , then with probability at least 1 − ϵ , the gap ∆ =
Revised: q u ∥ 2 and ∥ k v ∥ 2 are bounded by r , then with probability at least 1 − ϵ , the gap ∆ =

Original: [Equation]
Revised: [Equation]

Original: where ϕ is defined by Eqn. 4, will be bounded by O
Revised: where ϕ is defined by Eqn. 4, will be bounded by O

Original: [Equation]
Revised: [Equation]

Original: We can see that the error bound of RF for approximating original softmax-kernel function depends on both the dimension of feature map ϕ and temperature τ .
Revised: We can see that the error bound of RF for approximating original softmax-kernel function depends on both the dimension of feature map ϕ and temperature τ .

Original: Notably, the error bound is independent of node number N , which implies that the approximation ability is insensitive to dataset sizes.
Revised: Notably, the error bound is independent of node number N , which implies that the approximation ability is insensitive to dataset sizes.

Original: The second question is non-trivial since Eqn.
Revised: The second question is non-trivial since Eqn.

Original: 7 involves randomness of Gumbel variables and random transformation in ϕ , which cannot be decoupled apart.
Revised: 7 involves randomness of Gumbel variables and random transformation in ϕ , which cannot be decoupled apart.

Original: We define c uv =
Revised: We define c uv =

Original: [Equation]
Revised: [Equation]

Original: ϕ(
Revised: ϕ

Original: [Equation]
Revised: [Equation]

Revised: k

Original:  e gw/τ as the result from the kernelized Gumbel-Softmax and c u = { c uv } Nv =1 denotes the sampled edge vector for node u .
Revised: [Equation] √ [Equation] e gw/τ as the result from the kernelized Gumbel-Softmax and c u = { c uv } Nv =1 denotes the sampled edge vector for node u .

Original: We can arrive at the result as follows.
Revised: We can arrive at the result as follows.

Original: Theorem 2 (Property of Kernelized Gumbel-Softmax Random Variables) .
Revised: Theorem 2 (Property of Kernelized Gumbel-Softmax Random Variables) .

Original: Suppose m is sufficiently large, we have the convergence property for the kernelized Gumbel-Softmax operator
Revised: Suppose m is sufficiently large, we have the convergence property for the kernelized Gumbel-Softmax operator

Original: [Equation]
Revised: [Equation]

Original: It shows that when i) the dimension of feature map is large enough and ii) the temperature goes to zero, the distribution from which latent structures are sampled would converge to the original categorical distribution.
Revised: It shows that when i) the dimension of feature map is large enough and ii) the temperature goes to zero, the distribution from which latent structures are sampled would converge to the original categorical distribution.

Original: Remark.
Revised: Remark.

Original: The two theorems imply a trade-off between RF approximation and Gumbel-Softmax approximation w.r.t.
Revised: The two theorems imply a trade-off between RF approximation and Gumbel-Softmax approximation w.r.t.

Original: the choice of τ .
Revised: the choice of τ .

Original: A large τ would help to reduce the burden on kernel dimension m , and namely, small τ would require a very large m to guarantee enough RF approximation precision.
Revised: A large τ would help to reduce the burden on kernel dimension m , and namely, small τ would require a very large m to guarantee enough RF approximation precision.

Original: On the other hand, if τ is too large, the weight on each edge will converge to 1 N , i.e., the model nearly degrades to mean pooling, while a small τ would endow the kernelized Gumbel-Softmax with better approximation to the categorical distribution.
Revised: On the other hand, if τ is too large, the weight on each edge will converge to 1 N , i.e., the model nearly degrades to mean pooling, while a small τ would endow the kernelized Gumbel-Softmax with better approximation to the categorical distribution.

Original: Empirical studies on this are presented in Appendix D.
Revised: Empirical studies on this are presented in Appendix E.

Original: 3.3 Input Structures as Relational Bias
Revised: 3.3 Input Structures as Relational Bias

Original: Eqn.
Revised: Eqn.

Original: 7 does not leverage any information from observed geometry which, however, is often recognized important for modeling physically-structured data [3].
Revised: 7 does not leverage any information from observed geometry which, however, is often recognized important for modeling physically-structured data [3].

Original: We therefore accommodate input topology (if any) as relational bias via modifying the attention weight as ˜ a ( l ) uv ← ˜ a ( l ) uv
Revised: We therefore accommodate input topology (if any) as relational bias via modifying the attention weight as ˜ a ( l ) uv ← ˜ a ( l ) uv

Original: + I
Revised: + I

Original: [ a uv = 1] σ ( b ( l ) ) , where b ( l ) is a learnable scalar as relational bias for any adjacent node pairs ( u, v ) and σ is a certain

Original: [Table]

Original: ⌧ .

Original: Notably, the error bound is independent of node number N , which implies that the approximation ability is insensitive to dataset sizes.

Original: The second question is non-trivial since Eqn.

Original: 7 involves randomness of Gumbel variables and random transformation in  , which cannot be decoupled apart.

Original: We deﬁne c uv =  ( q u / p ⌧ ) >  ( k v / p ⌧ ) e gv/⌧ P Nw =1  ( q u / p ⌧ ) >  ( k w / p ⌧ ) e gw/⌧ as the result from the kernelized Gumbel-Softmax and c u

Original: = { c uv } Nv =1 denotes the sampled edge vector for node u .

Original: We can arrive at the result as follows.

Original: Theorem 2 (Property of Kernelized Gumbel-Softmax Random Variables) .

Original: Suppose m is sufﬁciently large, we have the convergence property for the kernelized Gumbel-Softmax operator exp

Original: [Equation] q > u k v ) P Nw
Revised: [ a uv = 1] σ ( b ( l ) ) ,

Original: [Equation]

Original: [Equation]

Original: q > u k w ) ,

Original: 0 P ( c uv = 1) = exp( q > u k v )

Original: P

Original: Nw =1 exp( q > k w ) .

Original: It shows that when i) the is enough and ii) temperature to zero, the distribution from which are sampled would converge to the

Original: [Table]
Revised: [Figure]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: [Equation]

Original: [Table]

Original: ; ˜ K ( l ) k

Original: = ˜

Original: G k   ( K ( l ) / p ⌧ ) , ˜ Q ( l ) k

Original: = ˜

Original: G k   ( Q ( l ) / p ⌧ ) ;

Original: U ( l ) k

Original: (˜ K ( l ) k ) >

Original: V ( l ) , O ( l ) k

Original: (˜ K ( l ) k ) > 1 N ⇥ 1 ;

Original: Z ( l +1) 1 K

Original: P

Original: Kk =1 ˜ Q ( l ) k U ( l ) k ˜ Q

Original: ( l ) k

Original: O ( l ) k ; % average K samples

Original: Z ( l +1)

Original: Z ( l +1)

Original: +  ( b ( l ) ) · AZ ( l +1) ; % add relational bias Output: Predict node labels ˆ Y = MLP ( { Z ( l ) } Ll =0 ) .
Revised: where b ( l ) is a learnable scalar as relational bias for any adjacent node pairs ( u, v ) and σ is a certain (bounded) activation function like sigmoid.

Original: Remark.

Original: The two theorems imply a trade-off between RF approximation and Gumbel- Softmax approximation w.r.t.

Original: the choice of ⌧ .

Original: A large ⌧ would help to reduce the burden on kernel dimension m , and namely, small ⌧ would require a very large m to guarantee enough RF approximation precision.

Original: On the other hand, if ⌧ is too large, the weight on each edge will converge to 1 N , i.e., the model nearly degrades to mean pooling, while a small ⌧ would endow the kernelized Gumbel-Softmax with better approximation to the categorical distribution.

Original: Empirical studies on this are presented in Appendix D.

Original: (bounded) activation function like sigmoid.

Original: The relational bias aims at assigning adjacent nodes in G with proper weights, and the node representations could be accordingly updated by
Revised: The relational bias aims at assigning adjacent nodes in G with proper weights, and the node representations could be accordingly updated by

Original: [Equation]
Revised: [Equation]

Original: Eqn. 8 increases the algorithmic complexity for message passing to O ( N + E ) , albeit within the same order-of-magnitude as common GNNs operating on input graphs.
Revised: Eqn. 8 increases the algorithmic complexity for message passing to O ( N + E ) , albeit within the same order-of-magnitude as common GNNs operating on input graphs.

Original: Also, one can consider higher-order adjacency as relational bias for better expressiveness at some expense of efficiency, as similarly done by [1].
Revised: Also, one can consider higher-order adjacency as relational bias for better expressiveness at some expense of efficiency, as similarly done by [1].

Original: We summarize the feed-forward computation of N ODE F ORMER in Alg. 1.
Revised: We summarize the feed-forward computation of N ODE F ORMER in Alg. 1.

Original: 3.4 Learning Objective
Revised: 3.4 Learning Objective

Original: Givennode features X = { x u } and training labels Y  = { y u }  , we are to maximize the  data log-likelihood which yields a supervised loss (with C classes)
Revised: Given training labels Y tr = { y u } u ∈N tr , where N tr denotes the set of labeled nodes, the common practice is to maximize the observed data log-likelihood which yields a supervised loss (with C classes)

Original: [Equation]
Revised: [Equation]

Original: where I [ · ] is an indicator function.
Revised: where I [ · ] is an indicator function.

Original: However, it may not suffice to generalize well due to that the graph topology learning increases the degrees of freedom and the number of training labels is not comparable to that.
Revised: However, it may not suffice to generalize well due to that the graph topology learning increases the degrees of freedom and the number of training labels is not comparable to that.

Original: Therefore, we additionally introduce an edge-level regularization:
Revised: Therefore, we additionally introduce an edge-level regularization:

Original: [Equation]
Revised: [Equation]

Original: where d u denotes the in-degree of node u and π ( l ) uv is the predicted probability for edge ( u, v ) at the l -th layer.
Revised: where d u denotes the in-degree of node u and π ( l ) uv is the predicted probability for edge ( u, v ) at the l -th layer.

Original: Eqn.
Revised: Eqn.

Original: 10 is a maximum likelihood estimation for edges in E , with data distribution defined
Revised: 10 is a maximum likelihood estimation for edges in E , with data distribution defined

Original: [Equation]
Revised: [Equation]

Original: We next show how to efficiently obtain π ( l ) uv .
Revised: We next show how to efficiently obtain π ( l ) uv .

Original: Although the feed-forward N ODE F ORMER computation defined by Eqn.
Revised: Although the feed-forward N ODE F ORMER computation defined by Eqn.

Original: 7 does not explicitly produce the value for each π ( l ) uv , we can query their values by
Revised: 7 does not explicitly produce the value for each π ( l ) uv , we can query their values by

Original: [Equation]
Revised: [Equation]

Original: A cc u r a cy
Revised: A cc u r a cy

Original: Cora
Revised: Cora

Original: A cc u r a cy
Revised: A cc u r a cy

Original: CiteSeer 60.
Revised: CiteSeer 60.

Original: A cc u r a cy
Revised: A cc u r a cy

Original: Deezer 25.
Revised: Deezer 25.

Original: A cc u r a cy
Revised: A cc u r a cy

Original: Actor
Revised: Actor

Original: GCN
Revised: GCN

Original: GAT
Revised: GAT

Original: MixHop
Revised: MixHop

Original: JKNet
Revised: JKNet

Original: DropEdge
Revised: DropEdge

Original: LDS
Revised: LDS

Original: IDGL
Revised: IDGL

Original: NodeFormermissing results on Deezer is caused by out-of-memory (OOM) [Figure] [Figure]
Revised: NodeFormer

Original: [Table]
Revised: [Table]

Original: [Figure]

Original: [Table]
Revised: [Table]

Original: where the summation term can be re-used from once computation, as is done by Eqn.
Revised: where the summation term can be re-used from once computation, as is done by Eqn.

Original: 5 and Eqn. 7.
Revised: 5 and Eqn. 7.

Original: Therefore, after once computation for the summation that requires O ( N ) , the computation for each π ( l ) uv requires O (1) complexity, yielding the total complexity controlled within O ( E ) (since we only need to query the observed edges).
Revised: Therefore, after once computation for the summation that requires O ( N ) , the computation for each π ( l ) uv requires O (1) complexity, yielding the total complexity controlled within O ( E ) (since we only need to query the observed edges).

Original: The final objective can be the combination of two: L =
Revised: The final objective can be the combination of two: L =

Original: L s + λ L e , where λ controls how much emphasis is put on input topology.
Revised: L s + λ L e , where λ controls how much emphasis is put on input topology.

Revised: We depict the whole data flow of

Revised: N ODE F ORMER ’s training in Fig.

Original:  Evaluation
Revised:  Evaluation

Original: We consider a diverse set of datasets for experiments and present detailed dataset information in
Revised: We consider a diverse set of datasets for experiments and present detailed dataset information in

Original: Appendix C. For implementation, we set σ as sigmoid function and τ as 0.25 for all datasets.
Revised: Appendix D. For implementation, we set σ as sigmoid function and τ as 0.25 for all datasets.

Original: The output prediction layer is a one-layer MLP.
Revised: The output prediction layer is a one-layer MLP.

Original: More implementation details are presented in Appendix B.
Revised: More implementation details are presented in Appendix C.

Original: All experiments are conducted on a NVIDIA V100 with 16 GB memory.
Revised: All experiments are conducted on a NVIDIA V100 with 16 GB memory.

Original: As baseline models, we basically consider GCN [19] and GAT [36].
Revised: As baseline models, we basically consider GCN [19] and GAT [36].

Original: Besides, we compare with some advanced GNN models, including JKNet [44] and MixHop [1].
Revised: Besides, we compare with some advanced GNN models, including JKNet [44] and MixHop [1].

Original: These GNN models all rely on input graphs.
Revised: These GNN models all rely on input graphs.

Original: We further consider DropEdge [27] and two SOTA graph structure learning methods,
Revised: We further consider DropEdge [27] and two SOTA graph structure learning methods,

Original: LDS-GNN [11] and IDGL [4] for comparison.
Revised: LDS-GNN [11] and IDGL [4] for comparison.

Original: For large-scale datasets, we additionally compare with two scalable GNNs, a linear model SGC [39] and a graph-sampling model GraphSAINT [47].
Revised: For large-scale datasets, we additionally compare with two scalable GNNs, a linear model SGC [39] and a graph-sampling model GraphSAINT [47].

Original: More detailed information about these models are presented in Appendix B. All the experiments are repeated five times with different initializations.
Revised: More detailed information about these models are presented in Appendix C. All the experiments are repeated five times with different initializations.

Original: 4.1 Experiments on Transductive Node Classification
Revised: 4.1 Experiments on Transductive Node Classification

Original: We study supervised node classification in transductive setting on common graph datasets: Cora ,
Revised: We study supervised node classification in transductive setting on common graph datasets: Cora ,

Original: Citeseer , Deezer and Actor .
Revised: Citeseer , Deezer and Actor .

Original: The first two have high homophily ratios and the last two are identified as heterophilic graphs [52, 20].
Revised: The first two have high homophily ratios and the last two are identified as heterophilic graphs [52, 20].

Original: These datasets are of small or medium sizes (with 2K ∼ 20K nodes).
Revised: These datasets are of small or medium sizes (with 2K ∼ 20K nodes).

Original: We use random splits with train/valid/test ratios as 50%/25%/25% and accuracy on test nodes for evaluation.
Revised: We use random splits with train/valid/test ratios as 50%/25%/25% and accuracy on test nodes for evaluation.

Original: Results are plotted in Fig.
Revised: Results are plotted in Fig.

Original: 2 and N ODE F ORMER achieves the best mean accuracy across four datasets and in particular, outperforms other models by a large margin on two heterophilic graphs.
Revised: 2 and N ODE F ORMER achieves the best mean accuracy across four datasets and in particular, outperforms other models by a large margin on two heterophilic graphs.

Original: The results indicate that N ODE F ORMER can handle both homophilious and nonhomophilious graphs.
Revised: The results indicate that N ODE F ORMER can handle both homophilious and nonhomophilious graphs.

Original: Compared with two structure learning models LDS and IDGL, N ODE F ORMER yields significantly better performance, which shows its superiority.
Revised: Compared with two structure learning models LDS and IDGL, N ODE F ORMER yields significantly better performance, which shows its superiority.

Original: Also, for deezer , LDS and
Revised: Also, for deezer , LDS and

Original: IDGL suffers from out-of-memory (OOM).
Revised: IDGL suffers from out-of-memory (OOM).

Original: In fact, the major difficulty for deezer is the largedimensions of input node features (nearly 30K), which causes OOM for IDGL even with the anchor approximation. In contrast, N ODE F ORMER manages to scale and produce desirable accuracy.
Revised: In fact, the major difficulty for deezer is the large

Original: [Table]
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: n i
Revised: [Table]

Original: [Figure]
Revised: [Figure]

Original: t
Revised: dimensions of input node features (nearly 30K), which causes OOM for IDGL even with the anchor approximation.

Original: i [Figure]
Revised: In contrast, N ODE F ORMER manages to scale and produce desirable accuracy.

Original: 4.2 Experiments on Larger Graph Datasets
Revised: 4.2 Experiments on Larger Graph Datasets

Original: To further test the scalability, we consider two large-sized networks, OGB-Proteins and Amazon2M , with over 0.1 million and 2 million of nodes, respectively.
Revised: To further test the scalability, we consider two large-sized networks, OGB-Proteins and Amazon2M , with over 0.1 million and 2 million of nodes, respectively.

Original: OGB-Proteins is a multi-task dataset with 112 output dimensions, while Amazon2M is extracted from the Amazon Co-Purchasing network that entails long-range dependence [13].
Revised: OGB-Proteins is a multi-task dataset with 112 output dimensions, while Amazon2M is extracted from the Amazon Co-Purchasing network that entails long-range dependence [13].

Original: For OGB-Proteins , we use the protocol of [15] and ROC-AUC for evaluation.
Revised: For OGB-Proteins , we use the protocol of [15] and ROC-AUC for evaluation.

Original: For Amazon2M ,unlike [5] using random splits, we consider a more challenging setting: we rank the nodesaccording to their degrees, and use the top 10% for training and the rest for testing. This introduces distribution shifts and is more alike to real situations where frequent items are often used for training a model that needs to handle infrequent testing products. For validation set, we hold out 20% data from the training set.
Revised: For Amazon2M , we adopt random splitting with 50%/25%/25% nodes for training, validation and testing, respectively.

Original: Due to the large dataset size, we adopt mini-batch partition for training, in which case, for N ODE F ORMER we only consider structure learning among nodes in a random mini-batch.
Revised: Due to the large dataset size, we adopt mini-batch partition for training, in which case, for N ODE F ORMER we only consider structure learning among nodes in a random mini-batch.

Original: We use batch size 10000 and 100000 for Proteins and Amazon2M , respectively.
Revised: We use batch size 10000 and 100000 for Proteins and Amazon2M , respectively.

Original: While the mini-batch partition may sacrifice the exposure to all instances, we found using large batch size can yield decent performance, which is also allowable thanks to the O ( N ) complexity of our model.
Revised: While the mini-batch partition may sacrifice the exposure to all instances, we found using large batch size can yield decent performance, which is also allowable thanks to the O ( N ) complexity of our model.

Original: For example, even setting the batch size as 100000, we found N ODE F ORMER costs only 5GB GPU memory for training on Amazon2M .
Revised: For example, even setting the batch size as 100000, we found N ODE F ORMER costs only 4GB GPU memory for training on Amazon2M .

Original: Table 2 presents the results on OGB-Proteins where for fair comparison mini-batch training is also used for other models except GraphSAINT.
Revised: Table 2 presents the results on OGB-Proteins where for fair comparison mini-batch training is also used for other models except GraphSAINT.

Original: We found that N ODE F ORMER yields much better ROC-AUC.
Revised: We found that N ODE F ORMER yields much better ROC-AUC and only requires comparable memory as simple GNN models.

Original: Table 3 reports the results on Amazon2M where besides random partition, we also consider using the METIS algorithm [5] for graph partition. Table 3 shows that N ODE F ORMER outperforms baselines by a large margin, which shows its practical efficacy  on large-scale datasets and also the capability for addressing long-range dependence with shallow layers (we set L = 3 ).
Revised: Table 3 reports the results on Amazon2M which shows that N ODE F ORMER outperforms baselines by a large margin and the memory cost is even fewer than GCN. This shows its practical efficacy and scalability on large-scale datasets and also the capability for addressing long-range dependence with shallow layers (we use L = 3 ).

Original: 4.3 Experiments on Graph-Enhanced Applications
Revised: 4.3 Experiments on Graph-Enhanced Applications

Original: We apply our model to semi-supervised image and text classification on Mini-ImageNet and 20News-Groups datasets, withoutany given input graphs.
Revised: We apply our model to semi-supervised image and text classification on Mini-ImageNet and 20News-Groups datasets, without input graphs.

Original: The instances of Mini-ImageNet [37] are 84×84 RGB images and we randomly choose 30 classes each of which contains 600 samples for experiments.
Revised: The instances of Mini-ImageNet [37] are 84× RGB images and we randomly choose 30 classes each of which contains 600 samples for experiments.

Original: 20News-Groups [24] consists of nearly 10K texts whose features are extracted by TF-IDF.
Revised: 20News-Groups [24] consists of nearly 10K texts whose features are extracted by TF-IDF.

Original: More details for preprocessing are presented in Appendix C. Also, for each dataset, we randomly split instances into 50%/25%/25% for train/valid/test.
Revised: More details for preprocessing are presented in Appendix D. Also, for each dataset, we randomly split instances into 50%/25%/25% for train/valid/test.

Original: Since there is no input graph, we use k -NN (over input node features) for artificially constructing a graph for enabling GNN’s message passing.
Revised: Since there is no input graph, we use k -NN (over input node features) for artificially constructing a graph for enabling GNN’s message passing and the graph-based components (edge regularization and relational bias) of N ODE F ORMER .

Original: Table 4 presents the comparison results under different k ’s. We can see that N ODE F ORMER achieves the best performance in seven cases out of eight in total.
Revised: Tablepresents the comparison results under different k ’s. We can see that N ODE F ORMER achieves the best performance in seven cases out of eight.

Original: The performance of graph-based competitors varies significantly with different k values, and N ODE F ORMER is much less sensitive.
Revised: The performance of GNN competitors varies significantly with different k values, and N ODE F ORMER is much less sensitive.

Revised: Intriguingly, when we do not use the input graph, i.e., removing both the edge regularization and relational bias, N ODE F ORMER can still yield competitive even superior results on Mini-ImageNet .

Revised: This suggests that the k -NN graphs are not necessarily informative and besides, our model learns useful latent graph structures from data.

Original: 4.4 Further Discussions
Revised: 4.4 Further Discussions

Original: Comparison of Time/Space Consumption.
Revised: Comparison of Time/Space Consumption.

Original: Fig.
Revised: Fig.

Original: 3 plots training/inference time and GPU memory costs of N ODE F ORMER and two SOTA structure learning models.
Revised: 3 plots training/inference time and GPU memory costs of N ODE F ORMER and two SOTA structure learning models.

Original: Compared with LDS, N ODEF ORMER reduces the training time, inference time, memory cost by up to 93.1%, 97.9%, 75.6%, respectively; compared with IDGL (using anchor-based approximation for speedup), N ODE F ORMER reduces the training time, inference time, memory cost by up to 61.8%, 80.8%, 80.6%, respectively.Ablation on Edge Loss and Relational Bias.
Revised: Compared with LDS, N ODEF ORMER reduces the training time, inference time, memory cost by up to 93.1%, 97.9%, 75.6%, respectively; compared with IDGL (using anchor-based approximation for speedup), N ODE F ORMER reduces the training time, inference time, memory cost by up to 61.8%, 80.8%, 80.6%, respectively.

Original: We study the effects of edge-level regularization and relation bias as ablation study shown in Table 4.

Original: More results are deferred to Appendix D and they consistently show that both components contribute to some positive effects and suggest that our edge-level loss and relation bias can both help to leverage useful information from input graphs.

Original: Ablation on Stochastic Components.
Revised: Ablation on Stochastic Components.

Original: Table 2 and 3 also include two variants of N ODE F ORMER for ablation study.
Revised: Table 2 and 3 also include two variants of N ODE F ORMER for ablation study.

Original: 1) N ODE F ORMER -dt: replace Gumbel-Softmax by original Softmax (with temperature 1.0) for deterministic propagation; 2) N ODE F ORMER -tp: use original Softmax with temperature set as 0.25 (the same as N ODE F ORMER ).
Revised: 1) N ODE F ORMER -dt: replace Gumbel-Softmax by original Softmax (with temperature 1.0) for deterministic propagation; 2) N ODE F ORMER -tp: use original Softmax with temperature set as 0.25 (the same as N ODE F ORMER ).

Original: There is performance drop when removing the Gumbel components, which may be due to over-normalizing or over-fitting that are amplified in large datasets, as we discussed in Section 3.1 and the kernelized Gumbel-Softmax operator shows its effectiveness.
Revised: There is performance drop when removing the Gumbel components, which may be due to over-normalizing or over-fitting that are amplified in large datasets, as we discussed in Section 3.1 and the kernelized Gumbel-Softmax operator shows its effectiveness.

Revised: Ablation on Edge Loss and Relational Bias.

Revised: We study the effects of edge-level regularization and relation bias as ablation study shown in Table 6 located in Appendix E, where the results consistently show that both components contribute to some positive effects and suggest that our edge-level loss and relation bias can both help to leverage useful information from input graphs.

Original: Impact of Temperature and Feature Map Dimension.
Revised: Impact of Temperature and Feature Map Dimension.

Original: We study the effects of τ and m in Fig.located in Appendix D and the variation trend accords with our theoretical analysis in Section 3.2.
Revised: We study the effects of τ and m in Fig.located in Appendix E and the variation trend accords with our theoretical analysis in Section 3.2.

Original: Specifically, the result shows that the test accuracy increases and then falls with the temperature changing from low to high values (usually achieves the peak accuracy with a temperature of 0.4).
Revised: Specifically, the result shows that the test accuracy increases and then falls with the temperature changing from low to high values (usually achieves the peak accuracy with a temperature of 0.4).

Original: Besides, we can see that when the temperature is relatively small, the test accuracy goes high with the dimension of random features increasing.
Revised: Besides, we can see that when the temperature is relatively small, the test accuracy goes high with the dimension of random features increasing.

Original: However, when the temperature is large, the accuracy would drop even with large feature dimension m .
Revised: However, when the temperature is large, the accuracy would drop even with large feature dimension m .

Original: Such a phenomenon accords with the theoretical result presented in Section 3.2.
Revised: Such a phenomenon accords with the theoretical result presented in Section 3.2.

Original: For low temperature which enables desirable approximation performance for
Revised: For low temperature which enables desirable approximation performance for

Original: Gumbel-Softmax, then larger random feature dimension would help to produce better approximation to the original exponentiate-then-dot operator.
Revised: Gumbel-Softmax, then larger random feature dimension would help to produce better approximation to the original exponentiate-then-dot operator.

Original: In contrast, high temperature could not guarantee precise approximation for the original categorical distribution, which deteriorates the performance.
Revised: In contrast, high temperature could not guarantee precise approximation for the original categorical distribution, which deteriorates the performance.

Original: Visualization and Implications.
Revised: Visualization and Implications.

Original: Fig.
Revised: Fig.

Original: 4 visualizes node embeddings and edge connections (filter out the edges with weights larger than a threshold) on 20News-Groups and Mini-Imagenet , which show that N ODE F ORMER tends to assign more weights for nodes with the same class and sparse edges for nodes with different classes.
Revised: 4 visualizes node embeddings and edge connections (filter out the edges with weights larger than a threshold) on 20News-Groups and Mini-Imagenet , which show that N ODE F ORMER tends to assign more weights for nodes with the same class and sparse edges for nodes with different classes.

Original: This helps to interpret why N ODE F ORMER improves the performance on downstream node-level prediction: the latent structures can propagate useful information to help the model learn better node representations that can be easily distinguished by the classifier.
Revised: This helps to interpret why N ODE F ORMER improves the performance on downstream node-level prediction: the latent structures can propagate useful information to help the model learn better node representations that can be easily distinguished by the classifier.

Original: We also compare the learned structures with original graphs in Fig.
Revised: We also compare the learned structures with original graphs in Fig.

Original: 6 located in Appendix D.
Revised: 7 located in Appendix E.

Original: We can see that the latent structures learned by N ODE F ORMER show different patterns from the observed ones, especially for heterophilic graphs.
Revised: We can see that the latent structures learned by N ODE F ORMER show different patterns from the observed ones, especially for heterophilic graphs.

Original: Another interesting phenomenon is that there exist some dominant nodes which are assigned large weights by other nodes, forming some vertical ‘lines’ in the heatmap.
Revised: Another interesting phenomenon is that there exist some dominant nodes which are assigned large weights by other nodes, forming some vertical ‘lines’ in the heatmap.

Original: This suggests that these nodes could contain critical information for the learning tasks and play as pivots that could improve the connectivity of the whole system.
Revised: This suggests that these nodes could contain critical information for the learning tasks and play as pivots that could improve the connectivity of the whole system.

Original:  Why N ODE F ORMER Improves Downstream Prediction?
Revised:  Why N ODE F ORMER Improves Downstream Prediction?

Original: There remains a natural question concerning our learning process: how effective can the learned latent topology be for downstream tasks?
Revised: There remains a natural question concerning our learning process: how effective can the learned latent topology be for downstream tasks?

Original: We next dissect the rationale from a Bayesian perspective.
Revised: We next dissect the rationale from a Bayesian perspective.

Original: In fact, our model induces a predictive distribution p ( Y , ˜
Revised: In fact, our model induces a predictive distribution p ( Y , ˜

Original: A | X , A ) =
Revised: A | X , A ) =

Original: p ( ˜ A
Revised: p ( ˜ A

Original: | X , A ) p ( Y | ˜
Revised: | X , A ) p ( Y | ˜

Original: A , X , A ) where we can treat the estimated graph ˜ A as a latent variable.
Revised: A , X , A ) where we can treat the estimated graph ˜ A as a latent variable.

Original: Specifically, p ( ˜ A | X , A ) is instantiated with the structure estimation module and p ( Y | ˜
Revised: Specifically, p ( ˜ A | X , A ) is instantiated with the structure estimation module and p ( Y | ˜

Original: A , X , A ) is instantiated with the feature propagation module.
Revised: A , X , A ) is instantiated with the feature propagation module.

Original: In principle, ideal latent graphs should account for downstream tasks and maximize the potentials  of message passing for producing informative node representations.
Revised: In principle, ideal latent graphs should account for downstream tasks and maximize the potentials [Figure] of message passing for producing informative node representations

Original: Thus, optimal latent graphs presumably come from the posterior p ( ˜ A | Y , X 
Revised: Thus, optimal latent graphs presumably come from the posterior p ( ˜ A | Y , X , A ) = p [Equation] Y | X

Original: [Equation]
Revised: [Equation]

Revised: A

Revised: [Equation]

Revised: ˜ A )

Revised: [Equation]

Revised: A

Revised: [Equation]

Revised: X

Revised: [Equation]

Original:  which is given by
Revised: [Equation] Y p ( Y | X , A , ˜ A ) p (˜ A | X , A ) d Y which is given by

Original: Bayes theorem.
Revised: Bayes theorem.

Original: Unfortunately, such a posterior is unknown and intractable for the integration
Revised: Unfortunately, such a posterior is unknown and intractable for the integration.

Original: [Figure]

Original: A Variational Perspective.
Revised: A Variational Perspective.

Original: An intriguing conclusion stems from another view into the learning process: we can treat the structure estimation as a variational distribution q ( ˜ A | X , A ) and our learning objective in Section 3.4 can be viewed as the embodiment of a minimization problem over the predictive and variational distributions via
Revised: An intriguing conclusion stems from another view into the learning process: we can treat the structure estimation as a variational distribution q ( ˜ A | X , A ) and our learning objective in Section 3.4 can be viewed as the embodiment of a minimization problem over the predictive and variational distributions via

Original: [Equation]
Revised: [Equation]

Original: where D denotes the Kullback-Leibler divergence.
Revised: where D denotes the Kullback-Leibler divergence.

Original: Specifically, the predictive term is equivalent to minimizing the supervised loss (with Gumbel-Softmax as a surrogate for sampling-based estimates over q ( ˜ A | X , A ) ), and the KL regularization term is embodied with the edge-level MLE loss (Eqn. 10) (if we define the prior distribution p 

Revised: Specifically, the predictive term is equivalent to minimizing the supervised loss (with Gumbel-Softmax as a surrogate for sampling-based estimates over q ( ˜ A | X , A ) ), and the KL regularization term is embodied with the edge-level MLE loss (Eqn. 10) (if we define the prior distribution p

Original: ( ˜ A | X , A ) following Eqn. 11).
Revised: ( ˜ A | X , A ) following Eqn. 11).

Original: One may notice that Eqn. 13 is essentially the Evidence Lower Bound (ELBO) for the log-likelihood log p ( Y | X , A ) .
Revised: One may notice that Eqn. 13 is essentially the Evidence Lower Bound (ELBO) for the log-likelihood log p ( Y | X , A ) .

Original: Proposition 1.
Revised: Proposition 1.

Original: Assume q can exploit arbitrary distributions over ˜ A .
Revised: Assume q can exploit arbitrary distributions over ˜ A .

Original: When Eqn. 13 achieves the optimum, we have 1) D [Equation] q [Equation]
Revised: When Eqn. 13 achieves the optimum, we have 1) D ( q ( ˜ A | X , A )

Original: A | X , A ) ∥ p [Equation] ˜ A | Y , X , A ))
Revised: ∥ p ( ˜ A | Y , X , A ))

Original: = 0 and 2)
Revised: = 0 and 2)

Original: log p
Revised: log p

Original: ( Y | X , A ) is maximized.
Revised: ( Y | X , A ) is maximized.

Original: The proposition indicates that our adopted learning objective intrinsically minimizes the divergence between latent graphs generated by the model and the samples from the posterior p ( ˜ A | Y , X , A ) that ideally helps to propagate useful adjacent information w.r.t.
Revised: The proposition indicates that our adopted learning objective intrinsically minimizes the divergence between latent graphs generated by the model and the samples from the posterior p ( ˜ A | Y , X , A ) that ideally helps to propagate useful adjacent information w.r.t.

Original: downstream tasks.
Revised: downstream tasks.

Original: Therefore, a well-trained network of N ODE F ORMER on labeled data could produce effective latent topology that contributes to boosting the downstream performance.
Revised: Therefore, a well-trained network of N ODE F ORMER on labeled data could produce effective latent topology that contributes to boosting the downstream performance.

Original:  Conclusion
Revised:  Conclusion

Original: This paper proposes a scalable and efficient graph Transformer (especially for node level) that can propagate layer-wise node signals between arbitrary pairs beyond input topology.
Revised: This paper proposes a scalable and efficient graph Transformer (especially for node level) that can propagate layer-wise node signals between arbitrary pairs beyond input topology.

Original: The key module, a kernelized Gumbel-Softmax operator, enables us to learn layer-specific latent graphs with linear algorithmic complexity without compromising the precision.
Revised: The key module, a kernelized Gumbel-Softmax operator, enables us to learn layer-specific latent graphs with linear algorithmic complexity without compromising the precision.

Original: The results on diverse graph datasets and situations verify the effectiveness, scalability, and stability.
Revised: The results on diverse graph datasets and situations verify the effectiveness, scalability, and stability.

Original: We provide more discussions on the limitations and potential impacts in Appendix E.
Revised: We provide more discussions on the limitations and potential impacts in Appendix F.

Original: Acknowledgement
Revised: Acknowledgement

Original: This work was partly supported by National Key Research and Development Program of China (2020AAA0107600), National Natural Science Foundation of China (61972250, 72061127003), and
Revised: This work was partly supported by National Key Research and Development Program of China (2020AAA0107600), National Natural Science Foundation of China (61972250, 72061127003), and

Original: Shanghai Municipal Science and Technology (Major) Project (22511105100, 2021SHZDZX0102).
Revised: Shanghai Municipal Science and Technology (Major) Project (22511105100, 2021SHZDZX0102).

Revised: Appendix A More Details for N ODE F ORMER A.1 Differentiable Sampling-based Message Passing on Latent Structures

Revised: We provide more details concerning the differentiable sampling-based message passing through our kernelized Gumbel-Softmax operator, as complementary to the content of Sec. 3.1.

Revised: As illustrated in

Original: A Proof for Technical Results A.1 Proof for Theorem
Revised: Sec. 3.1, the l -th layer’s feature propagation is defined over the l -th layer’s latent graph composed of the sampled edges e ( l ) uv ∼ Cat ( π u ) ( l ) . For each layer, we sample K times for each node, i.e., there will be K sampled neighbored nodes for each node u . We assume ˜ E ( l ) =

Revised: { e ( l ) uv } as the set of sampled edges in the latent graph of the l -th layer.

Revised: Then the updating rule for node embeddings at the l -th layer based on the latent graph can be written as

Revised: [Equation]

Revised: [Equation]

Revised: The above equation introduces dis-continuity due to the sampling process that disables the end-to-end differentiable training.

Revised: We thus adopt Gumbel-Softmax as a reparameterization trick to approximate the discrete sampled results via continuous relaxation:

Revised: [Equation]

Revised: The temperature τ controls the closeness to hard discrete samples [22].

Revised: If τ is close to zero, then the

Revised: Gumbel-Softmax term

Revised: [Equation]

Revised: for any v converges to a one-hot vector:

Revised: [Equation]

Revised: , if v satisfies

Revised: [Equation]

Revised: otherwise

Revised: [Equation]

Revised: The Eqn. 15 requires O ( N 2 ) for computing the embeddings for N nodes in one layer.

Revised: To reduce the complexity to O ( N )

Revised: [Equation]

Revised: we resort to the kernel approximation idea, following similar reasoning as

Revised: Eqn. 3 and 5:

Revised: [Equation]

Revised: The above result yields the one-layer updating rule for N ODE F ORMER ’s feed-forwarding w.r.t.

Revised: each node u .

Revised: In terms of practical implementation, we adopt matrix multiplications for computing the node embeddings for all the nodes in the next layer, for which we present the details in the next subsection.

Revised: A.2 Model Implementation from the Matrix View

Revised: In practice, the implementation of N ODE F ORMER is based on matrix operations that simultanenously update all the nodes in one layer.

Revised: We present the feed-forward process of N ODE F ORMER from a

Revised: [Table]

Revised: ⌧ .

Revised: Notably, the error bound is independent of node number N , which implies that the approximation ability is insensitive to dataset sizes.

Revised: The second question is non-trivial since Eqn.

Revised: 7 involves randomness of Gumbel variables and random transformation in  , which cannot be decoupled apart.

Revised: We deﬁne c uv =  ( q u / p ⌧ ) >  ( k v / p ⌧ ) e gv/⌧ P Nw =1  ( q u / p ⌧ ) >  ( k w / p ⌧ ) e gw/⌧ as the result from the kernelized Gumbel-Softmax and c u

Revised: = { c uv } Nv =1 denotes the sampled edge vector for node u .

Revised: We can arrive at the result as follows.

Revised: Theorem 2 (Property of Kernelized Gumbel-Softmax Random Variables) .

Revised: Suppose m is sufﬁciently large, we have the convergence property for the kernelized Gumbel-Softmax operator exp

Revised: [Equation]

Revised: q > u k v )

Revised: P

Revised: Nw

Revised: [Equation]

Revised: [Equation]

Revised: q > u k w ) ,

Revised: 0 P ( c uv = 1) = exp( q > u k v )

Revised: P

Revised: Nw =1 exp( q > k w ) .

Revised: It shows that when i) the is enough and ii) temperature to zero, the distribution from which are sampled would converge to the

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: [Equation]

Revised: [Table]

Revised: ; ˜ K ( l ) k

Revised: = ˜

Revised: G k   ( K ( l ) / p ⌧ ) , ˜ Q ( l ) k

Revised: = ˜

Revised: G k   ( Q ( l ) / p ⌧ ) ;

Revised: U ( l ) k

Revised: (˜ K ( l ) k ) >

Revised: V ( l ) , O ( l ) k

Revised: (˜ K ( l ) k ) > 1 N ⇥ 1 ;

Revised: Z ( l +1) 1 K

Revised: P

Revised: Kk =1 ˜ Q ( l ) k U ( l ) k ˜ Q

Revised: ( l ) k

Revised: O ( l ) k ; % average K samples

Revised: Z ( l +1)

Revised: Z ( l +1)

Revised: +  ( b ( l ) ) · AZ ( l +1)

Revised: ; % add relational bias

Revised: Output: Predict node labels ˆ Y =

Revised: MLP ( { Z ( l ) } Ll =0 ) .

Revised: Remark.

Revised: The two theorems imply a trade-off between RF approximation and Gumbel- Softmax approximation w.r.t.

Revised: the choice of ⌧ .

Revised: A large ⌧ would help to reduce the burden on kernel dimension m , and namely, small ⌧ would require a very large m to guarantee enough RF approximation precision.

Revised: On the other hand, if ⌧ is too large, the weight on each edge will converge to 1 N , i.e., the model nearly degrades to mean pooling, while a small ⌧ would endow the kernelized Gumbel-Softmax with better approximation to the categorical distribution.

Revised: Empirical studies on this are presented in Appendix D. matrix view in Fig.

Revised: 5 where

Revised: Alg. 1 depicts how node embeddings are updated in each layer through our introduced kernelized Gumbel-Softmax message

Revised: B Proof for Technical Results B.1 Proof for Theorem

Original: To prove our theorem, we first introduce the following lemma given by the Lemma 2 in [6].
Revised: To prove our theorem, we first introduce the following lemma given by the Lemma 2 in [6].

Original: Proposition 1.
Revised: Proposition 1.

Original: Denote a softmax kernel as SM ( x , y ) =
Revised: Denote a softmax kernel as SM ( x , y ) =

Original: exp( x ⊤ y ) .
Revised: exp( x ⊤ y ) .

Original: The Positive Random Features defined by Eqn. 4 for softmax-kernel estimation, i.e.,
Revised: The Positive Random Features defined by Eqn. 4 for softmax-kernel estimation, i.e.,

Original: [Equation]
Revised: [Equation]

Original: exp [Equation] ⊤ 
Revised: ∥ x ∥ 2 2 ) exp( w ⊤ i y − ∥

Original: [Equation] y − ∥ y ∥ 2 2 )] , has the mean and variance over w ∼ N (0 , I d ) as
Revised: y ∥ 2 2 )] , has the mean and variance over w ∼ N (0 , I d ) as

Original: [Equation]
Revised: [Equation]

Original: The lemma shows that the Positive Random Features can achieve unbiased approximation for the softmax kernel with a quantified variance.
Revised: The lemma shows that the Positive Random Features can achieve unbiased approximation for the softmax kernel with a quantified variance.

Original: Back to our main theorem, suppose the L2-norms of q u and k v are bounded by r , we can derive the probability using the Chebyshev’s inequality: 
Revised: Back to our main theorem, suppose the L2-norms of q u and k v are bounded by r , we can derive the probability using the Chebyshev’s inequality: [Equation]

Original: [Equation]
Revised: [Equation]

Original: where ∆ = (cid:12)(cid:12)(cid:12)(cid:100)
Revised: where ∆ = (cid:12) (cid:12)(cid:12) (cid:100)

Original: [Equation]
Revised: [Equation]

Original: (cid:12)(cid:12)(cid:12) denotes the deviation of the kernel approximation.
Revised: denotes the deviation of the kernel approximation.

Original: Using the result in Lemma 1, we can further obtain that the RHS of Eqn.
Revised: Using the result in Lemma 1, we can further obtain that the RHS of Eqn.

Original: 15 is no greater than
Revised: 19 is no greater than

Original: [Equation]
Revised: [Equation]

Original: Since ∥ q u + k v √ τ ∥ 2 ≤ 4 rτ and 2 q ⊤ u k v τ ≤ 2 rτ , we can achieve the stated result:
Revised: Since ∥ q u + k v √ τ ∥ 2 ≤ 4 rτ and 2 q ⊤ u k v τ ≤ 2 rτ , we can achieve the stated result:

Original: [Equation]
Revised: [Equation]

Original: A.2 Proof for Theorem
Revised: B.2 Proof for Theorem

Original: Before entering the proof for the theorem, we first introduce two basic technical lemmas.
Revised: Before entering the proof for the theorem, we first introduce two basic technical lemmas.

Original: While such results are already mentioned in previous studies [16, 22], their proofs will be useful for the subsequent reasoning.
Revised: While such results are already mentioned in previous studies [16, 22], their proofs will be useful for the subsequent reasoning.

Original: Therefore, we restate the proofs as building blocks for the following presentation.
Revised: Therefore, we restate the proofs as building blocks for the following presentation.

Original: Proposition 2.
Revised: Proposition 2.

Original: Given real numbers x i , x j ∈ R and u i , u j i.i.d.
Revised: Given real numbers x i , x j ∈ R and u i , u j i.i.d.

Original: sampled from uniform distribution within (0 , 1) .
Revised: sampled from uniform distribution within (0 , 1) .

Original: With Gumbel perturbation defined as g ( u ) = − log( − log( u )) , we have the probability
Revised: With Gumbel perturbation defined as g ( u ) = − log( − log( u )) , we have the probability

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: Due to g ( u ) = − log( − log( u )) , the inequality of interests x i + g ( u i ) >
Revised: Due to g ( u ) = − log( − log( u )) , the inequality of interests x i + g ( u i ) >

Original: x j + g ( u j ) can be rearranged as
Revised: x j + g ( u j ) can be rearranged as

Original: [Equation]
Revised: [Equation]

Original: Since log( u j ) < 0 , Eqn. 18 can be written as
Revised: Since log( u j ) < 0 , Eqn. 22 can be written as

Original: [Equation]
Revised: [Equation]

Original: As u i , u j are i.i.d.
Revised: As u i , u j are i.i.d.

Original: sampled from a uniform distribution, the probability when the above formula can be calculated via:
Revised: sampled from a uniform distribution, the probability when the above formula can be calculated via:

Original: [Equation]
Revised: [Equation]

Original: Thus, we conclude the proof with
Revised: Thus, we conclude the proof with

Original: [Equation]
Revised: [Equation]

Original: Proposition 3.
Revised: Proposition 3.

Original: Let X ∼ Gumbel
Revised: Let X ∼ Gumbel

Original: ( α, τ ) (i.e. X k =
Revised: ( α, τ ) (i.e. X k =

Original: [Equation]
Revised: [Equation]

Original: τ ) ) with location parameters α ∈ (0 , ∞ ) n and temperature τ ∈ (0 , ∞ ) , then:
Revised: ) with location parameters α ∈ (0 , ∞ ) n and temperature τ ∈ (0 , ∞ ) , then:

Original: • P ( X k > X 
Revised: • P ( X k > X i ,

Original: i , ∀ i ̸ =

Original: [Equation]
Revised: [Equation]

Original: ) = [Equation] • P (limτ → 0 X k =
Revised: • P (lim

Original: [Equation]
Revised: [Equation]

Original: ) =
Revised: →

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: This result can be similarly proved as Lemma 2.
Revised: This result can be similarly proved as Lemma 2.

Original: The event of interests X k >
Revised: The event of interests X k >

Original: X
Revised: X

Original: i , ∀ i ̸
Revised: i , ∀ i ̸

Original: = k is equivalent to
Revised: = k is equivalent to

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: Since all the above inequalities are independent given u k , we can rearrange the first inequality as
Revised: Since all the above inequalities are independent given u k , we can rearrange the first inequality as

Original: [Equation]
Revised: [Equation]

Original: Since u 1 ∼ U [0 , 1] , the probability for the first inequality in Eqn.
Revised: Since u 1 ∼ U [0 , 1] , the probability for the first inequality in Eqn.

Original: 22 being true would be u α 1 /α k k .
Revised: 26 being true would be u α 1 /α k k .

Original: Thus, the probability for Eqn.
Revised: Thus, the probability for Eqn.

Original: 22 being true can be calculated via
Revised: 26 being true can be calculated via

Original: [Equation]
Revised: [Equation]

Original: For simplicity, we assume
Revised: For simplicity, we assume

Original: [Equation]
Revised: [Equation]

Original:  i = 1 .
Revised: n i =1 α i = 1 .

Original: Then for any g k ∈ [0 , 1] , we obtain
Revised: Then for any g k ∈ [0 , 1] , we obtain

Original: [Equation]
Revised: [Equation]

Original: and arrive at the result for the first bullet point.
Revised: and arrive at the result for the first bullet point.

Original: For the second bullet point, when τ → 0 , we have
Revised: For the second bullet point, when τ → 0 , we have

Original: [Equation]
Revised: [Equation]

Original: Such a fact indicates that the output of a Concrete distribution with τ → 0 will be a one-hot vector ( X argmax i
Revised: Such a fact indicates that the output of a Concrete distribution with τ → 0 will be a one-hot vector ( X argmax i

Original: α i
Revised: α i

Original: = 1 ).
Revised: = 1 ).

Original: This yields the conclusion that
Revised: This yields the conclusion that

Original: [Equation]
Revised: [Equation]

Original: Now we turn to the proof of our theorem.
Revised: Now we turn to the proof of our theorem.

Original: We are to prove that the kernelized form in Eqn.
Revised: We are to prove that the kernelized form in Eqn.

Original: 7 has the same property as the original Gumbel-Softmax in the limit sense (when τ goes to zero).
Revised: 7 has the same property as the original Gumbel-Softmax in the limit sense (when τ goes to zero).

Original: We recall that we have defined q u = W ( l ) Q z ( l ) u , k u = W ( l ) K z ( l ) u and v u = W ( l ) V z ( l ) u for simplicity.
Revised: We recall that we have defined q u = W ( l ) Q z ( l ) u , k u = W ( l ) K z ( l ) u and v u = W ( l ) V z ( l ) u for simplicity.

Original: First, by definition we have
Revised: First, by definition we have

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: The property holds that for ∀ w ̸ = v , we have lim τ 
Revised: The property holds that for ∀ w ̸ = v , we have lim τ → 0 ϕ (

Original: [Equation]
Revised: [Equation]

Original: ϕ
Revised: ϕ

Revised: [Equation]

Revised: τ

Original: [Equation]
Revised: [Equation]

Revised: ⊤ ϕ

Original:  equals to ∞ or 0, i.e. the output of the kernelized Gumbel-Softmax is still a one-hot vector when τ → 0 .
Revised: [Equation] τ [Equation] gwτ equals to ∞ or 0, i.e. the output of the kernelized Gumbel-Softmax is still a one-hot vector when τ → 0 .

Original: Let
Revised: Let

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: Here Y v is defined in the same way as c uv in Section 3.2.
Revised: Here Y v is defined in the same way as c uv in Section 3.2.

Original: We thus have P (lim τ → 0 Y v = 1) =
Revised: We thus have P (lim τ → 0 Y v = 1) =

Original: P ( Y v > Y v ′ , ∀ v ′ ̸
Revised: P ( Y v > Y v ′ , ∀ v ′ ̸

Original: = v ) .
Revised: = v ) .

Original: To compute P ( Y v > Y v ′ , ∀ v ′ ̸ = v ) , for simplicity, let us consider the probability P
Revised: To compute P ( Y v > Y v ′ , ∀ v ′ ̸ = v ) , for simplicity, let us consider the probability P

Original: ( Y v > Y v ′ )
Revised: ( Y v > Y v ′ )

Original: =
Revised: =

Original: P ( ϕ ( q u √ τ )
Revised: P ( ϕ ( q u √ τ )

Original: ⊤ ϕ
Revised: ⊤ ϕ

Original: ( k v √ τ ) e gvτ > ϕ ( q u √ τ )
Revised: ( k v √ τ ) e gvτ > ϕ ( q u √ τ )

Original: ⊤ ϕ
Revised: ⊤ ϕ

Original: ( k v ′ √ τ ) e gv ′ τ ) .
Revised: ( k v ′ √ τ ) e gv ′ τ ) .

Original: To keep notation clean, we define
Revised: To keep notation clean, we define

Original: [Equation]
Revised: [Equation]

Revised: [Equation]

Original: Then the above-mentioned probability can be rewritten as P (log β v + g v τ > log β v ′
Revised: Then the above-mentioned probability can be rewritten as P (log β v + g v τ > log β v ′

Original: + g v ′ τ ) , where β v and β v ′ are two i.i.d.
Revised: + g v ′ τ ) , where β v and β v ′ are two i.i.d.

Original: random variables.
Revised: random variables.

Original: From Lemma 1, we have E ( β v ) =
Revised: From Lemma 1, we have E ( β v ) =

Original: exp( q ⊤ u k v /τ )
Revised: exp( q ⊤ u k v /τ )

Original: =
Revised: =

Original: α 1 τ v , E ( β v ′ )
Revised: α 1 τ v , E ( β v ′ )

Original: =
Revised: =

Original: exp( q ⊤ u k v ′ /τ )
Revised: exp( q ⊤ u k v ′ /τ )

Original: =
Revised: =

Original: α 1 τ v ′ , where α v and α v ′ are two constant values.
Revised: α 1 τ v ′ , where α v and α v ′ are two constant values.

Original: Then using Lemma 2, we have
Revised: Then using Lemma 2, we have

Original: [Equation]
Revised: [Equation]

Original: According to the Chebyshev’s inequality, we have P ( | β v − α 1 τ v | ≤ ϵ v ) ≥ 1 − σ 2 v ϵ 2 v .
Revised: According to the Chebyshev’s inequality, we have P ( | β v − α 1 τ v | ≤ ϵ v ) ≥ 1 − σ 2 v ϵ 2 v .

Original: Here σ 2 v =
Revised: Here σ 2 v =

Original: V w ( (cid:100)
Revised: V w ( (cid:100)

Original: SM m ( q u √ τ , k j √ τ )) , which can given by Lemma1.
Revised: [Equation] ) , which can given by Lemma

Original: Due to the convexity of logarithmic function, we have
Revised: Due to the convexity of logarithmic function, we have

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: and subsequently,
Revised: and subsequently,

Original: [Equation]
Revised: [Equation]

Original: Therefore we have P ( | log β v −1 τ log α v | ≤
Revised: Therefore we have P ( | log β [Equation] −

Original: [Equation]
Revised: [Equation]

Original: 1 τ v | ≤ ϵ v ) .
Revised: | ≤ ϵ v ) .

Original: Based on this, we can derive the result:
Revised: Based on this, we can derive the result:

Original: [Equation]
Revised: [Equation]

Original: Since β v and β v ′ are two i.i.d.
Revised: Since β v and β v ′ are two i.i

Revised: [Equation]

Original:  random variables, we have
Revised: d. random variables [Equation] we have

Original: [Equation]
Revised: [Equation]

Original: For simplicity, we denote ϵ =
Revised: For simplicity [Equation] we denote ϵ =

Original: [Equation]
Revised: [Equation]

Original: and P ϵ =
Revised: and P ϵ =

Original: [Equation]
Revised: (1 − σ 2 v ϵ 2 v )(1 − σ 2 v ′

Original: [Equation]
Revised: ϵ 2 v ′ ) .

Original: We therefore have
Revised: We therefore have

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: Using the triangular inequality, we can yield
Revised: Using the triangular inequality, we can yield

Original: [Equation]
Revised: [Equation]

Original: Combining Eqn. 36 and [Equation] we have
Revised: Combining Eqn. 40 and 41, we have

Original: [Equation]
Revised: [Equation]

Original: Let c = log β v − log β v ′ , so that E ( c ) = 1 τ (log α v − log α v ′ ) .
Revised: Let c = log β v − log β v ′ , so that E ( c ) = 1 τ (log α v − log α v ′ ) .

Original: From Eqn.
Revised: From Eqn.

Original: [Equation]

Original:  we can obtain
Revised: 42, we can obtain

Original: [Equation]
Revised: [Equation]

Original: [Equation] According to Lemma [Equation] the probability P ( E ( c ) − ϵ ≥ g v ′ − g v τ ) can be written as
Revised: According to Lemma 2, the probability P ( E ( c ) − ϵ ≥ g v ′ − g v τ ) can be written as

Original: [Equation]
Revised: [Equation]

Original: Since c, g v , g v ′ are generated independently, combining Eqn. 39 and 40, we can yieldP ( c ≥ g [Equation] [Equation]
Revised: Since c, g v , g v ′ are generated independently, combining Eqn. 43 and 44, we can yield

Original: g

Original: [Equation]
Revised: [Equation]

Original: Similarly, from Eq.
Revised: Similarly, from Eq.

Original: 38 we have P ( c ≤ E ( c ) + ϵ ) ≥ P ϵ and subsequently,
Revised: 42 we have P ( c ≤ E ( c ) + ϵ ) ≥ P ϵ and subsequently,

Original: [Equation]
Revised: [Equation]

Original:  Thus we have P ( c ≤ g v ′ − g v τ ) ≥ P ϵ (1 − 1 1+ αv ′ αv e − τϵ ) and also
Revised: [Equation] Thus we have P ( c ≤ g [Equation]

Original: P
Revised: g

Original: [Equation]
Revised: [Equation]

Original: c ≥ g v ′ − g v τ
Revised: ) ≥ P ϵ ( [Equation] ) and also

Original: [Equation]
Revised: [Equation]

Original: Combining Eqn. 41 and 43, we conclude that
Revised: Combining Eqn. 45 and 47, we conclude that

Original: [Equation]
Revised: [Equation]

Original: Based on this we consider the limitation for two sides and thus obtain
Revised: Based on this we consider the limitation for two sides and thus obtain

Original: [Equation]
Revised: [Equation]

Original: [Equation]

Original: Then with similar reasoning as Lemma 3, we have
Revised: Then with similar reasoning as Lemma 3, we have

Original: [Equation]
Revised: [Equation]

Original: Recall that
Revised: Recall that

Original: [Equation]
Revised: [Equation]

Original: where x = q u √ τ , y =
Revised: where x = q u √ τ , y =

Original: k v,v ′ √ τ .
Revised: k v,v ′ √ τ .

Original: Therefore, P ϵ is dependent of the precision ϵ v , ϵ v ′ , the random feature dimension m , and the temperature τ .
Revised: Therefore, P ϵ is dependent of the precision ϵ v , ϵ v ′ , the random feature dimension m , and the temperature τ .

Original: If m is sufficiently large, σ would converge to zero and P ϵ goes to 1.
Revised: If m is sufficiently large, σ would converge to zero and P ϵ goes to 1.

Original: In such a case, Eqn. 46 holds once τ tends to zero.
Revised: In such a case, Eqn. 50 holds once τ tends to zero.

Original: We thus conclude the proof.
Revised: We thus conclude the proof.

Original: A.3 Proof for Proposition
Revised: B.3 Proof for Proposition

Original: According to our definitions in Section 5, we have
Revised: According to our definitions in Section 5, we have

Original: [Equation]
Revised: [Equation]

Original: Since we assume q ϕ can exploit arbitrary distributions over ˜ A , we know that when the ELBO is optimized to the optimum, D KL ( q ϕ (
Revised: Since we assume q ϕ can exploit arbitrary distributions over ˜ A , we know that when the ELBO is optimized to the optimum, D KL ( q ϕ (

Original: ˜ A
Revised: ˜ A

Original: | X , A ) ∥ p ( ˜ A | Y , X , A ))
Revised: | X , A ) ∥ p ( ˜ A | Y , X , A ))

Original: = 0 holds.
Revised: = 0 holds.

Original: Otherwise, there exists ϕ ∗ ̸
Revised: Otherwise, there exists ϕ ∗ ̸

Original: = ϕ such that ELBO ( θ, ϕ ∗ ) >
Revised: = ϕ such that ELBO ( θ, ϕ ∗ ) >

Original: ELBO ( θ, ϕ ) .
Revised: ELBO ( θ, ϕ ) .

Original: Pushing further, when the optimum is achieved, log p θ ( Y | X , A ) would equal to ELBO and namely is maximized.
Revised: Pushing further, when the optimum is achieved, log p θ ( Y | X , A ) would equal to ELBO and namely is maximized.

Original: B Implementation Details
Revised: C Implementation Details

Original: We present implementation details in our experiments for reproducibility.
Revised: We present implementation details in our experiments for reproducibility.

Original: We implement our model as well as the baselines with Python 3.8, Pytorch 1.8 and Pytorch Geometric 2.0.
Revised: For more concrete details concerning architectures and hyper-parameter settings for N ODE F ORMER , one can directly refer to our public repository https://github.com/qitianwu/NodeFormer . We next present descriptions for baseline models’ implementation.

Original: For baseline models MLP, GCN, GAT, MixHop and JKnet, we use the implementation provided by [20] 3 .
Revised: For baseline models MLP, GCN, GAT, MixHop and JKnet, we use the implementation provided by [20] 3 .

Original: For DropEdge and two structure learning baseline models (LDS and IDGL), we also refer to their implementation provided by the original papers [27, 11, 4].
Revised: For DropEdge and two structure learning baseline models (LDS and IDGL), we also refer to their implementation provided by the original papers [27, 11, 4].

Original: Concretely, we use GCN as the backbone for them.
Revised: Concretely, we use GCN as the backbone for them.

Original: B.1 Details for Node Classification Experiments  
Revised: C.1 Details for Node Classification Experiments in Sec. 4.

Original: Architectures.
Revised: Architectures.

Original: For experiments on the datasets Cora , Citeseer , Deezer and Actor , the baseline models (GCN, GAT, MixHop, JKNet) are implemented with the following settings:
Revised: For experiments on the datasets Cora , Citeseer , Deezer and Actor , the baseline models (GCN, GAT, MixHop, JKNet) are implemented with the following settings:

Original: 3 https://github.com/CUAI/Non-Homophily-Benchmarks.

Original: • Two GNN layers with hidden size 32 by default (unless otherwise mentioned).
Revised: • Two GNN layers with hidden size 32 by default (unless otherwise mentioned).

Original: GAT uses 8 attention heads followed by its original setting.
Revised: GAT uses 8 attention heads followed by its original setting.

Original: • The activation function is ReLU (except GAT using ELU).
Revised: • The activation function is ReLU (except GAT using ELU).

Original: The architecture of our N ODE F ORMER is specified as follows:
Revised: The architecture of our N ODE F ORMER is specified as follows:

Original: • Two message-passing layers with hidden size 32, andwe use 4 attention heads for each layer.
Revised: • Two message-passing layers with hidden size 32. We also consider multi-head designs for our all-pair attentive message passing, and for each head we use independent parameterization.

Revised: The results for different heads are combined in an average manner in each layer.

Original: • The activation function is ELU, and we  specify σ as sigmoid functionto bound the relational bias. For experiments on the two large datasets (OGB-Proteins andAmazon2M), we implement N ODEF ORMER with 3 layers with hidden size 64 for better model capacity. We consider  the same layer number and hidden size for competitors MLP and GCN
Revised: • The activation function is ELU that is only used for input MLP, and we do not use any activation for the feature propagation layers. In terms of relational bias, we specify σ as sigmoid function and consider 2-order adjacency to strengthen the observed links of the input graph.

Original: Training Details.
Revised: Training Details.

Original: In each epoch, we feed the whole data into the model (except on Amazon2M for which we use mini-batch partition as we mentioned in Section 4.1), calculate the loss and conduct gradient descent accordingly.
Revised: In each epoch, we feed the whole data into the model, calculate the loss and conduct gradient descent accordingly.

Original: Concretely, we use BCE-Loss for two-class classification and NLLLoss for multi-class classification, the Adam optimizer is used for gradient-based optimization.
Revised: Concretely, we use BCE-Loss for two-class classification and NLL-Loss for multi-class classification, the Adam optimizer is used for gradient-based optimization.

Original: The training procedure will repeat the above process until a given budget of 500 epochs.
Revised: The training procedure will repeat the above process until a given budget of 1000 epochs.

Original: Finally, we report the test accuracy achieved by the epoch that gives the highest accuracy on validation dataset.
Revised: Finally, we report the test accuracy achieved by the epoch that gives the highest accuracy on validation dataset

Original: Hyperparameters.

Original: For each model, we use grid search on validation set for hyper-parameter setting.
Revised: For each model, we use grid search on validation set for hyper-parameter setting.

Original: The learning rate is searched within { 0 . 01 , 0 . 001 , 0 . 0001 , 0 . 00001 }, weight decay within {0 . 05 , 0 . 005 , 0 . 0005 , 0 . 00005 } , and dropout probability within { 0 . 0 , 0 .
Revised: learning rate is searched within { 0 . 01 , 0 . 001 , 0 . 0001 , 0 . 00001 } weight decay within {

Original: 5 } The hyperparameters for the models are set as follows (we use the same notation as the original papers).
Revised: probability

Original: • For GCN and GAT, the learning rate is 0.01, and weight decay is set to 0.05.
Revised: • For GCN and GAT, the learning rate is 0.01, and weight decay is set to 0.05.

Original: No dropout is used.
Revised: No dropout is used.

Original: • For MixHop, the hyperparameters are the same as above, except that we further use grid search for hidden channels within {8, 16, 32, 64, 128}.
Revised: • For MixHop, the hyperparameters are the same as above, except that we further use grid search for hidden channels within {8, 16, 32, 64, 128}.

Original: We adopt 2 hops for all the four datasets.
Revised: We adopt 2 hops for all the four datasets.

Original: • For JKNet, GCN is used as the backbone.
Revised: • For JKNet, GCN is used as the backbone.

Original: Learning rate is set to 0.01 for Deezer and 0.001 for all the other three datasets.
Revised: Learning rate is set to 0.01 for Deezer and 0.001 for all the other three datasets.

Original: We concatenate the features in the final stage for Deezer, while we use max-pooling for the three other datasets.
Revised: We concatenate the features in the final stage for Deezer, while we use max-pooling for the three other datasets.

Original: The hidden size is set as default, except for Deezer as 64.
Revised: The hidden size is set as default, except for Deezer as 64.

Original: • For DropEdge, the hidden size is chosen from {32, 64, 96, 128, 160}, the learning rate is within {0.01, 0.001, 0.0001}, and the dropedge rate is chosen from {0.3, 0.4, 0.5}.
Revised: • For DropEdge, the hidden size is chosen from {32, 64, 96, 128, 160}, the learning rate is within {0.01, 0.001, 0.0001}, and the dropedge rate is chosen from {0.3, 0.4, 0.5}.

Original: • For LDS, the sampling time S = 16 , the patience window size ρ = 6 , the hidden size ∈ {8, 16, 32, 64}, the inner learning rate γ ∈ {1e-4, 1e-3, 1e-2, 1e-1}, and the number of updates used to compute the truncated hypergradient τ ∈ {5, 10, 15}.
Revised: • For LDS, the sampling time S = 16 , the patience window size ρ = 6 , the hidden size ∈ {8, 16, 32, 64}, the inner learning rate γ ∈ {1e-4, 1e-3, 1e-2, 1e-1}, and the number of updates used to compute the truncated hypergradient τ ∈ {5, 10, 15}.

Original: • For IDGL, we use its original version without anchor approximation on Cora , Citeseer and Actor .
Revised: • For IDGL, we use its original version without anchor approximation on Cora , Citeseer and Actor .

Original: For Deezer , even using anchor approximation, it would also suffer from out-of-memory.
Revised: For Deezer , even using anchor approximation, it would also suffer from out-of-memory.

Original: Besides, we set: ϵ = 0 .
Revised: Besides, we Architectures.

Original: 01 , hidden size ∈ {16, 64, 96, 128}, λ ∈ {0.5, 0.6, 0.7, 0.8}, η ∈ {0, 0.1, 0.2}, α ∈ {0, 0.1, 0.2}, β ∈ {0, 0.1}, γ ∈ {0.1, 0.2}, m ∈ {6, 9, 12}.
Revised: For experiments on the two large datasets (OGB-Proteins and Amazon2M), the baseline models are implemented with the following settings: • Three GNN layers with hidden size 64.

Original: • For our N ODE F ORMERmodel, on Cora and Citeseer , the learning rate is 0.001 and weight decay is 0.005.
Revised: • The activation function is ReLU (except GAT using ELU). The architecture of our N ODE F ORMER is specified as follows:

Original: The learning rate is 1e-5 for Deezer and 1e-4 for Actor , and the weight decay are set as 0.05. For OGB-Proteins and Amazon2M , the learning rate is 0.01 and no weight decaying is used. No dropout is used for all datasets.
Revised: • Three message-passing layers with hidden size 64.

Original: The temperature τ is set to 0.25.
Revised: The head number is set as 1.

Original:  The weight λ is set to 1 for Cora , Citeseer , 0.01 for Actor , Deezer , Amazon2m and 0.1 for OGB-Proteins . The sampling number K is set as 5 for two large datasets and 10 for others.
Revised: • The activation function is ELU that is used for all the layers. In terms of relational bias, we specify σ as identity function and consider 1-order adjacency to strengthen the observed links of the input graph.

Revised: Training Details.

Revised: In each epoch, we use random mini-batch partition to split the whole set of nodes and feed each mini-batch of nodes into the model for all-pair propagation, as we mentioned in

Revised: Section 4.1.

Original:  The dimension of feature map m is 30.
Revised: Similarly, we use BCE-Loss for two-class classification and NLL-Loss for multi-class classification, the Adam optimizer is used for gradient-based optimization. The training procedure will repeat the above process until a given budget of 1000 epochs. The evaluation on testing data is conducted on CPU which enables full-batch feature propagation. Finally, we report the test accuracy achieved by the epoch that gives the highest accuracy on validation dataset.

Original: B.2 Details for Graph-Enhanced Experiments  
Revised: C.3 Details for Graph-Enhanced Experiments in Sec. 4.

Original: Architectures.
Revised: Architectures.

Original: The architectures of baselines (GCN, GAT, LDS and IDGL) and N ODE F ORMER model are the same as the transductive setting, except that we use grid search to adaptively tune the hidden size.
Revised: The architectures of baselines (GCN, GAT, LDS and IDGL) and N ODE F ORMER model are the same as the transductive setting, except that we use grid search to adaptively tune the hidden size.

Original: Besides, we also adopt BatchNorm for baseline models.
Revised: Besides, we also adopt BatchNorm for baseline models.

Original: Training Details.
Revised: Training Details.

Original: The input data have no graph structures in this setting.
Revised: The input data have no graph structures in this setting.

Original: As mentioned in Section 4.3, we use k -NN for artificially constructing a graph to enable message passing.
Revised: As mentioned in Section 4.3, we use k -NN for artificially constructing a graph to enable message passing.

Original: The training procedure is the same as the transductive setting.
Revised: The training procedure is the same as the transductive setting.

Original: Hyperparameters.
Revised: Hyperparameters

Revised: The

Original: The hyperparameters for the models are listed as follows.
Revised: hyperparameters for baseline models are listed as follows.

Original: • For GCN, the learning rate is 0.01 and the weight decay is 5e-4 on both datasets.
Revised: • For GCN, the learning rate is 0.01 and the weight decay is 5e-4 on both datasets.

Original: The size of hidden channel is set to 64.
Revised: The size of hidden channel is set to 64.

Original: Dropout is not used during training.
Revised: Dropout is not used during training.

Original: • For GAT, the learning rate is 0.001 and the weight decay is 5e-3 on both datasets.
Revised: • For GAT, the learning rate is 0.001 and the weight decay is 5e-3 on both datasets.

Original: The size of hidden channel is 32 on Mini-ImageNet and 64 on 20News .
Revised: The size of hidden channel is 32 on Mini-ImageNet and 64 on 20News .

Original: No dropout is used during training.
Revised: No dropout is used during training.

Original: The number of attention heads is 8.
Revised: The number of attention heads is 8.

Original: • For LDS, its hyperparameters are determined by grid search in the same manner as in the transductive setting.
Revised: • For LDS, its hyperparameters are determined by grid search in the same manner as in the transductive setting.

Original: • For IDGL, we use its anchor-based version that can scale to these two datasets.
Revised: • For IDGL, we use its anchor-based version that can scale to these two datasets.

Original: Besides, on 20News , we set: hidden size=64, learning rate=0.01 λ = 0 .
Revised: Besides, on 20News , we set: hidden size=64, learning rate=0.01 λ = 0 .

Original: 7 , η = 0 .
Revised: 7 , η = 0 .

Original: 1 , α = 0 .
Revised: 1 , α = 0 .

Original: 1 , β = 0 , γ = 0 .
Revised: 1 , β = 0 , γ = 0 .

Original: 1 , ϵ = 0 .
Revised: 1 , ϵ = 0 .

Original: 01 , m = 12 .
Revised: 01 , m = 12 .

Original: On Mini-ImageNet , we set: hidden size=96, learning rate=0.01 λ = 0 .
Revised: On Mini-ImageNet , we set: hidden size=96, learning rate=0.01 λ = 0 .

Original: 8 , η = 0 .
Revised: 8 , η = 0 .

Original: 2 , α = 0 , β = 0 , γ = 0 .
Revised: 2 , α = 0 , β = 0 , γ = 0 .

Original: 1 , ϵ = 0 .
Revised: 1 , ϵ = 0 .

Original: 01 , m = 12 .
Revised: 01 , m = 12 .

Original: • For our N ODE F ORMER model, the size of hidden channels is 64 on 20News , and 128 on Mini-ImageNet .

Original: The number of attention heads is set to 6 on Mini-ImageNet and 4 on 20News .

Original: For both datasets, the learning rate is 0.001, and the weight decay is 0.005.

Original: The weight λ is set to 1.

Original: The temperature τ is set to 0.25 for both datasets.

Original: The number of samples K is 10, and the dimension of feature map m is 30.

Original: No dropout is used during training.

Original: C Dataset Information
Revised: D Dataset Information

Original: We present detailed information for our used datasets concerning the data collection, preprocessing and statistic information.
Revised: We present detailed information for our used datasets concerning the data collection, preprocessing and statistic information.

Original: Table 5 provides an overview of the datasets we used in the experiment.
Revised: Table 5 provides an overview of the datasets we used in the experiment.

Original: C.1 Dataset Information
Revised: D.1 Dataset Information

Original: [Table]

Original: Social network non-homophilous 28, 92, 31,

Original: [Table]

Original: Actors in movies non

Original: [Table]

Original: [Table]

Original: Protein interaction multi

Original: [Table]

Original: [-classification 132, 39,561,  
-]
Revised: [-classification 132, 39,561,  
-]

Original: Amazon2M

Original: [Table]

Original: [Table]

Original: long-

Original: [Table]

Original: dependence 2,449,029 61,859,

Original: [Table]

Original: no

Original: [Table]

Original: [Table]

Original: [Table]

Original: graph 18,

Original: [Table]

Original: [Table]

Original: Text classification no graph/

Original: [Table]

Original: -NN graph 9,

Original: Node Classification Datasets.
Revised: Node Classification Datasets.

Original: For experiments on transductive node classification, we evaluate our model on two homophilous datasets Cora and Citeseer [32], and other two non-homophilous datasets Actor [25] and Deezer [28].
Revised: For experiments on transductive node classification, we evaluate our model on two homophilous datasets Cora and Citeseer [32], and other two non-homophilous datasets Actor [25] and Deezer [28].

Original: The first two are citation network datasets that contain sparse bag-of-words feature vectors for each document and a list of citation links between documents.
Revised: The first two are citation network datasets that contain sparse bag-of-words feature vectors for each document and a list of citation links between documents.

Original: The citation links are treated as (undirected) edges and each document has a class label.
Revised: The citation links are treated as (undirected) edges and each document has a class label.

Original: Deezer is a social network of users on Deezer from European countries, where edges represent mutual follower relationships.
Revised: Deezer is a social network of users on Deezer from European countries, where edges represent mutual follower relationships.

Original: The node features are based on artists liked by each user and nodes are labeled  with reported gender.
Revised: The node features are based on artists liked by each user and nodes are labeled [Table] with reported gender.

Original: Actor is a graph representing actor co-occurrence in Wikipedia pages.
Revised: Actor is a graph representing actor co-occurrence in Wikipedia pages.

Original: Each node corresponds to an actor, and the edge between two nodes denotes co-occurrence on the same
Revised: Each node corresponds to an actor, and the edge between two nodes denotes co-occurrence on the same

Original: Wikipedia page.
Revised: Wikipedia page.

Original: Node features correspond to some keywords in the Wikipedia pages and the nodes are classified into five categories w.r.t.
Revised: Node features correspond to some keywords in the Wikipedia pages and the nodes are classified into five categories w.r.t.

Original: words of actor’s Wikipedia.
Revised: words of actor’s Wikipedia.

Original: These four datasets are relatively small with thousands of instances and edges ( Deezer is the largest one with nearly 20K nodes).
Revised: These four datasets are relatively small with thousands of instances and edges ( Deezer is the largest one with nearly 20K nodes).

Original: To evaluate N ODE F ORMER ’s scalability, we further consider two large datasets: OGB-Proteins [15] and Amazon2M [5].
Revised: To evaluate N ODE F ORMER ’s scalability, we further consider two large datasets: OGB-Proteins [15] and Amazon2M [5].

Original: These two datasets have million-level nodes and edges and require the model for scalable training.
Revised: These two datasets have million-level nodes and edges and require the model for scalable training.

Original: The OGB-Proteins dataset is an undirected, and typed (according to species) graph in which nodes represent proteins and edges indicate different types of biologically meaningful associations between proteins.
Revised: The OGB-Proteins dataset is an undirected, and typed (according to species) graph in which nodes represent proteins and edges indicate different types of biologically meaningful associations between proteins.

Original: All edges come with 8-dimensional features, where each dimension represents the approximate confidence of a single association type and takes on values betweenand 1.
Revised: All edges come with 8-dimensional features, where each dimension represents the approximate confidence of a single association type and takes on values betweenand 1.

Original: The proteins come from 8 species and our task is to predict the presence of 112 protein functions in a multi-label binary classification setup respectively.
Revised: The proteins come from 8 species and our task is to predict the presence of 112 protein functions in a multi-label binary classification setup respectively.

Original: Amazon2M is extracted from
Revised: Amazon2M is extracted from

Original: Amazon Co-Purchasing network [23], where each node represents a product, and the graph link represents whether two products are purchased together, the node features are generated by extracting bag-of-word features from the product descriptions.
Revised: Amazon Co-Purchasing network [23], where each node represents a product, and the graph link represents whether two products are purchased together, the node features are generated by extracting bag-of-word features from the product descriptions.

Original: The top-level categories are used as labels for the products.
Revised: The top-level categories are used as labels for the products.

Original: Graph-enhanced Application Datasets.
Revised: Graph-enhanced Application Datasets.

Original: We evaluate our model on two datasets without graph structure: 20News-Groups [24] and Mini-ImageNet [37].
Revised: We evaluate our model on two datasets without graph structure: 20News-Groups [24] and Mini-ImageNet [37].

Original: The 20News dataset is a collection of approximately 20,000 newsgroup documents (nodes), partitioned (nearly) evenly across 20 different newsgroups.
Revised: The 20News dataset is a collection of approximately 20,000 newsgroup documents (nodes), partitioned (nearly) evenly across 20 different newsgroups.

Original: We take 10 classes from 20 newsgroups and use words (TFIDF) with a frequency of more than 5% as features.
Revised: We take 10 classes from 20 newsgroups and use words (TFIDF) with a frequency of more than 5% as features.

Original: The Mini-ImageNet dataset consists of 84 × 84 RGB images fromdifferent classes with 600 samples per class.
Revised: The Mini-ImageNet dataset consists of 84 × 84 RGB images fromdifferent classes with 600 samples per class.

Original: For our experiment use, we choose 30 classes from the dataset, each with 600 images (nodes) that have 128 features extracted by CNN.
Revised: For our experiment use, we choose 30 classes from the dataset, each with 600 images (nodes) that have 128 features extracted by CNN.

Original: C.2 Dataset Preprocessing
Revised: D.2 Dataset Preprocessing

Original: All the datasets we used in the experiment are directly collected from the source, except
Revised: All the datasets we used in the experiment are directly collected from the source, except

Original: Mini-ImageNet , whose features are extracted by ourselves.
Revised: Mini-ImageNet , whose features are extracted by ourselves.

Original: Following the setting of [30], we compute node embeddings via a CNN model with 4 convolutional layers followed by a fully-connected layer resulting in a 128 dimensional embedding.
Revised: Following the setting of [30], we compute node embeddings via a CNN model with 4 convolutional layers followed by a fully-connected layer resulting in a 128 dimensional embedding.

Original: Finally, the 128 dimensional outputs are treated as the features of the nodes (images) for subsequent GNN-based downstream task.
Revised: Finally, the 128 dimensional outputs are treated as the features of the nodes (images) for subsequent GNN-based downstream task.

Original: D More Experiment Results
Revised: E More Experiment Results

Original: We present extra ablation study results on the four transductive datasets for N ODE F ORMER w/ and w/o relational bias and edge-level regularization.
Revised: We present extra ablation study results on the four transductive datasets for N ODE F ORMER w/ and w/o relational bias and edge-level regularization.

Original: Fig.
Revised: Fig.

Original: 5 studies the impact of the temperature τ and the dimension of feature map m on Cora .
Revised: 6 studies the impact of the temperature τ and the dimension of feature map m on Cora .

Original: Furthermore, we visualize the attention maps of two model layers and compare with original input graphs of Cora , Citeseer , Deezer and Actor in Fig. 
Revised: Furthermore, we visualize the attention maps of two model layers and compare with original input graphs of Cora , Citeseer , Deezer and Actor in Fig. [Table] [Figure] [Figure]

Revised: Citeseer

Original: [Table]
Revised: [Figure] Actor [Figure] u t

Revised: G r a p h

Revised: L a y e r

Revised: L

Original: [Figure]
Revised: [Figure]

Original: E Current Limitations, Outlooks and Potential Impacts
Revised: F Current Limitations, Outlooks and Potential Impacts

Original: Current Limitations.
Revised: Current Limitations.

Original: In the present work, we focus on node classification for experiments, though
Revised: In the present work, we focus on node classification for experiments, though

Original: N ODE F ORMER can be used as a flexible (graph) encoder for other graph-related problems such as graph classification, link prediction, etc.
Revised: N ODE F ORMER can be used as a flexible (graph) encoder for other graph-related problems such as graph classification, link prediction, etc.

Original: Beyond testing accuracy, social aspects like robustness and explainability can also be considered as the target for future works on top of N ODE F ORMER .
Revised: Beyond testing accuracy, social aspects like robustness and explainability can also be considered as the target for future works on top of N ODE F ORMER .

Original: Potential Impact.
Revised: Potential Impact.

Original: Besides facilitating better node representations via message passing, graph structure learning also plays as key components in many other perpendicular problems in graph learning community, like explainability [46], adversarial robustness [49], training acceleration [33], handling feature extrapolation [40] and cold-start users in recommendation [41].N ODE F ORMER Cora Citeseer
Revised: Besides facilitating better node representations via message passing, graph structure learning also plays as key components in many other perpendicular problems in graph learning community, like explainability [46], adversarial robustness [49], training acceleration [33], handling feature extrapolation [40] and cold-start users in recommendation [41].

Original: Deezer

Original: Actor

Original: [Figure] L [Figure] can serve as a plug-in scalable structure learning encoder for uncovering underlying dependence, identifying novel structures and purifying noisy data in practical systems.
Revised: N ODE F ORMER can serve as a plug-in scalable structure learning encoder for uncovering underlying dependence, identifying novel structures and purifying noisy data in practical systems.

Original: Another promising direction is to leverage our kernelized Gumbel-Softmax operator as a plug-in module for designing efficient and expressive Transformers on graph data where the large graph size plays a critical performance bottleneck.
Revised: Another promising direction is to leverage our kernelized Gumbel-Softmax operator as a plug-in module for designing efficient and expressive Transformers on graph data where the large graph size plays a critical performance bottleneck.

Original: Pushing further, N ODE F ORMER could be applied to efficiently model the potential inter-dependence among data points for representation learning, which broadly intersects with various learning tasks (e.g., vision, nlp, scientific discovery, etc.)

Original: where the connection among data points exists yet remains unobserved.

Original: As the number of instances can be arbitrarily large across different datasets, modeling the data dependence is often computationally expensive and prohibitive, and

Original: N ODE F ORMER can be used to reduce the overhead and opens new possibility.