RapidGNN: Energy and Communication-Efficient Distributed Training on Large-Scale Graph Neural Networks

Arefin Niam; M S Q Zulkar Nine; Tevfik Kosar

REVIEW 4 major objections 5 minor 1 cited by

RapidGNN: Energy and Communication-Efficient Distributed Training on Large-Scale Graph Neural Networks

T0 review · 4 major / 5 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read RapidGNN claims that precomputing the exact mini-batch schedule turns distributed GNN feature fetching from an on-demand bottleneck into a cache-and-prefetch pipeline, yielding 2.46x to 3.00x throughput gains and 10-15x fewer remote fetches

desk verdict A credible distributed-GNN training system that turns deterministic sampling into cache and prefetch wins, but the headline 'end-to-end' speedup omits the offline precompute cost and the evaluation is too thin to support the scaling and SOTA claims. read the letter →

arxiv 2509.05207 v1 pith:E63XTRDA submitted 2025-09-05 cs.LG cs.AI

Arefin Niam , Tevfik Kosar , M S Q Zulkar Nine This is my paper

classification cs.LGcs.AI

keywords distributedGNNtrainingcommunicationoptimizationdeterministicsamplingfeaturecachingprefetchingenergyefficiencyscalability

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

RapidGNN is a distributed GNN training framework that tries to eliminate the remote-feature-fetch bottleneck before it happens. By fixing the random seed of the neighbor sampler, the system can precompute every mini-batch and every remote node access for the whole training run, then use that schedule to build a small steady cache of the most frequently accessed remote nodes and to prefetch upcoming batches while the current batch trains. The paper reports that this schedule-aware approach is 2.46x to 3.00x faster in end-to-end training throughput than three baselines across Reddit, OGBN-Products, and OGBN-Papers100M, cuts remote feature fetches by 9.70x to 15.39x, scales near-linearly with more machines, and cuts CPU/GPU energy by 44% and 32%. The argument matters because it promises speedups without changing model convergence or requiring architectural changes.

What carries the argument

The load-bearing mechanism is the precomputed deterministic sampling schedule, produced by hashing a global seed with worker ID, epoch, and batch index to generate pseudorandom streams for the K-hop sampler. From that schedule the system enumerates all remote node accesses across all epochs, ranks nodes by access frequency, and selects the top-n_hot 'celebrity' nodes for a steady device cache C_s. A secondary double-buffer cache for the next epoch is built in parallel and swapped at epoch boundaries; a rolling prefetch queue of depth Q stages features for upcoming batches. The invariant is that per-step communication equals only the prefetcher's miss set M_i^e, and device memory is bounded b

What would settle it

Measure and report the wall-clock time of the precompute phase on OGBN-Papers100M, including SSD streaming of sampled metadata and the vectorized pull for the hot cache, and compare total wall-clock time (precompute plus training) against the baseline for the same number of epochs. If the precompute step adds a nontrivial fraction of baseline training time, the claimed end-to-end speedup is reduced; timing that one phase settles the question.

Watch

Extended reading notes

Core claim

RapidGNN's central claim is that in distributed mini-batch GNN training, the communication bottleneck can be largely removed by converting online, reactive feature fetching into an offline, deterministic schedule. The paper argues that with a seed-fixed sampler, the sequence of batches and the union of needed remote node IDs is known in advance; a one-shot vectorized pull materializes features for the top-n_hot most frequently used remote nodes into a double-buffered device cache, and an asynchronous prefetcher stages the next Q batches concurrently with training. Residual cache misses are fetched by synchronous RPCs, but the paper's measurements show those misses are rare enough that remote

Load-bearing premise

The speedup numbers depend on the offline precomputation that enumerates every batch and remote access being cheap enough that excluding it from the reported 'end-to-end' training time does not change the comparison; if precomputing the schedule for a 1.6-billion-edge graph costs as much as an epoch or more of training, the headline speedups would shrink.

Editorial extensions

If this is right

If the reported speedups hold, distributed GNN training on billion-edge graphs can run 2-3x faster with only a modest fixed GPU-memory cost, making larger models and datasets feasible on the same hardware.
Reducing remote fetches by roughly 10-15x cuts network traffic and synchronization stalls; on shared or billed clusters this translates directly into lower cost and energy use.
Because convergence is preserved through an unbiased gradient estimator, users can adopt RapidGNN as a drop-in replacement for existing training loops without retuning model hyperparameters.
The bounded per-worker memory and decentralized precomputation mean the design can scale to more workers without a central coordinator becoming a bottleneck.
The reported energy savings follow from shorter training duration, implying communication-efficient scheduling is also a power-saving strategy for sustainable supercomputing.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

The paper reports per-epoch and end-to-end training time but does not include the wall-clock cost of the offline precomputation phase; if that phase is expensive on very large graphs, the true end-to-end speedup may be smaller than 2.46x-3.00x.
The same precomputed schedule could be reused across multiple training runs on the same graph, such as hyperparameter sweeps, which would amortize the precompute cost and make the reported speedups realistic for production use.
The long-tail access distribution suggests a frequency-based cache is near-optimal for these datasets; on graphs with more uniform access or dynamic structure, the hot set would need online updating, and the prefetch window Q becomes a tunable trade-off between memory and stall rate.
A testable extension is a sensitivity model for cache size n_hot and prefetch depth Q; the paper shows diminishing returns for cache size, but formal guidance from graph statistics alone would let practitioners set these parameters reliably.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Here's my take on RapidGNN. The core idea is genuinely nice: fix the PRNG seed for the sampler, precompute the entire training schedule, then use the known access pattern to build a hot-node steady cache and a rolling prefetch queue. That lets you replace most on-demand remote feature fetches with a one-time VectorPull plus asynchronous prefetching. The design is clean, the memory bound is explicit, and the reported throughput, network traffic, and energy numbers are internally consistent across three datasets and batch sizes. The Reddit speedups (3-6x) are predictably large because of the skewed access pattern. Proposition 3.1 is basically a restatement of what it means to seed a PRNG per batch, but it's correct and the convergence plots support it.

The soft spots are real, and one is load-bearing. The abstract and Section 5.2 call the speedups 'end-to-end training throughput,' but Algorithm 1's precompute phase — enumerating every batch for every epoch, ranking remote nodes by frequency, and building the cache — is never timed. Section 3 says the precomputed data is streamed to SSD to avoid CPU memory bloat, which tells me that phase is substantial. On OGBN-Papers100M with 1.62B edges and 10 epochs, that precompute could cost as much as a full epoch or more. If so, the 2.46-3.00x average speedup drops significantly once you include it. This is not a minor omission; the paper's central metric is defined to exclude a major cost. At minimum, the authors need to report T_precompute and show it's small, or re-baseline with end-to-end time.

Beyond that, the evaluation is thin: only 2 to 4 machines, 10 epochs, no repeated runs or error bars, and the baselines are just DistDGL variants. P3, which is explicitly about hiding GNN feature communication, and the two-level caching work [39] are cited but not compared. So the 'state-of-the-art' claim is overreach. Energy numbers are measured only for one configuration (batch 3000, Products, 3 machines).

I'm not saying this is a bad paper. The idea is worth building on, and the measured effects are plausible. But the end-to-end claim as written is not supported. It deserves a serious referee and a revision: add the precompute timing, expand baselines, and add error bars. I'd bring it to reading group only if someone is working on GNN training systems; otherwise it's a 'maybe'.

Referee Report

4 major / 5 minor

Summary. The paper presents RapidGNN, a distributed GNN training framework that precomputes the full deterministic mini-batch sampling schedule before training, ranks remote nodes by access frequency, caches the top-n_hot remote node features in a per-worker device memory cache, and runs a rolling prefetch queue (size Q) with double buffering to hide residual remote feature fetch latency. The evaluation on Reddit, OGBN-Products, and OGBN-Papers100M reports average training-throughput speedups of 2.46x, 2.26x, and 3.00x over DGL-METIS, DGL-Random, and distributed GCN baselines, remote-fetch reductions of 9.70x-15.39x, near-linear scaling from 2 to 4 machines, and CPU/GPU energy savings of 44%/32%. Proposition 3.1 argues that hash-seeded deterministic sampling preserves the distribution of online uniform sampling, and Figure 9 shows matching training-accuracy curves for 10 epochs on two datasets.

Significance. If the headline numbers survive complete accounting, RapidGNN is a practical and simple optimization: it leaves the GNN architecture unchanged, makes the sampling schedule reproducible, and its bounded per-worker memory formula (Memdevice <= 2 n_hot d + Q m_max d) is a useful design invariant. The paper's strengths are the direct use of benchmark datasets, the long-tail frequency analysis, and the explicit pseudo-code for the schedule. However, the claims are currently supported only by per-epoch/per-step measurements after an offline precomputation phase whose cost is never reported; the system is also evaluated on only 10 epochs, 2-4 machines, and without repeated-run error bars. The result is potentially valuable but not yet established in the form advertised.

major comments (4)

[§3, Algorithm 1 and §5.2, Table 2] The abstract's central claim is 'end-to-end training throughput' improvement, but Algorithm 1's offline phase (lines 1-4: precompute {B_e}, compute N_remote, rank by frequency, and VectorPull the top-n_hot features) is never timed. Section 3 says this phase streams 'extensively sampled data' to and from SSD, implying a substantial I/O pass. For OGBN-Papers100M (1.62B edges, ~111M nodes, 10 epochs, batch size up to 3000), enumerating multi-hop neighborhoods for all batches and ranking remote nodes can plausibly cost more than one training epoch. Since Table 2 reports only per-step training speedups measured after this phase, the reported 2.46x-3.00x are not end-to-end unless the precompute time is negligible. Please report the wall-clock time of Algorithm 1 lines 1-4, add it to RapidGNN's total in the comparison, and discuss how precompute time scales with worker count P.
[§5.2, §5.3] The experimental basis for the headline speedups is thin in a way that affects external validity: all runs use only 10 epochs, 2-4 machines, and no repeated-run standard deviations are given. Figure 6 reports epoch speedup relative to 2 machines for 3 and 4 machines, but Figure 6 and Table 2 do not indicate variance. Because the reported speedups differ by up to 4x across datasets (1.32x for OGBN-Products batch 2000 vs 4.85x for Reddit batch 2000), the 'average speedup' depends heavily on the selected configurations and on the omitted precompute phase. At minimum, provide repeated runs and error bars for the main Table 2 entries and state whether the speedups include precompute time.
[§5.5, Proposition 3.1] Proposition 3.1 is used to support the claim that deterministic precomputation 'does not bias or destabilize the stochastic gradient estimates.' The proof's part (b) states that a cryptographic hash maps distinct tuples to 'independent uniform outputs'; a cryptographic hash is deterministic and pseudorandom, not statistically independent, so the proof as written is informal. The empirical validation in Figure 9 is also limited to training accuracy over 10 epochs on OGBN-Products and Reddit; no OGBN-Papers curve and no validation/test accuracy are shown. Please either replace the hash argument with a standard PRG/counter-based argument or present stronger evidence (e.g., test accuracy, more epochs, all three datasets). This point matters because 'without changing convergence' is part of the paper's claimed contribution.
[§2.2, §5.1] The evaluation compares RapidGNN only against DGL-Random, DGL-METIS, and a distributed GCN baseline. None of the communication-optimization systems discussed in §2.2 (P3, DGCL, DGS, Dorylus, quantization-based methods) is included as a baseline, despite the introduction describing them as complementary and the evaluation section calling the comparisons 'SOTA models.' This makes the 'state-of-the-art' claim overstated. The paper should either add at least one strong communication-optimized baseline (e.g., DistDGL with halo caching plus P3-style pipelining) or explicitly scope the claims to DGL-default baselines.

minor comments (5)

[§5.1] Hyperparameters are not reported: fan-out F, number of GNN layers, hidden dimensions, optimizer, learning rate, and the exact n_hot and Q values used for each dataset/configuration are missing. Without these, the experiments are not reproducible.
[§5.4, Table 3] The energy comparison is for a single configuration (OGBN-Products, batch size 3000, 3 machines, 10 epochs) with no repeated trials. The abstract's 44% and 32% CPU/GPU savings should be qualified as measured on this configuration, not as a general claim.
[Abstract and §5.2] The abstract says 'end-to-end training throughput,' but Table 2's column header is 'Step Speedup' and §5.2 reports per-epoch/per-step metrics. Please make the wording consistent and reserve 'end-to-end' for totals that include precompute/sampling.
[Figures 4-7] Several figures lack error bars and precise units: Figure 4 reports 'mean data transferred' but not variance; Figure 5's x-axis is 'Cache Size' without stating whether it is in nodes, features, or bytes; Figure 7's memory plots use abbreviations that are not defined in the caption.
[§3, Reference [12]] The phrase 'simulation of Belady's MIN [39]' is unclear: reference [39] is a two-level graph caching paper, not the original Belady's MIN citation. Please clarify the connection or cite the original MIN algorithm.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: RapidGNN's central claims are direct empirical benchmarks against external baselines, not predictions derived from fitted inputs.

full rationale

The paper's central claims (2.46x–3.00x throughput speedups, 9.70x–15.39x remote-fetch reductions, near-linear scaling, and energy savings) are supported by direct measurements of training time, network traffic, memory, and energy against external baselines (DGL-METIS, DGL-Random, DistGCN) in Section 5. These are not derived from fitted constants or from the paper's own definitions. The only formal result, Proposition 3.1, argues that deterministic seed-based sampling preserves the marginal distribution and unbiasedness of online uniform neighbor sampling; this follows from the explicit construction using a uniform sampler with independently seeded PRNG streams and is additionally checked empirically in Figure 9. No load-bearing self-citation, imported uniqueness theorem, or ansatz-smuggling-via-citation appears in the derivation. The most plausible concern—that the offline precomputation phase's wall-clock time is not included in the reported 'end-to-end' numbers—is a measurement-scope and reproducibility limitation, not a circularity: the reported speedups are measured outcomes, not quantities made true by construction. Therefore, the circularity score is 0.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

RapidGNN is a software framework, not a new postulated physical or mathematical entity; it introduces no new particles, forces, or conserved quantities. The claims rest on tunable cache and prefetch parameters plus empirical assumptions about hash randomness, sampling equivalence, access-frequency skew, and precomputation cost.

free parameters (3)

n_hot (steady cache size) = not reported for main results; swept 25,000 to 200,000 in Fig. 5
The cache-size parameter directly determines the memory bound and measured hit rate, but the value used for Table 2 and the energy runs is not given.
Q (prefetch window) = not reported
The prefetch queue depth is part of the memory bound and determines how far ahead communication is pipelined; no value is stated.
fan-out F and GNN layer count = not reported
The K-hop sampler fan-out and model depth control how many remote features are needed per batch and are not specified in the experimental setup.

assumptions (4)

domain assumption A cryptographic hash function H produces statistically independent uniform outputs for distinct (s_0, w, e, i) tuples.
Used in Proposition 3.1 to argue that deterministic batches have the same law as online uniform sampling.
domain assumption Uniform neighbor sampling with a fixed seed yields the same gradient-estimator distribution as online sampling.
This is the core of Proposition 3.1(c), but in practice PRNG and hash randomness is pseudorandom, not mathematically independent.
domain assumption Remote-node feature access follows a long-tail distribution that is stable across epochs, making top-n_hot caching effective.
Fig. 3 demonstrates the power law on OGBN-Products for one epoch; the same assumption is applied to Reddit and OGBN-Papers without separate evidence.
domain assumption Precomputing and SSD-streaming the full deterministic sampling schedule is cheap enough to not affect reported end-to-end training time.
No precompute wall-clock time or I/O cost is reported; the throughput, scalability, and energy claims assume this cost is negligible or included.

how reviews work

0 comments

Cite this review

Pith. "Pith review of RapidGNN: Energy and Communication-Efficient Distributed Training on Large-Scale Graph Neural Networks." pith.science (2026). https://pith.science/paper/E63XTRDA

@misc{pith2026250905207,
  author       = {Pith},
  title        = {Pith review of: RapidGNN: Energy and Communication-Efficient Distributed Training on Large-Scale Graph Neural Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/E63XTRDA}},
  note         = {Machine review of arXiv:2509.05207}
}

read the original abstract

Graph Neural Networks (GNNs) have become popular across a diverse set of tasks in exploring structural relationships between entities. However, due to the highly connected structure of the datasets, distributed training of GNNs on large-scale graphs poses significant challenges. Traditional sampling-based approaches mitigate the computational loads, yet the communication overhead remains a challenge. This paper presents RapidGNN, a distributed GNN training framework with deterministic sampling-based scheduling to enable efficient cache construction and prefetching of remote features. Evaluation on benchmark graph datasets demonstrates RapidGNN's effectiveness across different scales and topologies. RapidGNN improves end-to-end training throughput by 2.46x to 3.00x on average over baseline methods across the benchmark datasets, while cutting remote feature fetches by over 9.70x to 15.39x. RapidGNN further demonstrates near-linear scalability with an increasing number of computing units efficiently. Furthermore, it achieves increased energy efficiency over the baseline methods for both CPU and GPU by 44% and 32%, respectively.

Figures

Figures reproduced from arXiv: 2509.05207 by the authors.

**Figure 2.** RapidGNN overview. A seed fixes a K-hop sampler (fan-out [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗

**Figure 3.** Frequency distribution of remote feature accesses [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: Mean data transfer overhead comparison for graph [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

**Figure 5.** Figure 5: Average number of remote feature fetches per epoch [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]

**Figure 9.** Figure 9: Training accuracy across batch sizes on OGBN-Products (top three) and Reddit (bottom three). In all six configurations, RapidGNN’s accuracy curves rapidly rise and plateau at the same level as the baselines. We observe no signs of slowed convergence or increased varian…

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

GreenDyGNN: Runtime-Adaptive Energy-Efficient Communication for Distributed GNN Training
cs.DC 2026-04 unverdicted novelty 5.0 of 10

GreenDyGNN applies Double-DQN to adapt cache management in distributed GNN training, cutting energy by up to 43% under congestion versus static policies.

Reference graph

Works this paper leans on

46 extracted references · 36 canonical work pages · cited by 1 Pith paper

[39]

Zhe Zhang, Ziyue Luo, and Chuan Wu. 2023. Two-level graph caching for expediting distributed gnn training. InIEEE INFOCOM 2023-IEEE Conference on Computer Communications. IEEE, 1–10

work page 2023
[1]

Lars Backstrom, Paolo Boldi, Marco Rosa, Johan Ugander, and Sebastiano Vigna
[2]

Simon Batzner, Albert Musaelian, Lixin Sun, Mario Geiger, Jonathan P Mailoa, Mordechai Kornbluth, Nicola Molinari, Tess E Smidt, and Boris Kozinsky. 2022. E (3)-equivariant graph neural networks for data-efficient and accurate interatomic potentials.Nature communications13, 1 (2022), 2453

work page 2022
[3]

Cristina Bazgan, Katrin Casel, and Pierre Cazals. 2025. Dense graph partitioning on sparse and dense graphs.J. Comput. System Sci.(2025), 103619

work page 2025
[4]

Alaa Bessadok, Mohamed Ali Mahjoub, and Islem Rekik. 2022. Graph neural networks in network neuroscience.IEEE Transactions on Pattern Analysis and Machine Intelligence45, 5 (2022), 5833–5848

work page 2022
[5]

Tristan Bilot, Nour El Madhoun, Khaldoun Al Agha, and Anis Zouaoui. 2023. Graph neural networks for intrusion detection: A survey.IEEE Access11 (2023), 49114–49139

work page 2023
[6]

Zhenkun Cai, Xiao Yan, Yidi Wu, Kaihao Ma, James Cheng, and Fan Yu. 2021. DGCL: An efficient communication library for distributed GNN training. In Proceedings of the Sixteenth European Conference on Computer Systems. 130–144

work page 2021
[7]

Jie Chen, Tengfei Ma, and Cao Xiao. 2018. Fastgcn: fast learning with graph convolutional networks via importance sampling.arXiv preprint arXiv:1801.10247 (2018)

arXiv 2018

Show all 46 references

[8]

Jianfei Chen, Jun Zhu, and Le Song. 2017. Stochastic training of graph con- volutional networks with variance reduction.arXiv preprint arXiv:1710.10568 (2017)

2017 arXiv
[9]

Wei-Lin Chiang, Xuanqing Liu, Si Si, Yang Li, Samy Bengio, and Cho-Jui Hsieh
[10]

Avery Ching, Sergey Edunov, Maja Kabiljo, Dionysios Logothetis, and Sambavi Muthukrishnan. 2015. One trillion edges: Graph processing at facebook-scale. Proceedings of the VLDB Endowment8, 12 (2015), 1804–1815

2015
[11]

DGL Team. 2024. RedditDataset — DGL 2.5 documentation. https://tinyurl.com/ 58u8tjsr. Accessed: 2025-04-24

2024
[12]

Nikoli Dryden, Roman Böhringer, Tal Ben-Nun, and Torsten Hoefler. 2021. Clair- voyant prefetching for distributed machine learning I/O. InProceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis. 1–15

2021
[13]

Swapnil Gandhi and Anand Padmanabha Iyer. 2021. P3: Distributed deep graph learning at scale. In15th {USENIX} Symposium on Operating Systems Design and Implementation ({OSDI}21). 551–568

2021
[14]

Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. 2017. Neural message passing for quantum chemistry. InInternational conference on machine learning. PMLR, 1263–1272

2017
[15]

Will Hamilton, Zhitao Ying, and Jure Leskovec. 2017. Inductive representation learning on large graphs.Advances in neural information processing systems30 (2017)

2017
[16]

Kanchan Jha, Sriparna Saha, and Hiteshi Singh. 2022. Prediction of protein– protein interaction using graph neural networks.Scientific Reports12, 1 (2022), 8360

2022
[17]

Peng Jiang and Masuma Akter Rumi. 2021. Communication-efficient sam- pling for distributed training of graph convolutional networks.arXiv preprint arXiv:2101.07706(2021)

2021 arXiv
[18]

John Jumper, Richard Evans, Alexander Pritzel, Tim Green, Michael Figurnov, Olaf Ronneberger, Kathryn Tunyasuvunakool, Russ Bates, Augustin Žídek, Anna Potapenko, et al. 2021. Highly accurate protein structure prediction with Al- phaFold.nature596, 7873 (2021), 583–589

2021
[19]

Xuan Kan, Hejie Cui, Joshua Lukemire, Ying Guo, and Carl Yang. 2022. Fbnetgen: Task-aware gnn-based fmri analysis via functional brain network generation. In International Conference on Medical Imaging with Deep Learning. PMLR, 618–637

2022
[20]

George Karypis and Vipin Kumar. 1998. A fast and high quality multilevel scheme for partitioning irregular graphs.SIAM Journal on scientific Computing20, 1 (1998), 359–392

1998
[21]

Gunawi, Cody Hammock, Joe Mambretti, Alexander Barnes, François Halbach, Alex Rocha, and Joe Stubbs

Kate Keahey, Jason Anderson, Zhuo Zhen, Pierre Riteau, Paul Ruth, Dan Stanzione, Mert Cevik, Jacob Colleran, Haryadi S. Gunawi, Cody Hammock, Joe Mambretti, Alexander Barnes, François Halbach, Alex Rocha, and Joe Stubbs. 2020. Lessons Learned from the Chameleon Testbed. InProc...

2020
[22]

Thomas N Kipf and Max Welling. 2016. Semi-supervised classification with graph convolutional networks.arXiv preprint arXiv:1609.02907(2016)

2016 arXiv
[23]

Xiao-Shuang Li, Xiang Liu, Le Lu, Xian-Sheng Hua, Ying Chi, and Kelin Xia
[24]

Meta Platforms, Inc. 2025. Meta Reports Fourth Quarter and Full Year 2024 Re- sults. https://investor.atmeta.com/investor-news/press-release-details/2025/ Meta-Reports-Fourth-Quarter-and-Full-Year-2024-Results/default.aspx Ac- cessed: 2025-04-29

2025
[25]

NVIDIA. 2024. NVIDIA Management Library (NVML). https://tinyurl.com/ 35x5pmzf. Accessed: 2025-04-24

2024
[26]

psutil. 2024. psutil 7.0.0. https://tinyurl.com/35x5pmzf. Accessed: 2025-04-24

2024
[27]

Manon Réau, Nicolas Renaud, Li C Xue, and Alexandre MJJ Bonvin. 2023. DeepRank-GNN: a graph neural network framework to learn patterns in protein– protein interfaces.Bioinformatics39, 1 (2023), btac759

2023
[28]

Patrick Reiser, Marlen Neubert, André Eberhard, Luca Torresi, Chen Zhou, Chen Shao, Houssam Metni, Clint van Hoesel, Henrik Schopmans, Timo Sommer, et al
[29]

Yingxia Shao, Hongzheng Li, Xizhi Gu, Hongbo Yin, Yawen Li, Xupeng Miao, Wentao Zhang, Bin Cui, and Lei Chen. 2024. Distributed graph neural network training: A survey.Comput. Surveys56, 8 (2024), 1–39

2024
[30]

Jonathan Shlomi, Peter Battaglia, and Jean-Roch Vlimant. 2020. Graph neural networks in particle physics.Machine Learning: Science and Technology2, 2 (2020), 021001

2020
[31]

John Thorpe, Yifan Qiao, Jonathan Eyolfson, Shen Teng, Guanzhou Hu, Zhihao Jia, Jinliang Wei, Keval Vora, Ravi Netravali, Miryung Kim, et al . 2021. Dory- lus: Affordable, scalable, and accurate{GNN} training with distributed{CPU} servers and serverless threads. In15th USENIX ...

2021
[32]

Graph neural networks for materials science and chemistry.Communica- tions Materials3, 1 (2022), 93

2022
[33]

Xinchen Wan, Kai Chen, and Yiming Zhang. 2022. Dgs: Communication-efficient graph sampling for distributed gnn training. In2022 IEEE 30th International Conference on Network Protocols (ICNP). IEEE, 1–11

2022
[34]

Jihe Wang, Ying Wu, and Danghui Wang. 2024. SC-GNN: A Communication- Efficient Semantic Compression for Distributed Training of GNNs. InProceedings of the 61st ACM/IEEE Design Automation Conference. 1–6

2024
[35]

Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, et al. 2019. Deep graph library: A graph- centric, highly-performant package for graph neural networks.arXiv preprint arXiv:1909.01315(2019)

2019 arXiv
[36]

Borui Wan, Juntao Zhao, and Chuan Wu. 2023. Adaptive message quantization and parallelization for distributed full-graph gnn training.Proceedings of Machine Learning and Systems5 (2023), 203–218

2023
[37]

Hanqing Zeng, Hongkuan Zhou, Ajitesh Srivastava, Rajgopal Kannan, and Viktor Prasanna. 2019. Graphsaint: Graph sampling based inductive learning method. arXiv preprint arXiv:1907.04931(2019)

2019 arXiv
[38]

Meng Zhang, Qinghao Hu, Peng Sun, Yonggang Wen, and Tianwei Zhang. 2023. Boosting distributed full-graph gnn training with asynchronous one-bit commu- nication.arXiv preprint arXiv:2303.01277(2023)

2023 arXiv
[40]

Jiacheng Xiong, Zhaoping Xiong, Kaixian Chen, Hualiang Jiang, and Mingyue Zheng. 2021. Graph neural networks for automated de novo drug design.Drug discovery today26, 6 (2021), 1382–1393

2021
[41]

Difan Zou, Ziniu Hu, Yewen Wang, Song Jiang, Yizhou Sun, and Quanquan Gu
[44]

Da Zheng, Chao Ma, Minjie Wang, Jinjing Zhou, Qidong Su, Xiang Song, Quan Gan, Zheng Zhang, and George Karypis. 2020. DistDGL: Distributed graph neural network training for billion-scale graphs. In2020 IEEE/ACM 10th Workshop on Irregular Applications: Architectures and Algorit...

2020
[46]

Layer-dependent importance sampling for training deep and large graph convolutional networks.Advances in neural information processing systems32 (2019)

2019
[2012]

InProceedings of the 4th annual ACM Web science conference

Four degrees of separation. InProceedings of the 4th annual ACM Web science conference. 33–42
[2019]

InProceedings of the 25th ACM SIGKDD international conference on knowledge discovery & data mining

Cluster-gcn: An efficient algorithm for training deep and large graph convolutional networks. InProceedings of the 25th ACM SIGKDD international conference on knowledge discovery & data mining. 257–266
[2022]

Briefings in bioinformatics23, 4 (2022), bbac231

Multiphysical graph neural network (MP-GNN) for COVID-19 drug design. Briefings in bioinformatics23, 4 (2022), bbac231

2022

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.

[1] [39]

Zhe Zhang, Ziyue Luo, and Chuan Wu. 2023. Two-level graph caching for expediting distributed gnn training. InIEEE INFOCOM 2023-IEEE Conference on Computer Communications. IEEE, 1–10

work page 2023

[2] [1]

Lars Backstrom, Paolo Boldi, Marco Rosa, Johan Ugander, and Sebastiano Vigna

[3] [2]

Simon Batzner, Albert Musaelian, Lixin Sun, Mario Geiger, Jonathan P Mailoa, Mordechai Kornbluth, Nicola Molinari, Tess E Smidt, and Boris Kozinsky. 2022. E (3)-equivariant graph neural networks for data-efficient and accurate interatomic potentials.Nature communications13, 1 (2022), 2453

work page 2022

[4] [3]

Cristina Bazgan, Katrin Casel, and Pierre Cazals. 2025. Dense graph partitioning on sparse and dense graphs.J. Comput. System Sci.(2025), 103619

work page 2025

[5] [4]

Alaa Bessadok, Mohamed Ali Mahjoub, and Islem Rekik. 2022. Graph neural networks in network neuroscience.IEEE Transactions on Pattern Analysis and Machine Intelligence45, 5 (2022), 5833–5848

work page 2022

[6] [5]

Tristan Bilot, Nour El Madhoun, Khaldoun Al Agha, and Anis Zouaoui. 2023. Graph neural networks for intrusion detection: A survey.IEEE Access11 (2023), 49114–49139

work page 2023

[7] [6]

Zhenkun Cai, Xiao Yan, Yidi Wu, Kaihao Ma, James Cheng, and Fan Yu. 2021. DGCL: An efficient communication library for distributed GNN training. In Proceedings of the Sixteenth European Conference on Computer Systems. 130–144

work page 2021

[8] [7]

Jie Chen, Tengfei Ma, and Cao Xiao. 2018. Fastgcn: fast learning with graph convolutional networks via importance sampling.arXiv preprint arXiv:1801.10247 (2018)

arXiv 2018