---
kind: concept
slug: graph-neural-network
title: Graph neural network
summary: >-
  A graph neural network (GNN) gives each node an embedding by mixing its features with its neighbours'. Covered: forty-eight variants, from pretext-trained and contrastive encoders to lane-topology, weather, traffic and signed-graph models, plus surveys and benchmarks. The trade-off: results depend on task and graph, and the numbers are author-reported.
tags: [graph-learning, message-passing, self-supervised-learning, heterophily, learned-graph-structure, molecular-graph, molecular-fingerprint, knowledge-graph, question-answering, graph-generation, weather-forecasting, multiplex-graph, graph-attention, imputation, trajectory-prediction, distribution-shift, pose-estimation, pretraining, anomaly-detection, skeleton-action-recognition, 3d-object-detection, over-smoothing, generalized-pagerank, combinatorial-optimization, explainability, point-cloud-registration, neural-ode, traffic-forecasting, physics-informed-learning, positional-encoding, graph-transformer, lane-topology, endpoint-detection, graph-augmentation, adversarial-augmentation, linear-attention, node-classification, large-scale-benchmark, signed-graph, directed-graph, frequency-domain, spectral-gnn, edge-sparsification, biomedical-networks]
papers: ["1712.04997", "1908.11540", "2004.08919", "1509.09292", "2011.09643", "2103.00111", "2010.14945", "2104.01111", "1911.06962", "2104.06378", "2201.08860", "2105.05727", "2106.04399", "2209.14734", "2212.12794", "2310.06119", "2310.10196", "2505.01912", "2102.07810", "2103.12340", "2105.02605", "2106.15004", "2108.00298", "2108.09091", "2202.02466", "2204.01855", "2205.12257", "2210.09338", "2303.10876", "1905.00067", "2006.07988", "2104.10330", "2106.06947", "2107.12213", "1906.01629", "2011.04573", "2011.13005", "2106.12931", "2507.05291", "2103.00113", "2106.05234", "2110.07875", "2208.05233", "2303.14483", "2307.03759", "2405.14747", "2505.17771", "2504.01989", "2106.05819", "2306.08385", "2103.09430", "2407.09777", "2101.11174", "2105.00696", "2206.09113", "2209.00546", "2210.07606", "2311.06190", "2101.10025", "2011.07057", "2003.12962", "2401.00423", "2104.04883"]
related: [emotion-recognition-in-conversation, graph-transformer, linear-attention, random-feature-approximation, information-bottleneck, object-queries, relational-graph-convolution, contrastive-learning, data-augmentation, self-supervised-learning, adversarial-robustness, attention-mechanism, self-attention, recurrent-neural-network, time-series-forecasting, scene-graph-generation, knowledge-graph-completion, knowledge-graph-reasoning, commonsense-knowledge-injection, language-model-pretraining, masked-language-modeling, molecular-representation-learning, diffusion-models, discrete-diffusion, equivariance-constraint, euclidean-equivariant-network, benchmark-validity, semi-supervised-learning, node-embedding, attributed-network-embedding, dynamic-graph-embedding, domain-generalization, imitation-learning, perspective-n-point, generalized-pagerank, temporal-convolutional-network, anomaly-detection, object-detection, stochastic-block-model, bev-representation, bird-eye-view-perception, branch-and-bound, explainable-ai, finite-element-method, physics-informed-neural-network, surrogate-modeling, local-feature-matching, metric-learning, positional-encoding, multi-layer-perceptron, spectral-methods, frequency-domain-learning]
status: draft
updated_at: 2026-11-01
---

## Overview

A graph neural network takes node features and the adjacency structure of a
graph and returns an embedding for each node. An optional readout turns the
node embeddings into one embedding for the whole graph [arxiv:2103.00111 §3.1].
The GNN is usually the encoder in graph self-supervised learning
[arxiv:2103.00111 §3.1].

Graphs differ from images and text because nodes are linked to each other, so
samples are not independent [arxiv:2103.00111 §1]. A GNN handles this by
letting each node's representation depend on its neighbours. Most variants
below follow the same aggregate-and-combine form, which the general
message-passing scheme describes [arxiv:1911.06962 eq. 2] [eq. 3].

Fifty-nine cards on wikillm list this concept. Forty-five of them have a
variant below. Forty-three describe one GNN model used for a task. The other
two are surveys whose GNN material is itself a variant: the graph
self-supervision survey gives the first variant, and the scene graph survey
names GNN-based methods as one model family. The remaining fourteen are nine
surveys, four benchmarks and one graph-free baseline, summarised under
Benchmarks and surveys. The surveys do not compare GNN architectures in
depth. The graph-self-supervision survey names GCN and GAT only as baselines
and does not give their equations [arxiv:2103.00111 §8]. The traffic survey
writes out GCN, GAT and DCRNN equations, but its benchmark table mixes papers
with different splits [arxiv:2101.11174 eq. 1–6] [arxiv:2101.11174 tab. 11].

## Variants

### Pretext-trained encoder (graph self-supervised learning)

The encoder $f_\theta$ maps node features $\mathbf{X}$ and the adjacency
matrix $\mathbf{A}$ to node embeddings $\mathbf{H}$. A pretext decoder and a
pretext loss are trained on unlabelled graphs [arxiv:2103.00111 eq. 1]. The
pretext target can be a reconstruction of the graph, an auxiliary property, a
contrast between two augmented views, or a mix of these [arxiv:2103.00111 §3.2].
Three training schemes then combine the encoder with labels:
pre-train and fine-tune, joint learning with a trade-off weight $\alpha$, and
unsupervised representation learning, where the encoder is frozen
[arxiv:2103.00111 §3.3] [eq. 6–8].

The survey gives no training settings for any surveyed method, so learning
rates, depths and widths must come from each method's original paper
[arxiv:2103.00111 §3].

Reported node-classification accuracy, compiled from the cited works: the
self-supervised rows reach 84.7 on Cora and 74.2 on Citeseer, while the GCN
and GAT baselines score 81.5 and 83.0 on Cora and 70.3 and 72.5 on Citeseer
[arxiv:2103.00111 tab. 5]. The rows labelled PF or JL generally score higher
than the URL rows [arxiv:2103.00111 tab. 5].

### Adaptive augmentation for graph contrastive learning (GCA)

Two random views of the same graph are encoded by one two-layer GCN. A
projection head and a cosine critic with a temperature then pull each node's
two embeddings together and push them away from every other node, in both
directions [arxiv:2010.14945 §3.2] [eq. 1] [eq. 2]. The change from earlier
graph contrastive methods is how the views are built. Each edge is kept with
probability one minus a removal rate, and the rate is a capped, log-normalised
function of the edge's centrality score, so central edges tend to survive
[arxiv:2010.14945 §3.3.1] [eq. 3] [eq. 4]. The node score is degree,
eigenvector centrality or PageRank, and the paper names the three choices
GCA-DE, GCA-EV and GCA-PR [§3.3.1] [tab. 3].

Feature dimensions are masked the same way. One mask per view is shared by
all nodes, and each dimension's weight sums the centrality of the nodes that
have it [arxiv:2010.14945 §3.3.2] [eq. 6] [eq. 7] [eq. 8] [eq. 9].

Author-reported linear-probe node classification on five datasets: a GCA
variant is the best label-free row on all five, and above GCN and GAT on four
of them. On Amazon-Photo, GAT is higher than all three GCA variants
[arxiv:2010.14945 tab. 3]. The ablation on Amazon-Computers gives 87.85 for
full adaptive augmentation and 86.25 for uniform edges and features, which
the paper reports as a gain from each adaptive part [arxiv:2010.14945 tab. 4]
[§4.3].

Card: [Graph Contrastive Learning with Adaptive Augmentation](/papers/2010.14945).

### Learned edge dropping for graph contrastive learning (AD-GCL)

AD-GCL replaces hand-picked graph augmentations with a learned one. A GIN
encoder is trained to match each graph with an edge-dropped copy. A separate
GNN augmenter gives every edge a drop probability and is trained to make the
two copies as different as possible. A penalty on the mean drop probability,
weighted by λ_reg, stops it from dropping almost every edge
[arxiv:2106.05819 §3.2] [eq. 6–8]. The two networks are updated in turn, one
minibatch at a time [arxiv:2106.05819 alg. 1]. A Gumbel-max relaxation keeps
the sampled edge mask differentiable [arxiv:2106.05819 §3.2]. The paper links
the objective to the graph information bottleneck, under assumptions it states
[arxiv:2106.05819 §3.1] [app. B].

Author-reported linear-probe accuracy on TU datasets, with λ_reg fixed at 5
(AD-GCL-FIX): on COLLAB it reaches 73.32 against 71.26 for GraphCL
[arxiv:2106.05819 tab. 1]. The paper counts significant wins over InfoGraph
and GraphCL on 5 and 6 of 8 TU datasets [§5.1]. The gains are not uniform. In
the semi-supervised table GraphCL is higher on PROTEINS, 74.17 against 73.96
[tab. 3], and the paper's mean rank across nine transfer datasets is 2.4
[§5.3]. The abstract's headline gains are up to 14%, 6% and 3% for the
unsupervised, transfer and semi-supervised settings [arxiv:2106.05819 abstract].

The paper's code differs from its text in ways that change the numbers. The
dropout default is 0.0 in the code, against 0.5 in the paper's appendix. The
code keeps every edge and weights its messages, where the paper removes edges
[code: unsupervised/convs/gine_conv.py#L52-L53]. The code's contrastive loss
uses a temperature of 0.2 and averages the two directions, which eq. 9 does
not [code: unsupervised/learning/ginfominmax.py#L33]. The original InfoGraph
and GraphCL numbers used an SVM probe, while this paper uses a linear probe,
so the two sets of numbers are not directly comparable [§5.1].

Card: [Adversarial Graph Augmentation to Improve Graph Contrastive Learning](/papers/2106.05819).

### Relation-typed windowed graph over a sequence (DialogueGCN)

In a conversation, each utterance is a node, initialised with features from a
bidirectional GRU that reads the utterances in order
[arxiv:1908.11540 §3.3.1]. Each node is linked to the 10 utterances before it,
the 10 after it, and itself [arxiv:1908.11540 §3.3.2].

Edge weights are a softmax over bilinear scores of the two nodes, normalised
over each node's incoming edges [arxiv:1908.11540 eq. 1]. Each edge also has a
relation type: the speaker of the source, the speaker of the target, and
whether the source comes first [arxiv:1908.11540 §3.3.2] [tab. 1].

The first graph layer uses one weight matrix per relation, with the edge
weights and a self term [arxiv:1908.11540 eq. 2]. The second layer drops the
relation types and uses one shared weight matrix over the window
[arxiv:1908.11540 eq. 3].

Ablations on IEMOCAP, weighted F1 [arxiv:1908.11540 §5.2–§5.3]:

- Full model, window (10, 10): 64.18.
- Window (4, 4): 59.41. Window (0, 0), self-edges only: 55.80.
- Without the graph encoder: 55.30 [arxiv:1908.11540 tab. 5].
- Without speaker-pair relations, before/after kept: 61.03 [arxiv:1908.11540 tab. 6].
- Without before/after relations, speaker pairs kept: 62.52 [arxiv:1908.11540 tab. 6].

Card: [DialogueGCN](/papers/1908.11540).

### Feature-similarity graph added to a GCN (SimP-GCN)

A GCN layer averages each node with its neighbours. The authors argue that
this pulls neighbouring features together and erases the original node
similarity, and that the effect is strongest when linked nodes differ in label
[arxiv:2011.09643 §3]. The share of edges shared by the original graph and a
feature-similarity graph is 0.03% on Actor and 0.91% on Cornell, against 3.88%
on Cora [arxiv:2011.09643 tab. 1].

SimP-GCN extends a two-layer GCN. It builds a second graph that links each
node to its 20 most cosine-similar nodes by features [arxiv:2011.09643 §4.1].
A learned sigmoid score per node sets how much each layer trusts the original
graph and how much the feature graph [arxiv:2011.09643 §4.1]. A learned
per-node count of self-loops scales the node's own term, with a fixed weight γ
[arxiv:2011.09643 §4.1]. The loss adds a regression: for each node, its 5 most
similar and 5 most dissimilar nodes are sampled, and the difference of their
first-layer hidden states is fitted to their feature similarity, weighted by λ
[arxiv:2011.09643 §4.2] [§4.3].

Results are author-reported on seven datasets. On assortative graphs the gain
over GCN is small: 82.8 against 81.3 on Cora, 72.6 against 71.5 on Citeseer
and 81.1 against 79.3 on Pubmed [arxiv:2011.09643 tab. 3]. On disassortative
graphs it is large: 84.05 against 52.70 on Cornell, 81.62 against 52.16 on
Texas and 85.49 against 45.88 on Wisconsin [arxiv:2011.09643 tab. 4]. The GCN
and GAT numbers on those graphs are copied from the GCNII paper, not rerun
[arxiv:2011.09643 §5.2].

Ablation on Cornell [arxiv:2011.09643 tab. 5]:

- Full model: 84.05. Without the self-supervised term: 82.70.
- Without the self-loop term (γ = 0): 65.95.
- Without the self-loop term and without the self-supervised term: 64.59.

Under the Metattack poisoning attack, the authors report that SimP-GCN beats
GCN at every perturbation rate on Cora, Citeseer and Pubmed. The curves are
only in a figure, so no values are given here [arxiv:2011.09643 §5.3] [fig. 2].

Card: [Node Similarity Preserving Graph Convolutional Networks](/papers/2011.09643).

### Learned edge gates inside the GNN (PTDNet)

PTDNet keeps a small learned scorer for each GNN layer. It scores each edge from its two endpoint states, and a hard-concrete gate turns that score into a keep decision that is differentiable in training and can be exactly zero [arxiv:2011.07057 §4.2] [eq. 3] [eq. 4]. Two penalties push the kept graph toward fewer edges: the expected number of kept edges [eq. 5], and the nuclear norm of each masked adjacency, approximated by its top-K singular values [§4.3] [alg. 2]. The authors report GCN on Cora at 0.828 ± 0.026 against 0.811 ± 0.015 for the basic model. Those gaps sit inside one standard deviation, while the gains with injected noisy edges are larger [arxiv:2011.07057 tab. 3] [§5.3]. The paper gives no values for the stretch parameters γ and ζ beyond their signs, and no combined loss [§4.2.2]. Card: [Learning to Drop: Robust Graph Neural Network via Topological Denoising](/papers/2011.07057).

### Learned graph with no predefined adjacency (GCNN-DDGF)

The usual GCN needs an adjacency matrix. This model is for stations or nodes
that are linked by a graph the user cannot define well. The authors build the
graph convolution on $\tilde{A} = A + I$, with the usual symmetric degree
normalisation, and then treat the normalised filter $\hat{A}$ as an unknown
symmetric $N \times N$ matrix learned with the weights
[arxiv:1712.04997 §3.1.1] [eq. 6–7] [§3.3.1] [eq. 15]. The paper calls this
the data-driven graph filter (DDGF).

The task is next-hour bike demand at each of 272 stations, from the last 24
hourly vectors of all stations [arxiv:1712.04997 §5] [tab. 2]. The baselines
include four GCNs whose graph is fixed in advance: spatial distance, origin–
destination demand, average trip duration and demand correlation. Each one
sets the entries of $\tilde{A}$ with a threshold [arxiv:1712.04997 §3.2]. The
demand-correlation graph uses correlations computed from the training data
only [arxiv:1712.04997 §3.2.4] [§5].

Two DDGF variants exist. The regular one stacks learned-filter layers with
ReLU [arxiv:1712.04997 §3.3.2] [eq. 9]. The recurrent one passes the filtered
station vector at each step through an LSTM and predicts the next hour from the
last hidden state [arxiv:1712.04997 §3.3.2] [fig. 1b].

Results are author-reported on one dataset, after selection on validation.
Test RMSE: the recurrent variant 2.12, the regular variant 2.35, the best
predefined-graph GCN (demand correlation) 2.50, and the historical average 3.44
[arxiv:1712.04997 tab. 3]. The paper gives no run-to-run variance, so the gap
between the two DDGF variants has no reported uncertainty [§5].

The learned graph has 1,565 edges with weight at least 0.15 after normalising
to [0, 1], and the authors read its edges as partly matching the predefined
graphs [arxiv:1712.04997 §5.3]. This is a description of one trained model, not
a test of which graph is correct.

Card: [Predicting Station-level Hourly Demands in a Large-scale Bike-sharing Network](/papers/1712.04997).

### Molecular message passing inside a drug-target encoder (MPNN)

DeepPurpose is a library that trains encoder-decoder models for drug-target
interaction prediction. The user picks the compound encoder and the protein
encoder by name [arxiv:2004.08919 §2.1]. One compound encoder is a message-
passing neural network (MPNN) over the molecular graph. The other compound
encoders use fingerprints, CNNs, RNNs or a Transformer over SMILES or
substructure tokens [arxiv:2004.08919 app. A]. The protein encoders do not use
a graph [arxiv:2004.08919 app. A].

The paper says the MPNN readout is the mean or the sum over atoms
[arxiv:2004.08919 app. A]. The compound and protein embeddings are concatenated
and passed to an MLP decoder [arxiv:2004.08919 §2.2].

Author-reported on DAVIS, with figure values read from a low-resolution
raster: the MPNN+AAC pair reaches MSE 0.242 and concordance index 0.881, against
0.254 and 0.879 for the CNN+CNN pair, and against 0.262 and 0.870 for DeepDTA
[arxiv:2004.08919 fig. 1]. The figure gives a parenthesised value next to
each mean that the text does not define. The paper does not state the
optimiser, learning rate, epochs or batch size for these results
[arxiv:2004.08919 §3].

Card: [DeepPurpose](/papers/2004.08919).

### Differentiable circular fingerprint for molecules (neural fingerprints)

A circular fingerprint hashes each local substructure into a fixed slot, so it
must be long to avoid collisions and it cannot be tuned for the task
[arxiv:1509.09292 §1]. The neural fingerprint keeps the same rounds of
neighbourhood update but makes the hash and the slot lookup differentiable
[arxiv:1509.09292 §3] [alg. 2]. Each atom mixes its neighbours' states, using
one weight matrix per number of bonds, and after every round a softmax over the
fingerprint slots is summed over atoms [arxiv:1509.09292 §3] [alg. 2]. The
per-round vectors add up to one fingerprint.

The fingerprint is trained end-to-end with a small regression head on labelled
molecules [arxiv:1509.09292 §4.2]. The paper's three regression sets are aqueous
solubility, antimalarial drug efficacy and organic photovoltaic efficiency
[arxiv:1509.09292 §4.2]. Author-reported results in [tab. 1] compare against
circular fingerprints under the same heads. On solubility the neural version
with a one-hidden-layer head scores 0.52 against 1.40 for circular fingerprints
with a one-hidden-layer head. On drug efficacy the circular fingerprint with a
linear head is slightly better (1.13 against 1.15). On photovoltaic efficiency
the neural version with the hidden layer scores 1.43 against 2.00. The metric is
not named in the paper, so the values cannot be compared against other papers
[tab. 1].

The paper reports that neural and circular fingerprints correlate at r = 0.823
on the solubility set [arxiv:1509.09292 §4] [fig. 3]. The learned features can
be inspected by listing the fragments that most activate each one, which the
authors show for solubility and toxicity [arxiv:1509.09292 §4.1] [fig. 4]
[fig. 5]. Information moves only as far as the depth of the network, and the
model does not distinguish stereoisomers [arxiv:1509.09292 §5]. The paper
gives the cost as O(RNFL + RNF²) for N atoms, R rounds, F features and
length L [arxiv:1509.09292 §5]. The card lists implementation details that the
paper leaves out.

Card: [Convolutional Networks on Graphs for Learning Molecular Fingerprints](/papers/1509.09292).

### Message passing in scene graph generation

The scene graph survey lists GNN-based methods as one of five model families,
which pass messages over the graph of objects and relations
[arxiv:2104.01111 §2.5]. It gives no GNN equations and no hyperparameters.
Its best SGCls R@100 row on VG150 is an RNN/LSTM method, BGT-Net at 47.1,
not a GNN [arxiv:2104.01111 tab. 2]. Card:
[A Comprehensive Survey of Scene Graphs](/papers/2104.01111).

### Direction-aware message passing for scene graphs (GPS-Net)

GPS-Net is a one-stage scene graph generator. Its message passing scores each ordered pair of objects with a tri-linear product of subject, object and union features, then sends each neighbour's features along both directions of the pair [arxiv:2003.12962 §3.1] [eq. 3] [eq. 4]. A node-priority loss gives each object a focusing parameter from the share of relation triplets that contain it, capped at 2 [§3.2] [eq. 6] [eq. 7]. A frequency prior is softened and gated per pair before relation classification [§3.3] [eq. 9] [eq. 10]. In the Visual Genome ablation, message passing gives the largest single gain: SGDET R@50 rises from 26.3 to 28.1 [arxiv:2003.12962 tab. 5]. Author-reported mean recall is 45.9 with the MOTIFS detector, against 43.7 for MOTIFS [tab. 1]. The paper's best exponent is 4 [§4.4], but the released code uses 5, and its detector build computes priority from proposal overlap rather than triplets. Do not treat the code as the paper's method; see the card's Paper vs code. Card: [GPS-Net: Graph Property Sensing Network for Scene Graph Generation](/papers/2003.12962).

### Enclosing-subgraph GNN for inductive link prediction (GraIL)

Knowledge-graph completion usually learns one vector per entity and assumes a
fixed entity set, the transductive setting [arxiv:1911.06962 §1]. GraIL scores a candidate triple (u, r, v)
from the subgraph that connects u and v. It keeps the nodes within k hops of
both targets, labels each node by its distances to u and to v, and runs a
relation-aware GNN with edge attention over that subgraph. The score reads the
pooled subgraph and the two target states [arxiv:1911.06962 §3.1] [eq. 5]. The
model uses no entity embeddings, so it can be applied to inductive splits whose
test graph shares the relation set but no entities [arxiv:1911.06962 §4.1].

Author-reported: inductive AUC-PR is the best of all compared models on all 12
split–dataset columns, against RuleN, Neural-LP and DRUM. On WN18RR v1 the
values are 94.32 for GraIL and 90.26 for RuleN [arxiv:1911.06962 tab. 1]. On
transductive splits GraIL is not the strongest model alone. Ensembling it with
each KGE model gives average gains of 1.5% on WN18RR and 0.62% on NELL-995, and
none significant on FB15k-237. The paper gives no significance test
[arxiv:1911.06962 §4.2].

Ablation on the v3 splits [arxiv:1911.06962 tab. 7]: replacing the intersection
of the two neighbourhoods with their union drops FB (v3) from 91.68 to 84.25.
Removing the double-radius labels drops it to 82.07.

Card: [Inductive Relation Prediction by Subgraph Reasoning](/papers/1911.06962).

### Language model with a knowledge-graph GNN, joint scoring (QA-GNN)

For a multiple-choice question, the pretrained LM encodes the question joined
to one answer choice [arxiv:2104.06378 §3]. The retrieved ConceptNet subgraph
is capped at 200 nodes, and the LM scores each node's relevance to the QA
context [arxiv:2104.06378 §4.2] [§3.2]. The method then adds one QA-context
node, linked to the question entities and the answer entities. Five
attention-weighted GNN layers pass messages over this working graph. A head
reads the LM vector, the context node and a pooled graph vector
[arxiv:2104.06378 §3.1] [§3.3] [§3.4].

Author-reported: on the CommonsenseQA in-house test, 73.41 for QA-GNN against
68.69 for RoBERTa-large and 71.11 for MHGRN [arxiv:2104.06378 tab. 3]. The
relevance score is worth about one point on the in-house dev set, 76.54 against
75.56 without it [arxiv:2104.06378 §4.6.1]. The model has about 360M
parameters and took about 20 hours on two RTX 2080 Ti for CommonsenseQA
[arxiv:2104.06378 §4.3] [§4.5]. The released code computes the relevance
scores differently from the paper; see Contradictions.

Card: [QA-GNN](/papers/2104.06378).

### Interaction tokens between a language model and a knowledge-graph GNN (GreaseLM)

GreaseLM runs an LM and a GNN over the same question. It has a stack of
unimodal LM layers, followed by M fusion layers. Each fusion layer runs one
more LM block and one graph-attention layer. It then mixes only two bottleneck
vectors, an interaction token and an interaction node, through a small MLP.
All other tokens and nodes read these two vectors in the next layer
[arxiv:2201.08860 §4.2] [§4.3]. The subgraph retrieval follows QA-GNN
[arxiv:2201.08860 app. B.1].

Author-reported: on the CommonsenseQA in-house test, 74.2 for GreaseLM against
73.4 for QA-GNN and 71.1 for MHGRN [arxiv:2201.08860 tab. 2]. On OpenbookQA test
it reaches 84.8 [arxiv:2201.08860 tab. 3], and on MedQA-USMLE 38.5
[arxiv:2201.08860 tab. 6]. Removing the modality interaction drops the dev
score from 78.5 to 76.5 [arxiv:2201.08860 tab. 8]. Connecting the interaction
node to all retrieved nodes, instead of only the linked ones, gives 77.6
[arxiv:2201.08860 app. C.1]. On dev questions with negation, GreaseLM scores
69.9 against 66.2 for QA-GNN [arxiv:2201.08860 tab. 5].

Card: [GreaseLM](/papers/2201.08860).

### Word-document graph with BERT node features (BertGCN)

The graph contains document nodes and word nodes. Each document node starts
from a BERT or RoBERTa [CLS] embedding, and word nodes start at zero
[arxiv:2105.05727 §3.1]. A two-layer GCN runs over the whole corpus. Its
prediction is mixed with a BERT-only prediction, using a weight lambda
[arxiv:2105.05727 §3.2] [eq. 6]. BERT cannot process the whole graph at once,
so the method keeps a memory bank with one embedding per document. The bank is
refreshed each epoch and again for each minibatch. BERT starts from a copy
fine-tuned on the target data [arxiv:2105.05727 §3.3].

Author-reported test accuracy with BERT-base [arxiv:2105.05727 tab. 1]: 89.3 on
20NG, 98.1 on R8, 96.6 on R52, 72.8 on Ohsumed and 86.0 on MR. The BERT-only
row gives 85.3, 97.8, 96.4, 70.5 and 85.7. The authors credit the graph with the
largest gains on the long-document sets, 20NG and Ohsumed. On the short-document
sets R52 and MR, pretrained models alone beat the GCN-only baselines
[arxiv:2105.05727 §4.2]. Without the small BERT learning rate the
20NG dev run does not converge, at 10.3 accuracy [arxiv:2105.05727 tab. 2]. The
lambda of 0.7 was chosen on that dev set [arxiv:2105.05727 §4.3] [fig. 1].

Card: [BertGCN](/papers/2105.05727).

### GNN as a flow predictor (GFlowNet)

GFlowNet trains a policy that builds a discrete object step by step, so that a
finished object is sampled in proportion to its reward. The GNN here is a
message-passing network that predicts the flow on each allowed action in the
construction graph. Its convolution runs for 10 steps [arxiv:2106.04399 app. A.4].
Training matches log-flows with a squared-error loss over the construction DAG,
and the training trajectories may come from another policy
[arxiv:2106.04399 §2.2].

Author-reported on a molecule task at 10^5 samples: the top-10 mean reward is
8.36 for GFlowNet, 8.06 for PPO and 8.05 for MARS [arxiv:2106.04399 app. A.7].
The mean pairwise Tanimoto similarity of the top-1000 molecules is 0.44 for
GFlowNet, 0.62 for PPO and 0.59 for MARS [arxiv:2106.04399 §4.2] [app. A.7]. Lower
means more diverse. Card: [Flow Network based Generative Models for
Non-Iterative Diverse Candidate Generation](/papers/2106.04399).

### Graph transformer denoiser for discrete graph diffusion (DiGress)

DiGress generates whole graphs by discrete denoising diffusion. Each node and
each edge is corrupted by a Markov chain over its categories, and a network
predicts the clean categories from the noisy graph [arxiv:2209.14734 §3.1]
[§3.2]. The network is a graph transformer that carries node, edge and
graph-level features [arxiv:2209.14734 §3.2]. It belongs under this concept
because it works directly on the graph's nodes and edges. The paper also
replaces the uniform noise of earlier graph diffusion with noise that
moves toward training-set frequencies, which gives better results on QM9
[arxiv:2209.14734 §4.1] [tab. 6].

Author-reported: 74% and 75% of generated graphs are valid, unique and novel on
SBM and planar graphs [arxiv:2209.14734 tab. 1]. On QM9 the validity is 99.0 ±
0.1 [arxiv:2209.14734 tab. 2]. On MOSES, the FCD is 1.19 against 1.22 for the
autoregressive GraphINVENT [arxiv:2209.14734 tab. 3]. Sampling graphs larger
than any training graph works on GuacaMol, at 85.6% valid and unique at
n_max + 10, and fails on MOSES, at 2.2% [arxiv:2209.14734 tab. 7].

Card: [DiGress](/papers/2209.14734).

### Encode-process-decode mesh GNN for weather (GraphCast)

GraphCast forecasts global weather 6 hours ahead, then feeds its own output back
to reach 10 days [arxiv:2212.12794 app. §3.1]. The grid has 721 by 1440 points,
each with 227 target values [arxiv:2212.12794 app. §2.3]. An encoder moves
grid features onto a multi-mesh made from a refined icosahedron. The mesh has
40,962 nodes at the finest level, and its edges from all refinement levels are
kept, so coarse edges give long-range links [arxiv:2212.12794 app. §3.3]. A
processor of 16 message-passing layers, with unshared weights, runs on the mesh.
A decoder returns to the grid, and the output is a scaled change added to the
current state [arxiv:2212.12794 app. §3.4] [§3.5] [§3.6] [§3.7].

Training uses a latitude- and level-weighted squared error over rollouts of up
to 12 steps, with backpropagation through time [arxiv:2212.12794 app. §4.2]
[§4.3]. The model has 36.7 million parameters [arxiv:2212.12794 §GraphCast].

Author-reported: GraphCast has lower RMSE than the operational HRES forecast
(HRES-fc0) on 90.3% of 1380 targets over 10 days [arxiv:2212.12794
§Forecast verification results]. The MSE objective blurs predictions at long
lead times, and blurring HRES narrows the gap to 88.0% [arxiv:2212.12794
§Forecast verification results] [app. §7.4]. The repository holds the inference
and loss code but not the training loop, so training cannot be checked against
code [arxiv:2212.12794 §Paper vs code].

Card: [GraphCast](/papers/2212.12794).

### Multiplex node embedding by high-order mutual information (HDMI)

Some networks link the same nodes in several ways, and each kind of link is a
separate layer. HDMI gives each layer its own one-layer GCN encoder, then
fuses the layer embeddings per node with a semantic attention step
[arxiv:2102.07810 §3.2] [eq. 21–23]. No labels are used. The training signal
has three terms: each node against a global summary, each node against its own
attributes, and each node against the attributes of another node. Corrupted
inputs supply the negatives [arxiv:2102.07810 §3.1.1] [eq. 9–11].

Author-reported: HDMI has the highest Macro-F1 on all four datasets, at 0.901
on ACM, 0.650 on IMDB, 0.820 on DBLP and 0.808 on Amazon [arxiv:2102.07810
tab. 3]. On clustering and similarity search it is not best everywhere. On
ACM, DMGI_attn scores higher NMI, 0.702 against 0.695 [arxiv:2102.07810 tab. 4].
Card: [HDMI](/papers/2102.07810).

### Non-local graph block for occluded instances (BCNet)

BCNet is a mask head for detect-then-segment models. It treats the 14 × 14
region feature as a graph with one node per pixel, and it runs two
non-local graph layers over it [arxiv:2103.12340 §3.2] [eq. 1–3]. The first
layer, for the occluder, predicts the front object's mask and boundary. Its
output is added back to the region feature and guides the second layer, which
predicts the partly hidden object [arxiv:2103.12340 §3.1] [eq. 4–6]. Each
adjacency is a softmax over pairwise dot products of two learned projections
[arxiv:2103.12340 eq. 2–3].

Author-reported: 39.8 mask AP on COCO test-dev with Faster R-CNN and ResNet-101,
against 39.7 for HTC and 37.0 for Mask R-CNN [arxiv:2103.12340 tab. 8]. Modelling
the occluder raises COCO-OCC AP from 29.04 to 30.37 [arxiv:2103.12340 tab. 1].
The bilayer graph beats a single graph layer by 1.05 COCO-OCC AP, 30.68
against 29.63 [arxiv:2103.12340 tab. 3]. The gains are larger on the
overlap-heavy subset than on COCO [arxiv:2103.12340 tab. 1].
Card: [BCNet](/papers/2103.12340).

### Graph-nested language model for textual graphs (GraphFormers)

GraphFormers places a graph-attention step inside each layer of a BERT-style
encoder (UniLM-base), so each node's text is encoded together with its
neighbours' context at every layer [arxiv:2105.02605 §3.1]. Layer 0 encodes
each node alone. In later layers, the [CLS] states of all nodes form one graph
vector per node, with a learned position bias, and that vector joins the
node's tokens in an asymmetric attention [arxiv:2105.02605 §3.1] [eq. 1] [eq. 4].
The unidirectional variant lets only the centre node query its neighbourhood,
so neighbour states can be cached and reused [arxiv:2105.02605 §3.2] [eq. 5].
Training is link prediction with in-batch negatives [arxiv:2105.02605 §3.3]
[eq. 6].

Author-reported P@1 on three textual link-prediction sets: 0.7786 on Product,
0.7267 on DBLP and 0.3952 on Wiki, against 0.7570, 0.6934 and 0.3712 for the
best cascaded baseline, PLM+Max [arxiv:2105.02605 tab. 2]. Removing the
progressive warm-up costs 1.71 DBLP P@1 points [arxiv:2105.02605 tab. 4]. At
200 neighbours the time overhead is 3.5% [arxiv:2105.02605 §4.5] [tab. 5].
Card: [GraphFormers](/papers/2105.02605).

### Lane-graph policy and trajectory decoder (PGP)

PGP predicts K = 10 future paths of a target vehicle from two seconds of
history and a lane graph. GRU encoders, agent-to-node attention and GCN or GAT
layers give each lane node a feature [arxiv:2106.15004 §4.1] [app. A.2–A.4].
A policy scores the outgoing edges of each node with a softmax and rolls out
routes through the lane graph [arxiv:2106.15004 §4.2] [eq. 1–2]. Each route,
together with a 5-dimensional latent sample, drives an attention decoder whose
outputs are clustered into modes [arxiv:2106.15004 §4.3] [app. A.6]. The policy
is trained by behaviour cloning on ground-truth routes, and the decoder by
winner-takes-all regression [arxiv:2106.15004 eq. 3] [eq. 5].

Author-reported on nuScenes: MinADE10 1.00 and MissRate10,2 0.37, against 1.16
and 0.46 for P2T [arxiv:2106.15004 tab. 1]. In the encoder ablation the graph
layer changes MinADE10 by at most 0.01, whether it is absent, GCN or GAT
[arxiv:2106.15004 tab. 2]. The decoder ablation spans MinADE10 from 1.01 to 1.12
[arxiv:2106.15004 tab. 3], so the decoder matters more on this benchmark.
Card: [PGP](/papers/2106.15004).

### Graph network with gated recurrence for series imputation (GRIL)

GRIL fills missing values in a multivariate series whose channels are sensors
on a fixed graph. It is a bidirectional recurrent network. Each step runs a GRU
whose gates are message-passing networks, once forward and once backward
[arxiv:2108.00298 §4]. Each step makes two guesses for every gap. The first
comes from the hidden state. The second comes from neighbouring sensors, which
send their filled values and masks, while the sensor's own input is excluded
[arxiv:2108.00298 §4] [eq. 9–10]. A final MLP combines the two directions
[arxiv:2108.00298 eq. 11].

Author-reported: MAE is 27.1% below BRITS on out-of-sample AQI and 54.4% and
54.7% below on point-missing PEMS-BAY and CER-E [arxiv:2108.00298 tab. 1]
[tab. 2]. The smallest real-data reduction is 13.2%, on METR-LA with block
missingness [arxiv:2108.00298 tab. 2]. On METR-LA block missingness, a learned
graph gives MAE 2.03, against 2.63 for a fully connected graph and 3.42 for no
edges [arxiv:2108.00298 tab. 9].
Card: [GRIL](/papers/2108.00298).

### Edited graphs for out-of-distribution nodes (EERM)

When a node-level task has one graph and no environment labels, EERM builds
virtual environments from that graph. K learned editors each flip a sampled set
of node pairs in the adjacency matrix, adding missing edges and removing
present ones [arxiv:2202.02466 §3.2] [app. A]. The editors are trained with
REINFORCE to maximise the variance of the GNN's risk across the edited graphs.
The GNN then minimises that variance plus a weighted mean risk
[arxiv:2202.02466 §3.2] [eq. 5].

Author-reported gains over ERM with the same backbone. On Facebook-100 the gaps
run from −0.13 to +3.63 points. The largest is on Texas, 53.82 against 50.19
when trained on Bingham, Duke and Princeton [arxiv:2202.02466 tab. 2]. On
OGB-Arxiv, GPRGNN improves from 47.25 to 49.88 on the 2014–2016 split
[arxiv:2202.02466 tab. 3]. Several Facebook-100 gains lie within one standard
deviation, so they are weak evidence [arxiv:2202.02466 tab. 2]. Each editor
holds an n × n parameter matrix [arxiv:2202.02466 app. A], so memory grows with
the square of the node count, and the paper gives no sparse alternative.
Card: [EERM](/papers/2202.02466).

### Graph attention over feature tracks for pose matching (OnePose)

OnePose estimates a 6D object pose from a short RGB scan, without a CAD model or
per-object training [arxiv:2205.12257 §1]. The scan becomes a sparse 3D point
map, and each point keeps the 2D features that observed it, its feature track
[arxiv:2205.12257 §3.1]. For each query, a graph attention layer re-weights
each track's descriptors. Stacked attention groups then let query features and
3D descriptors attend to each other, a dual softmax selects matches, and PnP
with RANSAC gives the pose [arxiv:2205.12257 §3.2] [§4.2]. The paper stacks
N = 4 groups [arxiv:2205.12257 §4.2].

Author-reported on the authors' dataset: for large objects, 0.471 at
1cm-1deg against 0.435 for HLoc with SuperPoint and SuperGlue, at 58 ms against
618 ms per frame [arxiv:2205.12257 tab. 1]. On medium objects HLoc is higher,
0.643 against 0.629 [arxiv:2205.12257 tab. 1]. Replacing the attention in the
aggregation with a plain average lowers large-object accuracy to 0.449
[arxiv:2205.12257 tab. 4].
Card: [OnePose](/papers/2205.12257).

### Language model and knowledge graph pretrained jointly (DRAGON)

DRAGON pretrains one encoder on a text segment and a small knowledge-graph
subgraph at the same time. An interaction token and an interaction node pass
information between the two sides after each fusion layer [arxiv:2210.09338 §2.2]
[eq. 5–7]. The pretraining loss is masked language modelling plus link
prediction on held-out edges, scored with DistMult [arxiv:2210.09338 §2.3]
[eq. 8–10]. The general model uses 19 unimodal language-model layers and 5
fusion layers [arxiv:2210.09338 §3.1].

Author-reported: 76.0 on CommonsenseQA and 72.0 on OpenbookQA, against 74.2 and
66.9 for GreaseLM, which uses the graph only in fine-tuning [arxiv:2210.09338
tab. 1]. Feeding the graph as sentences instead of as a graph lowers CSQA to
74.7 [arxiv:2210.09338 tab. 5]. On MedQA the reported score is 47.5
[arxiv:2210.09338 tab. 6].
Card: [DRAGON](/papers/2210.09338).

### Equivariant interaction graph for motion prediction (EqMotion)

EqMotion predicts the future motion of interacting agents with a network that
is equivariant to translation, rotation and reflection [arxiv:2303.10876 §3.2]
[§4]. Each agent has a geometric feature whose coordinates transform with the
scene. It also has a pattern feature built from speed and turning angle, which
is invariant [arxiv:2303.10876 §4.1]. Interaction categories come only from
invariant inputs [arxiv:2303.10876 §4.2] [eq. 2]. Each layer moves the
coordinates by category-weighted differences to the other agents, and updates
the pattern feature by message passing [arxiv:2303.10876 §4.3] [§4.4]
[eq. 3–4]. The experiments use a fully connected graph [arxiv:2303.10876 §4.3].

Author-reported: 55.0 mm mean joint error at 400 ms on H3.6M, against 58.3 for
SPGSN [arxiv:2303.10876 tab. 2]. On charged particles, interaction recognition
reaches 80.9% against 70.4% for dNRI [arxiv:2303.10876 tab. 1]. The equivariance
result is a proof for the layers as written, not a test of the released code
[arxiv:2303.10876 §4.6].
Card: [EqMotion](/papers/2303.10876).

### Higher-order neighbourhood mixing (MixHop)

MixHop replaces the one-hop propagation of a GCN layer with a concatenation
over several adjacency powers, each with its own weights
[arxiv:1905.00067 §3.1] [eq. 4]. With the power set {1} the layer is the GCN
layer [§3.1]. The authors argue that a stack of vanilla GCN layers cannot
represent a two-hop delta operator, a difference between features at two
distances, while MixHop with powers {0, 1, 2} can [§3.3]. Powers are applied
by repeated sparse products, so no adjacency power is formed, and the cost per
layer is stated as O(j_max · m · s) [§3.2].

The width of each power is learned with a five-stage group-lasso procedure: a
wide network is trained, whole columns are shrunk, columns are pruned to match
the size of the {1} baseline, and the network is retrained with plain L2 [§4.2].
The default architecture splits the hidden width equally across powers [§5.2].

Author-reported on the Planetoid splits, with 20 labelled nodes per class: the
default architecture scores 71.4, 81.8 and 80.0 on Citeseer, Cora and Pubmed,
and the learned architecture 71.4, 81.9 and 80.8 [arxiv:1905.00067 tab. 1].
The vanilla GCN row is copied from Kipf and Welling, at 70.3, 81.5 and 79.0
[tab. 1]. The {1} baseline, which the authors ran themselves, scores 70.7, 81.1
and 79.9 [tab. 1]. On random splits with 100 labels per class, the learned
architecture scores 77.0, 87.2 and 83.8, against 76.7, 86.1 and 82.2 for the
vanilla GCN [tab. 3]. The paper does not say whether the random-split baselines
were rerun [tab. 3]. At low homophily on the synthetic graphs, MixHop is
significantly better than the strongest baseline [§6.1].

Card: [MixHop](/papers/1905.00067).

### Learned propagation weights (GPR-GNN)

GPR-GNN separates feature extraction from propagation. A 2-layer MLP gives each
node a representation H^(0). The representation is propagated K times with the
symmetric normalised adjacency with self-loops, and the output is the sum of
the K+1 terms, each weighted by a learned scalar γ_k [arxiv:2006.07988 eq. 1]
[§3]. Initialising γ to personalised-PageRank weights gives APPNP, and a one-hot
γ at step K gives SGC [§3]. The paper does not restrict the learned γ_k to be
positive [§3]. Because the output is a polynomial in the normalised adjacency,
learning γ is learning a graph filter [§4]. The paper's low-pass result needs
non-negative γ_k that sum to one, and with γ_k = (−α)^k and large K the filter
acts as high-pass [§4] [app. A.3]. The paper uses K = 10 [§5].

Author-reported mean accuracy over 100 random splits, with 95% intervals. The
paper gives the homophilic graphs a 2.5 / 2.5 / 95 split and the heterophilic
graphs 60 / 20 / 20 [§5] [app. A.9]. GPR-GNN has the best mean on seven of ten
datasets [tab. 2]. On Texas it scores 92.92, against 92.26 for the MLP and 75.16
for GCN [tab. 2]. On Cornell APPNP is higher, 91.80 against 91.36 [tab. 2]. On
the synthetic sparse split at φ = −1 it scores 97.19, against 55.24 for GCN and
49.57 for APPNP [tab. 5]. With a random initialisation of γ, the same setting
drops to 88.39 [tab. 5]. The paper reports the per-epoch cost close to APPNP's,
with 17.62 ms on Cora against 17.16 ms [tab. 3].

Card: [GPR-GNN](/papers/2006.07988).

### Learned sensor graph for anomaly detection (GDN)

GDN learns the graph it needs. Each sensor has a learned embedding, and the top
k sensors by cosine similarity of embeddings become its neighbours, giving a
directed edge set [arxiv:2106.06947 §3.4] [eq. 2] [eq. 3]. A graph-attention
layer forecasts each sensor's next value from its neighbours' windows. The
attention uses both the embeddings and the projected windows [§3.5] [eq. 5–8].
Each sensor's representation is multiplied element-wise by its embedding before
a fully connected output layer [§3.5] [eq. 9]. The model is trained on normal
data with squared error [§3.1] [eq. 10]. A time tick scores the largest
per-sensor error, normalised by the sensor's median and IQR. The score is
smoothed and compared with a threshold [§3.6] [eq. 11–13].

Author-reported F1 on SWaT is 0.81 and on WADI 0.57. The best baseline in the
table, MAD-GAN, scores 0.77 and 0.37 [arxiv:2106.06947 tab. 2]. Removing the
learned top-k graph lowers WADI F1 to 0.51, removing the embedding from
attention lowers it to 0.49, and uniform attention gives 0.48 [tab. 3]. The
paper reports no standard deviations [tab. 2].

Card: [GDN](/papers/2106.06947).

### Learned proposal graph for LiDAR detection (BADet)

BADet is a two-stage LiDAR 3D detector. The first stage proposes boxes. The
second stage makes each proposal a node. Proposals whose centres lie closer
than a cut-off r are linked, and each node is linked to itself
[arxiv:2104.10330 §3.3.1] [eq. 2]. The node state concatenates voxel,
bird's-eye-view pixel and point features [§3.2] [eq. 1]. The paper's node
state has 120 dimensions [§4.1.2]. Each update step computes, for each
neighbour, a message from the relative position minus a predicted alignment
offset, concatenated with the neighbour's state. The messages are max-pooled
over the neighbourhood, and the result is added to the node state
[§3.3.2] [alg. 1] [eq. 3]. The paper runs T steps. It reports T = 3 for its
test submission and T = 4 as best on validation [§4.4.4]. The cut-off r is not
stated [§3.3.1].

Author-reported. On the KITTI test split, Car at moderate difficulty scores
81.61 AP3D and 91.32 APBEV, against 81.62 AP3D for Voxel R-CNN and 90.65 APBEV
for PV-RCNN [arxiv:2104.10330 tab. 1]. On the KITTI validation split, the
moderate AP3D is 85.77, against 84.52 for Voxel R-CNN [tab. 2]. On validation,
T = 0 gives 79.94, T = 3 gives 85.77, T = 4 gives 85.79 and T = 5 gives 79.87
[tab. 7]. The authors attribute the drop at T = 5 to gradient vanishing, which
they do not test [§4.4.4]. The refiner takes 61.98 ms of a 140.36 ms frame on
a GTX 1080 Ti [§4.5] [tab. 8].

Card: [BADet](/papers/2104.10330).

### Channel-wise topology for skeleton action recognition (CTR-GCN)

Skeleton graph convolutions usually share one adjacency matrix across all
channels. CTR-GC keeps a shared matrix A and adds a correction for each sample
and channel. The correction, scaled by a trainable α, comes from pairwise joint
correlations of pooled features. Each channel then aggregates joints with its
own refined matrix [arxiv:2107.12213 §3.2] [eq. 4–8]. The correlation is a
Tanh of the difference between two learned projections. An MLP form is an
alternative [§3.2] [eq. 5]. Three such branches are summed in each spatial
module, and a multi-scale temporal module follows [§3.4] [fig. 3]. The paper
does not give the initial value of α [§3.2].

Author-reported. On NTU RGB+D 120 the cross-subject and cross-setup top-1 are
88.9 and 90.6, against 87.3 and 88.6 for Dynamic GCN [arxiv:2107.12213 tab. 5].
On NTU RGB+D cross-subject it scores 92.4, against 91.5 for MS-G3D and Dynamic
GCN [tab. 6]. On NW-UCLA it scores 96.5, against 95.3 [tab. 7]. In the ablation
on NTU 120 cross-subject, removing the shared matrix gives 84.0 and removing
the correction gives 83.7, against 84.9 for the full model [tab. 2]. The full
model has 1.46M parameters, and the ST-GCN baseline has 1.22M [tab. 2]. The
paper reports about 1.97 GFLOPs for CTR-GC against 1.65 for ST-GC [tab. 4].
The authors' repository is licensed CC BY-NC 4.0, which excludes commercial
use. An implementation should therefore be written from the paper.

Card: [CTR-GCN](/papers/2107.12213).

### Bipartite graph convolution as a branching rule (learn2branch)

In branch-and-bound for a mixed-integer linear program, the solver splits on
one fractional variable at each node. Strong branching picks the best variable
but solves two LPs per candidate, so solvers fall back to cheaper hybrid rules
[arxiv:1906.01629 §3.2]. This variant encodes the solver state as a bipartite
graph, with one node per LP row, one per LP column, and one edge per non-zero
coefficient [arxiv:1906.01629 §4.2]. A single graph convolution runs in two
half-steps, from variables to constraints and back, with sum aggregation
[arxiv:1906.01629 §4.3] [eq. 4]. Training is behavioural cloning: cross-entropy
over the candidate variables, with strong branching's choice as the label, and
no reinforcement learning [arxiv:1906.01629 §4.1] [eq. 3].

Author-reported: the expert's variable is ranked first (acc@1) on 65.5% of
set-covering test cases, against 57.6 for SVMrank, and on 56.5% of
maximum-independent-set cases, against 48.9 for LambdaMART [arxiv:1906.01629
tab. 1]. Solve time is below SCIP's reliability pseudocost rule in most
settings. The card counts 11 of 12 size settings from the table; the authors
do not state that count [arxiv:1906.01629 tab. 2]. Models are trained on easy
instances and the authors say they generalise to larger ones [arxiv:1906.01629
tab. 2] [§5.2]. Training took 3.8 to 18.2 hours per problem [arxiv:1906.01629
suppl. §5].

Card: [Exact Combinatorial Optimization with Graph Convolutional Neural Networks](/papers/1906.01629).

### Amortised explainer network (PGExplainer)

Explaining a GNN means finding a small set of edges whose presence keeps the
prediction [arxiv:2011.04573 §1] [§4.1]. Per-instance explainers such as
GNNExplainer run a new optimisation for every node or graph, and do not carry
over to unseen nodes [arxiv:2011.04573 §1] [§4.3]. PGExplainer trains one MLP
on the frozen GNN's embeddings. For an edge (i, j) it takes the embeddings of
i and j, plus the explained node's embedding for node tasks, and outputs one
logit for the edge [arxiv:2011.04573 §4.3] [eq. 8] [eq. 10–11]. Sampled edge
masks use a binary concrete relaxation. The loss is a cross-entropy between the
GNN's prediction on the full graph and on the masked graph, summed over
instances [arxiv:2011.04573 §4.2] [eq. 4] [eq. 9]. Only the explainer's MLP is
trained [§4.3]. The appendix anneals the temperature from 5.0 to 2.0 [app. B].

Author-reported: on the synthetic motif benchmarks and MUTAG, explanation AUC
is the highest of all methods in all six settings, for example 0.963 against
0.925 for GNNExplainer on BA-Shapes and 0.873 against 0.727 on MUTAG
[arxiv:2011.04573 tab. 2]. Inference for one new instance takes about 6 to 80
ms, against 410 to 935 ms for GNNExplainer [tab. 2]. That comparison leaves out
the explainer's own training time [app. C.1]. The AUC measures recovery of
constructed motifs, not explanation quality in general [§5.1]. Feature-level
explanations are out of scope [app. D].

Card: [Parameterized Explainer for Graph Neural Network](/papers/2011.04573).

### Overlap-attention GNN for low-overlap point clouds (PREDATOR)

Two 3D scans taken from different places may share little surface. PREDATOR
lets the two clouds exchange information before it chooses where to match
[arxiv:2011.13005 §3.3]. Inside each cloud, superpoints are linked to their
nearest neighbours, and a graph layer updates each one with a max over
neighbours of a learned function of its feature and the offset to it
[arxiv:2011.13005 eq. 2–3]. Cross-attention then links every superpoint of one
cloud to every superpoint of the other, in both directions. A second
within-cloud GNN refines the result [§3.3]. A linear head gives each superpoint
an overlap logit, and the decoder adds a matchability score per point
[§3.3] [§3.4]. Interest points are sampled in proportion to overlap times
matchability [§4.1].

Author-reported: at 5000 samples, registration recall on 3DLoMatch (10–30%
overlap) is 59.8% against 40.1% for FCGF, and 89.0% on 3DMatch [arxiv:2011.13005
tab. 2]. The sampling rule matters as much as the network. On 3DLoMatch at 5000
samples, probabilistic sampling by overlap times matchability gives 59.8%,
top-k sampling 58.5% and random sampling 43.3% [arxiv:2011.13005 tab. 1].
Adding the overlap-attention block to FCGF lifts 3DLoMatch recall at 250
samples from 26.8 to 55.9 [tab. 10]. On 3DMatch the block takes 70 ms of a 271
ms pair, and the data loader takes 191 ms [tab. 11]. Cross-attention memory
grows with the square of the superpoint count, which is why batch size is one
[app. A.3].

Card: [PREDATOR: Registration of 3D Point Clouds with Low Overlap](/papers/2011.13005).

### Graph ODE with restart term (STGODE)

STGODE writes graph propagation over a road sensor network as a tensor ODE with
a restart term that keeps each node tied to its input state [arxiv:2106.12931
§4.2] [eq. 8]. It uses two adjacency matrices: a spatial one from road
distances, and a semantic one from DTW similarity of sensor series [§4.1]
[eq. 4–6]. Each block is a dilated temporal convolution, an Euler solve of the
ODE whose step count the paper does not state, and a second temporal
convolution [§4.3] [§4.4] [fig. 5]. Blocks run in parallel for each adjacency,
and their outputs are max-pooled before a two-layer MLP forecasts the next hour
[§4.4] [§4.5]. The paper argues that without the restart term, repeated
propagation collapses the states onto the top eigenvector [arxiv:2106.12931
eq. 10]. The input is one hour of 5-minute steps, and the output is the next 60
minutes [§5.3].

Author-reported: lowest RMSE, MAE and MAPE on all six PeMS datasets for the
60-minute horizon [arxiv:2106.12931 tab. 2]. Some margins are small: RMSE 32.82
against 33.65 for STSGCN on PeMS04, and 25.97 against 26.22 for ASTGCN(r) on
PeMS08 [tab. 2]. No variance, repeated runs or significance tests are reported
[§5.4]. The official code departs from the paper in ways that change the model,
see Contradictions.

Card: [Spatial-Temporal Graph ODE Networks for Traffic Flow Forecasting](/papers/2106.12931).

### Mesh GNN with a stress-divergence penalty (P-DivGNN)

P-DivGNN predicts the stress at every node of a periodic micro-structure mesh,
given the cell's mean stress [arxiv:2507.05291 §2.2] [§3]. Each mesh node is a
graph node carrying the mean stress, its position and a boundary label.
Periodic edges join nodes on opposite sides of the square cell [§3.1]
[fig. 2]. The network is an encode-process-decode message-passing GNN with
latent width 128 and ten steps that share one set of weights [§3.2]. The loss
adds to the NMSE a penalty on the mean squared discrete stress divergence,
weighted by λ, which pushes the prediction towards local equilibrium [§3.3]
[eq. 41–42].

Author-reported: on the linear dataset the NMSE falls from 1.13e-2 for a
periodic GNN without the penalty to 1.08e-2, and the mean divergence falls from
1.11e-3 to 3.23e-4 [arxiv:2507.05291 tab. 1]. On the hyperelastic dataset the
NMSE falls from 5.36e-2 to 2.18e-2 [tab. 2]. Inference is about 500 times faster
than finite-element simulation on hyperelastic meshes [§5.3.1]. That figure
compares GPU inference with CPU FE, and it excludes training [§5.3.1]. The
penalty weight is tied to the stress scale, which is why the paper uses
λ = 1e-2 for hyperelastic data [§5.2].

Card: [Physics-Informed Graph Neural Networks to Reconstruct Local Fields Considering Finite Strain Hyperelasticity](/papers/2507.05291).

### Node-subgraph contrast for unsupervised anomaly scores (CoLA)

Each node is paired with a small subgraph sampled around it, and also with a
subgraph sampled around another node. A one-layer GCN with a bilinear
discriminator learns to tell these pairs apart [arxiv:2103.00113 §4.1]
[§4.2] [eq. 8]. No anomaly labels are used. A node's score is the average,
over R = 256 sampled rounds, of the negative-pair score minus the
positive-pair score, so a higher score means more anomalous
[arxiv:2103.00113 §4.3] [eq. 11–12] [§5.2.3]. Subgraphs have 4 nodes in the
experiments [arxiv:2103.00113 §5.2.3].

Author-reported ROC-AUC is the best of the compared methods in all seven
benchmark columns, with 0.9512 on Pubmed [arxiv:2103.00113 tab. 3]. The
benchmark anomalies are injected: dense cliques of unrelated nodes, and
contextual copies of distant attributes. The scores therefore measure recovery
of injected anomalies, not real anomaly rates [arxiv:2103.00113 §5.1]. The
released code has no loader for the ogbn-arxiv row, so that row cannot be
reproduced from the repository [code: utils.py#L60-L62].

Card: [Anomaly Detection on Attributed Networks via Contrastive Self-Supervised Learning](/papers/2103.00113).

### Transformer with graph structural biases (Graphormer)

Graphormer is an ordinary Transformer encoder with three additions that carry
graph structure. Each node gets learned embeddings for its in-degree and its
out-degree [arxiv:2106.05234 §3.1] [eq. 5]. Each shortest-path distance
between two nodes has one learned scalar, added to their attention score
[eq. 6]. A third term averages learned weights over the edge features along
one shortest path [eq. 7]. An extra graph token, linked to every node, carries
the graph-level read-out [arxiv:2106.05234 §3.2]. The paper states that a
Graphormer layer can represent the aggregate and combine steps of GIN, GCN and
GraphSAGE, given suitable weights [arxiv:2106.05234 §3.3] [app. A].

Author-reported: validation MAE 0.1234 on PCQM4M-LSC against 0.1395 for
GIN-VN [arxiv:2106.05234 tab. 1], and MolHIV AUC 80.51 with FLAG augmentation
[arxiv:2106.05234 tab. 3]. The paper names the cost of full attention, which
grows with the square of the node count, as a main limitation and leaves large
graphs to future work [arxiv:2106.05234 §6]. The text describes pre-layer-norm,
but the PCQM4M and ZINC scripts train post-layer-norm unless a flag is set
[code: examples/property_prediction/pcqv2.sh#L18-L21].

Card: [Do Transformers Really Perform Bad for Graph Representation?](/papers/2106.05234).

### Learnable positional stream (LSPE)

LSPE keeps a second vector per node, its positional features, next to its
structural features. Both are updated at every layer. The positional update is
a message-passing function of its own with a tanh output, so positions can be
negative [arxiv:2110.07875 §3.1] [eq. 7–9]. Starting positions come from
random-walk return probabilities (RWPE) or from Laplacian eigenvectors (LapPE).
The paper prefers RWPE, which avoids the sign ambiguity of eigenvectors
[arxiv:2110.07875 §2] [§3.1]. The same two-stream update is applied to GatedGCN
and PNA, and to the Transformer GNNs SAN and GraphiT [arxiv:2110.07875 app. C].

Author-reported: GatedGCN with LSPE and the optional Laplacian loss reaches
test MAE 0.090 ± 0.001 on ZINC, against 0.251 ± 0.009 without positional
encoding [arxiv:2110.07875 tab. 1]. The Laplacian loss moves the best ZINC score
only from 0.093 to 0.090 [arxiv:2110.07875 §4.2]. On the two OGB datasets the
authors report results comparable to the baselines, not clear gains
[arxiv:2110.07875 §4.2] [tab. 2].

Card: [Graph Neural Networks with Learnable Structural and Positional Representations](/papers/2110.07875).

### All-pair message passing with a learned sparse graph (NodeFormer)

NodeFormer lets every node exchange messages with every other node in each
layer, without building the full N × N attention table. It writes softmax
attention as an inner product of random feature maps, so the sums over nodes
are computed once and shared by all queries, which gives cost linear in the
number of nodes [arxiv:2306.08385 §3.1] [eq. 3–5]. Gumbel noise on the logits,
scaled by a temperature τ, turns the attention into a relaxed one-neighbour
sample per node. The layer averages K such draws, so each layer has a sparse
latent graph that differs from layer to layer [§3.1] [eq. 6–7] [alg. 1]. The
paper's bound on the random-feature error depends on the number of features
and on τ, not on N [§3.2]. If an input graph exists, the model adds a learned
relational bias for observed edges and a likelihood term that rewards high
probability on them [§3.3] [§3.4] [eq. 8–10].

Author-reported: on OGB-Proteins, 77.45 ROC-AUC against 74.63 for
GraphSAINT-GAT, with 3.2 GB against 5.2 GB of training memory [arxiv:2306.08385
tab. 2]. On Amazon2M it reaches 87.85 accuracy against 85.17 for GraphSAINT-GAT
[tab. 3]. The ordinary-softmax rows at the same τ are 1.3 to 2.0 points lower
on OGB-Proteins, which is the paper's evidence for the Gumbel operator
[tab. 2] [§4.4]. Relative to LDS, the paper reports up to 93.1% less training
time and 97.9% less inference time [§4.4]. The model is not evaluated on graph
classification [§2].

The released code departs from the paper's formulas in several places. It
scales queries and keys by d^(-1/4) on top of the τ scaling, draws Gumbel noise
only in training, and concatenates the heads where the appendix says they are
averaged [arxiv:2306.08385 app. C.1] [code: nodeformer.py#L77-L78]
[code: nodeformer.py#L277-L282] [code: nodeformer.py#L288-L289]. The repository
has no license file, so implementers should work from the equations and not
copy code [arxiv:2306.08385 §Pitfalls].

Card: [NodeFormer: A Scalable Graph Structure Learning Transformer for Node Classification](/papers/2306.08385).

### Lane topology from endpoint gaps and query similarity (TopoLogic)

Lane detectors that predict connections with an MLP on each lane query encode
every lane alone, so the endpoints of two connected lanes rarely coincide
exactly [arxiv:2405.14747 §1]. TopoLogic adds two matrices. The first scores
each lane pair by the gap between the end of one lane and the start of the
other [arxiv:2405.14747 §3.3] [eq. 1–3]. A learnable function of that gap,
exp(−x^α / (λσ)), maps it to a score [eq. 4]. The authors argue that this
form tolerates larger endpoint shifts than their Gaussian, sigmoid and tanh
alternatives [arxiv:2405.14747 §3.3] [fig. 3]. The second matrix is a sigmoid
of the dot product of two three-layer MLP encodings of the lane queries
[arxiv:2405.14747 §3.4] [eq. 7–9]. Two learnable scalars combine the matrices
[eq. 10], and the result feeds a graph layer in each decoder layer. That layer
mixes each lane's features with those of the lanes it connects to
[arxiv:2405.14747 §3.2] [fig. 2]. The paper gives no equation for this graph
update. Only the similarity matrix receives a topology loss; the geometric
matrix is trained only through the detection loss [arxiv:2405.14747 §3.6].

Author-reported on OpenLane-V2 subset_A with a ResNet-50 backbone: TOP_ll
23.9 against 10.9 for TopoNet, and OLS 44.1 against 39.8 (v2.1.0)
[arxiv:2405.14747 tab. 1]. Geometry alone reaches 20.1 of the 23.9, similarity
alone 12.9, and an MLP on queries 10.8 [tab. 4]. Added after training, without
retraining, the geometric step raises TopoNet's TOP_ll from 10.9 to 22.3
[tab. 5]. Every number comes from one benchmark, and the paper states that the
work is for research only [§5].

Card: [TopoLogic](/papers/2405.14747).

### Point-lane graph with endpoint queries (TopoPoint)

Lane queries are supervised together with the whole lane, so the two ends of
connected lanes often do not coincide in the output [arxiv:2505.17771 §1]
[fig. 1]. TopoPoint adds one query per endpoint, separate from the lane
queries [§3.4]. Both sets first pass through a merged self-attention, with
geometric biases from the TopoLogic mapping added to the logits [eq. 3–8]
[§3.4].

The point-lane graph convolution, PLGCN, passes messages between points and
lanes. Its adjacency is built from the point-lane topology and the geometric
matrix, with two learnable weights. Points receive messages from lanes through
it, and lanes receive from points through its transpose [arxiv:2505.17771
eq. 11–12] [§3.4]. The lane branch adds a lane-lane graph convolution, with
adjacency I + M_ll + M_llᵀ, and a traffic-to-lane convolution, and PLGCN runs
once before and once after this step [eq. 13–16] [fig. 3]. Three topology
matrices, point-lane, lane-lane and lane-traffic, come from sigmoids of MLP
dot products [eq. 18–20] [§3.5].

At inference, points and lanes scoring above 0.3 are kept. Each kept point is
averaged with the kept lane ends within 1.5 m, and each matched lane takes that
average as its endpoint [arxiv:2505.17771 alg. 1] [§3.7] [§4.2]. The algorithm
does not say which end of a lane is matched. The released code does this
differently, see Contradictions.

Author-reported on OpenLane-V2 subset_A, with ResNet-50 and 24 epochs
[arxiv:2505.17771 tab. 1]: OLS 48.8 against 44.1 for TopoLogic, and DET_p 52.6
against 45.2. On subset_B, OLS is 49.2 against 42.3. DET_p is the authors' own
endpoint metric [§4.1] [eq. 23], and TopoNet, TopoMLP and TopoLogic DET_p were
computed by the authors, so only OLS is a shared benchmark number [tab. 1].
In the ablation, which starts from a re-run TopoLogic baseline [tab. 2], the
merged self-attention adds 5.0 DET_p on top of the front-view change. The
point-lane graph convolutions add
0.7 OLS and 2.0 DET_p, and the matching step adds 0.5 OLS and 0.8 DET_p. The
whole graph network, when removed, lowers subset_A OLS from 48.8 to 46.2 and
DET_p from 52.6 to 48.6 [tab. 3].

Card: [TopoPoint](/papers/2505.17771).

### Pre-trained long-history encoder feeding a sparse learned graph (STEP)

STEP adds a frozen time-series Transformer to a Graph WaveNet forecaster. The
Transformer is pre-trained once per dataset by reconstructing masked patches of
a long history [arxiv:2206.09113 §3.1] [§4.1]. Its state for the last short
patch is added to the backend's latent features, and its states build a kNN
target that regularises a Gumbel-sampled sparse graph [arxiv:2206.09113 eq. 3]
[eq. 5]. The forecaster reads only 12 steps. Author-reported horizon-12 MAE is
3.37 on METR-LA against 3.53 for Graph WaveNet, and 1.79 against 1.95 on
PEMS-BAY [arxiv:2206.09113 tab. 2]. The paper does not win every cell: on
PEMS04 at horizon 12 its RMSE of 31.33 is behind GMAN's 30.21 and is not
marked significant [tab. 2]. The released code drops the paper's dynamic term
from the graph logits, so the learned graph is nearly static, and test-time
predictions are random unless the sampler is seeded [arxiv:2206.09113 Paper vs
code] [Pitfalls].

Card: [STEP](/papers/2206.09113).

### Signed and directed edges with a magnetic Laplacian (MSGNN)

MSGNN builds a Hermitian matrix in which an edge's sign sits in the real part
and its direction in a phase, scaled by a charge parameter q [arxiv:2209.00546
§3.2]. Its normalised form has eigenvalues in [0, 2] [§3.2]. The network is two
layers of first-order complex Chebyshev filters with real weights and a complex
ReLU [§3.3] [§3.4]. With positive weights it reduces to MagNet, and with no
direction to the signed Laplacian [§2] [§3.2]. Author-reported link-prediction
accuracy is 73.0 on BitCoin-OTC sign prediction, against 70.1 for SSSNET, and
86.3 on Epinions direction prediction, against 73.9 for SSSNET [arxiv:2209.00546
tab. 1]. The paper claims the highest accuracy in all 25 link-prediction cells;
on FiLL 5C it ties SNEA, so the claim holds outright in 24 [§4.4.2] [tab. 1].
Node clustering is evaluated only on synthetic graphs [§4.4.1]. The main table's
q is not stated. The card reads the released code as computing q0 once, from
the first split, a reading it did not run [arxiv:2209.00546 Paper vs code].

Card: [MSGNN](/papers/2209.00546).

### Adaptive mixing of low-pass, high-pass and identity channels (ACM-GCN)

Each ACM-GCN layer runs three channels: a low-pass average of neighbours, a
high-pass neighbour difference and the node's own features. A learned,
per-node softmax weights them [arxiv:2210.07606 §4.2]. A second option, ACMII,
applies the ReLU before propagation instead [§4.2]. ACM+ and ACM++ add a
structure channel and a residual [app. B]. The paper also proposes a
label-free aggregation homophily that compares same-class and other-class
similarity after aggregation, and reports that it tracks GNN accuracy better
than the edge, node and class homophily measures [§3.1] [fig. 2]. On random
60/20/20 splits, ACM-GCN reaches 94.75 on Cornell against 82.46 for GCN, and
90.66 on PubMed against 88.90 for GCN [arxiv:2210.07606 app. A.1]. On the
Geom-GCN 48/32/20 splits its Cornell score of 85.14 is below GGCN (85.68) and
GloGNN++ (85.95) [app. A.2]. Removing the mixing step costs about three points
on Cornell, 91.64 against 94.75 [tab. 1]. Per-epoch time is about twice GCN's
on Cornell [tab. 1]. The released code multiplies the mix by 3 and never
applies the layer normalisation the appendix describes [arxiv:2210.07606 Paper
vs code].

Card: [Revisiting Heterophily For Graph Neural Networks](/papers/2210.07606).

### Fully connected space-time graph in the Fourier domain (FourierGNN)

FourierGNN treats a window of N series over T steps as one fully connected
graph with N·T nodes [arxiv:2311.06190 §4.1]. Each layer multiplies the
spectrum by a complex d-by-d matrix that all frequencies share, and it sums
the layer outputs over K = 3 orders [§4.2] [app. F.4]. The shared matrix does
not grow with the window: on ECG it has 0.18M parameters against 82.96M for a
version with one matrix per frequency [app. C.2]. Author-reported horizon-12
results are a Traffic MAE of 0.011 against 0.013 for GraphWaveNet, and an
Electricity MAE of 0.051 against 0.055 for FEDformer [arxiv:2311.06190 tab. 1].
Traffic uses 190,564 parameters against 280,860 for GraphWaveNet [tab. 3]. Its
Traffic MAPE of 28.71 is above LSTNet's 25.77 [tab. 1]. The released code
uses diagonal weights, builds no adjacency and compresses time to eight steps,
so it is a different model from the paper's equations [arxiv:2311.06190 Paper
vs code].

Card: [FourierGNN](/papers/2311.06190).

### Per-period learned graphs for multivariate forecasting (MSGNet)

MSGNet forecasts several series together by treating each strong period of the input as its own scale. An FFT picks the k strongest periods, and the series is reshaped for each one [arxiv:2401.00423 §4.2] [eq. 3] [eq. 4]. Each scale has its own learned adjacency, a softmax over a ReLU of two low-rank embeddings, and a Mixhop graph convolution over its powers [§4.3] [eq. 6] [eq. 7]. Self-attention then runs within each period [§4.4] [eq. 8], and the scales are summed with softmax weights over their amplitudes [eq. 9]. Author-reported: average rank 1.813 across eight datasets against 2.750 for TimesNet [arxiv:2401.00423 tab. 1], and average MSE on Flight of 0.208 against 0.265 [§5.4]. The efficiency table shows lower time per epoch than TimesNet at every horizon, but higher GPU memory at horizons 96, 192 and 336 [tab. 7]. The released code differs from the equations in how scales are chained and how attention is masked, so check the card's Paper vs code before implementing. Card: [MSGNet](/papers/2401.00423).

## Benchmarks and surveys

These cards do not propose a GNN, but their numbers tell an implementer how
GNN baselines behave under a fixed protocol.

### Large-scale graph benchmark (OGB-LSC)

OGB-LSC has three large datasets, one per kind of graph question: node
classification on MAG240M, link prediction on WikiKG90M and graph regression on
PCQM4M [arxiv:2103.09430 §2]. It ships baselines and a summary of the KDD Cup
2021 winners [§2] [§3]. Author-reported single-model test scores on the
original datasets are 69.42% accuracy for R-GAT on MAG240M [arxiv:2103.09430
tab. 2], 0.8637 MRR for ComplEx-Concat on WikiKG90M [tab. 5], and 0.1494 eV MAE
for GIN-virtual on PCQM4M [tab. 6]. The winners' ensembles score higher, but
they also use labels as inputs and ensembles, so compare them only with each
other [§2] [tab. 2].

The WikiKG90M protocol ranks the true tail among 1,000 sampled negatives and
scores only the top 10. Reciprocal rank is zero beyond rank 10, and a repeated
id in any top-10 list sets the whole score to zero [§2.2]
[code: ogb/lsc/wikikg90m.py#L210-L229]. The v2 dataset removes the candidate
tails, and the paper reports 0.1833 MRR for ComplEx-Concat there [§3]. The
paper does not say which split that figure comes from [app. C]. Compare
results only under the same protocol, since ranking by training frequency alone
reaches 0.75 validation MRR on v1 [§2.2] [§3].

Card: [OGB-LSC: A Large-Scale Challenge for Machine Learning on Graphs](/papers/2103.09430).

### Spatio-temporal forecasting benchmark (BasicTS+)

BasicTS+ runs about 45 published models through one training and evaluation
pipeline, with z-score scaling and masked MAE [arxiv:2310.06119 §4.1]. The
paper's central claim is that reported results differ across papers because
of data processing, training and evaluation choices. It reports that Graph
WaveNet's MAE on PEMS04, reproduced in this pipeline, is up to 33% lower than
the values other papers report [arxiv:2310.06119 §4.1].

The paper sorts datasets by temporal pattern and by how indistinguishable their
samples are [arxiv:2310.06119 §5.1] [§5.2]. Its reported finding is that
advanced networks beat linear models only on datasets with clear patterns, and
that GCN-style spatial modelling helps only on datasets whose samples are hard
to tell apart [arxiv:2310.06119 §6.2] [§6.3]. In its STF table, D2STGNN has the
lowest MAE on METR-LA at 2.88 and STEP has the lowest on PEMS-BAY at 1.48
[arxiv:2310.06119 §6.4]. The paper reports seconds per epoch next to accuracy.
STEP takes 497 s per epoch on METR-LA [arxiv:2310.06119 §6.4].

### Molecular property prediction under distribution shift (BOOM)

BOOM holds out, for each property, the molecules whose values have the lowest
density in a kernel density estimate. It evaluates 15 models, averaged over 3
runs [arxiv:2505.01912 §2] [app. A.1]. Its headline is that the top model's
average OOD error is about three times its in-distribution error
[arxiv:2505.01912 abstract].

Among the GNNs, GotenNet has the lowest OOD RMSE on 7 of 10 properties and MACE
on 2 [arxiv:2505.01912 §4.1] [tab. 7]. Averaged over models, the 3D models have
lower OOD RMSE than the graph models on all 10 properties [arxiv:2505.01912
§4.4] [tab. 1]. Pretraining a transformer improves ID error by 12% to 35%, but
OOD error does not change significantly [arxiv:2505.01912 §4.2]. The OOD and
ID scores are only moderately correlated across tasks, with d = 0.4678
[arxiv:2505.01912 §4.7]. Its released QM9 split, the paper's text, and the code
disagree on the size of the test sets; see Contradictions.

### Large models for time series and spatio-temporal data (survey)

This survey has no experiments and trains no model. It sorts the field into
time series (LM4TS) and spatio-temporal data (LM4STD), and the spatio-temporal
branch covers spatio-temporal graphs, temporal knowledge graphs and video
[arxiv:2310.10196 §3] [§5]. Read it as a map of the literature, not as evidence
that a GNN performs well. Its coverage claims are the authors' own
[arxiv:2310.10196 tab. 1].

### Traffic prediction benchmark (DL-Traff)

This paper reviews grid-based and graph-based traffic models and runs a subset
of them under one protocol. The graph models predict 12 future speeds from the
12 past speeds [arxiv:2108.09091 §2]. Author-reported: Graph WaveNet has the
lowest 12-step RMSE and MAE on METR-LA, 11.485 and 4.848, and MTGNN has the
lowest 12-step MAE on PeMS-BAY, 1.950 [arxiv:2108.09091 tab. 5]. The authors
say DCRNN, Graph WaveNet and MTGNN rank in the top three across datasets
[arxiv:2108.09091 §5.2]. The shared protocol is the point of the paper, but the
released code departs from the stated settings in places (see Contradictions).

### Graph transformer survey (Shehzad et al.)

The survey sorts how graph structure enters self-attention: node and edge
positional encodings, message-passing placements, and attention biases
[arxiv:2407.09777 §3.1]. It also sorts how attention is computed, as global
quadratic, global linear or local [§3.2]. Its taxonomy has four types: shallow,
deep, scalable and pre-trained [§4]. It runs no experiments. Its tables are the
authors' own reading of the original papers, and some rows conflict with the
text, for example the attention type of GAT [§3.2.1] [§4.1 table]. Check each
model against its own paper before relying on a row.

Card: [Graph Transformers: A Survey](/papers/2407.09777).

### Graph representation learning survey (Khoshraftar and An)

A survey of static and dynamic graph embedding, covering traditional methods
and GNNs. It runs no experiments [arxiv:2204.01855 §1] [§6]. For GNN limitations
it lists the cause and the named fixes: expressive power, over-smoothing,
scalability, long-range dependencies, catastrophic forgetting, homophily,
substructures, over-squashing and design space [arxiv:2204.01855 §4.6]. The
authors state that the survey covers more than 300 papers, which is their own
count [arxiv:2204.01855 §1].

### Graph learning survey by method family (Xia et al.)

The survey sorts graph learning into four families: graph signal processing,
matrix factorization, random walks, and deep learning on graphs
[arxiv:2105.00696 §1.3]. The deep learning family covers graph convolutional
networks, graph attention networks, graph auto-encoders and spatial-temporal
networks [arxiv:2105.00696 §2.4]. It runs no experiments and reports no
benchmark numbers, so it maps the field rather than ranking methods. It also
gives no training settings for any method [arxiv:2105.00696 §1.3]. Its one
summary table lists methods against neural components and applications, with
repeated rows and two labels that look like typos [arxiv:2105.00696 tab. 2].
Check each cited original before quoting a name or a result.

Card: [Graph Learning: A Survey](/papers/2105.00696).

### Graph-free forecaster with learned identities (STID)

STID drops the graph. It embeds each series' history with one linear map, then
adds three learned identities: one per series, one per time-of-day slot and one
per day of the week [arxiv:2208.05233 §3] [eq. 2]. Residual MLP blocks and a
linear head predict the next steps [eq. 3–4]. The paper's argument is that two
windows can look alike in their history but have different futures, and the
identities separate them [arxiv:2208.05233 §1].

Author-reported: the lowest average MAE on PEMS04, PEMS07, PEMS08, PEMS-BAY and
Electricity among the methods in its table, which includes DCRNN, Graph
WaveNet, AGCRN, MTGNN and GMAN [arxiv:2208.05233 tab. 3]. It also has the lowest
seconds per epoch [arxiv:2208.05233 tab. 2]. The results come from single runs
with no seeds or spread [arxiv:2208.05233 §4]. The paper's Electricity setting
(168 input steps, 12 outputs) differs from the released configuration (336 and
336), so name the configuration you used [arxiv:2208.05233 §4.1].

Card: [Spatial-Temporal Identity: A Simple yet Effective Baseline for Multivariate Time Series Forecasting](/papers/2208.05233).

### Graph neural networks for traffic forecasting (survey)

The survey reviews 212 papers from 2018 to 2020 on GNNs for traffic
forecasting [arxiv:2101.11174 §1]. It sorts the problems into flow, speed,
demand and others, sorts traffic graphs into road, region and station levels,
and classifies adjacency matrices as road-based, distance-based,
similarity-based or dynamic [arxiv:2101.11174 §3] [§4.1]. It lists the GNN
families used, with spectral and spatial convolutions, and a typical
spatio-temporal stack of a 1D-CNN and a GCN [§4.2] [fig. 5]. The benchmark
table copies results from the surveyed papers, which the authors say are not
directly comparable [§5.3] [tab. 11]. Its TaxiNYC and BikeNYC rows are
30-minute results, while its stated default horizon is 60 minutes [§5.3].

Card: [Graph Neural Network for Traffic Forecasting: A Survey](/papers/2101.11174).

### Spatio-temporal GNN survey for urban data (Jin et al.)

The survey maps spatio-temporal GNNs (STGNNs) for city data such as traffic, air
quality and crime. It sorts graph construction into topology, distance,
similarity and interaction rules [arxiv:2303.14483 §2]. It sorts the building
blocks into graph convolution, recurrent units, temporal convolution and
self-attention, and the fusion of space and time into factorised and coupled
designs [arxiv:2303.14483 §5]. Recent variants include adaptive graphs,
multi-scale and decomposition models, and neural ODEs [arxiv:2303.14483 §6]
[§7.4]. It runs no experiments. Its literature count puts transportation above
60% of the surveyed applications [arxiv:2303.14483 §4] [fig. 4].

Card: [Spatio-Temporal Graph Neural Networks for Predictive Learning in Urban Computing: A Survey](/papers/2303.14483).

### Graph neural networks for time series (survey)

The survey covers GNNs for four time-series tasks: forecasting, classification,
anomaly detection and imputation. It gives an objective for each task and a
taxonomy by spatial, temporal and architecture choices [arxiv:2307.03759 §3].
It lists four ways to build the graph from data: inverse travel distance, a 0/1
link graph, similarity between series, and Granger causality [arxiv:2307.03759
§2]. It runs no experiments, and its appendix lists benchmark datasets without
results [arxiv:2307.03759 app. F].

Card: [A Survey on Graph Neural Networks for Time Series: Forecasting, Classification, Imputation, and Anomaly Detection](/papers/2307.03759).

### Lane topology survey (Yao et al.)

This survey sorts lane topology reasoning for HD maps into procedural modeling,
aerial imagery and onboard sensors, and calls the onboard group the current
state of the art [arxiv:2504.01989 §2.3]. It proposes no method and has no
code [arxiv:2504.01989 Paper vs code]. Its onboard pipeline ends in a topology
decoder that may be a GNN, an MLP or a language model, and it gives no
equations for any of them [arxiv:2504.01989 §2.3] [fig. 6].

The useful part for an implementer is the metric definitions. Lane-level
metrics are DET_l, with Fréchet thresholds 1.0, 2.0 and 3.0, and TOP_ll
[arxiv:2504.01989 eq. 6–7]. The survey's tables copy scores for Topo-Boundary
and OpenLane-V2, and the text does not say, row by row, whether each was
re-run or copied [arxiv:2504.01989 tab. 2] [tab. 3]. On OpenLane-V2 subset A,
its TopoNet TOP_ll is 4.1, against 10.9 in the TopoLogic and TopoPoint cards;
see Contradictions.

Card: [A Concise Survey on Lane Topology Reasoning for HD Mapping](/papers/2504.01989).

### Power-system review of GNN families (survey)

The review sorts GNNs into six families: spectral and spatial GCNs, graph
recurrent networks, graph attention, graph generative networks,
spatio-temporal GNNs and hybrid forms [arxiv:2101.10025 tab. I]. It then maps
applications to families, covering fault diagnosis, power forecasting,
power-flow approximation and synthetic data generation [tab. II] [§III]. It has
no method of its own and runs no experiments. Every number it copies comes from
a cited work with different data and splits, so the tables should not be
ranked against one another [arxiv:2101.10025 §III] [Pitfalls]. It gives the
renormalised graph convolution [eq. 9] and the single-head attention form
[eq. 16] [eq. 17].

Card: [A Review of Graph Neural Networks and Their Applications in Power Systems](/papers/2101.10025).

### Graph representation learning in biomedicine (survey)

A review of graph representation learning for biomedical networks, such as protein interactions, drug interactions and co-occurring medical codes. It sorts methods into shallow node embeddings, graph neural networks and generative graph models, and applies them to molecules, genomics, therapeutics and healthcare [arxiv:2104.04883 §1] [§2] [§4]–[§7]. It runs no experiments and gives no metrics or training settings, so use it as a map of the families and read the cited papers for numbers [arxiv:2104.04883 §1]. Card: [Graph Representation Learning in Biomedicine](/papers/2104.04883).

## When to use which

| Situation | Use | Why |
|---|---|---|
| Few labels, a large unlabelled graph collection, node-level task | Pretext-trained encoder, then fine-tune (PF) or freeze (URL) | Labels are costly and purely supervised models over-fit when they are scarce [arxiv:2103.00111 §1]. The PF and JL rows score generally higher than URL rows on node classification [arxiv:2103.00111 tab. 5]. The survey does not say which scheme is best in general. |
| One static graph, no labels, node embeddings for a downstream classifier, and the augmentation strengths can be tuned per dataset | Graph contrastive learning with adaptive augmentation (GCA) | Author-reported: the best label-free row on all five benchmarks, e.g. 93.10 on Coauthor-CS against 92.11 for MVGRL [arxiv:2010.14945 tab. 3]. Against GCN and GAT the best GCA variant leads by 0.03 to 1.11 points on four datasets, and GAT leads on Amazon-Photo [tab. 3]. The paper's per-dataset settings differ across datasets, so expect a search [tab. 5]. |
| Graph-level pretraining with no labels, a GIN-style encoder, and no wish to hand-pick augmentations | Learned edge dropping with a drop-ratio penalty (AD-GCL) | Author-reported 73.32 against 71.26 for GraphCL on COLLAB under linear probing [arxiv:2106.05819 tab. 1]. GraphCL is higher on PROTEINS in the semi-supervised table [tab. 3]. Each run takes 14.4 minutes on COLLAB on one GPU, against 3.2 hours for JOAO [arxiv:2106.05819 app. H]. The code differs from the paper in several places, so check the paper-versus-code notes before you reproduce it. |
| Node classification on a large graph, where the given edges may be incomplete and a linear-cost layer is needed | All-pair message passing with a learned sparse graph (NodeFormer) | Author-reported 77.45 ROC-AUC on OGB-Proteins against 74.63 for GraphSAINT-GAT, at 3.2 GB against 5.2 GB of training memory [arxiv:2306.08385 tab. 2]. Its Gumbel operator is 1.3 to 2.0 points above ordinary softmax at the same τ on that dataset [tab. 2]. The kNN results are best in seven of eight settings [tab. 4]. The random-feature count and τ must be tuned together [§3.2] [§4.4]. |
| Graph-level classification | Train a supervised GNN baseline first | Most URL rows score below the supervised GIN baseline on the datasets they report [arxiv:2103.00111 tab. 7]. Pre-trained encoders do not always help: GCC is not uniformly better than its own URL variant [arxiv:2103.00111 tab. 7]. |
| Edges carry meaning (who spoke, and in what order) and nodes form a sequence | Relation-typed windowed graph | On IEMOCAP, removing speaker pairs costs 3.15 F1 and removing order costs 1.66 F1 against the full model [arxiv:1908.11540 tab. 6]. This is one benchmark with author-reported numbers. |
| Many speakers | Expect a smaller gain | The number of relation types grows as $2M^2$, and the paper gives no rule for mapping speakers to indices across dialogues [arxiv:1908.11540 §3.3.2]. On MELD the gain over DialogueRNN is 1.07 F1 [arxiv:1908.11540 tab. 4]. |
| Linked nodes often differ in label or features, or the graph may be attacked | Feature-similarity graph added to a GCN (SimP-GCN) | Author-reported gain of about 31 points on Cornell over GCN, and 1 to 2 points on the three assortative graphs [arxiv:2011.09643 tab. 3] [tab. 4]. The feature graph needs a dense N × N similarity matrix [arxiv:2011.09643 §4.3]. The paper does not say how λ and γ were chosen [arxiv:2011.09643 §5.1]. |
| No trustworthy graph is available, many nodes with a history each, node-level forecast | Learned graph filter (GCNN-DDGF) | Author-reported test RMSE of 2.12 against 2.50 for the best predefined-graph GCN on 272 stations [arxiv:1712.04997 tab. 3]. Each learned filter has N² entries, here 272 × 272 [arxiv:1712.04997 §4]. The result is from one city and one dataset. |
| Molecules as input, and a fixed encoder choice is acceptable | Molecular MPNN as the compound encoder | On DAVIS the MPNN+AAC pair has the lowest MSE in the figure, but the margin over CNN+CNN is 0.012 [arxiv:2004.08919 fig. 1]. The paper gives no training settings for these numbers [arxiv:2004.08919 §3]. |
| Labelled molecules, a fixed-length fingerprint wanted as model input, and the fingerprint may be trained with the model | Neural fingerprint with a small regression head (neural fingerprints) | Solubility score 0.52 against 1.40 for circular fingerprints with a one-hidden-layer head [arxiv:1509.09292 tab. 1]. On drug efficacy the circular fingerprint with a linear head is slightly better, 1.13 against 1.15 [tab. 1]. The paper uses three regression datasets [§4.2], and the card lists implementation details it leaves out. |
| Tight compute or memory budget | A smaller window | Window (4, 4) reaches 59.41 against 64.18 for (10, 10) [arxiv:1908.11540 §5.2]. A fully connected graph has $O(N^2)$ edges, while the window keeps $p+f$ per node [arxiv:1908.11540 §3.3.2]. |
| New entities at test time, knowledge-graph link prediction | Enclosing-subgraph GNN (GraIL) | Author-reported best inductive AUC-PR on every split, e.g. 94.32 against 90.26 for RuleN on WN18RR v1 [arxiv:1911.06962 tab. 1]. Transductively it is not the strongest model alone [arxiv:1911.06962 §4.2]. Subgraph extraction, not the network, dominates inference cost [arxiv:1911.06962 §3.4]. Hits@10 depends on the negatives sampled [arxiv:1911.06962 §4.1]. |
| Commonsense multiple-choice QA with a knowledge graph and a pretrained LM | QA-GNN, or GreaseLM when the LM and graph should exchange information at several depths | Both report gains over the LM alone on CommonsenseQA: 73.41 for QA-GNN and 74.2 for GreaseLM against 68.69 for RoBERTa-large [arxiv:2104.06378 tab. 3] [arxiv:2201.08860 tab. 2]. QA-GNN's cost is about 360M parameters and about 20 GPU hours on CommonsenseQA [arxiv:2104.06378 §4.5]. GreaseLM's leaderboard row lists about 359M parameters, and its compute is not stated in the main text [arxiv:2201.08860 tab. 4]. |
| Text classification over a fixed corpus, unlabelled test documents available | Word-document GCN with BERT features (BertGCN) | On 20NG, BertGCN reaches 89.3 against 85.3 for BERT [arxiv:2105.05727 tab. 1]. On MR, RoBERTa alone (89.4) is close to RoBERTaGCN (89.7) and above BertGCN with BERT (86.0) [arxiv:2105.05727 tab. 1]. The memory bank needs one embedding per document, refreshed every epoch [arxiv:2105.05727 §3.3]. |
| Diverse discrete objects in proportion to a reward | A flow-matching GNN policy (GFlowNet) | On molecules at 10^5 samples, top-10 mean reward is 8.36 against 8.06 for PPO [arxiv:2106.04399 app. A.7]. The top-1000 set is more diverse, with mean similarity 0.44 against 0.62 for PPO [arxiv:2106.04399 §4.2]. |
| Generate new labelled graphs in one shot | Graph diffusion with a graph transformer denoiser (DiGress) | Author-reported 74% and 75% valid, unique and novel on SBM and planar graphs [arxiv:2209.14734 tab. 1]. Size extrapolation is uneven: it fails on MOSES and works on GuacaMol [arxiv:2209.14734 tab. 7]. |
| Global forecast on a lat-lon grid, enough compute to train for weeks | Mesh GNN encode-process-decode (GraphCast) | Author-reported lower RMSE than HRES-fc0 on 90.3% of 1380 targets [arxiv:2212.12794 §Forecast verification results]. Training used 32 TPU v4 for about 4 weeks [arxiv:2212.12794 app. §4.7]. The output is deterministic, and the MSE objective blurs at long lead times [arxiv:2212.12794 §Conclusions]. |
| Property prediction for molecules whose values lie outside the training range | 3D equivariant GNN, e.g. GotenNet or MACE, checked on your own OOD split | In BOOM, GotenNet has the lowest OOD RMSE on 7 of 10 properties [arxiv:2505.01912 §4.1]. Every model's OOD error is well above its ID error [arxiv:2505.01912 abstract]. No model leads on all tasks, so test on the property you need. |
| Sensors where similar histories can diverge | GCN-style spatial modelling, after checking the data | The paper's results support its hypothesis H2.1, that spatial modelling helps on datasets with significant indistinguishability [arxiv:2310.06119 §5.2] [§6.3]. The released notebook computes only the r2 ratio and uses e_l = 0.4, not the paper's 0.5 [arxiv:2310.06119 §5.2]. |
| Unlabelled network with several kinds of link, node-level task | Per-layer GCN fused by attention, trained on mutual information (HDMI) | Author-reported best Macro-F1 on ACM, IMDB, DBLP and Amazon [arxiv:2102.07810 tab. 3]. Not best on every clustering column, e.g. ACM NMI [arxiv:2102.07810 tab. 4]. The paper does not say whether the fusion module has its own discriminator [arxiv:2102.07810 §4.1.4]. |
| Objects partly hidden by other objects in a mask head | Bilayer non-local graph block (BCNet) | Occluder modelling lifts COCO-OCC AP from 29.04 to 30.37 [arxiv:2103.12340 tab. 1]. The gain is larger on the occlusion subset than on COCO [arxiv:2103.12340 tab. 1]. The loss weights were tuned on a validation set that the paper does not name [arxiv:2103.12340 §3.3]. |
| Each node carries text, and links between nodes matter, with GPU time to spare | Graph attention inside each encoder layer (GraphFormers) | P@1 is higher than the cascaded PLM+Max baseline on all three datasets [arxiv:2105.02605 tab. 2]. Memory at 200 neighbours is 7.33 GiB against 6.92 GiB [arxiv:2105.02605 tab. 5]. Dropping the progressive warm-up lowers DBLP P@1 from 0.7267 to 0.7096 [arxiv:2105.02605 tab. 4]. |
| Vehicle futures on a lane map, several plausible paths needed | Lane-graph policy with a trajectory decoder (PGP) | MinADE10 1.00 against 1.16 for P2T on nuScenes [arxiv:2106.15004 tab. 1]. The graph layer changes MinADE10 by at most 0.01 in the encoder ablation [arxiv:2106.15004 tab. 2], while the decoder ablation spans 0.11 [arxiv:2106.15004 tab. 3]. Only one dataset is evaluated [arxiv:2106.15004 §5]. |
| Sensor series with gaps and a fixed sensor graph | Bidirectional GRU with message-passing gates (GRIL) | MAE 27.1% below BRITS out-of-sample on AQI [arxiv:2108.00298 tab. 1]. A learned graph beats a fully connected one on METR-LA [arxiv:2108.00298 tab. 9]. The method assumes the graph does not change over time [arxiv:2108.00298 §3]. |
| One graph, no environment labels, node-level shift | Adversarially edited graphs with mean-plus-variance risk (EERM) | Gains over ERM on Facebook-100 and OGB-Arxiv are small in places, and some are within one standard deviation [arxiv:2202.02466 tab. 2] [tab. 3]. The editors need an n × n matrix each [arxiv:2202.02466 app. A], so large graphs need a design the paper does not give. |
| Object pose from a short scan, no CAD model | Graph attention over feature tracks (OnePose) | On large objects, 0.471 against 0.435 for HLoc (SuperPoint + SuperGlue) at 58 ms against 618 ms per frame [arxiv:2205.12257 tab. 1]. HLoc is higher on medium objects [arxiv:2205.12257 tab. 1]. The results are on the authors' dataset only. |
| Question answering with a knowledge graph, and you can pretrain | Joint text and graph encoder with bidirectional fusion (DRAGON) | 76.0 on CommonsenseQA against 74.2 for GreaseLM, which uses the graph only at fine-tuning [arxiv:2210.09338 tab. 1]. The paper's pretraining corpora are BookCorpus with ConceptNet, and PubMed with UMLS for biomedicine [arxiv:2210.09338 §3.1] [§4]. |
| Several agents whose motion should turn with the scene | Equivariant interaction graph (EqMotion) | 55.0 mm at 400 ms on H3.6M against 58.3 for SPGSN [arxiv:2303.10876 tab. 2]. Equivariance is proven for the layers as written, not tested on the released code [arxiv:2303.10876 §4.6]. |
| Node classification with few labels, homophily unknown or possibly low | Learned propagation weights (GPR-GNN) | On Texas, 92.92 against 75.16 for GCN [arxiv:2006.07988 tab. 2]. APPNP is higher on Cornell [tab. 2]. The learned weights can be negative and nothing in the method constrains them, so inspect their signs on your graph [§4]. |
| Citation-style benchmarks where the useful neighbourhood distances are unknown | Higher-order mixing (MixHop) | Learned widths score 0.4 to 1.8 points above the GCN row on the Planetoid splits [arxiv:1905.00067 tab. 1]. Learning the widths needs the five-stage search [§4.2]. |
| Multivariate sensors with no known sensor graph, normal data only | Learned sensor graph (GDN) | F1 0.81 on SWaT against 0.77 for MAD-GAN, and 0.57 on WADI against 0.37 [arxiv:2106.06947 tab. 2]. Replacing the learned top-k graph with the complete graph lowers WADI F1 to 0.51 [tab. 3]. |
| Two-stage LiDAR detector, and GPU time for a refinement stage | Proposal graph refiner (BADet) | Car moderate AP3D on KITTI validation is 85.77, against 84.52 for Voxel R-CNN [arxiv:2104.10330 tab. 2]. The refiner takes about 62 ms of a 140 ms frame [§4.5] [tab. 8]. Results fall at T = 5 [tab. 7]. |
| Skeleton action recognition, where one shared joint topology limits the features | Channel-wise topology refinement (CTR-GCN) | 88.9 cross-subject on NTU RGB+D 120, against 87.3 for Dynamic GCN [arxiv:2107.12213 tab. 5]. The model has 1.46M parameters against 1.22M for the ST-GCN baseline [tab. 2]. The authors' code is non-commercial, so write the implementation from the paper. |
| Branch-and-bound variable choice in a mixed-integer solver, where strong branching is too slow at every node | Bipartite GCN that imitates strong branching (learn2branch) | Author-reported acc@1 of 65.5 on set covering against 57.6 for SVMrank [arxiv:1906.01629 tab. 1]. Training takes 3.8 to 18.2 hours per problem, and the labels need a re-implementation of strong branching inside SCIP [arxiv:1906.01629 suppl. §5] [suppl. §1]. |
| Explain many instances, or unseen nodes or graphs, from a frozen GNN | Amortised explainer (PGExplainer) | Explanation AUC of 0.963 against 0.925 for GNNExplainer on BA-Shapes [arxiv:2011.04573 tab. 2]. Inference is about 6 to 80 ms per instance against 410 to 935 ms, but the explainer's training time is excluded [tab. 2] [app. C.1]. Feature explanations are not evaluated [app. D]. |
| Two 3D scans with little shared surface to register | Overlap-attention GNN (PREDATOR) | 3DLoMatch recall of 59.8% against 40.1% for FCGF at 5000 samples [arxiv:2011.13005 tab. 2]. The block takes 70 ms of a 271 ms pair on 3DMatch, and cross-attention memory grows with the square of the superpoint count [tab. 11] [app. A.3]. |
| Road sensors with a distance graph and a similarity graph, 60-minute forecast | Graph ODE with restart term (STGODE) | Lowest RMSE, MAE and MAPE on all six PeMS datasets [arxiv:2106.12931 tab. 2]. The margin is small on PeMS04, 32.82 against 33.65 for STSGCN [tab. 2]. No variance is reported [§5.4]. The released code differs from the text in ways that change the model [§Paper vs code]. |
| Periodic micro-structure with stress needed at each node, and FE data to train on | Mesh GNN with a divergence penalty (P-DivGNN) | Hyperelastic NMSE of 2.18e-2 against 5.36e-2 for the periodic GNN [arxiv:2507.05291 tab. 2]. Inference is about 500 times faster than FE on hyperelastic meshes, comparing GPU with CPU and excluding training [§5.3.1]. The penalty weight depends on the stress scale [§5.2]. |
| Unlabelled attributed network, anomalies unknown, and a per-node score needed | Node-subgraph contrast with sampled scores (CoLA) | Author-reported best ROC-AUC on all seven benchmark columns, 0.9512 on Pubmed [arxiv:2103.00113 tab. 3]. Scoring draws 256 positive and 256 negative samples per node, and the sampling is the main cost on large graphs [arxiv:2103.00113 §4.5]. The anomalies are injected, so the scores do not show real-world accuracy [arxiv:2103.00113 §5.1]. |
| Graph-level regression on molecules, with compute for full pairwise attention | Graphormer | Author-reported validation MAE 0.1234 on PCQM4M-LSC against 0.1395 for GIN-VN [arxiv:2106.05234 tab. 1]. Full attention grows with the square of the node count, and the paper leaves large graphs to future work [arxiv:2106.05234 §6]. Check the layer-norm placement, because the text and the released scripts differ [arxiv:2106.05234 §3.2] [code: examples/property_prediction/pcqv2.sh#L18-L21]. |
| Small molecular graphs where message passing misses node positions, and a sparse GNN is preferred | Learned positional stream with RWPE starts (LSPE) | Author-reported test MAE 0.090 on ZINC for GatedGCN-LSPE against 0.251 without positional encoding [arxiv:2110.07875 tab. 1]. The optional Laplacian loss adds only a small gain, from 0.093 to 0.090 [arxiv:2110.07875 §4.2]. Gains on the OGB datasets are comparable to the baselines, not clearly better [arxiv:2110.07875 §4.2] [tab. 2]. |
| Multivariate sensor series with no known graph, and a simple, fast baseline wanted | Graph-free forecaster with learned identities (STID) | Lowest average MAE on five benchmarks in the paper's table, from single runs [arxiv:2208.05233 tab. 3]. It conflicts with the sensor-graph row above, since STID argues that identities rather than a graph resolve indistinguishable samples [arxiv:2208.05233 §1]. See Contradictions. |
| Lane or road-element links at intersections, where predicted endpoints rarely meet exactly | Geometric endpoint-gap matrix fused with query similarity (TopoLogic) | Author-reported TOP_ll 23.9 against 10.9 for TopoNet on OpenLane-V2 subset_A [arxiv:2405.14747 tab. 1]. Geometry alone gives 20.1 [tab. 4]. Post-processing gains are reported for TopoNet, SMERF and LaneSegNet, but the repository has no code for applying the step to them [arxiv:2405.14747 tab. 5] [§Pitfalls]. The model needs eight GPUs for 24 epochs, and its N × N topology grows with the square of the query count [arxiv:2405.14747 §4.2]. |
| Lane-topology model where lane ends must coincide, and extra endpoint queries and a second graph pass are affordable | Point-lane graph with endpoint queries (TopoPoint) | Author-reported OLS 48.8 against 44.1 for TopoLogic on subset A [arxiv:2505.17771 tab. 1]. DET_p, the endpoint score, is the authors' own metric [§4.1]. The matching step's gain is 0.5 OLS in the paper's ablation, and the released code runs a different rule [tab. 2] [§Paper vs code]. Training uses eight V100 GPUs for 24 epochs [§4.2]. |
| Edges that are signed (friend or foe) or directed, and the task is sign, direction or link-type prediction | Magnetic signed Laplacian GNN (MSGNN) | Author-reported 73.0 against 70.1 for SSSNET on BitCoin-OTC sign prediction, and 86.3 against 73.9 on Epinions direction prediction [arxiv:2209.00546 tab. 1]. The main table's charge q is not stated, so pick one and report it [arxiv:2209.00546 Paper vs code]. The formulas keep self-loops, but the code removes them [§3.1]. |
| Node classification where neighbours often carry different labels, with budget to tune per dataset | Adaptive channel mixing (ACM-GCN) | 94.75 against 82.46 for GCN on Cornell, under random 60/20/20 splits [arxiv:2210.07606 app. A.1]. On the Geom-GCN fixed splits it trails GGCN and GloGNN++ on Cornell [app. A.2]. It costs about twice GCN's time per epoch [tab. 1]. Check the released code's scale factor of 3 before comparing [arxiv:2210.07606 Paper vs code]. |
| Multivariate forecasting with a short window, no sensor graph, and a small parameter budget | Fully connected space-time graph in the Fourier domain (FourierGNN) | Horizon-12 Traffic MAE 0.011 against 0.013 for GraphWaveNet, with 190,564 against 280,860 parameters [arxiv:2311.06190 tab. 1] [tab. 3]. LSTNet has the lower Traffic MAPE [tab. 1]. The released code uses diagonal weights and no adjacency, so it does not match the paper's model [arxiv:2311.06190 Paper vs code]. |
| Traffic forecasting, a long history to pre-train on, and a frozen pre-trained encoder fits the budget | Pre-trained encoder supplying a sparse learned graph (STEP) | Horizon-12 MAE 3.37 against 3.53 for Graph WaveNet on METR-LA, and 1.79 against 1.95 on PEMS-BAY [arxiv:2206.09113 tab. 2]. Pre-training is run once per dataset [§4.1]. In the released code the learned graph is nearly static and test-time predictions are random [arxiv:2206.09113 Pitfalls]. |
| Edges are noisy or partly irrelevant to the task, and the GNN can be trained end to end | Learned per-layer edge gates with an edge-count penalty (PTDNet) | Author-reported GCN on Cora at 0.828 against 0.811 for the basic model, within one standard deviation [arxiv:2011.07057 tab. 3]. Gains are larger with injected noisy edges [§5.3]. The public code covers GCN only and cannot load PPI, and its default γ = 0 appears to switch off the edge-count term (read from the code, not run) [Learning to Drop, Paper vs code]. |
| Several series with rhythms at different periods, where the links between series may change with the period | Per-period adaptive graphs over FFT-selected scales (MSGNet) | Author-reported average rank 1.813 across eight datasets against 2.750 for TimesNet [arxiv:2401.00423 tab. 1]. Training is faster than TimesNet at every horizon, but GPU memory is higher at short horizons [tab. 7]. The released code differs from the equations, so see the card before implementing [MSGNet, Paper vs code]. |
| Scene graphs with long-tailed predicates and objects of unequal importance | Direction-aware message passing with a node-priority loss (GPS-Net) | Author-reported mean 45.9 against 43.7 for MOTIFS on Visual Genome [arxiv:2003.12962 tab. 1]. Message passing gives the largest single ablation gain, SGDET R@50 from 26.3 to 28.1 [tab. 5]. The released code differs in priority definition and exponent [GPS-Net, Paper vs code]. |

## Implementation sketch

Four patterns: pretraining a GNN encoder on a pretext loss, a relation-typed
layer, a GCN layer with a feature-similarity graph, and a layer with a learned
graph filter. The pseudocode is ours.
Lines follow the cited equations. The other variants use the same
aggregate-and-combine form, with the differences listed above.

```pseudocode
# Step A: pretext pre-training of a GNN encoder  [arxiv:2103.00111 eq. 1]
# Input:  unlabelled graphs D = [(X, A), ...]; encoder f; pretext head p
def pretrain(D, f, p, ssl_loss, opt):
    for X, A in D:
        # Node embeddings from features and adjacency  [§3.1]
        H = f(X, A)
        # Pretext loss: reconstruction, property or view agreement  [§3.2]
        loss = ssl_loss(p(H), X, A)
        opt.step(loss)
    return f

# Step B: downstream training on labels  [arxiv:2103.00111 eq. 2]
# PF: keep training f. URL: freeze f, train only q  [§3.3]
def finetune(G, y, f, q, opt, frozen):
    H = f(G.X, G.A)
    loss = cross_entropy(q(H[G.labelled]), y)
    params = q.params if frozen else f.params + q.params
    opt.step(loss, params)
```

```pseudocode
# Relation-typed windowed layer  [arxiv:1908.11540 eq. 1-2]
# Input:  g (N, d) sequence features; window[i] neighbour ids incl. i;
#         rel[i][j] relation id of edge j -> i
def relation_layer(g, window, rel, W_rel, W_root):
    # Edge weights: softmax of bilinear scores over each window  [eq. 1]
    alpha = window_softmax(g, window)
    out = []
    for i in range(N):
        # Self term, then relation-specific neighbour sum  [eq. 2]
        # c_{i,r} normalisation is fixed or learned; not stated [§3.3.2]
        h = alpha[i][i] * (W_root @ g[i])
        for j in window[i]:
            if j != i:
                h += alpha[i][j] * (W_rel[rel[i][j]] @ g[j])
        out.append(relu(h))
    return out
```

```pseudocode
# One SimP-GCN layer, paper formula  [arxiv:2011.09643 §4.1]
# Input:  H (N, d); A_hat, K_hat normalised original and kNN graphs
# Output: (N, d')
def simp_gcn_layer(H, A_hat, K_hat, W, w_s, b_s, w_k, b_k, gamma, activate):
    HW = H @ W                                         # (N, d')
    # Per-node balance between the two graphs, in (0, 1)  [§4.1]
    s = sigmoid(H @ w_s + b_s)                         # (N, 1)
    # Per-node self-loop count  [§4.1]
    k = H @ w_k + b_k                                  # (N, 1)
    # One activation over the combined propagation  [§4.1]
    out = s * (A_hat @ HW) + (1 - s) * (K_hat @ HW) + gamma * k * HW
    return relu(out) if activate else out
```

```pseudocode
# One learned-filter layer, paper formula  [arxiv:1712.04997 eq. 9] [eq. 15]
# Input:  X (N, C); A_hat (N, N) learned, trained with the other weights
# Output: (N, C')
def ddgf_layer(X, A_hat, W, b, activate):
    # Keep the learned matrix symmetric; the paper does not say how  [§3.3.1]
    filt = 0.5 * (A_hat + A_hat.T)                     # (N, N)
    # Symmetric degree normalisation  [eq. 15]
    d = filt.sum(axis=1) ** -0.5                        # (N,)
    norm = d[:, None] * filt * d[None, :]               # (N, N)
    # Mix stations, then transform features  [eq. 9]
    out = (norm @ X) @ W + b                            # (N, C')
    return relu(out) if activate else out
```

## Contradictions

- **Graph-free versus graph-based forecasting.** STID reports the lowest
  average MAE on five sensor datasets without using any graph
  [arxiv:2208.05233 tab. 3]. BasicTS+ finds that GCN-style spatial modelling
  helps only on datasets whose samples are hard to tell apart
  [arxiv:2310.06119 §6.3]. STID names the same indistinguishability as the
  bottleneck, but argues that identities fix it [arxiv:2208.05233 §1]. The two
  cards do not report a shared protocol, so this disagreement is not settled
  here.
- **Survey versus itself (anomaly scores).** The GNN time-series survey sums
  absolute channel errors for its anomaly score [arxiv:2307.03759 §5.1], but
  describes GDN as using the maximum channel error [arxiv:2307.03759 §5.2]. A
  sum and a maximum react differently to one large channel error. The survey
  does not say which one to use.
- **Paper versus public code (LSPE).** The paper treats the Laplacian
  orthogonality term as differentiable [arxiv:2110.07875 eq. 12]. The released
  code detaches that term before computing it, so it adds a constant to the
  loss value and no gradient [code: nets/ZINC_graph_regression/gatedgcn_net.py#L154-L156].
  Only the trace term trains as written.
- **Paper versus public code (Graphormer).** The text describes pre-layer-norm
  [arxiv:2106.05234 §3.2], but the PCQM4M and ZINC scripts train post-layer-norm
  unless a flag is set [code: examples/property_prediction/pcqv2.sh#L18-L21].
  An implementation that follows the text may behave differently from the
  released scripts.
- **Paper versus public code (DialogueGCN).** The paper writes a bilinear edge
  score and an activation σ in both graph layers [arxiv:1908.11540 eq. 1–3].
  The public code scores edges with a learned vector per absolute position and
  applies no activation in the graph layers
  [code: DialogueGCN/model.py#L540-L568] [code: DialogueGCN/model.py#L796-L807].
  Neither reproduces the other.
- **Reported numbers may be optimistic (DialogueGCN).** The public IEMOCAP script prints the
  maximum test F1 over all epochs [code: DialogueGCN/train_IEMOCAP.py#L322-L336].
  The official README reports 64.67 and 64.44 with a different configuration
  from the paper's. The paper reports 64.18 [arxiv:1908.11540 tab. 3].
- **Compiled numbers come from different protocols.** The graph
  self-supervision survey says it runs an experimental comparison, but most
  rows of its tables are copied from the original papers, which use different
  protocols. The survey does not say which rows were re-run
  [arxiv:2103.00111 §8].
- **Paper versus public code (SimP-GCN).** The paper applies one activation
  to the combined propagation [arxiv:2011.09643 §4.1]. The released code applies
  ReLU to each branch and then sums them
  [code: raw/code/2011.09643/src/models_simp.py#L170-L174]
  [code: raw/code/2011.09643/src/layers.py#L69-L87]. The self-supervised head
  takes the difference of hidden states in the paper and its absolute value in
  the code [arxiv:2011.09643 §4.2]
  [code: raw/code/2011.09643/src/selfsl.py#L85-L90]. The repository has no
  license file, so this page cites it and copies no code.
- **Baseline GCN numbers differ between cards.** The survey lists GCN at 81.5
  on Cora and 70.3 on Citeseer [arxiv:2103.00111 tab. 5]. SimP-GCN lists GCN at
  81.3 and 71.5 on the same datasets [arxiv:2011.09643 tab. 3]. The survey also
  lists SimP-GCN's own numbers, 82.8, 72.6 and 81.1 [arxiv:2103.00111 tab. 5].
  The cards do not say which GCN numbers were rerun.
- **Learned filter: paper versus public code.** The paper's output layer
  applies the graph filter [arxiv:1712.04997 eq. 10], and eq. 15 has one
  filter for the whole network. The repository, as checked for the card, has
  no filter in the output layer and learns one filter per hidden layer. It also
  uses Adam, where the paper says classic SGD [arxiv:1712.04997 §5.1], and a
  learning rate of 0.01 against 0.005 in Table 2 [arxiv:1712.04997 tab. 2]. The
  public code implements only the regular variant. The recurrent variant
  behind the best reported RMSE cannot be checked against code. The card's
  Paper vs code section lists the details.
- **Readout: paper versus public code (MPNN).** The paper says the MPNN readout
  is the mean or the sum over atoms [arxiv:2004.08919 app. A]. The card's check
  of the public code finds the mean only.
- **PPI scale.** GAT scores 97.3 on PPI, far above every self-supervised row
  (51 to 74). The PPI metric is not named, so the column cannot be compared
  across rows without checking each original paper [arxiv:2103.00111 tab. 5].
- **QA-GNN: relevance score, paper versus code.** The paper defines a node's
  relevance as the LM probability of the node text given the QA context
  [arxiv:2104.06378 §3.2] [eq. 1]. The released code instead uses the summed
  token loss of a sentence built from the QA context and the node name, with
  no tokens masked, and it centres and rescales the result on the context node
  [arxiv:2104.06378 §Paper vs code]. The code also uses 4 attention heads where
  the paper describes one, and it multiplies attention weights by the source's
  out-degree [arxiv:2104.06378 §Paper vs code]. Follow the paper or the code,
  and state which one you reproduce.
- **GraIL: label order, paper versus code.** The paper's first label component
  is the distance to u, computed while avoiding v [arxiv:1911.06962 §3.1]. The
  code computes that component with u removed, so it holds the distance to v
  [arxiv:1911.06962 §Paper vs code]. Edge dropout is also scaled by PyTorch's
  rule, so a kept edge has weight 2 in training. The paper does not mention
  this [arxiv:1911.06962 §Paper vs code]. The repository has no license file.
- **GreaseLM: initial interaction node and residuals, paper versus code.** The
  paper says the interaction node is initialised randomly [arxiv:2201.08860
  §4.3]. The code sets it to zero [arxiv:2201.08860 §Paper vs code]. The code's
  GNN layer also has no residual term, which the paper's equation includes
  [arxiv:2201.08860 §Paper vs code]. The text gives a gain of 0.9 over LM+KG
  models on CommonsenseQA test, while the table gives 0.8 [arxiv:2201.08860
  tab. 2] [§6].
- **BertGCN: default encoder, paper versus code.** The paper's headline model
  uses BERT-base [arxiv:2105.05727 §4.1]. The code's default encoder is
  RoBERTa-base, so running the defaults gives RoBERTaGCN, not BertGCN
  [arxiv:2105.05727 §Paper vs code]. The code also truncates BERT's input to
  128 tokens, while the graph uses the full text [arxiv:2105.05727 §Pitfalls].
- **GFlowNet: epsilon and loss scale, paper versus code.** The paper's
  epsilon is 2.5e-5 [arxiv:2106.04399 app. A.4]. The molecule configuration in
  the code sets it to about 2.4e-8 [arxiv:2106.04399 §Paper vs code]. The paper
  sums the loss over trajectory states, while the code averages each part over
  the batch [arxiv:2106.04399 §Paper vs code]. Learning rates do not transfer
  directly between the two.
- **DiGress: edge weight and guidance, paper versus code.** The paper leaves the
  edge weight lambda unset, while the code uses 5 in every experiment
  [arxiv:2209.14734 §3.2] [§Paper vs code]. The regressor for guided
  generation is not in the repository, and its scale is not stated in the
  paper, so the guided QM9 results cannot be reproduced from the repository
  [arxiv:2209.14734 §5] [alg. 3].
- **GraphCast: deployed model and training.** The released weights include an
  operational model fine-tuned on HRES data, which the paper does not describe
  [arxiv:2212.12794 §Paper vs code]. The paper's training schedule has no
  counterpart in the repository [arxiv:2212.12794 app. §4.5].
- **BasicTS+: evaluation scale.** The paper reports metrics on re-normalised
  data [arxiv:2310.06119 §4.2]. The released code leaves rescaling off by
  default, so its default metrics are on normalised values [arxiv:2310.06119
  §Paper vs code]. The code's WAPE and MAPE also differ from the paper's
  formulas [arxiv:2310.06119 §Paper vs code].
- **BOOM: test-set sizes.** The paper's text gives the OOD set as the lowest
  10% of QM9 and the ID set as 10% of QM9 [arxiv:2505.01912 app. A.1]. The
  released code uses 10,000 OOD molecules and 5% ID [arxiv:2505.01912 §Paper vs
  code]. The table labels Random Forest and MLP as SMILES models, though they use
  RDKit descriptors [arxiv:2505.01912 tab. 7] [§Paper vs code].
- **BCNet: normalisation and boundary loss, paper versus code.** The paper uses
  layer normalisation and ReLU in its graph layer [arxiv:2103.12340 §3.2]. The
  code uses batch normalisation and no ReLU [code: detectron2/modeling/roi_heads/mask_head.py#L397-L398].
  The boundary loss is summed twice before a weight of 0.5, so one boundary term
  has weight 1.0 where the paper gives 0.5 [arxiv:2103.12340 §3.3]
  [code: detectron2/modeling/meta_arch/fcos.py#L208-L209].
- **GraphFormers: attention form and masking, paper versus code.** The paper's
  asymmetric attention takes its queries from the plain tokens [arxiv:2105.02605 eq. 4].
  The code uses standard self-attention over the augmented tokens
  [code: src/models/modeling_graphformers.py#L165]. The paper masks the tokens of
  every input node [arxiv:2105.02605 §3.3]; the code masks only the centre node
  [code: src/data_handler.py#L166-L168].
- **GRIL: kernel width and validation split, paper versus code.** The paper sets
  the kernel width to the standard deviation of distances [arxiv:2108.00298 app. B.1].
  The code divides by that standard deviation squared
  [code: lib/datasets/air_quality.py#L81-L82]. The paper's traffic and CER-E
  split is 70 / 10 / 20 [arxiv:2108.00298 app. B.2]; the code gives 72 / 8 / 20.
- **EERM: editor normalisation and resets, paper versus code.** The paper
  normalises each editor row with a softmax [arxiv:2202.02466 app. A]. The code
  takes the softmax over the other dimension [code: synthetic/model.py#L99-L103].
  Algorithm 1 carries the editors across iterations [arxiv:2202.02466 alg. 1];
  the code resets them every epoch [code: synthetic/main.py#L108].
- **OnePose: attention form, paper versus code.** The paper says linear attention
  is used in all attention layers [arxiv:2205.12257 §4.2]. In the code only the
  self and cross layers use it; the aggregation layers use softmax attention
  [code: src/models/GATsSPG_architectures/GATs.py#L43-L44]. The aggregation score
  is an inner product in the paper [arxiv:2205.12257 §3.2] and an additive
  LeakyReLU score in the code [code: src/models/GATsSPG_architectures/GATs.py#L78-L88].
- **DRAGON: negative term and pretraining recipe.** Eq. 10 as printed gives the
  negative triples the same sign as the positive one, so the printed objective has
  no finite minimum. The code uses −log σ(−φ′) instead
  [arxiv:2210.09338 eq. 10] [code: modeling/modeling_gnn.py#L216]. The released
  pretraining script is a CommonsenseQA demo, not the recipe in the paper
  [arxiv:2210.09338 §3.1] [code: scripts/run_pretrain.sh#L9].
- **EqMotion: layers, paper versus code.** The code adds a residual term in the
  inner-agent attention that eq. 6 does not have [arxiv:2303.10876 eq. 6]
  [code: h36m/gcl_t.py#L136-L143]. It also passes the aggregated factors through
  an extra MLP that eq. 7 does not include [arxiv:2303.10876 eq. 7]
  [code: h36m/gcl_t.py#L115-L118]. The equivariance theorem covers the layers as
  written, so it does not cover these additions [arxiv:2303.10876 §4.6].
- **DL-Traff: grid settings, paper versus code.** The paper states MAE for every
  model and a learning rate of 0.001 [arxiv:2108.09091 §5.1]. The grid code uses
  MSE [code: grid/workTaxiBJ/predflowio/Param_STDN.py#L15] and a learning rate of
  0.0001 [code: grid/workTaxiBJ/predflowio/Param_STDN.py#L12]. It computes only
  the MSE, so the paper's grid MAE and MAPE cannot be reproduced from it
  [code: grid/workTaxiBJ/predflowio/predflowio_STDN_noflow.py#L112].
- **PGP: which encoder gives the headline row.** Table 1's PGP row matches the
  encoder with no GNN layers, while the text describes two GAT layers
  [arxiv:2106.15004 tab. 1] [tab. 2] [§5]. The paper does not say which setting
  produced Table 1. The gap is 0.01 MinADE10, so the choice does not change the
  comparison's direction.

- **Heterophilic GCN baselines differ between cards.** SimP-GCN reports GCN at
  52.16 on Texas and 52.70 on Cornell, copied from GCNII [arxiv:2011.09643
  tab. 4] [§5.2]. GPR-GNN reports GCN at 75.16 on Texas and 66.72 on Cornell
  [arxiv:2006.07988 tab. 2]. GPR-GNN uses random 60 / 20 / 20 splits on
  heterophilic graphs [§5]. The cited sections do not say whether the two
  papers' splits and runs match, so the numbers are not reconciled here.
- **Filter theory versus the training recipe (GPR-GNN).** The
  over-smoothing argument assumes SGD with a decreasing learning rate
  [arxiv:2006.07988 §4] [app. A.4]. The experiments use Adam [app. A.9]. The
  cited sections do not say how the argument applies to Adam.
- **Threshold selection (GDN).** The paper sets the threshold to the maximum
  validation score [arxiv:2106.06947 §3.6] [§4.3]. The released script's
  default picks the threshold that maximises F1 on the test labels
  [code: run.sh#L20] [code: evaluate.py#L141-L144]. Numbers from the default
  run may therefore be optimistic.
- **Text versus table (CTR-GCN).** The paper says its method is best under
  nearly all benchmarks [arxiv:2107.12213 §4.6]. On NTU RGB+D cross-view,
  DDGCN scores 97.1 against 96.8 for CTR-GCN [tab. 6].
- **learn2branch: GNN architecture, paper versus code.** The paper has one
  constraint node per LP row [arxiv:1906.01629 §4.2]. The code makes one node
  per finite side of a row, so a ranged row gives two nodes with opposite-sign
  features [arxiv:1906.01629 §Paper vs code]. The code also adds a two-layer
  embedding for constraints and for variables, and an extra prenorm inside the
  message, neither of which the paper describes [arxiv:1906.01629 §Paper vs
  code]. Reproduce one of the two and say which.
- **learn2branch: table counts disagree.** For set covering, the GCNN node
  counts for medium and hard instances are 1450 and 29981 in tab. 2, but 1870
  and 56348 in tab. 3. The times agree to rounding [arxiv:1906.01629 tab. 2]
  [tab. 3]. The mapping of tab. 2's four blocks to problem families is inferred,
  because the titles sit outside the blocks in the source [arxiv:1906.01629
  tab. 2].
- **PGExplainer: relative gain.** The printed 24.7% gain on BA-2motifs is
  measured against GNNExplainer (0.742). Against the best printed baseline,
  Gradient at 0.773, PGExplainer's 0.926 is about 19.8% higher, by the card's
  calculation from the table [arxiv:2011.04573 tab. 2].
- **PGExplainer: dataset size and layer sizes.** The text describes 800
  BA-2motifs graphs, while the table lists 1,000 [arxiv:2011.04573 §5.1]
  [tab. 1]. The appendix's explanation layers do not chain: the first outputs
  64 values and the second takes 20 [arxiv:2011.04573 app. B].
- **PREDATOR: headline numbers across versions.** The arXiv abstract and the
  LaTeX source give different headline figures, "more than 20%" and "89%"
  against "more than 15 percent points" and "90.6%". The table gives 89.0 at
  5000 samples and 90.6 at 1000 [arxiv:2011.13005 tab. 2]. Cite the tables.
- **PREDATOR: loss and training, paper versus code.** The paper sums the
  matchability loss over all points [arxiv:2011.13005 eq. 11]; the code computes
  it only on ground-truth overlap points [arxiv:2011.13005 §Paper vs code]. The
  paper adds the matchability loss after a few epochs [§3.5]; the code keeps its
  weight at zero until validation feature-match recall passes 0.3 [§Paper vs
  code]. The paper gives no temperature for the soft assignment, and the code
  learns one [arxiv:2011.13005 eq. 7] [§Paper vs code].
- **PREDATOR: split sizes.** The text gives 46 training, 8 validation and 8 test
  scenes [arxiv:2011.13005 §4.1]. The appendix gives 54 training and 8 test
  scenes for the official benchmark [arxiv:2011.13005 app. A.2].
- **STGODE: model structure, paper versus code.** The paper's temporal
  convolution is a dilated stack with a residual [arxiv:2106.12931 §4.3]. The
  code returns the ReLU of its input, and skips the dilated stack, whenever the
  input and output channel counts match. That is six of 24 temporal-convolution
  instances [arxiv:2106.12931 §Paper vs code]. The code scales the spatial term
  by a learnable factor that starts near 0.345, not the paper's fixed α = 0.8
  [arxiv:2106.12931 §3.2] [§Paper vs code]. Its U and W matrices are not
  orthogonal as the paper requires, so the eigenvalue bound of §4.2 does not
  carry over [arxiv:2106.12931 §4.2] [§Paper vs code].
- **STGODE: graphs, training and leakage.** The code z-scores distances before
  the Gaussian kernel, while the paper uses raw distances [arxiv:2106.12931 eq.
  4]. The code's semantic graph uses a daily profile and a z-score-based kernel.
  By the card's derivation from the code, not run, it keeps pairs whose DTW
  distance lies within about 0.07 standard deviations of the mean [§Paper vs
  code]. Z-score statistics and the daily profile use the full series,
  including validation and test periods [§Paper vs code]. The paper uses Adam
  at learning rate 0.01 with batch 32, while the code uses AdamW at 2e-3 with
  batch 16 [arxiv:2106.12931 §5.3] [§Paper vs code].
- **STGODE: names and sensor counts.** The text says PeMSD3 and gives 288
  sensors for PeMSD7(M), where the table and the code say PeMS03 and 228
  [arxiv:2106.12931 §5.1] [tab. 1].
- **P-DivGNN: learning rate and penalty weight, paper versus code.** The paper
  uses learning rate 1e-2 on both datasets [arxiv:2507.05291 §4.2] [§5.2]. Both
  released training configs use 0.001 [§Paper vs code]. The paper sets λ = 1e-2
  for hyperelastic data, and the hyperelastic config uses 10 [§5.2] [§Paper vs
  code].
- **P-DivGNN: stopping, edges and divergence values.** The paper uses early
  stopping with patience 20 on validation NMSE [§4.2]. The released configs turn
  it off and keep the checkpoint with the lowest test loss [§Paper vs code]. The
  paper sets periodic edge features to zero [§3.1]; the code standardises them
  with the other edge features [§Paper vs code]. Section 4.3 gives a linear
  divergence of 4.56e-4 for P-DivGNN, and tab. 1 gives 3.23e-4 [arxiv:2507.05291
  §4.3] [tab. 1].
- **Paper versus public code (TopoLogic).** The paper's mapping has a learnable
  α, starting at 0.2, and a learnable λ, starting at 2, with σ in the exponent
  [arxiv:2405.14747 §3.3] [§4.2]. The released code learns P and w instead,
  starting at 2 and 10, and computes σ without using it [arxiv:2405.14747
  §Paper vs code]. Its inference path hard-codes P = 2, w = 11.5275 and both
  fusion scalars at 1, so reported results may not reflect the learned values
  [§Paper vs code].
- **Lane-topology numbers, survey versus other cards.** On OpenLane-V2 subset
  A, the survey's table gives TopoNet TOP_ll 4.1, TopoMLP 7.2, and TopoLogic
  DET_l 34.4 and TOP_ll 23.4 [arxiv:2504.01989 tab. 3]. TopoPoint's table gives
  10.9, 21.6, 29.9 and 23.9 for the same rows [arxiv:2505.17771 tab. 1], and the
  TopoLogic card gives 23.9 and 10.9 for TopoLogic and TopoNet [arxiv:2405.14747
  tab. 1]. The survey does not say which source its rows were copied from, so
  the numbers are not reconciled here.
- **Paper versus public code (TopoPoint).** The paper's point-to-lane matching
  is commented out in the released code, and the active refinement matches lane
  ends to other lanes' starts with a similarity threshold, not the paper's 1.5 m
  distance [arxiv:2505.17771 §Paper vs code]. The code also builds no geometric
  attention mask and uses unnormalised graph adjacencies [§Paper vs code]. Its
  geometric matrices are detached, so the topology losses do not reach the
  endpoints through them [arxiv:2505.17771 §Pitfalls]. The ablation's matching
  gain is for the paper's version, not for the released code.
- **Graph WaveNet numbers across papers.** BasicTS+ reports that, in its own
  pipeline, Graph WaveNet's PEMS04 MAE is up to 33% lower than other papers
  report [arxiv:2310.06119 §4.1]. STEP's table gives Graph WaveNet an MAE of
  20.69 at horizon 12 on PEMS04 [arxiv:2206.09113 tab. 2]. The two cards use
  different protocols and horizons, so the figures are not directly
  comparable, and this card does not settle which is right.

## Papers

- [Predicting Station-level Hourly Demands in a Large-scale Bike-sharing Network](/papers/1712.04997): a GCN whose graph filter is learned from data, with a regular and an LSTM-based variant for hourly bike demand.
- [DialogueGCN: A Graph Convolutional Neural Network for Emotion Recognition in Conversation](/papers/1908.11540): a windowed, relation-typed graph layer over a BiGRU encoder for text-only emotion recognition in conversation.
- [Graph Self-Supervised Learning: A Survey](/papers/2103.00111): frames GNN pretraining as an encoder trained on a pretext loss, with three training schemes and compiled node- and graph-classification results.
- [Graph Contrastive Learning with Adaptive Augmentation](/papers/2010.14945): GCA, two centrality-guided augmented views of a graph with a node-level contrastive loss, for label-free node embeddings.
- [DeepPurpose: A Deep Learning Library for Drug-Target Interaction Prediction](/papers/2004.08919): a library of encoder-decoder models for drug-target interaction, with an MPNN compound encoder and several protein encoders.
- [Convolutional Networks on Graphs for Learning Molecular Fingerprints](/papers/1509.09292): replaces the hashing and indexing steps of circular fingerprints with learnable, softmax-pooled ones, trained end-to-end on molecular regression.
- [Node Similarity Preserving Graph Convolutional Networks](/papers/2011.09643): adds a feature-similarity kNN graph and a self-supervised pair regression to a two-layer GCN, for graphs where linked nodes differ and under structure attacks.
- [A Comprehensive Survey of Scene Graphs: Generation and Application](/papers/2104.01111): a survey that names GNN-based scene graph generation as one model family, with no GNN equations of its own.
- [Inductive Relation Prediction by Subgraph Reasoning](/papers/1911.06962): GraIL, which scores a knowledge-graph triple from its enclosing subgraph with double-radius labels and no entity embeddings.
- [QA-GNN: Reasoning with Language Models and Knowledge Graphs for Question Answering](/papers/2104.06378): joins an LM with a retrieved ConceptNet subgraph, scores node relevance with the LM, and reasons with an attention GNN over a QA-context node.
- [GreaseLM: Graph REASoning Enhanced Language Models for Question Answering](/papers/2201.08860): runs an LM and a graph network side by side and exchanges information through an interaction token and an interaction node in several fusion layers.
- [BertGCN: Transductive Text Classification by Combining GCN and BERT](/papers/2105.05727): a word-document graph whose document nodes start from BERT embeddings, trained jointly with a memory bank and mixed with a BERT-only prediction.
- [Flow Network based Generative Models for Non-Iterative Diverse Candidate Generation](/papers/2106.04399): GFlowNet, which uses a message-passing network as the flow predictor to sample objects in proportion to their reward.
- [DiGress: Discrete Denoising diffusion for graph generation](/papers/2209.14734): one-shot graph generation by discrete denoising diffusion with a graph transformer denoiser, with cycle and spectral features and property guidance.
- [GraphCast: Learning skillful medium-range global weather forecasting](/papers/2212.12794): an encode-process-decode mesh GNN with 16 processor layers that forecasts global weather in six-hour steps.
- [Exploring Progress in Multivariate Time Series Forecasting: Comprehensive Benchmarking and Heterogeneity Analysis](/papers/2310.06119): BasicTS+, a shared pipeline for forecasting benchmarks and a dataset split by temporal pattern and sample indistinguishability.
- [Large Models for Time Series and Spatio-Temporal Data: A Survey and Outlook](/papers/2310.10196): a survey of LLM and foundation-model work for time series and spatio-temporal graphs, with no experiments.
- [BOOM](/papers/2505.01912): a benchmark that holds out low-density molecular property values, with 15 models including several GNNs.
- [HDMI: High-order Deep Multiplex Infomax](/papers/2102.07810): a per-layer GCN with mutual-information training and attention fusion, for unlabelled multiplex networks.
- [Deep Occlusion-Aware Instance Segmentation with Overlapping BiLayers](/papers/2103.12340): BCNet, two non-local graph layers in a mask head, the first modelling the occluder.
- [GraphFormers: GNN-nested Transformers for Representation Learning on Textual Graph](/papers/2105.02605): a graph-attention step inside each layer of a BERT-style encoder, for textual graphs.
- [Multimodal Trajectory Prediction Conditioned on Lane-Graph Traversals](/papers/2106.15004): PGP, a lane-graph policy and attention decoder that predicts several vehicle paths.
- [GRIL](/papers/2108.00298): GRIL, a bidirectional GRU whose gates are message-passing networks, for sensor imputation.
- [DL-Traff: Survey and Benchmark of Deep Learning Models for Urban Traffic Prediction](/papers/2108.09091): a survey and a shared-protocol benchmark of grid and graph traffic models.
- [Handling Distribution Shifts on Graphs: An Invariance Perspective](/papers/2202.02466): EERM, learned graph editors that create virtual environments for node-level generalisation.
- [A Survey on Graph Representation Learning Methods](/papers/2204.01855): a survey of static and dynamic graph embedding, with GNN limitations and named fixes.
- [OnePose: One-Shot Object Pose Estimation without CAD Models](/papers/2205.12257): a graph attention matcher from 2D features to the 3D points of a scanned object.
- [Deep Bidirectional Language-Knowledge Graph Pretraining](/papers/2210.09338): DRAGON, joint pretraining of one encoder on text and a local knowledge-graph subgraph.
- [EqMotion: Equivariant Multi-agent Motion Prediction with Invariant Interaction Reasoning](/papers/2303.10876): an equivariant interaction graph for predicting the motion of several agents.
- [MixHop: Higher-Order Graph Convolutional Architectures via Sparsified Neighborhood Mixing](/papers/1905.00067): concatenates propagated features over several adjacency powers, each with its own weights.
- [Adaptive Universal Generalized PageRank Graph Neural Network](/papers/2006.07988): GPR-GNN, learned weights on K+1 propagation steps of an MLP's output, which may be negative.
- [BADet: Boundary-Aware 3D Object Detection from Point Clouds](/papers/2104.10330): graph refinement of LiDAR proposals with max-aggregated messages and learned alignment offsets.
- [Graph Neural Network-Based Anomaly Detection in Multivariate Time Series](/papers/2106.06947): GDN, a sensor graph learned from embedding similarity, with graph-attention forecasting and deviation scoring.
- [Channel-wise Topology Refinement Graph Convolution for Skeleton-Based Action Recognition](/papers/2107.12213): CTR-GC, a shared skeleton adjacency refined per channel and per sample from joint correlations.
- [Exact Combinatorial Optimization with Graph Convolutional Neural Networks](/papers/1906.01629): a bipartite GCN that learns branch-and-bound variable selection by imitating strong branching.
- [Parameterized Explainer for Graph Neural Network](/papers/2011.04573): PGExplainer, one shared edge-scoring MLP that explains a frozen GNN for many instances and unseen graphs.
- [PREDATOR: Registration of 3D Point Clouds with Low Overlap](/papers/2011.13005): a GNN and cross-attention in the bottleneck that predict overlap and matchability for scans with little shared surface.
- [Spatial-Temporal Graph ODE Networks for Traffic Flow Forecasting](/papers/2106.12931): STGODE, graph propagation written as a tensor ODE with a restart term, over distance and DTW graphs.
- [Physics-Informed Graph Neural Networks to Reconstruct Local Fields Considering Finite Strain Hyperelasticity](/papers/2507.05291): P-DivGNN, a mesh GNN with periodic edges and a stress-divergence penalty for micro-structure stress.
- [Anomaly Detection on Attributed Networks via Contrastive Self-Supervised Learning](/papers/2103.00113): CoLA, a one-layer GCN that scores each node by how well it matches sampled local subgraphs, with no labels.
- [Do Transformers Really Perform Bad for Graph Representation?](/papers/2106.05234): Graphormer, a Transformer with degree, shortest-path and path-edge attention terms and a graph token.
- [Graph Neural Networks with Learnable Structural and Positional Representations](/papers/2110.07875): LSPE, a learned per-node positional stream updated in every layer, started from random-walk return probabilities.
- [Spatial-Temporal Identity: A Simple yet Effective Baseline for Multivariate Time Series Forecasting](/papers/2208.05233): STID, an MLP forecaster with learned series and time identities and no graph.
- [Spatio-Temporal Graph Neural Networks for Predictive Learning in Urban Computing: A Survey](/papers/2303.14483): a survey of spatio-temporal GNNs for city data, covering graph construction and model variants, with no experiments.
- [A Survey on Graph Neural Networks for Time Series: Forecasting, Classification, Imputation, and Anomaly Detection](/papers/2307.03759): a survey of GNNs for four time-series tasks, with task objectives and graph-construction rules, and no experiments.
- [TopoLogic: An Interpretable Pipeline for Lane Topology Reasoning on Driving Scenes](/papers/2405.14747): a lane-topology GNN layer fed by an endpoint-gap matrix with a learnable distance mapping and a query-similarity matrix.
- [TopoPoint: Enhance Topology Reasoning via Endpoint Detection in Autonomous Driving](/papers/2505.17771): separate endpoint queries and a point-lane graph network, with a matching step that pulls lane ends to detected points at inference.
- [A Concise Survey on Lane Topology Reasoning for HD Mapping](/papers/2504.01989): a survey of lane topology methods, their metrics and their OpenLane-V2 and Topo-Boundary scores, with no method of its own.
- [Graph Learning: A Survey](/papers/2105.00696): a survey that sorts graph learning into four families, graph deep learning among them, with no experiments.
- [Adversarial Graph Augmentation to Improve Graph Contrastive Learning](/papers/2106.05819): AD-GCL, a learned edge-drop augmenter trained against a GIN encoder, with a penalty on the drop ratio.
- [NodeFormer: A Scalable Graph Structure Learning Transformer for Node Classification](/papers/2306.08385): all-pair attention in linear time through random features and a sparse latent graph per layer.
- [OGB-LSC: A Large-Scale Challenge for Machine Learning on Graphs](/papers/2103.09430): three large graph datasets with baselines, and a summary of the KDD Cup 2021 winners.
- [Graph Transformers: A Survey](/papers/2407.09777): a survey of how graph structure enters attention and how attention is computed, with no experiments.
- [Graph Neural Network for Traffic Forecasting: A Survey](/papers/2101.11174): a survey of GNNs for traffic forecasting from 2018 to 2020, with a benchmark table copied from the surveyed papers.
- [STEP: Pre-training Enhanced Spatial-temporal Graph Neural Network for Multivariate Time Series Forecasting](/papers/2206.09113): a frozen masked-patch Transformer pre-trained on long history, feeding a Graph WaveNet backend and a Gumbel-sampled sparse graph.
- [MSGNN](/papers/2209.00546): a two-layer complex spectral GNN on a magnetic signed Laplacian, for signed and directed graphs.
- [Revisiting Heterophily For Graph Neural Networks](/papers/2210.07606): ACM-GCN, per-node adaptive mixing of low-pass, high-pass and identity channels, plus a post-aggregation homophily measure.
- [FourierGNN: Rethinking Multivariate Time Series Forecasting from a Pure Graph Perspective](/papers/2311.06190): a fully connected space-time graph of series and steps, with shared complex Fourier-domain layers.
- [A Review of Graph Neural Networks and Their Applications in Power Systems](/papers/2101.10025): a survey of GNN families and their power-system applications, with no experiments of its own.
- [Learning to Drop: Robust Graph Neural Network via Topological Denoising](/papers/2011.07057): PTDNet, a per-layer edge scorer trained with the GNN, with a hard-concrete gate, an expected-edge penalty and a low-rank penalty.
- [GPS-Net: Graph Property Sensing Network for Scene Graph Generation](/papers/2003.12962): direction-aware message passing, a node-priority focal loss and a gated frequency prior for one-stage scene graph generation.
- [MSGNet](/papers/2401.00423): FFT-selected periods, a learned adjacency and Mixhop convolution per period, then within-period attention and an amplitude-weighted sum.
- [Graph Representation Learning in Biomedicine](/papers/2104.04883): a review of shallow, GNN and generative graph methods for molecules, genomics, drugs and patient records, with no experiments.