Pith. sign in

REVIEW 4 major objections 6 minor 47 references

A Batch-Insensitive Dynamic GNN Approach to Address Temporal Discontinuity in Graph Streams

T0 review · 4 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

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

Pith's one-line read Large-batch training enlarges the parameter search space of dynamic graph models, and the paper's two-part regularizer shrinks it back, allowing up to 11x larger batches.

desk verdict The central Lipschitz bound is mathematically wrong, and the paper leans on it for everything; the empirical trick might still be useful, but not in this form. read the letter →

arxiv 2506.19282 v1 pith:FJOXPW3U submitted 2025-06-24 cs.LG cs.GR

Yang Zhou , Xiaoning Ren This is my paper
classification cs.LGcs.GR
keywords dynamicgraphneuralnetworkstemporaldiscontinuityLipschitzboundbatchtrainingattentionmechanismgraphsregularizationlinkprediction
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

The paper argues that training memory-based dynamic graph neural networks with large batches causes temporal discontinuity—events get processed out of order or simultaneously—which both loses temporal information and enlarges the model's weight search space. It quantifies this through a Lipschitz upper bound on the binary cross-entropy loss, showing the bound grows with batch size and makes convergence harder. To counter it, the paper proposes BADGNN, combining Temporal Lipschitz Regularization (TLR), which penalizes the query–value interaction term in the bound, with Adaptive Attention Adjustment (A3), which re-concentrates softmax attention by rescaling the attention logits. On Wikipedia, Reddit, and Mooc, BADGNN keeps accuracy close to or above TGN while supporting batch sizes up to 3500—more than 11x and 3.5x larger than TGN's on Wikipedia and Mooc—and cuts training time by roughly 30–54%.

What carries the argument

The load-bearing object is the Batch Sensitivity Range (BSR), the combination $BSR = \mu_1\Lambda - \mu_2\Delta$ extracted from the attention Lipschitz bound. $\Lambda$ measures the interaction strength between the query matrix $M_q$ and the value matrix $V$; $\Delta$ measures the spectral activity of the softmax-weighted features. TLR shrinks $\Lambda$ through a simplified Frobenius-norm penalty, and A3 inflates the logits of the score function $g(x) = mn \cdot QK^T/\sqrt{d_k}$ to make softmax attention more concentrated. Together they shrink the weight search space that large batches are claimed to open up, without requiring explicit event reordering or gradient-consistency constraints.

What would settle it

On the Wikipedia dataset, remove the TLR penalty while keeping the A3 rescaling and train at batch size 3500: if AP does not drop relative to full BADGNN, the regularization term is not carrying the claimed load; separately, evaluating the supremum in Eq. 10 on random logits for batch sizes 50, 500, and 3500 would show whether the bound actually grows with $n$.

Watch

Extended reading notes

Core claim

The central claim is that large batch sizes degrade dynamic graph models not only by discarding temporal information but by geometrically expanding the parameter search space, and that this expansion can be controlled directly. The authors derive an upper bound on the Lipschitz constant of the BCE loss, Eq. 10, that grows with batch size $n$, and a bound on multi-head attention (Corollary 1) that decomposes into a positive term $\Lambda$ and a negative term $\Delta$. The Batch Sensitivity Range $BSR = \mu_1\Lambda - \mu_2\Delta$ is the target: TLR constrains $\Lambda$ by adding $\|M_q V^T\|_F \|V\|_F$ to the loss, while A3 multiplies the attention score function by $mn$ (equivalently dividing $d_k$ by $(mn)^2$), sharpening the softmax distribution. The paper reports that this combination stabilizes training at batch size 3500, matching or improving AP/AUC on Wikipedia, Reddit, and Mooc relative to TGN, PRES, and TGAT.

Load-bearing premise

The argument stands or falls on the claim, made in Section 4.2, that the Lipschitz constant of the BCE loss grows with batch size as in Eq. 10 and that this growth enlarges the parameter search space; the proof of Eq. 10 is deferred to an appendix not included in this version, and the step from an input-output sensitivity constant to the geometry of optimization is assumed.

Editorial extensions

If this is right

  • If the mechanism is right, memory-based dynamic GNNs can be trained with much larger batches without the usual accuracy cliff, making large-scale temporal graph training cheaper.
  • The two components are complementary: regularization alone and attention adjustment alone both improve over TGN at batch size 3500, and combining them gives the best or near-best AP/AUC on Wikipedia and Mooc.
  • Because the method does not reorder events or enforce gradient consistency, it avoids the structural side effects that memory-coherence baselines can introduce, while achieving similar or better large-batch robustness.
  • The reported speedups (2x on Wikipedia, 1.4x on Mooc over TGN) follow directly from the larger admissible batch sizes, so the efficiency gain is a corollary of the stability claim.
  • The analysis in Corollary 1 applies to the self-attention mechanism itself, so the same Lipschitz-control recipe could be transplanted to other attention-based temporal encoders beyond the TGN backbone used here.

Reading between the lines

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

  • The same BSR decomposition could be applied to other attention-based temporal GNNs even without a memory module, since the bound is architecture-level rather than memory-specific.
  • The paper defers the proof of Theorem 1 to an appendix not included in this version; directly computing the supremum in Eq. 10 on random logits for growing batch sizes would be the fastest way to validate or refute the claimed batch-size dependence.
  • If the Lipschitz-to-search-space link is the real cause, the same regularization should transfer to other convex losses by recomputing their Lipschitz constants, which the paper states its analysis permits.
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.

Referee Report

4 major / 6 minor

Summary. The paper studies the performance degradation of memory-based dynamic graph neural networks (MDGNNs) when trained with large batches, attributing the degradation to temporal discontinuity and to an expansion of the parameter search space. The authors claim to quantify this expansion via a Lipschitz bound on the BCE loss and propose BADGNN, consisting of Temporal Lipschitz Regularization (TLR) and Adaptive Attention Adjustment (A3). Experiments on Wikipedia, Reddit, and Mooc compare TGN, TGAT, PRES, and ablated variants, reporting competitive accuracy at larger batch sizes and reduced training time. The authors also provide an anonymous code repository.

Significance. The problem addressed is real and practically important: training MDGNNs with large batches is desirable for scalability, and principled remedies would be valuable. The paper contains a number of useful empirical observations, including the ablation of the two proposed components and a hyperparameter sensitivity analysis, and the authors make their code available, which supports reproducibility. However, the central theoretical result that batch size expands the parameter search space is not established as stated. The Lipschitz constant in Theorem 1 does not follow from the definitions in Section 3.2, and the connection between a loss sensitivity bound and the volume of the weight space is a non-sequitur. As a result, the theoretical motivation for TLR and A3 is not supported, and the empirical results alone do not establish the claimed mechanism. The contribution, while containing interesting heuristics, is not at the level required for acceptance.

major comments (4)
  1. [Section 4.2, Eq. (10)] Theorem 1 as stated is not a Lipschitz constant under any of the norms introduced in Section 3.2. For the sum loss in Eq. (9), the gradient with respect to the logits is the vector (p_1 - y_1, ..., p_n - y_n). Its Euclidean norm is sup sqrt(Σ(p_i - y_i)^2), which is at most sqrt(n); its L1 norm is sup Σ|p_i - y_i|, which is at most n; and neither equals |Σ(p_i - y_i)|. The absolute value of the sum can vanish even when every gradient component is nonzero, and if the loss is averaged over the batch (the default BCEWithLogitsLoss reduction used by TGN), the Euclidean Lipschitz constant is at most 1/sqrt(n), which decreases with batch size. The claim that 'the Lipschitz constant of the loss function grows with the batch size' is therefore unsupported by the stated equation.
  2. [Section 4.2 (after Eq. 10)] Even if Eq. (10) were accepted as a sensitivity bound, the paper does not justify the step from a Lipschitz constant of the loss function to the 'size' or 'volume' of the parameter search space. A Lipschitz constant measures how much the loss changes with respect to its argument; it does not determine the geometry of the weight space or the difficulty of optimization. The propositions in Section 4.1 and the BSR construction in Section 5.1 do not provide such a connection. Since the abstract and the experimental design are built on this claimed enlargement of the search space, this logical gap is load-bearing.
  3. [Section 4.3, Eqs. (11)-(14)] The proofs of Theorem 1 and Corollary 1 are deferred to an appendix that is missing from the manuscript. The proof sketch of Corollary 1 is not self-contained: the quantity σ in Eq. (12) is introduced only as 'a small positive value' without defining what it bounds; the norm ||·||_* in Eq. (14) is used without specifying the matrix space; and the expression in Eq. (12) has ambiguous fraction and square-root placement. Without the appendix, the central theoretical claims cannot be verified.
  4. [Section 6.4] The hyperparameters λ_TLR and λ_A3 are tuned on Wikipedia at a fixed batch size of 3500 (Section 6.4) and then applied to the other datasets in Tables 3 and 5, but this transfer is not stated explicitly and no cross-validation is reported. More importantly, the experiments do not measure the Lipschitz bound, the BSR, or any proxy for the parameter search space, so the empirical results do not test the theoretical mechanism; they only show that the proposed heuristic components help on these datasets.
minor comments (6)
  1. [Equation (9)] The loss is written as a sum over the batch, but the experimental setup follows TGN, which uses BCEWithLogitsLoss with mean reduction; the discrepancy should be clarified.
  2. [Introduction] The reference list contains a duplicate citation '[15, 15, ...]'.
  3. [Section 4.1, Proposition 1] The 'Simplified Proof' is not rigorous; setting ∇L_miss = 0 simply leaves one coordinate of the update unchanged and does not establish that the optimum is 'difficult to obtain'.
  4. [Section 5.2] The statement that the regularizer R(X) 'encourages them to be approximately orthogonal' is not supported; minimizing ||M_q V^T||_F * ||V||_F encourages small norms rather than orthogonality.
  5. [Figure 2] The three panels are referenced in the text but not fully explained; the caption and the surrounding discussion should make clear what each panel represents.
  6. [Appendix references] The paper refers to 'the Appendix' in Sections 4.2 and 4.3, but the submission as provided does not include an appendix; the references to it should either be removed or the appendix included.

Circularity Check

2 steps flagged · score 6.0 of 10

Theorem 1's claimed Lipschitz constant is defined as the unnormalized BCE sum, making its batch-size growth true by construction; the headline Wikipedia result uses hyperparameters tuned on Wikipedia, so part of the empirical claim is self-confirming.

  1. self definitional [Section 4.2, Eq. 9-10 and the paragraph following Eq. 10]
    "Loss = -∑_{i=1}^n [y_i log p_i + (1-y_i) log(1-p_i)] ... Theorem 1. The Lipschitz constant of binary cross-entropy loss BCE_loss Eq 9 defined as: L_F(Loss) = sup_{x∈X} |∑_{i=1}^n (p_i−y_i)|. ... In Eq 10, n denotes the batch size. The above derivation demonstrates that the Lipschitz constant of the loss function grows with the batch size n, since each additional sample introduces a potential gradient term."

    Eq. 10 is not a Lipschitz constant under the paper's own Definition 1: it is the absolute value of the directional derivative of the unnormalized BCE sum of Eq. 9 along the all-ones direction. For the Euclidean, L1, or L∞ operator norms introduced in §3.2, the constant would be sqrt(∑(p_i−y_i)^2), ∑|p_i−y_i|, or max|p_i−y_i|, none of which equals |∑(p_i−y_i)|. Thus the asserted growth with n is built into the choice of defining L_F(Loss) as an unnormalized sum rather than derived from a norm-based Lipschitz bound. Under the mean-reduced BCE used by TGN and PyTorch's default BCEWithLogitsLoss, the corresponding Euclidean constant is at most 1/sqrt(n), which decreases with batch size.

  2. fitted input called prediction [Section 6.4 (Hyperparameter Sensitivity Analysis) and Section 6.2, Table 2]
    "All experiments are carried out on the Wikipedia dataset with a fixed batch size of 3500. The results are presented in Figure 5. ... The best performance is observed when both hyperparameters take moderate values, such as λ_A3≈0.04 and λ_TLR≈0.0005."

    The main Wikipedia result in Table 2 (BADGNN 96.2 AP at batch size 3500) is obtained with hyperparameters λ_A3 and λ_TLR selected by maximizing AP on the Wikipedia dataset itself. Reporting that same configuration on Wikipedia as 'BADGNN maintains strong performance' is therefore a fitted result rather than an out-of-sample prediction. The Mooc, Reddit, and cross-batch comparisons remain informative, but the headline Wikipedia claim is partly self-confirming via in-dataset hyperparameter tuning.

full rationale

The paper's load-bearing theoretical claim is that a Lipschitz bound grows with batch size and thereby enlarges the parameter search space. That claim rests entirely on Theorem 1/Eq. 10, where the 'Lipschitz constant' is stated as sup |∑(p_i−y_i)|, which is the derivative of the unnormalized BCE sum of Eq. 9 along the all-ones direction. Under the norms defined in §3.2, this expression is not a Lipschitz constant; the growth conclusion is an artifact of the unnormalized sum and of dropping the norm, and it reverses if the mean-reduced BCE actually used in training is analyzed. This makes the theoretical motivation for TLR and A3 self-definitional rather than a first-principles derivation. Separately, the Wikipedia headline result uses hyperparameters tuned on Wikipedia in §6.4, so that specific empirical claim is partly fitted input presented as evaluation. There is no load-bearing self-citation: the references to prior Lipschitz work and to PRES are external and not by the present authors. The missing appendix for Theorem 1 is a completeness/correctness concern, not itself circularity, but it removes any possibility of independent verification of the claimed derivation. Overall, the central mechanism and one headline empirical result reduce by construction, while the methods themselves may still be useful heuristics; hence a partial circularity score of 6.

Assumptions & free parameters 4 free parameters · 5 assumptions · 1 invented entities

The central claim depends on the unproven Theorem 1 and Corollary 1, the assumed gradient-loss mechanism (Proposition 1), and the invented BSR metric. The free parameters lambda_TLR and lambda_A3 are fitted to one dataset; mu1, mu2, and sigma are introduced without values.

free parameters (4)
  • lambda_TLR = not fully specified; sensitivity analysis suggests 0.0005
    Regularization coefficient for TLR, tuned on Wikipedia in Sec 6.4; exact values used in main experiments are not reported.
  • lambda_A3 = not fully specified; sensitivity analysis suggests 0.04
    Coefficient for the attention adjustment, tuned on Wikipedia in Sec 6.4; final values for Tables 2-4 not stated.
  • mu1, mu2 (BSR weights) = not specified
    Introduced in Eq. 16 to define Batch Sensitivity Range, but never assigned values or used in experiments.
  • sigma (softmax lower bound) = not specified
    A small positive constant introduced in Eq. 12 to define the lower bound of the softmax function; no value given.
assumptions (5)
  • domain assumption If there is a gradient loss (nabla L_miss = 0), the optimal solution w* is difficult to obtain (Proposition 1).
    Assumed relationship between missing gradient information and optimization difficulty; no formal proof.
  • standard math The loss function is non-negative, convex, continuous, and differentiable (Section 4.1).
    BCE loss with sigmoid satisfies these, but the analysis is then restricted to such losses.
  • standard math The overall Lipschitz constant is the product of loss and model Lipschitz constants (Eq. 8).
    For compositions, the Lipschitz constant is bounded by the product, not exactly equal; the paper states equality without qualification.
  • standard math Each attention head is continuous and differentiable (Corollary 1).
    Standard smoothness assumption for attention mechanisms.
  • ad hoc to paper The softmax function has a positive lower bound sigma (Section 4.3).
    Introduced to define the bound in Eq. 12, but no value or justification beyond 'small positive value'.
invented entities (1)
  • Batch Sensitivity Range (BSR)
    purpose: Quantify the sensitivity of the model's weight search space to changes in batch size (Eq. 16).
    Defined as mu1*Lambda - mu2*Delta, but never used in experiments or validated externally; no clear connection to optimization.

how reviews work

0 comments
Cite this review

Pith. "Pith review of A Batch-Insensitive Dynamic GNN Approach to Address Temporal Discontinuity in Graph Streams." pith.science (2026). https://pith.science/paper/FJOXPW3U

@misc{pith2026250619282,
  author       = {Pith},
  title        = {Pith review of: A Batch-Insensitive Dynamic GNN Approach to Address Temporal Discontinuity in Graph Streams},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/FJOXPW3U}},
  note         = {Machine review of arXiv:2506.19282}
}
read the original abstract

In dynamic graphs, preserving temporal continuity is critical. However, Memory-based Dynamic Graph Neural Networks (MDGNNs) trained with large batches often disrupt event sequences, leading to temporal information loss. This discontinuity not only deteriorates temporal modeling but also hinders optimization by increasing the difficulty of parameter convergence. Our theoretical study quantifies this through a Lipschitz upper bound, showing that large batch sizes enlarge the parameter search space. In response, we propose BADGNN, a novel batch-agnostic framework consisting of two core components: (1) Temporal Lipschitz Regularization (TLR) to control parameter search space expansion, and (2) Adaptive Attention Adjustment (A3) to alleviate attention distortion induced by both regularization and batching. Empirical results on three benchmark datasets show that BADGNN maintains strong performance while enabling significantly larger batch sizes and faster training compared to TGN. Our code is available at Code: https://anonymous.4open.science/r/TGN_Lipichitz-C033/.

Figures

Figures reproduced from arXiv: 2506.19282 by the authors.

Figure 1
Figure 1. Line illustrates Model performance decrease with [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. The top shows a model without information loss, [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 3
Figure 3. The top section shows the memory and states up [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: This figure illustrates the AP of TGN and our pro [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Analysis of Model Performance Sensitivity to coefficient of A3 and TLR. [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

47 extracted references · 31 canonical work pages

  1. [1]

    Alexandre Araujo, Benjamin Négrevergne, Yann Chevaleyre, and Jamal Atif

    work page

  2. [2]

    Arghal, E

    R. Arghal, E. Lei, and S. S. Bidokhti. 2022. Robust graph neural networks via prob- abilistic Lipschitz constraints. InLearning for Dynamics and Control Conference. 1073–1085

    work page 2022

  3. [3]

    George Dasoulas, Kevin Scaman, and Aladin Virmaux. 2021. Lipschitz normal- ization for self-attention layers with application to graph neural networks. In International Conference on Machine Learning. PMLR, 2456–2466

    work page 2021

  4. [4]

    Wenqi Fan, Yao Ma, Qing Li, Yuan He, Yihong Eric Zhao, Jiliang Tang, and Dawei Yin. 2019. Graph Neural Networks for Social Recommendation. The World Wide Web Conference (2019). https://api.semanticscholar.org/CorpusID:67769538

    work page 2019

  5. [5]

    ZhengZhao Feng, Rui Wang, TianXing Wang, Mingli Song, Sai Wu, and Shuib- ing He. 2024. A Comprehensive Survey of Dynamic Graph Neural Networks: Models, Frameworks, Benchmarks, Experiments and Challenges. arXiv preprint arXiv:2405.00476 (2024)

    arXiv 2024

  6. [6]

    Paul Geuchen, Thomas Heindl, Dominik Stöger, and Felix Voigtlaender. 2023. Upper and lower bounds for the Lipschitz constant of random neural net- works. ArXiv abs/2311.01356 (2023). https://api.semanticscholar.org/CorpusID: 264935036

    work page Pith review arXiv 2023

  7. [7]

    Henry Gouk, Eibe Frank, Bernhard Pfahringer, and Michael J. Cree. 2018. Regular- isation of neural networks by enforcing Lipschitz continuity. Machine Learning 110 (2018), 393 – 416. https://api.semanticscholar.org/CorpusID:4811672

    work page 2018

  8. [8]

    Palash Goyal, Sujit Rokka Chhetri, and Arquimedes Canedo. 2020. dyngraph2vec: Capturing network dynamics using dynamic graph representation learning. Knowledge-Based Systems 187 (2020), 104816

    work page 2020

Show all 47 references
  1. [9]

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

    2017

  2. [10]

    William L Hamilton. 2020. Graph representation learning. Morgan & Claypool Publishers

    2020

  3. [11]

    Hamilton, Rex Ying, and Jure Leskovec

    William L. Hamilton, Rex Ying, and Jure Leskovec. 2017. Representation Learning on Graphs: Methods and Applications. IEEE Data Eng. Bull. 40 (2017), 52–74. https://api.semanticscholar.org/CorpusID:3215337

    2017

  4. [12]

    Kai Han, An Xiao, Enhua Wu, Jianyuan Guo, Chunjing Xu, and Yunhe Wang

  5. [13]

    Y. Jia, C. Zhang, and S. Vosoughi. 2024. Aligning Relational Learning with Lipschitz Fairness. International Conference on Learning Representations. In ICLR

    2024

  6. [14]

    Seyed Mehran Kazemi, Rishab Goel, Kshitij Jain, Ivan Kobyzev, Akshay Sethi, Peter Forsyth, and Pascal Poupart. 2020. Representation learning for dynamic graphs: A survey. Journal of Machine Learning Research 21, 70 (2020), 1–73

    2020

  7. [15]

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

    2016 arXiv

  8. [16]

    Srijan Kumar, Xikun Zhang, and Jure Leskovec. 2019. Predicting dynamic em- bedding trajectory in temporal interaction networks. In Proceedings of the 25th ACM SIGKDD international conference on knowledge discovery & data mining. 1269–1278

    2019

  9. [17]

    Weikai Li, Zhiping Xiao, Xiao Luo, and Yizhou Sun. 2024. Fast Inference of Removal-Based Node Influence. In Proceedings of the ACM Web Conference

    2024

  10. [18]

    Yiming Li, Yanyan Shen, Lei Chen, and Mingxuan Yuan. 2023. Zebra: When tem- poral graph neural networks meet temporal personalized PageRank.Proceedings of the VLDB Endowment 16, 6 (2023), 1332–1345

    2023

  11. [19]

    Zhuoling Li, Gaowei Zhang, Lingyu Xu, and Jie Yu. 2021. Dynamic Graph Learning-Neural Network for Multivariate Time Series Modeling. ArXiv abs/2112.03273 (2021). https://api.semanticscholar.org/CorpusID:244920721

    2021 arXiv

  12. [20]

    Franco Manessi, Alessandro Rozza, and Mario Manzo. 2017. Dynamic Graph Convolutional Networks.Pattern Recognit. 97 (2017). https://api.semanticscholar. org/CorpusID:16745566

    2017

  13. [21]

    Aldo Pareja, Giacomo Domeniconi, Jie Chen, Tengfei Ma, Toyotaro Suzumura, Hiroki Kanezashi, Tim Kaler, Tao Schardl, and Charles Leiserson. 2020. Evolvegcn: Evolving graph convolutional networks for dynamic graphs. In Proceedings of the AAAI conference on artificial intelligenc...

    2020

  14. [22]

    Hongbin Pei, Bingzhen Wei, Kevin Chen-Chuan Chang, Yu Lei, and Bo Yang. 2020. Geom-GCN: Geometric Graph Convolutional Networks. ArXiv abs/2002.05287 (2020). https://api.semanticscholar.org/CorpusID:210843644

    2020 arXiv

  15. [23]

    Xianbiao Qi, Jianan Wang, and Lei Zhang. 2023. Understanding Optimization of Deep Learning. ArXiv abs/2306.09338 (2023). https://api.semanticscholar.org/ CorpusID:259171775

    2023 arXiv

  16. [24]

    Emanuele Rossi, Ben Chamberlain, Fabrizio Frasca, Davide Eynard, Federico Monti, and Michael Bronstein. 2020. Temporal graph networks for deep learning on dynamic graphs. arXiv preprint arXiv:2006.10637 (2020)

    2020 arXiv

  17. [25]

    Joakim Skarding, Bogdan Gabrys, and Katarzyna Musial. 2020. Foundations and Modeling of Dynamic Networks Using Dynamic Graph Neural Networks: A Survey. IEEE Access 9 (2020), 79143–79168. https://api.semanticscholar.org/ CorpusID:218665617

    2020

  18. [26]

    Joakim Skarding, Bogdan Gabrys, and Katarzyna Musial. 2021. Foundations and modeling of dynamic networks using dynamic graph neural networks: A survey. iEEE Access 9 (2021), 79143–79168

    2021

  19. [27]

    Junwei Su, Difan Zou, and Chuan Wu. 2024. PRES: Toward Scalable Memory- Based Dynamic Graph Neural Networks.arXiv preprint arXiv:2402.04284 (2024)

    2024 arXiv

  20. [28]

    Szegedy, W

    C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus. 2014. Intriguing properties of neural networks. In ICLR

    2014

  21. [29]

    Sahil Tyagi and Prateek Sharma. 2020. Taming resource heterogeneity in distributed ml training with dynamic batching. In 2020 IEEE International Conference on Autonomic Computing and Self-Organizing Systems (ACSOS). IEEE, 188–194

    2020

  22. [30]

    Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. 2017. Graph attention networks. arXiv preprint arXiv:1710.10903 (2017)

    2017 arXiv

  23. [31]

    Xixi Wang, Bo Jiang, Xiao Wang, and Bin Luo. 2024. Learning Dynamic Batch- Graph Representation for Deep Representation Learning. International Journal of Computer Vision (2024), 1–22

    2024

  24. [32]

    Xuhong Wang, Ding Lyu, Mengjian Li, Yang Xia, Qi Yang, Xinwen Wang, Xin- guang Wang, Ping Cui, Yupu Yang, Bowen Sun, et al . 2021. Apan: Asynchro- nous propagation attention network for real-time temporal graph embedding. In Proceedings of the 2021 international conference on ...

    2021

  25. [33]

    Shiwen Wu, Fei Sun, Fei Sun, and Bin Cui. 2020. Graph Neural Networks in Recommender Systems: A Survey. Comput. Surveys 55 (2020), 1 – 37. https: //api.semanticscholar.org/CorpusID:226246289

    2020

  26. [34]

    Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. 2020. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems 32, 1 (2020), 4–24

    2020

  27. [35]

    Da Xu, Chuanwei Ruan, Evren Korpeoglu, Sushant Kumar, and Kannan Achan

  28. [36]

    Leshanshui Yang, Clément Chatelain, and Sébastien Adam. 2023. Dynamic Graph Representation Learning With Neural Networks: A Survey.IEEE Access 12 (2023), 43460–43484. https://api.semanticscholar.org/CorpusID:258079246

    2023

  29. [37]

    Hamil- ton, and Jure Leskovec

    Rex Ying, Ruining He, Kaifeng Chen, Pong Eksombatchai, William L. Hamil- ton, and Jure Leskovec. 2018. Graph Convolutional Neural Networks for Web-Scale Recommender Systems. Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining (2018)...

    2018

  30. [38]

    arXiv preprint arXiv:2002.07962 (2020)

    Inductive representation learning on temporal graphs. arXiv preprint arXiv:2002.07962 (2020)

    2020 arXiv

  31. [39]

    X. Zhao, Z. Zhang, Z. Zhang, L. Wu, J. Jin, Y. Zhou, R. Jin, D. Dou, and D. Yan

  32. [40]

    Hongkuan Zhou, Da Zheng, Israt Nisa, Vasileios Ioannidis, Xiang Song, and George Karypis. 2022. Tgl: A general framework for temporal gnn training on billion-scale graphs. arXiv preprint arXiv:2203.14883 (2022)

    2022 arXiv

  33. [41]

    Mueller, R

    Hang Zhang, Chongruo Wu, Zhongyue Zhang, Yi Zhu, Zhi-Li Zhang, Haibin Lin, Yue Sun, Tong He, Jonas W. Mueller, R. Manmatha, Mu Li, and Alex Smola. 2020. ResNeSt: Split-Attention Networks. 2022 IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops (CVPRW) (20...

    2020

  34. [42]

    Lekui Zhou, Yang Yang, Xiang Ren, Fei Wu, and Yueting Zhuang. 2018. Dynamic network embedding by modeling triadic closure process. In Proceedings of the AAAI conference on artificial intelligence, Vol. 32

    2018

  35. [43]

    Expressive 1-Lipschitz neural networks for robust multiple graph learning against adversarial attacks. In ICML. 12719–12735

  36. [45]

    Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang, Changcheng Li, and Maosong Sun. 2020. Graph neural networks: A review of methods and applications. AI open 1 (2020), 57–81

    2020

  37. [47]

    Jiabo Zhuang, Shunmei Meng, Jing Zhang, and Victor S. Sheng. 2023. Contrastive Learning Based Graph Convolution Network for Social Recommendation. ACM Trans. Knowl. Discov. Data 17, 8, Article 120 (June 2023), 21 pages. doi:10.1145/ 3587268

    2023

  38. [2020]

    https://api.semanticscholar.org/CorpusID:219686989

    Fast & Accurate Method for Bounding the Singular Values of Convolutional Layers with Application to Lipschitz Regularization.ArXiv abs/2006.08391 (2020). https://api.semanticscholar.org/CorpusID:219686989

    2020 arXiv

  39. [2021]

    In Neural Information Processing Systems

    Transformer in Transformer. In Neural Information Processing Systems. https://api.semanticscholar.org/CorpusID:232076027

Pith tools

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