TGM: A Modular and Efficient Library for Machine Learning on Temporal Graphs
Authors: Jacob Chmura
Shenyang Huang
Tran Gia Bao Ngo
Ali Parviz
Farimah Poursafaei
Jure Leskovec
Michael M. Bronstein
Guillaume Rabusseau
Matthias Fey
Reihaneh Rabbany
Venue: ICLR 2026 Poster (2026)
Keywords: Temporal Graph Learning
Dynamic Graphs
Deep Learning
Programming Framework
Software Libraries
Primary area: learning on graphs and other geometries & topologies
TL;DR: We present TGM, a modular research library for efficient and reproducible machine learning on temporal graphs.  TGM supports both discrete and continuous-time temporal graph methods.

Abstract: Well-designed open-source software drives progress in Machine Learning (ML) research. While static graph ML enjoys mature frameworks like PyTorch Geometric and DGL, ML for temporal graphs (TG), networks that evolve over time, lacks comparable infrastructure. Existing TG libraries are often tailored to specific architectures, hindering support for diverse models in this rapidly evolving field. Additionally, the divide between continuous- and discrete-time dynamic graph methods (CTDG and DTDG) limits direct comparisons and idea transfer. To address these gaps, we introduce Temporal Graph Modelling (TGM), a research-oriented library for ML on temporal graphs, the first to unify CTDG and DTDG approaches. TGM offers first-class support for dynamic node features, time-granularity conversions, and native handling of link-, node-, and graph-level tasks. Empirically, TGM achieves an average 7.8× speedup across multiple models, datasets, and tasks compared to the widely used DyGLib, and an average 175× speedup on graph discretization relative to available implementations. Beyond efficiency, we show in our experiments how TGM unlocks entirely new research possibilities by enabling dynamic graph property prediction and time-driven training paradigms, opening the door to questions previously impractical to study.

Published as a conference paper at ICLR 2026
TGM: A MODULAR AND EFFICIENT LIBRARY FOR MA- CHINE LEARNING ON TEMPORAL GRAPHS
Jacob Chmura ,,2,,, Shenyang Huang 1,.3, Tran Gia Bao Ngo Ali Parviz!
Farimah Poursafaei 1.2 Jure Leskovec', Michael Bronstein 3.6
Guillaume Rabusseau 1.7.s Matthias Fey Reihaneh Rabbany 1.2.8
* Equal Contribution, Mila - Quebec AI Institute, Mcciill University, Uniivrssty of Oxford,
NNw Jersey Institute of Technology, UUiiversity of Manitoba, Stanford University,
7 AITHYRA, DIRO, Université de Montréal, 9CIFAR AI Chair, Kumo.AA
Corresponding authors: (jacob chmura, shenyang. hacteeyannnhuungg...... @ma il mogi ca
ABSTRACT
Well-designed open-source software drives progress in Machine Learning (ML) research. While static graph ML enjoys mature frameworks like PyTorch Geomet- ric and DGL, ML for temporal graphs (TG), networks that evolve over time, lacks comparable infrastructure. Existing TG libraries are often tailored specific archi- tectures, hindering support for diverse models in this rapidly evolving field. Addi- tionally, the divide between continuous- and discrete-ting dynamic graph methods (CTDG and DTDG) limits direct comparisons and idea transfer. To address these gaps, we introduce Temporal Graph Modelling (TGM), a research-oriented library for ML temporal graphs, the first to unify CTDG and DTDG approaches. TGM offers first-class support for dynamic node features, time teae-rrralaarty conversions, and native handling of link-, node-, and graph-level tasks. Empirically, TGM achieves an average 7.8x speedup across multiple models, datasets, and tasks compared the widely used DyGLib, and average 175x speedup graph discretization relative to available implementations. Beyond efficiency, we show our experiments how TGM unlocks entirely new research possibilities by enabling dynamic graph property prediction and time-driven training paradigms, opening the door to questions previously impractical study.
Code: tgm-team/tgn
Documentation: rgm.readthedocs.io
INTRODUCTION AND MOTIVATION
Advances in machine learning driven by open, easy-to-use libraries that let researchers focus de- veloping frontier architectures. For example, deep learning research was propelled by Caffe (Jia et al., 2014), TensorFlow (Abadi et al., 2016) and PyTorch (Paszke et al., 2019). Similarly, developments in graph machine learning (Kipf & Welling, 2016; Veličković et al., 2017; Dwivedì & Bresson, 2020; Rampášek et al., 2022) are accelerated by libraries such as PyG (Fey & Lenssen, 2019; Fey al., 2025) and DGL (Wang et al., 2019). However, both PyG and DGL are designed for static graphs and cannot capture the temporal dynamics of networks, known as Temporal Graphs (TGs). Real-world examples include transaction (Shamsi et al., 2022), social (Huang et al., 2023a), trade (Poursafaei et al., 2022b), and communication networks (Yoon et al., 2020) among others.
Recently, Temporal Graph Learning (TGL) has emerged to capture both spatial and temporal de- pendencies in networks (Cornell al., 2025; Cao al., 2020; Han et al., 2014). The field has seen growth with high-impact, cross-domain applications, such as Linkedln's LiGNN system (Borisyuk et al., 2024) for user recommendations and mobility modelling that informed COVID-19 policy decisions (Chang et al., 2021). Unlike static graph ML, TGL must treat time first-class signal, making timestamps central to modelling and data processing. Despite research progress, software infrastructure has not kept pace.
Limitations of existing libraries, Current TG libraries (Yu et al., 2023a: Rozemberezki et al., 2021) narrow in scope: many implement only single algorithm family (Wang & Mendis, 2024;

---

Published as a conference paper at ICLR 2026
TGM Graph Representation
Data Transformations (Hooks)
Edge Events
t=
Negative Sampling
User Defined Hook
K-G
Time
C-1
t-3
t-
Node Events
Uniform Neighber Sampling Hook
MANAGER
Receney Neighbor Sampling Hoak
Time Operations
Neural Network Layers
lteration by Events
Iteration by Time
TPNet DyöFormer
TGN TGAT
T-GCN GCLSTM
Graph Discrelization
Time Granularity
Figure I: Overview of TGM features, TGM has native support for node events and unified continuous- and discrete-time graph iteration (left). Generic hooks formalize common transformations (top- right). TGM supports broad range of temporal graph learning methods (bottom-right).
Zhou et al., 2023b) and most lack extensibility, resulting in a fragmented ecosystem. For instance, TGL (Zhou al., 2022a), DisTGGL (Zhou et al., 2023b) and TGLite (Wang & Mendis, 2024) optimized for temporal message passing architectures (Rossi et al., 2020; da Xu et al., 2020) but do not support emerging transformer-basee approaches (Yu et al., 2023a; Gao et al., 2025). Also, none provide time conversion operations which are critical for analyzing temporal granularity in TGs (Huang al., 2024). Finally, existing libraries fall short on usability features needed to foster reproducible research such as profiling tools, test suites, and modular abstractions (see Table 1).
Motivation for unified framework. Unlike NLP, where the transformer serves as a canonical architecture (Vaswani et al., 2017). TGL lacks standard model family. This leads to fragmented and error-prone experimentation: continuous- and discrete-time models require entirely different data pipelines, while core operations such as temporal neighbor sampling and negative edge construction are implemented inconsistently. Without a unified framework, the community faces difficulties in fair benchmarking, rapid prototyping, and combining ideas across approaches.
Our solution. We introduce TGM, a modular and efficient framework for TGL research. TGM introduces several firsts: native support for node events, generic hook mechanism that standardizes TG transformations, and unified support for both continuous- and discrete- time graphs, ending the long-standing separation between the lines of research (Rossi et al., 2020; You al., 2022). Node events naturally capture phenomena like social media posts or other user activity in real-world networks (Kazemi et al., 2020a). These abstractions unify diverse TG pipelines, lowering the barrier for practitioners and accelerating innovation. Beyond flexibility, TGM delivers efficiency: 7.8x faster than DyGLib standard TG models and an average speedup of 175x graph discretization.
In summary, the key properties of TGM are:
First unified library for TG. TGM is the first library support both continuous- and discrete-ting graphs, treating them as distinct views of the same underlying data. We implement 8 methods from both CTDG and DTDG literature, including frontier models.
Time as first-class citizen. Time operations are central to TGs. TGM natively incorporates time granularity into its API, with built-in support for graph discretization and snapshot iteration.
Efficiency. Our experiments show that TGM achieves average 7.8x faster end-to-end training than DyGLib, and 175x faster graph discretization compared with existing implementations. Research-orienter Designed for rapid prototyping, TGM emphasizes modularity and ease-of- use. Its novel hook mechanism standardizes temporal graph transformations while supporting the broadest range of TG tasks: link, node, and graph-level prediction.
2

---

Published as a conference paper at ICLR 2026
2
RELATED WORK
Continuous-time Dynamic Graph (CTDG) methods process temporal graphs as streams of timestamped edge events. TGAT (da Xu et al., 2020) pioneered inductive representation learning on temporal graphs, and TGN (Rossi et al., 2020) generalized this approach into a widely adopted framework, with TGAT as a special case. Both rely on temporal neighbor sampling for message passing. More recently, DyGLib (Yu et al., 2023a) emerged as a popular library, introducing DyGFormer, one of the first transformer-ben based CTDG architectures inspired by their success time series, NLP, and vision (Vaswani et al., 2017: Devlin et al., 2019; Dosovitskiy et al., 2021). Despite these advances, Poursafaei et al. (2022a) exposed flaws prior evaluation and proposed EdgeBank, strong heuristic baseline for link prediction. To address reproducibility. Huang et al. (2023a) introduced the large-scale Temporal Graph Benchmark (TGB), which we adopt for evaluating TGM. Recently, TPNet (Luu al., 2024b) further advanced sate-of-theeare link prediction by introducing temporal walk matrices with time decay, and is fully supported in TGM.
CTDG Methods.
DTDG Methods. Discrete-time Dynamic Graph (DTDG) snapshot- based methods represent tem- poral evolution as a sequence of static graph snapshots, adapting GNNs like GCN (Kipf & Welling, 2017) this setting. GCLSTM (Chen et al., 2018) integrates GCNs with LSTMs (Hochreiter & Schmidhuber, 1997) to capture spatial and temporal dependencies. while PyG Temporal (Rozem- berezki et al., 2021) provides a library of DTDG architectures for spatiotemporal graph learning. However, PyG Temporal lacks recent methods and standardized benchmarks like TGB. More re- cently, Unified Temporal Graph (UTG) (Huang et al., 2024) demonstrated a proof-of-coneepe for comparing CTDG and DTDG approaches via graph discretization. While UTG offers useful insights, its implementation is slow, limited to a few datasets, and not designed for reuse. In contrast, TGM supports fully vectorized graph discretization and time-iteration operations, unifying CTDG and DTDG within a single, robust framework and closing a long-standdng gap in TGL.
CTDG DTDG. Discrete and continuous-time formulations differ primarily in their treatment of time: DTDGs aggregate changes into snapshots while CTDGs record each event, providing fine-grained temporal resolution (Kazemi et al., 2020b; Longa al., 2023; Gravina & Bacciu, 2024). DTDGs offer simpler batch processing when data arrives regularly, whereas CTDGs are event-driven, making them better for capturing fin-grained dynamics and causal relationships. While DTDGs prioritize efficiency, they may lose important information when events occur more frequently than the snapshot rate (Kazemi al., 2020b). Prior discussions largely remain conceptual and offer no practical framework for comparing or unifying the two paradigms. For example, applying DTDG models to CTDG tasks requires discretizing continuous-time time events into snapshots.
TGL Libraries. Several libraries support temporal graph learning including DyGLib (Yu et al., 2023b), TGL (Zhou al., 2022b), DistTGL (Zhou al., 2023a), TGLite (Wang & Mendis, 2024), and TSL (Cini & Marisca, 2022). DyGLib provides pipelines for continuous-ting time models but is limited by scalability, lack of modularity, and weak support for discrete-time methods (Gastinger et al., 2024). TGL and DisITGL offer large-scale sampling and multi-GPU execution but lack asseachee-friendd interface and have seen few recent updates. TGLite focuses on continuous-time message-flow flow models, while TSL addresses spatiotemporal modelling on static graphs
Table 1 summarizes key aspects of these libraries. TGM stands out as the only library that supports both CTDG and DTDG methods, bridging continuous- and discrete-time research paradigms. Its efficient and modular design facilitates flexible experimentation, while support for time conversion and dynamic node events enables diverse temporal graph learning tasks. Additionally, comprehensive tests and system profiling ensure reproducibility and provide research-ready infrastructure.
TGM FRAMEWORK
In this section, we present the foundation and concepts in TGM. In Section 3.1, we introduce the formulation of temporal graph in TGM and unify continuous- and discrete-time formulations by defining them as different ways of iteration over the graph. We also define the graph discretization operation principled way map from continuous events to snapshots. Then in Section 3.2, introduce the TGM hook formalism, a modular abstraction for composing graph operations. Together, these elements inform the software and system design in Section 4.
3

---

Published as a conference paper at ICLR 2026
Table 1: Comparison of TGL libraries. TGM is the only library that meets all desirable criteria for TGL research while other libraries lack one or more criteria.
TGL Features
Software Infrastructure
Library
CTDG
DTDG
Ops.
Node Events
Modular
Efficient
Unit Tests
Profiling
TGM (ours)
DyGLib
X
X
TGL
x
TGLite
PyG Temporal
X
Iteration by Events (batch size
Hourly Granulsrity
!!
I
!!!!
!!
I!!!
Iteration by Time (batch day)
Discretization
I1
I
!!!!
!!
Granulanty
Day
Day
Day
Time
Figure 2: TGM supports iteration by events and time. Discretization maps fine-grained timestamps (e.g., hourly) to coarser timestamps (e. daily), aggregating duplicated edges in the process.
3.1 TGM TEMPORAL GRAPH FORMULATION
Here, we first introduce the notation of temporal graphs in TGM. On temporal graphs, events are considered as a fundamental unit for representing the network's evolution (Kazemi et al., 2020a). To capture changes in graph structure and features, TGM distinguish between the following event types: Definition 3.1 (Node and Edge Events). An edge event (t,, s, d, Xedye) is an interaction between two nodes and d at time where Xedge E Redds is the associated edge feature vector. A node event (t, 8, Xnode) ) represents the arrival new features Xnode E Rdmode at node and timestamp t.
Definition 3.2 (Temporal Graph). A temporal graph
sequence of time-ordered events: {eo, ..., eT). ). Each event e; be an edge event node event. Also, G can be associated with static node feature matrix X x where n is the number unique nodes in G. For any time interval T C R+, the temporal sub-graph G contains all events in G intersecting T.
Representing Continuous and Diserete-Time Graphs. As temporal graphs are represented as sequences of events in TGM, TGM doesn't 't treat CTDG and DTDG different data types but rather as distinct ways of data iteration. We consider that any temporal graph admits a native time granularity the coarsest unit of time (e.g., seconds) that still discriminates between all event timestamps. If real-world time unavailable (e.g., due to privacy), TGM employs a special event-ordered granularity Tevents preserving only the relative order of events but lacks correspondence to real-world time granularity, thus Tevent is excluded from any time operations. Lastly, note that time granularities can be compared: f < > is coarser than f. This view unifies CTDG and DTDG alternative ways of iterating over the same event stream:
Definition 3.3 (CTDG: Event-based iteration). A CTDG often expressed as a stream of events (Kazemi et al., 2020a; Huang et al., 2023b; Rossi al., 2020; You et al., 2022). In TGM, iterating a CTDG corresponds to using the event-ordered granularity Tevent- Each batch contains a fixed number of events, independent of real-world time.
Definition 3.4 (DTDG: Time-based iteration). A DTDG is often expressed sequence of static graph snapshots sampled at regularly-spaced time intervals, i.c. as (Go, G..... }. where G, = (V,, E,} is static graph snapshot (Huang et al., 2024). In TGM, achieve this by iterating
4

---

Published as a conference paper at ICLR 2026
Table Examples of common temporal graph operations represented as hooks, and their attributes.
Hook Type
Neighbor Sampling
Evaluation TGB Eval
Device Ops.
Analytics
Recency
Uniform
GPU Transfer
DOS Estimate
R (Requires)
negativess |niighbors}
negatives)
0 {DOS}
P (Produces)
nniighoors]
negatives)
with time granularity i that is coarser than the native graph granularity. Iterating by time produces batches 9 [to.t.) 9 [(s,Au4))>"" where | tol = [t;+1 tg F.
Discretizing Temporal Graphs. For snapshot-based models, often useful to process the graph at a coarser granularity than the native т (c.g., daily instead of second-wise). Discretization converts the underlying network to this coarser timeline by collapsing duplicate edges within each time interval:
Definition 3.5 (Time Granularity Discretization... Let 9 be temporal graph with native time granularity т. For any 2 т, the discretization operator:
1 (G,T) r) + (G,
maps G to coarser granularity f, groups events into equivalence classes induced by and applies a reduction operator r to each class. The resulting graph & contains one representative event per class. Figure illustrates these time operations in TGM.
3.2 TGM HOOKS AND RECIPES
In TGM, we formalize TGL workflows as compositions of data transformations called hooks. Each hook specifies certain batch attributes inputs and outputs thus forming dependency relations between hooks, i.e. one hook produces attribute that is required by another. A set of hooks forming a valid composition of hook signatures are considered as a recipe.
Definition 3.6 (Materialized Batch). Let G|T be temporal subgraph. We denote by BIT.A the materialized batch associated with set of properties A. Intuitively, A captures the attributes that enrich the slice of data, typically tensors required by a model (e.g. neighborhood information in message-passinne passing architectures).
Definition 3.7 (Hook). hook ΦR.P a transformation on a materialized batch:
ΦR,P BlT.A + BlT,AuP
(2)
which declares contract based on the attributes required on the input R. C A. and the attributes produced P. so that the batch transformed by o has attributes A U U.P. Table illustrates several common temporal graph operations expressed as hooks using the notation introduced here.
The real power of hooks is unlocked by composing their transformations to express complete temporal graph workflows. The notion of a hook recipe formalizes this.
Definition 3.8 (Hook Recipe). A set of hooks ( ... their dependencies:
of P.PP. induces ordering given by
PARR, #
We call this hook recipe if this dependency graph is acyclic and every required is satisfied, i.e. Vj, R2 C Uieg P.. Thus, any hook recipe admits a valid ordering by topological sort. With this framework, exploring new research is simpler as complex workflows can be expressed with minimal boilerplate. Figure 3 illustrates how MI. and analytics pipelines are represented as recipes in TGM.
4 TGM SOFTWARE LIBRARY
We now describe the software implementation that realizes the framework described in the previous section. Figure presents the high-level system design: the data layer is an immutable time-sorted coordinate format (COO) storage with lightweight graph views for efficient slicing; the execution
5

---

Published as a conference paper at ICLR 2026
TGAT Link Prediction Recipe
50X preh
Negative Edge Sampler Hook
Recency Neighbor Sampling llook
t+3
Layer A
20
Precictions
DOS Analysis Recipe
Graph Laplacian Matrix Hook
Densitty of States Estimation Hook
Spectra
Figure 3: Example recipes in TGM: TGAT link prediction and Density of States Analysis. TGM provides a unified ecosystem supporting both representation learning and temporal graph analytics. The constituent hooks are modular, enabling reuse across different workflows within the community.
Time Cranularity
Naterial1ze
Graph Views Non memory
DataLoader
Batch
Iterate by time event
On-device lensors
Time Slices
Model Inputs
Hook Manager
Models & Layers Meeorry Altention, Deooders
Graph Storage
Exccution Context
Model Outputs
Raw Data
Hook Registry
Tasks Lnk, Node, Graph
Preprocessing
Custom Hooks
Data spits, Desoretzation
Evaluation Mist, NDOG, AUROC
Adaptors TGB. CSV, Pandas
Recipes Pre-defined Hooks
Data Layer
Execution Layer
ML Layer
Figure 4: Three Layer Architecture of TGM: data layer (left), with IO adaptors and preprocessing, immutable COO graph storage, and lightweight sub-graph views; execution layer (middle), where users register custom hooks apply pre-built recipes through the hook manager and dataloader to inject execution logic; and ML layer (right), where batches are materialized on device and used for node-, link-, graph-level prediction. Light blue elements denote user-facing APIs.
layer is built around a hook manager that transparently performs complex transformations (e.g.. temporal neighbors); and the ML layer materializes batches on-device for model computation. This separation of concerns yields workflows that are efficient and extensible, as we show in Section 5.3. Note that batch sizes significantly impact model performance (see Appendix G for further discussion).
I0 Adaptors and Data Preprocessing. TGM streamlines experimentation by integrating the widely- used benchmark dataset: TGB (Huang et al., 2023a; Gastinger al., 2024), in the form IO Adapters, including loading, preprocessing, and crain/validationtess splits. This allows researchers to start experiments immediately and compare models consistently with minimal overhead. Custom adapters are also supported via CSV and Pandas. Our design makes it straightforward to incorporate new benchmarks while ensuring consistent evaluation across all datasets (see Appendix D).
Graph Storage and Graph Views. The storage exposes an interface for graph queries, implemented using a time-sorted COO with cached index. This enables binary search over timestamps, which is critical for recent-neighbor retrieval. The backend is designed for extension, allowing alternative layouts (Zhang et al., 2021; Sha et al., 2017) so future models can use the most efficient data structures for their workload. Backed by the storage, graph views provide lightweight, concurrency to temporal sub-graphs. Each view tracks time boundaries and encodes read-acces acceacces through the time granularity abstraction. This enables TGM perform both CTDG and DTDG-style loading, making it straightforward to study the effects of snapshot resolutions, as illustrated in Section 5.3. Our discretization is fully vectorized, enabling efficient snapshot creation, demonstrated in Table 5.
access

---

Published as a conference paper at ICLR 2026
Hook Registry and Management. Building the graph abstractions, hooks are transformations that can be combined to create workflows (see Section s 3). Hooks process batches in chronological order to preserve temporality, while operations on events within the same batch, including neighbor sampling, device transfer, and negative edge generation, are executed in parallel, thus contributing to the efficiency of TGM. The HookManager handles shared state, resolves dependencies, and executes transparently during data loading. A key-value interface allows hooks to be registered under specific conditions (e.g., analyties hooks). We provide pre-defined recipes for common tasks such TGB link prediction, helping new practitioners avoid common pitfalls like mismanaging state across splits.
Diverse Model and Task Support. TGM provides PyTorch modules tailored for TGL, including memory units, attention layers, and link decoders. With this, TGM implements a range of TG methods, from baselines like EdgeBank (Poursafaei al., 2022a), to message passing-based models like TGAT (da Xu et al., 2020), and frontier models like DyGFormer (Yu et al., 2023a) and TPNet (Lu al., 2024b). Crucially, learnable components are decoupled from graph management, making easy for researchers to prototype new models.
from tgn Inpoort DGBata, DGraph, RacipeRegistry from tgn. loader import DCDataLoader
B Inject hook managar into our data loader Loader DGDataLoader nanager, ...)
from constanss imporrt RECIPE_TGB_LEE
optimizer
Load Dataset and split data train, ... frortrrrrrrttbt""tlliiiilii sspps)))
model, optimrizer aas
for egach in range (NUM)NNNNMMOOCCC EPOCHS):
Creetee storage backed views train split train_dg DGraph(train, device='cuda)
with activatee ("train"); batch loader:
loss conpute, loss(mode lackwback)))d(); optinizer.
Build TGB Link Property Prediction Recipe nanager RactpeRegistry Duriii TGB_ LINK) aonager.regsterr.... t Register custon hooks
nanager.reset_statte
Reset hocks after opoch
Example workflow in TGM. Left: dataset loading, graph creation, and hook registration; Right: manager injection. model setup, and training loop with automatic hook activation. Highlighted code maps to system components from Figure 4.
Figure 5:
Streamlined TGL Workflows. Figure 5 provides a high-level overview of a typical workflow in
TGM, showing how data preparation, graph creation, hook registration, and training are orchestrated. Registered hooks dynamically inject behaviour during data loading, ensuring models automatically receive the appropriate tensors. This unifies the model interface and defines which batch attributes each model consumes. The manager reset method exposes a simple API for clearing the state of active hooks. Complex workflows can be implemented by registering hooks under key-value pairs.
Robust and Research-Reade Infrastructure, Finally, TGM built following modern software engi- neering practices to ensure reliability, maintainability. and ease of use. We use type hinting throughout the codebase, which unifies model APIs and improve usability. Continuous integration pipelines run end-to-end tests on all layers, hooks, and graph APIs with test coverage to ensure correctness. Perfor- mance monitoring utilities can track GPU usage with support for tools such as FlameProf (Bobrov, 2017) to help identify bottlenecks. We also provide detailed tutorials, documentation, and examples for link, node and graph tasks. Overall, TGM provides a high-quality, research-ready platform that lowers the barrier to TG research while supporting efficient experimentation.
5 EXPERIMENTS
In this section, we evaluate TGM efficiency and research extensibility, Correctness results are reported in Section 5.2, where show that TGM reproduces prior library performance. The appendix also includes peak memory measurements B.2) and a detailed runtime breakdown ( BB3) collected with TGM 's profiling tools. All experiments share the TGB (Huang et al., 2023a; Gastinger et al., 2024) 70/15/15 chronological data splits for train/validation/tes., and hyperparameters as reported in Table 14. Runtimes are benchmarked under the same compute resources described in Section F.
5.1 EFFICIENCY BENCHMARK
We evaluate TGM on two standard TGL tasks: dynamic link property prediction and dynamic node property prediction. Since graph discretization is core operation in DTDG methods, we additionally
7

---

Published as a conference paper at ICLR 2026
Table 3: Training time per epoch (seconds, J) for link property prediction. The First and Second best results are highlighted (x marks unsupported). TGM achieves competitive performance to the system-optimizer TGLite library on TGAT and TGN models while supporting a broader range of architectures, and consistently outperforms the widely used research library DyGLib across all datasets and models, delivering a 4.4x speedup on the transformer-bant DyGFormer architecture.
Model
TGM
DyGLib
tgbl -w1kk
TGLite
TGL
TGM
DyGLib
sebl-subreddit
TGLite
TGL
TGM
DyGLib
t-bl-1
(obll-latton tm TGLite
TGL
TGAT
6.97
41.24
4.85
10,00
28.23
182.21
25.00
53.25
55.32
349.31
38,00
85.12
TGN
10.59
63.37
6.80
23.32
61.25
287.06
60.50
125.23
91.23
392.98
92.93
250.00
DyGmerr
17.00
75.10
X
72.29
326.60
142.40
633.99
TPNet
12.28
X
x
49.79
x
97.23
GCLSTM
3,56
9.17
140.69
GCN
2.50
X
7.88
x
96.89
x
benchmark the efficiency of TGM in this setting. All datasets are stored in CPU host memory and transferred to GPU when required. Full experiment details, including model hyperparameters and compute resources, are provided in Appendix F.
Link Property Prediction. We benchmark TGM against state-of-the-ard libraries on the dynamic link property prediction task using three standard datasets: tgbl-wiki, tgbl-subredd: it, and tgbl-1as fm. Competing baselines include DyGLib (Yu et al., 2023a), TGL (Zhou et al., 2022b), and TGLite (Wang & Mendis, 2024), all which are designed primarily for continuous-time models.
Table 3 reports training time per epoch across models implemented in TGM and competing libraries. First, TGM uniquely supports the widest range of architectures, spanning both CTDG and DTDG methods. In particular, DTDG models such as GCLSTM and GCN are supported via graph discretiza- tion and iterate-by-ting bimmmme functionality, and TGM is the only library with native support for TPNet (Lu et al., 2024a), the state-of-the- -hrt-arttt art link prediction model TGB as of September 2025. Second, TGM consistently ranks among the top two fastest implementations across datasets and models. It outperforms DyGLib and TGL in all cases, and only slightly behind the highly specialized TGLite on TGAT and TGN. For example, TGM achieves a 4.4x speedup over the alternative DyGFormer im- A key driver of performance our fully vectorized recency sampler, memory
plementation on Egbllwike implemented with a circular buffer in Py PyTorch-natie access. Finally, TGM offers native support for TGB evaluation, the standard benchmark protocol. Appendix B shows that TGM can be up to 246x faster than DyGLib for TGN on fgbl-wiki, owing to batch-level de-duplication and efficient data handling: while DyGLib repeatedly samples neighbors for each prediction, TGM samples once per batch. By contrast, TGL and TGLite do not support this one-vs-many evaluation, limiting their benchmarking robustness compared to TGM.
code, which enables
Node Property Prediction. We bench- mark TGM on the dynamic node prop- erty prediction task, comparing against both DyGLib and the native TGB im- plementations on the tabn-trade and tgbn-genre datasets. TGL and TGLite do not support this task. Ta- ble reports training time per epoch. Compared to DyGLib, TGM achieves up to a 10x speedup for TGN on Sgbn-traad while reducing training time by 80 seconds on tgbn-genre. Moreover, TGM is the only library sup- porting node property prediction for DTDG models: GCLSTM, GCN, and TGCN. Note, we encountered an OOM while running DyGLib on tgbn-genre with our 64GB RAM allocation (sce Ap- pendix F), requiring 256GB of memory produce the results reported in Table 4.
Table 4: Training time per epoch (seconds, J) for dynamic node property prediction. The First and Second best results are highlighted (x marks unsupported). TGM has the best all-around performance and uniquely supports message-passing (TGN), snapshots- (e.g. TGCN), and wransformer-basee (DyGFormer) models.
Model
t-bn-trade
tghr-gonrc DyGLib
TGM
DyGLib
TGB
TGM
TGB
TGN
12.94
19.37
11.07 X
208.88
918.46
281.36
DyGFomer
16.24
117.13
70.89
3539.95
X
P. TGCN
0.41
2.09
0.78
38.15
41.73
35.58
0.85
17.27
GCLSTM
0.88
X
17.71
GCN
0.80
17.21
8

---

Published as a conference paper at ICLR 2026
Table 6: The choice of snapshot time granularity significantly affects link prediction performance. Reported metric is MRR (1) with the First and Second best result for each dataset highlighted.
Lgbl-wiki T-GCN
Lgbl -subreddt T-GCN
Time Gran.
GCN
GCLSTM
GCN
GCLSTM
Hourly
0.510 +: 0.011
0.509 0.004
0.395
0.529
0.374
0.219
Daily
0.702 = 0.007
0.540
0.372
0017
0.266 + 0.07
0.231
0.003
0.212 0.004
Weekly
0.393 + 0.005
0.330
0.009
0.323 0.010
0.191 + 0.002
0.212 = 0.001
0.206 0.004
Graph Discretization. Enabling DTDG models CTDG tasks requires discretizing the original graph into snapshots. We compare TGM's implementation with that of UTG (Huang et al., 2024). Table 5 shows that TGM achieves dramatic speedups, up x LastFM. This improvement stems from a fully vector- ized, PyTrch-native native implementation that avoids cache- unfriendly Python dictionaries and other overheads com- mon prior repositories. This result underscores our commitment to nigh-performance, research-ready tool- ing, setting TGM apart from existing libraries in effi- ciency and engineering standards.
Table Discretization Latency to Hourly Snapshots (seconds, 4). TGM has substantial speedups due to our vec- torized, PyTorch-native implementation.
Dataset
Speedup
tgbl Egbl-wiki
1.94
0.04
49.62x
tgbl ggbl-subreddit
8.83
0.21
41.63x
tgbl-lastin lastfm
19.94
0.05
433.39x
5.2 CORRECTNESS TESTS
Table 7 reports MRR performance on texttttgbl-wiki for dynamic link property prediction, as well as NDCG on -gbn-trade for node property prediction. We cross-reference these results with TGB-reported performance and find that all models fall within the expected range. Note that we did not perform hyperparameter optimization but instead used the parameters listed in Table 14. On tgbl-wikk CTDG models outperform DTDG baselines, with TPNet achieving the highest validation and test MRR, followed by DyGFormer and TGN. In contrast, for node property prediction, DTDG models, particularly GCLSTM and GCN, achieve the best held-out NDCG. These results highlight complementary strength: CTDG models excel in link prediction, while DTDG models are more effective for node-level prediction.
Table 7: Performance on tgbl sgbl-wik ki and tgbn-traa datasets. Numbers are mean + std over runs. The First and Second best results are highlighted (- marks unsupported)
Category
Model
tgbl-xiki
tgbn-trade
Validation MRR (t)
Test MRR (t)
Validation NDCG (t)
Test NDCG (t)
Edgebank
0.495
0.527
Baselines
0.860
0.855
GCN
0.465 + 0,013
0.410 + 0.019
0.670 + 0013
0.629 +: 0,009
DTDG
GCLSTM
0.402 +
0.364 0015
0.761 + 0.003
0.692 + 0,002
TGCN
0.400:1
0.332.1
0.515-L0.006
0.458.1
TGAT
0.380 0,113
0.322-1 0.013
0.380 0.066
0.309 + 0.002
TGN
0,660 0.008
0.527 0.008
0.393 1: 0.001
0.329 + 0,002
CTDG
GraphMixer
0.610+
0.567+ 0.188
DyGFormer
0.743
0.712 1
0.386 0.0012
0.312 d: 0.0003
TPNet
0.771
0.747
0.398
0.289-t 0.0030
5.3 TGM RESEARCH EXPERIMENTS
In addition to its efficiency, TGM is designed as a flexible framework for exploring research questions in temporal graph learning. By supporting both CTDG and DTDG methods, along with native time conversions and composable hooks, TGM allows researchers to implement and test novel ideas effortlessly. We ran all three example experiments using a single script, which we include in anonymized code release. These experiments investigate the following questions: RQ1:

---

Published as a conference paper at ICLR 2026
Table 8: Binary classification task predicting whether the next daily snapshot will see an increased
number of edges. Reported metric is AUC (1) with the First and Second best results highlighted.
TGB
MiNT
Model
tgbl-wiki
ttgbl
-subredit
ADX
ARC
MIR
P.F.
0,018 0,058
0.617 8J47
0.397
0.100
0.625
8:022
0.365
T-GCN
0.667
0,085
0,600 0.44
0.897
1. 0.019
0.901
1 1.000
0,900
0
GCLSTM
0.567
0,047
0.526 0.020
0.588
1: 0.047
0.466
:: 0.019
0.656
1: 0.046
GCN
0.577 =: 0,033
0.200 0,000
0,503
: 0,049
0.608
0.061
0.555
#: 0.33
How accurately can we predict the future evolution of a graph property? RQ2: How does the time granularity of graph snapshots impact DTDG performance on continuous-time graph? RQ3: How do batching strategies, by fixed edges versus by time, affect the performance of a CTDG model?
RQ1: Future evolution of graph property. Graph-level tasks require grouping edges into snapshots. The ability to natively support iteration by time is unique to TGM, allowing researchers to explore research questions in dynamic graph property prediction. As shown in Table 8, we benchmark models on predicting whether future snapshots on tgbl-wiki, tgbl-subreddit and transaction networks from the MiNT benchmark ADX, ARC and MIR), will grow or shrink, critical problem for network evolution (Shamsi et al., 2025). The results highlight the sensitivity of model performance to temporal granularity: T-GCN performs best on tgbl sigblwiil k with an AUC of 0,667, while P.F surprisingly excel on - subdiiii with an AUC of 0.617. On MiNT, T-GCN consistently achieves the best scores with average AUC of 0.899 across three token networks.
RQ2: Effect of Time Granularity for DTDG methods. Table 6 demonstrates that the choice of snapshot granularity, i.e. hourly, daily, or weekly. has a substantial impact on the performance of aaapshot-based based temporal graph models. On the Wikipedia dataset, the impact is particularly pronounced: GCN's MRR increases by 30% when moving from weekly to daily snapshots, while T-GCN and GCLSTM improve by 21% and 5%, respectively. On Reddit, the same trend is observed, though less extreme: GCN achieves 0.529 MRR with hourly snapshots, dropping to 0.191 with weekly snapshots. These results underscore the importance of selecting an appropriate snapshot granularity for DTDG models. TGM makes this process effortless, allowing users to adjust the time granularity with a single line of code, treating it effectively as a hyperparameter.
RQ3: Effect of Batch Size for CTDG methods. Our analysis reveals that the configuration of the evaluation process itself is critical, yet previously overlooked, hyperparameter in temporal graph learn- ing. As demonstrated in Table 9, the choice of vali- dation batch size and temporal unit significantly im- pacts the reported performance of the TGAT model on link prediction. Note that when iterating by time, the number of edges in each batch is different, how- ever, each batch spans fixed amount of time instead. We observe pronounced degradation in MRR with larger batch sizes and coarser temporal units (c.g., Day versus Hour). TGM supports flexible tempo- ral batching via our graph formulation, enabling the investigation of batch size at test time.
Table 9: The choice of validation batch size and batch unit affects the performance of TGAT link prediction on tgbl ki. First and Second best are highlighted.
Size/Unit
Test MRR (1)
0.449 + 0.001
Batch size
50
0.414 : 0.066
100
0.414 1 0.004
200
0.403 + 0.004
Hour
0.402 + 0.012
Batch unit
Day
0.349 = 0.004
6 CONCLUSION
We present TGM, a modular and efficient framework for temporal graph learning built around a novel hook formalism. By decoupling graph operations from model logic, TGM enables rapid prototyping and code reuse, unifying CTDG and DTDG methods under a single research-ready library. Efficiency-wise. TGM is highly competitive and average 7.8x faster in training than the widely used DyGLib. We ultimately envision TGM as a foundation for a shared ecosystem where models, hooks, and analytics can be seamlessly composed and reused, accelerating TGL. research.
10

---

Published as a conference paper at ICLR 2026
ACKNOWLEDGEMENTS
This research was supported by the Canadian Institute for Advanced Research (CIFAR AI chair program), the EPSRC Turing AI World-Leading Research Fellowship No. EP/X040062/1 and EPSRC AI Hub No. EP/Y028872/1. Shenyang Huang was supported by the Natural Sciences and Engineering Research Council of Canada (NSERC) Postgraduate Scholarship Doctoral (PGS D) Award and Fonds de recherche du Québec Nature et Technologies (FRQNT) Doctoral Award.
This research was also enabled in part by compute resources provided by Mila (mila.quebec).
REPRODUCIBILITY STATEMENT
We provide complete codebase enable full reproducibility https://githut com/ t tteamttgm All experiments use fixed random seeds, and full hyperparamcters are listed in Table 14. The Python environment was built deterministically and managed with the uv package manager. Benchmarks were conducted in isolated SLURM jobs, and additional details on compute resources and experimental setup is provided Appendix F.
REFERENCES
Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael lsard, Manjunath Kudlur, Josh Levenberg, Rajat Monga, Sherry Moore, Derek Gordon Murray, Benoit Steiner, Paul A. Tucker, Vijay Vasudevan, Pete Warden, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. Tensorflow: A system for large- machine learning. In Kimberly Keeton and Timothy Roscoe (eds.), 12th USENIX Symposium Operating Systems Design and Implementation, OSDI 2016, Savannah, GA, USA, November 2-4, 2016, pp. 265-283. USENIX Association, 2016. URL https: //ww: usenix. pasenix.org. .rrg/ con.ference/sdii1 hataaa/tttechhccllleec http://ssssseeeeeetatatooo////aa
Anton Bobrov. Flameprof, 2017. URL http::://ttttbb..o////// http:///tubbcoaaaaeeaaaaaaaaaaae
Fedor Borisyuk, Shihai He, Yunbo Ouyang, Morteza Ramezani, Peng Du, Xiaochen Hou, Chengming Jiang, Nitin Pasumarthy, Priya Bannur, Birjodh Tiwana, et al. Lignn: Graph neural networks at linkedin. In Proceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pp. 4793 4803, 2024.
Defu Cao, Yujing Wang. Juanyong Duan, Ce Zhang, Xia Zhu, Congrui Huang, Yunhai Tong, Bixiong Xu, Jing Bai, Jie Tong, et al. Spectral temporal graph neural network for multivariate time-series forecasting. Advances in neural information processing systems, 33:17766-1777 2020.
Serina Chang, Emma Pierson, Pang Wei Koh, Jaline Gerardin, Beth Redbird, David Grusky, and Jure Leskovec. Mobility network models of covid-19 explain inequities and inform reopening. Nature, 589(7840):82-88) 2021.
Da Chen, Yanfeng Li, Yilun He, Xiaojun Jin, and Jie Tang. Ge-lstm: Graph convolution embedded 1stm for dynamic link prediction. In Proceedings of the 2018 IEEE International Conference Data Mining (ICDM), pp. 243-252. IEEE, 2018. doi: 10. 10.1109//DM22008800000
Andrea Cini and Ivan Marisca. Torch Spatiotemporal, 3 2022. URL https: htt.ippppppppppoo.....otoogooaaa http:/b.thhhooooooo.... Torchhpptiiotemppra//eet
Filip Cornell, Oleg Smirnov, Gabriela Zarzar Gandler, and Lele Cao. On the power of heuristics in temporal graphs. arXiv preprint arXiv:2502.04910, 2025.
da Xu, chuanwei ruan, evren korpeoglu, sushant kumar, and kannan achan. Inductive representation learning on temporal graphs. In International Conference on Learning Representations (ICLR), 2020.
Jacob Devlin, Ming- Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: pre-training of deep bidirectional transformers for language understanding. In Jill Burstein, Christy Doran, and Thamar Solorio (eds.), Proceedings of the 2019 Conference of the North American Chapter of
11

---

Published as a conference paper at ICLR 2026
the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2019, Minneapolis, MN, USA, June 2-7, 2019, Volume (Long and Short Papers), pp. 4171- 4186. Association for Computational Linguistics, 2019. doi: 10.18653/VI/N19- 1423. URL https:
/doi. /ooi..io.... orgg 10. 18653/v1 / 9-1423.
Zifeng Ding, Yifeng Li, Yuan He, Antonio Norelli, Jingcheng Wu, Volker Tresp, Michael Bronstein, and Yunpu Ma. Dygmamba: Efficiently modeling long-term temporal dependency on continuous- time dynamic graphs with state space models. arXiv preprint arXiv:2408.04713..22 2024.
Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition scale, In 9th International Conference on Learning Representations, ICLR 2021, Virtual Event, Austria, May 3-7, 2021. OpenReview.net, 2021. URL https: http::://operrevieeee net forum?ick YicbFaNTTy.
Vijay Prakash Dwivedi and Xavier Bresson. generalization of transformer networks to graphs. CoRR, 0oos/2012.09660 2020. URL https:
/ www.aawwww....graaaaaaaaa / 220./22922....9....
Matthias Fey and Jan Eric Lenssen. Fast graph represettionn learning with pytorch geometrie. CoRR, abs/1903.02428, 2019. URL http: / http///www.....oa/////a////// abaaaabss1110 02428.
Matthias Fey. Jinu Sumil, Akihiro Nitta, Rishi Puri, Manan Shah, Blaz Stojanovic, Ramona Bendias, Alexandria Barghi, Vid Koeijan, Zecheng Zhang, Xinwei He. Jan Eric Lenssen, and Jure Leskovee. Pyg 2.0: Scalable learning on real world graphs. CoRR, abs/2507.1699) 2025. doi: 10.48550/ ARXIV.2507.16991 URL https: /oii. org/10. 48550/arXi 2507. 16991.
Jian Gao, Jianshe Wu, and Jingyi Ding. Hyperevent:leaminng cohesive events for large-scale dynamic link prediction. CoRR, abs/2507.11186, 2025. doi: 10.48500ARXIV.250.11.58 URL https:
Julia Gastinger, Shenyang Huang, Mikhail Galkin, Erfan Loghmani. Ali Parviz, Farimah Poursafaci, Jacob Danovitch, Emanuele Rossi, Ioannis Koutis, Heiner Stuckenschmidt, Reihaneh Rabbany, and Guillaume Rabusseau. Tgb 2.0: A benchmark for learning temporal knowledge graphs and heterogeneous graphs. In A. Globerson, L. Mackey, D. Belgrave, A. Fan, U. Paquet, Tomezak, and C. Zhang (eds.), Advances in Neural Information Processing Systems, volume 37, pp. 140199-140229, Curran Associates, Inc., 2024. URL https://proceedinggg neurips ec /appr/ppr....e facpeeer_fieeeeeeeeeee /talee//pppr//00/00 /flie// Ca0Dccc223301roocteeeeeeeeseeee Track.pdi
_nnddetts_a_____aaaeeeeaaea Benchmarks
Alessio Gravina and Davide Bacciu. Deep learning for dynamic graphs: Models and benchmarks. IEEE Trans. Neural Networks Learn. Syst. 35(9): 1788-11801, 2024. doi: 10. 10.1109/NNNSS.000 3379735. URL https::////iii org/ 0 1109 29/00///NN TNNLS. 2024. 3379735.
Wentao Han, Youshan Miao, Kaiwei Li, Ming Wu, Fan Yang. Lidong Zhou, Vijayan Prabhakaran, Wenguang Chen, and Enhong Chen. Chronos: a graph engine for temporal graph analysis. In Proceedings of the Ninth European Conference Computer Systems, pp. 1-14, 2014.
Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural computation, 9()): 1735-1780, 1997.
Shenyang Huang, Farimah Poursafaei, Jacob Danovitch, Matthias Fey, Weihua Hu, Emanuele Rossi, Jure Leskovec, Michael Bronstein, Guillaume Rabusseau, and Reihaneh Rabbany. Temporal graph benchmark for machine learning temporal graphs. Advances in Neural Information Processing Systems, 36:2056-2073, 2023a.
Shenyang Huang, Farimah Poursafaci, Jacob Danovitch, Matthias Fey, Weihua Hu, Emanuele Rossi, Jure Leskovec, Michael M. Bronstein, Guillaume Rabusseau, and Reihaneh Rab- bany. Temporal graph benchmark for machine learning temporal graphs In Alice Oh, Tristan Naumann, Amir Globerson, Kate Saenko, Moritz Hardt, and Sergey Levine (eds.), Advances in Neural Information Processing Systems 36: Annual Conference Neural
12

---

Published as a conference paper at ICLR 2026
Information Processing Systems 2023, NearIPS 2023, New Orleans, LA, USA. December 10 16, 2023, 2023b. URL http::/pppprss.niippp htt.:///888621222622226662888888 and_Benchmarks html.
cc wwpppprrrpppppppppppppppppappeee files/paper/
Shenyang Huang, Farimah Poursafaci, Reihanch Rabbany, Guillaume Rabusseau, and Emanuele towards unified view of snapshot and event based models for temporal graphs. In Guy Wolf and Smita Krishnaswamy (eds.), Learning on Graphs Conference, 26-29 November 2024, Virtual, volume 269 of Proceedings of Machine Learning Research, pp. 28. PMLR, 2024. URL htwph: / http::/://ppcceednnngg.o. mll. www..peees/vee v22 http///aaagaaaaa/ html.
Rossi. UTG:
Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross B. Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embed- ding. Kien A. Hua, Yong Rui, Ralf Steinmetz, Alan Hanjalic, Apostol Natsev, and Wenwu Zhu (eds.), Proceedings of the ACM International Conference Multimedia, MM '14 Orlando. FL, USA, November 03 07, 2014 pp. 675-678, ACM, 2014, doi: 10.1145/2647868. 2654889. URL fittps://do... org. 10. 4 20155/6677855 21122244768822544888 2654889.
Seyed Mehran Kazemi, Rishab Goel, Sepehr Eghbali, Janahan Ramanan, Jaspreet Sahota, Sanjay Thakur, Stella Wu, Cathal Smyth, Pascal Poupart, and Marcus Brubaker. Time2vec: Learning vector representation of time. arXiv preprint arXiv:1907.05322 2019.
Seyed Mehran Kazemi, Rishab Goel, Kshitij Jain, Ivan Kobyzev, Akshay Sethi, Peter Forsyth, and Pascal Poupart. Representation learning for dynamic graphs: A survey, Mach. Leurn. Res., 21: 70:1-70:73, 2020a. URL httth:tt///// jmlr
7html.
Seyed Mehran Kazemi, Rishab Goel, Kshitij Jain, Ivan Kobyzev. Akshay Sethi, Peter Forsyth, and Pascal Poupart. Representation learning for dynamic graphs: A survey. Mach. Learn. Res., 21: 70:1-70:73, 2020b. URL https:://////c. .org///rrrr//ooooooooooo
org/ http://ppp/ep/-///spppa
html.
Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2016.
Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations (ICLR), 2017. URL https: //rxiiv. org/ hagg/bba abs / 609.009.0 02907.
Antonio Longa, Veronica Lachi, Gabriele Santin, Monica Bianchini, Bruno Lepri, Pietro Lio, Franco Scarselli, and Andrea Passerini. Graph neural networks for temporal graphs: State of the art, open challenges, and opportunities. Trans. Mach. Learn. Res., 2023, 2023. URL https: // //openreview. net www.:/rrtffofeumeeemmme innniidd-ii herrrmmmdddpccaaatgtt..
Xiaodong Lu, Leilei Sun, Tongyu Zhu, and Weifeng Lv. Improving temporal link predic- tion via temporal walk matrix projection. In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomczak, and Cheng Zhang (eds.), Ad- vances in Neural Information Processing Systems 38: Annual Conference
Neural Infor- mation Processing Systems 2024, NeurIPS 2024, Vancouver, BC, Canada, December 10 15, 2024, 2024a. URL http: /tt:://paaaae httpp/pppprpspe//peep nips sccppape_fiiiccc files /pppp/ppp2/2242. //00////////// ff7bf601 411.666147822dddeo 4a S-teeeeeeeeeettrrtct-ooroeereeee
Xiaodong Lu, Leilei Sun, Tongyu Zhu, and Weifeng Lv. Improving temporal link predic- tion via temporal walk matrix projection. In Amir Globersons, Lester Mackey, Danielle Belgrave, Angela Fan, Ulrich Paquet, Jakub M. Tomczak, and Cheng Zhang (eds.), ) Ad- vances in Neural Information Processing Systems 38: Annual Conference mation Processing Systems 2024, NeurlPS 2024, Vancouver, BC, Canada, December 10 15, 2024, 2024b. URL http: /ttp::///aapeeee httpppapprr/ss///eeppeeeeeeeeeee nips sc http//pprr___ffee files seiills/papeee http//aappeeee20 /2024/hash/ oottreeeeeee--ttttttttooeeeeeeee html.
Neural Infor-
Yuhong Luo and Pan Li. Neighborhood scalable temporal network representation learning. Learning Graphs Conference, 2022.
13

---

Published as a conference paper at ICLR 2026
Aldo Pareja, Giacomo Domeniconi, Jie Chen, Tengfei Ma, Toyotaro Suzumura, Hiroki Kanezashi, Tim Kaler, Tao B. Schardl, and Charles E. Leiserson. Evolvegen: Evolving graph convolutional networks for dynamic graphs. In The Thirty-Fourte AAAI Conference on Artificial Intelligence, AAAI 2020, The Thirty-Second Innovative Applications of Artificial Intelligence Conference, IAAI 2020, The Tenth AAAI Symposium on Educafional Advances in Artificial Intelligence, EAAI 2020, New York, NY, USA, February 7-12, 2020, pp. 5363-5370, AAAI Press, 2020. doi: 10. 10.1609/AAAI V34104.5984. URL https: /tl:://doo0 /dii.ii..... org/ 10. 609 aaaiaaaii........ v34104. 5984.
Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf. Edward Z. Yang, Zachary Vito,o Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. Pytorch: An imperative style, high-performance deep learning library. In Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d' Alché-Buc, Emily B. Fox, and Roman Garnett (eds.), Advances in Neural Information Processing Systems 32: Annual Conference on Neural Information Pro- cessing Systems 2019, NeurlPS 2019, December 8-14, 2019, Vancouver, BC, Canada, pp. 8024-8035, 2019. URL https: /ttp:///coooccce.ee//eeeecc www.ipeurp.... ec cctppppe///11////// 9/hah/ bdbca288 fee 9wt 2727770 Abstt.aat....................... html.
Farimah Poursafaei, Shenyang Huang, Kellin Pelrine, and Reihaneh Rabbany. Towards better evaluation for dynamic link prediction. Advances in Neural Information Processing Systems, 35: 32928-32941, 2022a.
Farimah Poursafaei, Shenyang Huang, Kellin Pelrine, and Reihaneh Rabbany. Towards better evaluation for dynamic link prediction. Advances in Neural Information Processing Systems, 35: 32928-32941 2022b.
Ladislav Rampášek, Michael Galkin, Vijay Prakash Dwivedi, Anh Tuan Luu, Guy Wolf, and Do- minique Beaini. Recipe for general, powerful, scalable graph transformer. Advances in Neural Information Processing Systems, 35:14501-144 14511, 2022.
Emanuele Rossi, Ben Chambers, Rex Ying, Michael Bronstein, and Federico Monti. Temporal graph networks for deep learning on dynamic graphs. In Proceedings of the 2020 ICML Workshop on Graph Representation Learning and Beyond, 2020. URL https: //ap:i//aavvv./a/aa org/abs 2006. 10637.
Benedek Rozemberezki, Paul Scherer, Yixuan He, George Panagopoulos, Alexander Riedel, Maria Sinziana Astefanoaci, Oliver Kiss, Ferene Béres, Guzmán López, Nicolas Collignon, and Rik Sarkar. Pytorch geometric temporal: Spatiotemporal signal processing with neural machine learning models. In Gianluca Demartini, Guido Zuccon, J. Shane Culpepper, Zi Huang, and Hanghang Tong (eds.), CIKM '21: The 30th ACM International Conference on Information and Knowledge Man- agement, Virtual Event, Queensland, Australia, November 5, 2021, pp. 4564-4573, ACM, 2021. doi: 10. 141114459667...0 0117445563773482044 URL https: /ttp:ooiooggg///////o/ooo 1145/114/4 31133337.3737.0111111 3482014. 4.
Ahmet Sangüü. Graph mixer networks. arXiv preprint arXiv:2301. 12493, 2023.
Mo Sha, Yuchen Li, Bingsheng He, and Kian-Lee Tan. Accelerating dynamic graph analytics on gpus. Proceedings of the VLDB Endowment, 11(1), 2017.
Kiarash Shamsi, Friedhelm Victor, Murat Kantarcioglu, Yulia R. Gel, and Cuneyt Gurcan Akcora. Chartalist: Labeled graph datasets for UTXO and account-based blockchains. In Sanmi Koyejo, S. Mohamed, A. Agarwal, Danielle Belgrave, K. Cho, and A. Oh (eds.), Advances in Neural Information Processing Systems 35: Annual Conference Neural Information Processing Systems 2022, NeurlPS 2022, New Orleans, LA, USA, November 28 December 2022, 2022. URL http: /ttp:::///pppr..eee nips. ec cc/pappr_fiiiiieeeeeeeeeeeeeeepp letrr_files/ppppee 2022 http//hhhhee24/ 9w863116111108 0e1.33166667cc6333bb222222220 ract aatt
Lnd_BBechmarks htmll
Kiarash Shamsi, Farimah Poursafaei, Shenyang Huang, Tran Gia Bao Ngo, Baris Coskunuzer, and Cuneyt Gurean Akcora. Graphpulse: Topological representations for temporal graph property prediction. In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austria, May 7-11, 2024. OpenReview.net, 2024. URL https: wwwp/evieeee.eeoe/oo/.e net/ forum? www.:dddiiiiieeccmm
14

---

Published as a conference paper at ICLR 2026
Kiarash Shamsi, Tran Gia Bao Ngo, Razieh Shirzadkhani, Shenyang Huang, Farimah Poursafaci, Poupak Azad, Reihanch Rabbany, Baris Coskunuzer, Guillaume Rabusseau, and Cuneyt Gurcan Akcora. MINT: Multi-network transfer benchmark for temporal graph learning. In The Thirty-ninth Annual Conference on Neural Information Processing Systems Datasets and Benchmarks Track, 2025. URL https::/p//.......... wwwoopeeeiieeeeee net. wor d=n IcsXIRV.
Benedict Aaron Tjandra, Federico Barbero, and Michael Bronstein. Enhancing the expressiv- ity of temporal graph networks through source-target identification, 2024. URL https://arxii org/abs/2411.03396
Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention all you need. Advances in neural information processing systems, 30, 2017.
Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. arXiv preprint arXiv: 2017.
Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, et al. Deep graph library: A graph-centric, geghly-performat package for graph neural networks. arXiv preprint arXiv:1909.0133: 2019.
Yufeng Wang and Charith Mendis. Tglite: lightweight programming framework for continuous- time temporal graph neural networks. In Proceedings of the 29th ACM International Con- ference on Architectural Support for Programning Languages and Operating Systems, Vol- ume 2, ASPLOS '24, pp. 1183-1199, New York, NY. USA, 2024. Association for Com- doi: 10.1145/462066553660111 URL https:
puting Machinery. ISBN 9798400703850. 02145/3320655 //doi.oor//11 1145/32206536664111.,, 3640414.
Minji Yoon, Bryan Hooi, Kijung Shin, and Christos Faloutsos. Fast and accurate anomaly detection in dynamic graphs with a two-pronged approach. CoRR, abs/2011.1308, 2020. URL https: // //arxiv..or org/ abs/ 22111. 13085.
Jiaxuan You, Tianyu Du, and Jure Leskovec. ROLAND: graph learning framework for dynamic graphs. In Aidong Zhang and Huzefa Rangwala (eds.), KDD '22: The 28th ACM SIGKDD Conference on Knowledge Discovery and Duta Mining, Washington, DC, USA, August 14 - 18, 2022, pp. 23666 ACM, 2022. doi: (0.1145/3534678.555 3533330. URL https: /tt//dooorroo orr// 3539300.
Le Yu, Leilei Sun, Bowen Du, and Weifeng Lv. Towards better dynamic graph learning: New architecture and unified library. Advances Neural Information Processing Systems, 2023a.
Le Yu, Leilei Sun, Bowen Du, and Weifeng Lv. Towards better dynamic graph learning: New architecture and unified library. Advances in Neural Information Processing Systems, 2023b.
Fan Zhang, Lei Zou, and Yanpeng Yu. Lpma an efficient data structure for dynamic graph on gpus. In Wenjie Zhang, Lei Zou, Zakaria Maamar, and Lu Chen (eds.), Web Information Systems Engineering WISE 2021, pp. 469,484, Cham, 2021. Springer International Publishing. ISBN 978-3-030-90888-11
Xiaohui Zhang, Yanbo Wang, Xiyuan Wang, and Muhan Zhang. Efficient neural common neighbor for temporal graph link prediction, 2024, URL https://arxiv. org/abs/2406.00922.
Ling Zhao, Yujiao Song, Chao Zhang. Yu Liu, Pu Wang. Tao Lin, Min Deng, and Haifeng Li. T-gen: A temporal graph convolutional network for traffic prediction. IEEE transactions intelligent transportation systems, 21 21(9):388833858 2019.
Hongkuan Zhou, Da Zheng, Israt Nisa, Vasileios Ioannidis, Xiang Song, and George Karypis. TGL: A general framework for temporal GNN training billion-scale graphs. CoRR, abs/2203.1488 14883, 2022a. doi: 10.48550/ARXI12200..oo 14883. URL https: /doi. 40g//1..4850000 48550 (00555//axixx arxiv. 2203. 14883.
15

---

Published as a conference paper at ICLR 2026
Hongkuan Zhou, Da Zheng, Israt Nisa, Vasileios Ioannidis, Xiang Song. and George Karypis. Tgl: a general framework for temporal gnn training on billion-scale graphs. Proc. VLDB Endow. 15(8):1572-1580, April 2022b. ISSN 2150-8097. doi: 10.44778/52933.3359922 URL
https:: //oi .org/orgg.... 11t.//....11//311111 01777/3529337.52222
Hongkuan Zhou, Da Zheng, Xiang Song, George Karypis, and Viktor Prasanna. Distgg:: Distributed memory-based temporal graph neural network training. In Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, SC '23, New York, NY, USA, 2023a. Association for Computing Machinery. ISBN 9798400701092. doi: 1 145/ 454455/55111 3581784441 784 3607056.
10.1145/3581 784.3607556 URL https: htt//oo..oooo ott/
Hongkuan Zhou, Da Zheng, Xiang Song, George Karypis, and Viktor K. Prasanna. Disttgl: Dis- tributed memory-basee temporal graph neural network training. In Dorian Amold, Rosa M. Badia, and Kathryn M. Mohror (eds.), Proceedings of the International Conference for High Performance Computing, Networking, Storage and Analysis, SC 2023, Denver, CO, USA, November 12-17, 2023, pp. 39:1-39:12 ACM, 2023b. doi: 10.114575581784.37775 URL https: doii wwt.oolgg//o.o... 114.1...11451 3581115551111101 358188311111111181 3607781.667555 3607056.
16

---

Published as a conference paper at ICLR 2026
Table 10: Validation time per epoch (seconds, 1) for link property prediction (top) and node property prediction (bottom). The First and Second best results are highlighted (x marks unsupported). OOT indicates that a single validation epoch did not complete after 3 hours.
Model
Xikipedia DyGLib
Reddit
LaatEM
TGM
TGLite
TGL
TGM
DyGLib
TGLite
TGL
TGM
DyGLib
TGLite
TGL
EdgeBank
11.08
950.05
X
50.01
134.55
X
X
223.01
470.08
X
TOAT
532.89
2898.53
2241.70
OCT
4163.20
TGN
13.84
3404.82
X
60.30
00T
X
X
112.23
OCT
X
DyGForeer
6.97
6125.05
1856.78
3854.252
TPNet
408.91
1735.71
3308.91
GCN
11.70
50.88
102.56
Model
Trade DyGLib
Geare DyGLib
TGM
TGB
TGM
TGB
P.F.
0.06
1.35
0.15
6.02
8.56
6.66
TGN
2.44
2.54
2.19
25.37
106.34
58.13
DyGFormer
3.49
21.13
11.78
588.69
TGCN
0.08
6.39
GCLSTM
0.07
6.48
GCN
0.07
6.46
A LLM USAGE
We acknowledge the use of LLMs assist in polishing the writing of this paper. All content, ideas, and results are our own. The LLM helped improve clarity, grammar, style, and LaTeX formatting.
B ADDITIONAL RESULTS
B.1 VALIDATION LATENCY BENCHMARKS
In Table 10, we report the TGB validation evaluation time per epoch for TGM and other libraries. Note that TGM supports highly optimized evaluation time for the robust TGB link prediction evaluation when compared to DyGLib. TGM consistently outperforms the widely used research library DyGLib across datasets and models. TGLite and TGL do not support the ma-yvsyany TGB-base link prediction evaluation (Gastinger et al., 2024).
B.2 PEAK GPU USAGE
Table 11 shows the peak GPU memory age of each model across three standard datasets. Lightweight models such GCN and GCLSTM consume minimal memory, making them efficient choices for resource- constrained environments, whereas larger ar- chitectures like GraphMixer and DyGFormer require significantly more GPU memory. This comparison highlights the trade-offs between model size and memory efficiency, providing a practical reference for selecting models temporal graph learning tasks.
Table II: Peak GPU memory usage (GB) per model on different datasets.
Model TGN
Egbl-wi3e
tgbl sebl-subredd::
tgbl 1essl-asttan
0.67
0.81
0.11
GraphMiser
2.61
2.62
2.62
DyGFomee
1.34
TPNet
1.37
1.47
1.15
GCLSTM
0.01
0.18
0.07
GON
B.3 CPROFILER MODEL BREAKDOWN
Table 12 shows runtime decomposition of TGAT on the LastEM dataset. The largest costs arise from the backward pass (258%)), model forward (26.5%), and optimizer updates (19.1% together accounting for over 70% of total runtime. Within data loading (26.5%). hook execution (15.1%) and graph materialization (11 (1.4%% dominate, with the recency sampler alone contributing 13.2%. Inside TGAT forward, attention layers (14.7%) and ML.Ps (6.0%) form the bulk of computation, while time
17

---

Published as a conference paper at ICLR 2026
encoding adds 3.5%. Using profiler in this way helps researchers and practitioners identify which components are the main bottlenecks and prioritize optimizations accordingly.
Table Breakdown of TGAT runtime on LastFM dataset.
Category
Component
Percent (%)
Hook execution
15.09
Recency sampler
13.19
Get neighbors
7.76
Data Loading
Update circular buffer
5.43
--
Other hooks
1.90
Graph materialization
11.40
TGAT forward
24.20
Attention layers
14.70
Model Forward
MLP layers
5,96
Time encoding
3.54
Other forward (decoders)
2.30
Backward pass
25.80
Optimizer (Adam)
19.10
Optimization
Loss computation
0.62
Other
1.61
C ADDITIONAL BACKGROUND: DTDG vs. CTDG
As defined in Section 3, temporal graph is graph whose structure and attributes evolve over time, capturing only the relationships between entities but also the dynamics of their interactions. Unlike static graphs, which provide single snapshot of connectivity, temporal graphs represent edges (and sometimes nodes) as time-stamped events or intervals, enabling modelling of when and how relationships form, change, or disappear. Temporal graph neural networks are typically categorized into two types: continuous- tieuuss-tmmeeeee dynamic graph (CTDG) methods and discrete- time dynamic graph (DTDG) methods. Section C. and Section C.2 provide further information about common approaches from each category.
C.1 DTDG METHODS
DTDG, snapshot- baasshot-basdddde based methods, take input sequence of graph snapshots, each representing the state of the temporal graph at discrete time intervals (e.g., hours or days). These approaches process each snapshot whole, typically using graph learning model, and employ mechanisms capture temporal dependencies across snapshots.
The majority of DTDG methods consist of two main components: a spatial encoder, commonly GNN-based, and a temporal encoder, usually an RNN or one of its variants. Given snapshot G,, spatial representation learned, Z, = f(V,, E,), where that takes the graph structure of the current snapshot and returns either node-level representations in G, or representation of the entire snapshot. GCN (Kipf & Welling, 2017) used as f in TGCN (Zhao et al., 2019), EvolveGINN (Pareja et al., 2020), and GCLSTM (Chen et al., 2018). In contrast, GraphPulse (Shamsi er al., 2024) encodes a whole-graph representation by extracting topological features from both the original graph G4 and transformed version G¹, using Topological Data Analysis (TDA). The concatenation the features from G, and G/ serves as the graph-level representation for downstream property prediction tasks.
a trainable or non-trainable function
To capture temporal dependencies across snapshots, an RNN or one of its variants (e.g.. GRU or LSTM) is typically employed. These are applied either to the sequence of snapshot representations Z, (Zhao et al., 2019; Chen et al., 2018; Shamsi et al., 2024) or directly to the evolving parameters of the GCN (Pareja et al., 2020).
18

---

Published as a conference paper at ICLR 2026
C.2 CTDG METHODS
In contrast, CTDG methods operate on a continuous stream of edges and can make predictions at arbitrary timestamps. They update internal representations incrementally new interactions arrive, incorporating fresh information into predictions. For computational efficiency, the edge stream is usually partitioned into fixed-size batches, with predictions performed sequentially per batch; once predictions are made, the corresponding edges are revealed to the model. Unlike DTDG methods, CTDG approaches do not rely on snapshots; instead, they maintain evolving node representations and sample temporal neighborhoods around nodes of interest for prediction.
Temporal Message Passing. The temporal message passing framework is a neighbourhood ag- gregation scheme which recursively computes latent representation by forwarding messages to temporal neighbours. Formally, if (s) denotes the k-hop neighbourhood of node s in the dynamic graph G, then the temporal neighbourhood N?(ss) is given by restricting neighbours to edge events chronologically before time t:
(s) { ((s,d,t') (s) it's t' tt}
(4)
The combination of temporal and topological constraints makes efficient neighbourhood particularly challenging, requiring complex hierarchical data structures and cache-aware programming to sustain tightthroughpt on GPU stream multiprocessors Zhang et al. (2021); Sha et (2017). We bypass the insertion and deletion complexity by assuming the entire graph structure is read-only. Temporal message proceeds by creating and passing messages between such sub-neighorhoods. messages are created by concatenating embeddings, aggregating embeddings across temporal neigh- bourhoods, then updating the new hidden representation. Such information flow occurs concurrently for each event in batch of data.
particular,
and Memory- -aase Learning. Time-encoding models use a shift-invariant model v : T Rd that maps real-valued time stamp into di-dimensional vector (e.g. TGAT da Xu et al. (2020) use time-ensoders like Time2 Vec Kazemi et al. (2019)). This encoding is then passed through modified self-attention blocks or feedforward layers. eeemory-based models, such TGN Rossi et al. (2020), utilize a fixed-bandwidth memory module that compresses relevant information for each node and updates it over time. EdgeBank Poursafaei et al. (2022a) is non-parametric, memory-based method that memorizes and predicts new links at test time based on their occurrence in the training data.
D DATASET DETAILS
In this work, we conduct experiments on Wikipedia (obtained from the TGB Huang et al. (2023a), where the dataset can be downloaded along with the package from TGB website), Red- dit, LastFM, datasets, obtained from Poursafaei et al. (2022b); these can be downloaded from These datasets span a vari-
https: //zpn/zzeoooooo org/ records/ceeeeeeeeee /7 ety of real-world domains, providing a broad testbed for evaluating temporal graph models. Detailed information about these datasets are as follows.
Wikipedia is bipartite interaction network that captures editing activity Wikipedia over one month. The nodes represent Wikipedia pages and their editors, and the edges indicate timestamped edits. Each edge is associated with 12-dimensional LIWC feature vector derived from the text.
Reddit models user-subreddit posting behaviour over one month. Nodes are users and subreddits, and edges represent posting requests made by users to subreddits, each associated with timestamp. Each edge is associated with a 1 172-dimensional LIWC feature vector based on post contents.
LastFM is a bipartite user-item interaction graph where nodes represent users and songs. Edges indicate that a user listened to a particular song at given time. The dataset includes 1000 users and the 1000 most-listened songs over a one-month period. This dataset not attributed.
Trade represents the international agriculture trading network between UN nations from 1986 to 2016. Nodes are countries and edges capture the annual sum agriculture trade values from one country to another. The task is to predict each nation's 's trade proportions in the following year.
Genre is a bipartite, weighted network connecting users to music genres based on listening history. Edges indicate the proportion of a song belonging genre that user listens to, aggregated weekly. The task is to predict user-genre interactions in the next week, capturing evolving user preferences for music recommendation.
19

---

Published as a conference paper at ICLR 2026
Table 13: Dataset statistics.
Dataset
# Nodes
Edges
# Unique Edges
# Unique Steps
Surprise
Duration
Wikipedia
9,227
157,474
18.257
152.757
0.108
month
Reddit
10,984
672.447
78.516
669,065
0.069
month
LastEM
1,980
1,293.103
154,993
1,283.614
0.35
month
Trade
255
468,245
468,245
32
0.023
30 years
Gence
1,505
17,858,395
17,858,395
133,758
0.005
month
E TEMPORAL GRAPH MODELS SUPPORTED IN TGM
TGM is a research-drite -hrave library providing implementations of state-of-the-art temporal graph learning models. At the time of writing, TGM includes the following models:
Persistent Forecast. A simple baseline that predicts the future state of each node or edge by assuming it remains unchanged from the most recent observation. Despite its simplicity, it often serves strong baseline for dynamic node property prediction.
EdgeBank. Poursafaei et al. (2022a) Maintains memory bank of historical edges and uses them to make predictions. By storing and sampling past interactions, EdgeBank leverages temporal patterns without explicit node embedding updates, providing lightweight but effective approach for dynamic link prediction.
TGAT. da Xu al. (2020) proposed to model dynamics node representations with TGAT layer, which is a combination of the graph attention mechanism with a time encoding function based on Bochner's s theorem, which provides a continuous functional mapping from time a vector space. This allows TGAT to efficiently learn from temporal neighbourhood features with the aid of self-attention mechanism and temporal dependencies encoded by the time encoding function.
TGN. Rossi et al. (2020) proposed an event-based model that is a combination of memory module, message aggregator, message updater and embedding module. In particular, the memory module maintains evolving memory for each node and updates this memory when the node is observed to be involved in an interaction, which is achieved by message function, message aggregator, and message updater. Finally, the embedding model is used compute the representation of nodes.
GCN. & Welling, 2017) Standard Graph Convolutional Network applied on static snapshots to encode structural information. Node features are aggregated from neighbors and combined with self-features to produce updated embeddings at each snapshot. When used in temporal settings, GCNs process sequences of snapshots independently in combination with temporal modules.
GCLSTM. To learn over a sequence of graph snapshots, Chen et al. (2018) proposed an end-to- end model named Graph Convolutional Long Short-Term Memory (GCLSTM) for dynamic link prediction. The LSTM serves as the backbone to capture temporal dependencies across graph snapshots, while GCN is applied to each snapshot encode structural dependencies between nodes. Specifically, two GCNs are used to update the hidden state and the cell state of the LSTM, and multilayer perceptron (MLP) decoder maps the features at the current time step back to the graph space. This design enables GCLSTM to effectively handle both link additions and deletions.
T-GCN. Zhao et (2019) integrates GCNs with gated recurrent units to learn node embeddings over sequences of graph snapshots, capturing temporal and structural information jointly.
GraphMixer. (Sangün, 2023) A graph adaptation of MLP-Mixer architectures. It alternates between node-wise and feature-wise mixing layers to capture structural correlations across nodes and temporal correlations across features. By stacking multiple mixer layers, GraphMixer can model complex dependencies in dynamic graphs while remaining simple and parameter--fffiieet.
DyGFormer. Yu et al. (2023a) proposed a Transformer-base architecture for modeling dynamic graphs. DyGFormer consists of two key components: the Neighbour Co-occurrence Encoder and Transformer. The Neighbour Co-occurrence Encoder leverages the recent first-hop neighbours the source and destination nodes of edge to capture correlations and compute relative embeddings. To enhance representation learning, Yu et al. (2023a) further introduced a patching technique that splits the source and destination node features, edge features, time embeddings (computed following
20

---

Published as a conference paper at ICLR 2026
TGAT (da Xu et al., 2020)), and relative embeddings into multiple patches. These patches are then fed into the Transformer to generate node representations with respect to an edge.
TPNet. TPNet is composed of two main modules: Node Representation Maintenance and Link Likelihood Computation. Lu et al. (2024b) unifies existing relative encoding methods by introducing temporal walk matrices with integrated time-decay function. These matrices establish a principled connection between relative encodings and temporal walks, offering a clearer framework for analyzing and designing temporal encodings. The time-decay effect further allows joint modelling of temporal and structural information. Since computing temporal walk matrices directly is computationally and memory intensive, TPNet employs theoretically grounded random feature propagation mechanism to implicitly approximate and maintain them efficiently.
The TGM team is actively expanding the library to incorporate additional cutting-edge models, including TNCN (Zhang et al.), DyGMamba (Ding et al., 2024), NAT (Luo & Li, 2022), and TGNv2 (Tjandra et al.).
F COMPUTE RESOURCES AND EXPERIMENT DETAILS
Compute: Experiments were Ubuntu 20.04 with 64 GB RAM, 4 isolated AMD EPYC 7502 CPU cores, and a single 80 GB A100 GPU. Jobs were managed with SLURM to ensure isolated environments and concurrent interference.
Experiment Details: We use the default TGB splits (Huang et al., 2023a; Gastinger et al., 2024), with hyperparameters listed in Table 14. For efficiency benchmarks, TGAT and TGN adopt the TGLite configuration (Wang & Mendis, 2024) for fairness. Other libraries were modified only minimally to measure latency, and TGLite/TGL times are taken directly from Fig. of (Wang & Mendis, 2024). All DTDG methods discretized the Trade dataset to yearly snapshots, and the Genre dataset to weekly snapshots.
Table 14: Hyperparameters used for each model
Parameter
Edgebank
GCN
GCLSTM
GraphMixer
DyGFormer
TPNet
Batch Size
200
200
200
200
200
200
200
200
Epochs
30
30
10
Learning Rate
lc-4
lc-4
lc-3
1o-3
le-3
20-4
lc-4
1c-4
Dropout
0.1
# Heads
2
2
Neiihbors
20
32
32
LLayers
2
2
Embeedinn Dim.
100
100
128
256
128
128
172
172
Time Dim.
100
100
100
100
Memory Dim.
100
Node Dim.
256
256
100
Sampling
Recency
Recency
Recency
Recency
Recency
Memory Mode
Unlimited
Time Gap
2000
Token Dim. Factor
0.5
Channel Dim. Factor
4.0
Channel Dim.
50
Patch Size
Channels
RP Layers
RP Time Decny
le.6
RP Dim
log( 2 El)
G EFFECT OF BATCH SIZE
TGL models often update their representation after batch has been processed to incorporate the most recent information. Events within batch are processed parallel TGM thus larger batch size leads to more efficient inference. Therefore, the batch size parameter becomes a trade-off between efficiency and model update frequency (or a model's staleness). In this work, we follow the TGB Huang et al. (2023a) evaluation procedure of using 200 edges per batch where applicable. With the time slicing operation in TGM, it now possible to explore arbitrary or dynamic batch size where batch is formed by slicing graph in custom time interval. An alternative way is to iterate by time
21

---

Published as a conference paper at ICLR 2026
in TGM, which provides variable batch size in terms of number of edges and more empirical results are reported in Section 5.3. We believe that exploring the implication of batching is an important future direction and leave it as interesting future work which can be built-upon in TGM.
H TGM TUTORIALS AND DOCUMENTATION
Ensuring reproducibility and case of use is top priority in TGM. We therefore provide full documentation suite, including beginner-friendly tutorials and a comprehensive API specification. Below, we include excerpts from our tutorials.
22

---

Temporal Graph Data in TGM
This tutorial shows the core graph API TGM. By the end, you should understand how to:
Construct and preprocess graph data (DGData)
Split and discretize temporal datasets (SplitStrategy)
Work with immutable graph views (DGraph)
Train with batches (DGBatch)
We also highlight some important errors, caching behaviour, and best practices.
1. The Core Objects
TGM's graph API revolves around four main objects:
Object
Description
Mutable
Device
Typical Usage
Semantics
DGData
Mutable bulk dataset storage (I0, splits, transforms)
Yes
No
Ingesting datasets from disk, TGB, preprocessing
DGraph
Immutable graph view backed by storage engine
No
Yes
Main user-facing graph object
DGBa tch
Materialized batches of tensors from temporal slice of data
Yes
Yes
What dataloaders yield, input models
P latest

---

Object
Description
Mutable
Device Semantics
Typical Usage
DGStorage
Internal backend for graph data (non-user-facing)
No
Yes
Powers graph
querying, caching, slice ops
Users typically only interact with the first 3. DGStorage internal and abstracted away. It is in our stream of work to build out more efficient storage backends for various workloads in the future.
Note:
2. Starting with DGData
DGData is your main entry point for working with temporal graph datasets. It's dataclass that holds bulk storage of events, timestamps, features, and metadata.
Because it's mutable, you can freely transform and prepare it before moving to the immutable graph representation (DGraph)
Features of DGData
Holds raw edge data (edge_index, edge timestamps)
Holds static node features, dynamic node features, and featuress (on CPU)
Provides 10 constructors (CSV, Pandas, TGB, pyTorch)
Supports temporal splitting and discretization
Ensures data is sorted chronologically, valid node ids, valid tensor shapes, etc.
See below for summary the data class attributes of DGData::
$dataclass
class DGData:
Container for dynamic graph data to be ingested by 'DGStorage".
Stores edge and node events, their timestamps, features, and optional split strategy. Provides methods split, discretize, and clone the data.
Attributes:
P latest
time_delta (TimeDeltaDG str): Time granularity of the timestamps (Tensor): 1D tensor of all event timestamps tnum_edge_events num_node_events).

---

edge_
edge_event_ice _event_ixx (Tensor): Indices edge events within "timestamps". edge_index (Tensor): Edge connections huu_edge_eeennts 2]. feats (Tensor
None): Optional edge features Lnun_edge.events,
D_edge].
node_event_1dxx (Tensor None): Indices of node events within
"timestamps"
node_ids (Tensor None): Node corresponding to node events
dynamic_node, feats (Tensor None) Node features
[num_node_event __node_dynamie
static_node_feats (Tensor None): Node features invariant over time [num_nodes, D_node_static].
Raises:
InvalidMNodeDDErro::: If edge node match "PADDED_NOCE NODE_ID
ValueError: any data attributes have non-well defined tensor shapes. EmptyGraphError: If attempting to initialize an empty graph.
Notes:
Timestamps must be negative and sorted; DGData will sort automatically if necessary.
Cloning creates deep copy tensors to prevent in in-place modi fications.
See tgm. data. DGData for full reference.
3. Constructing DGData
You build datasets in multiple ways. Let's look at each.
3.1 From TGB
This is most likely all you need. The Temporal Graph Benchmark (TGB) provides suite of temporal graph datasets with diverse scales and properties. We natively support direct construction from all the tgbl- and tgbn- TGM.
Note: Temporal knowledge graph (TKG) and temporal hypergraph (THG) are not yet supported in TGM.
Note:
To load TGB dataset, you must have the py-tgb package your python env.
from tgm import
DGData
P
latest
Load the Wikipedia dataset from TGB
data DGData. fooata.from... from_ tgb "tgbl-wiki" ))

---

(rint.data... time_delta, TimeDelta value=1)
www._eddee..saaaeeeeee.eedeed # torch. Sirchhh7 2])
(rintddata.dynamic..n dynamic_node__feeeeeoeooee feats) # None, no dynamic node features in tgbl-wiki None, no static node features in tgb1-wik1
print(data steeesttottteteeeeteeeeeo
TIP: You can print(data) to see which features and events exist within the dataset.
3.2 Custom Datasets
If you have our own dataset in TGM, you create DGData object either from_csv, @rom__aandas,, or directly from tensors. brief overview of each given below, consult the API reference for more details.
From CSV
Please consult our documentation for full description of our API. The table below summarizes the main pieces of data expected during construction. Note that analogous attributes expected in the other 1O constructors (e.g. from_pandar
from_ raw)
Attribute
Description
Тype
Required
Note
edge_ffle.
Path to CSV file containing edge data
str \
Yes
edge_df if using
ath
pathlib. Pa
from_pandas
th
edge_sre_co
Column name in edge file for srC nodes
str
Cannot have matching
1
constants.
PADDED_NODE..R LOOO__OODE____
edge__de dst_costooooo
Column name in edge file for dst nodes
str
Yes
Cannot have ids matching
constants.
PADDED NODE
edge_ttme,
Column name in edge file for edge times
str
Yes
Time must be non-negative
ol
P latest
nole_file.
Path CSV containing
str \I
No
node_df is using
ath
pathlib.Pa
from_pandas

---

Attribute
Description
Type
Required
Note
dynamic node data
th
node_id_co
Column name in node file for node event node ids
str
No, unless node_ mode_file file_pal h is specified
Cannot have matching
constants.
LOOED_NODE_ID
node_time__ o1
Column name in node file for node event node times
str
No, unless
Time must be non-negative
node _ode_file_ file__lleppepp. h is specified
dynamic_nod
Column name in node file for dynamic node features
str
No
e_feats_co
static_node
Path to CSV file containing static node features
str \
No
static _ooe__oeeff...... fe ats_df df if using
feats_file
pathlib. Pa
.path
th
prom_pandas
static_node
Column name in static node feats file for static node features
str
No, unless
featts_ool
static_node_f
specified
time time_delta
Time granularity of the graph data
TimeDeltaD
Yes
Default to event_ ordered granularity
event_ordered
A few key things to know:
g latest
time delta defines how timestamps are interpreted on your custom
The default is ''' which entails event-ordered semantics, This means there is no real-world time
unit assigned to your timestamps. This prevents from doing things like discretizing your data,

---

and iterating by temporal snapshots.
More often than not, your timestamps have some semantics meaning (e.g. seconds, days, etc).
this case, you should specify the appropriate time_delta value. See our time management tutorial for more details.
edge data:
We expect an edge_ adge_file___e file_patte which is csv file with edge_ sro_col, edge_dst dst_col,
edge_time seeetimm_coll minimum.
Your edge csv file may also contain Sdggefeeats_co which are the edge features your data
dynamic node data (optional)
If included, we expect sad__file__a___ which is csv file with node rode_id_com col,
node_time see_ttmm_cool minimum. These your dynamic node events.
Your dynamic node data csv file may also include dynamic_node, feats_cfeat_ol,, which are the dynamic node features in your data.
static node data (optional)
included, we expect static_node__ee feateffffs______tttt____ which csv file with
static_node_ ctattsseeeecooolll.ooooo the static node features for your dataset.
Internally, perform various checks the tensors shapes, node ranges, and timestamps values. If your data is well structured, everything should work. If you get an error message that is not intuitive, please let us know.
From Pandas
The API largely the same as above, except that we expected edge_df, node_df and static_node _tt_noodddee____________________ dataframes for the edge, dynamic node, and static node data respectively. instead of csv files.
import pandas
Define Edge Data
edge_df pd. DataaaaFrame(
'sre': [2, 2, 1].
'dst': [2, 4, 8),
't': [1, 10). 'edge_feat's carrch.randS5. for range(3)), Optional ))
Define Dynamic Node Data (Optional)
P latest
dynamic_node_dee _node_df pd. DataaaFFFame(
'node': [2, 4, 6].
't': [1, 2, 3],
"dynamic_node" feat': (torch.rand(S) tollc for in range(3)) ),

---

))
Define Static Node Features (Optional)
static_node_dff = pd.DataFrame((
featt rtorch. tolist() for in range(9))
}
dg wwraph.from_paaaeee
edge_dffedge....
edge_src_col= coc''''o''''''...
edge_dst_col='dd 'ott dst'.
edge__timecoo==''',,
hetpoolleeee_eeeeeeeee edge_ feat', node__f-adynmmic_nndddddff
edge_feats_col-
node_id_col= 'node'..
node_time_col='t:
dynamic_node_feats
static_node_fede @oode_feett__ffe$ee1 sarssddd=sttti_nndde
@atic__ooe__eatee static_node feat',
time_delta='s' Recond-wise granularity
From Tensors
If all your data is already in memory as torch. Tensor you can directly instantiate DGdata using the class method DGData. @GData.from_raa.. from_raw:
import torch
Define Edge Data
edge_index torch. LongTensor ([[2, 2], [2, 4], [1, 8]1)
edge_timestamps torch. torch. LongTensoo11,,, 5, 20])
edge_feats rand(3, 5) # optional edge features
Define Dynamic Node Data (Optional)
node_timeste tisttmmssssps torch. Longhhoongeenso(111 2, 31)
node_ids LorchhLongTeesor(12., 6])
dynamic_node_fen randh.rand(13, 5])
Define Static Node Features (Optional)
static_node_fedt rand(,, 11)
data DGData. fromtaafrom_raw
edge_timestamps time stapss,
see_iindexxede__ideee
edge_feaatsvedgeffetts
bode__timesttmmss-ndde_.iiteeee
node_ids=node_ide
P latest
htwp:i/nnndd..ftttsddanna...moo feats,
static_node strattssstaiicnode__eeeee

---

time_delta='s
second wise granularity
3.3 Errors to know
http://nons.mmmpppppphrrrrro Raised when you try construct a DGData object from empty data. This is probably not what you intended to do since downstream DGraph immutable.
tgm l exceptions......o.. InvalltllodeIDError Raised when you dataset contains node ID (reserved for padding).
4. Splitting DGData
After loading your data, you'll probably want to split your dataset into train, validation, and test splits. TGM provides strategy pattern interface for different split strategies:
: Split by fixed timestamp boundaries
TemporalRatiosp1t::
Split by ratio of both edge and node events
TGBSplit:: Pre-defined TGB data splits
Important:
The TGB data splits uses pre-defined event masks, to match the splits as per the TGB leaderboard. you try change this, you'll get ValueError.
The split method defined on DGData::
def split(self,, strategy: SplitStrategy None None) -> Tuple (DDletD ...]: """Spli dataset according to strategy.
Args:
strategy (SplitStrategy None): Optional strategy override the default. If None, uses ssplit_strategy' or defaults to
"TemporalRatiosplit::
Returns:
Tuple[DGDate, ...l: Split datasets (train/val/test).
Raises:
ValueError: If attempting override the split strategy for TGB datasets.
Notes:
P latest
Splits preserve the underlying storage; only indices

---

Splitting TGB Datasets
tgm import DGData
Load the Wikipedia dataset from TGB data from_tgf ('tgbl-wikk')
Split using native TGB masks train_data, val_data, gest_data data.split()
If you tried override the split strategy, you' 11 get
from tgm.split import TemporalRatiosplit
split_strategy Temporallatiooslittt val=0.1, test=0.1) data. data. htt..:llsssrrrgggppplttttttttett Raises ValueError
5. Discretizing DGData
In TGM, we do not enforce strict definition of continuous time (resp. discrete time) dynamic graph CTDG (resp. DTDG). Instead, as you have seen, we define graphs based on their time granularity. Therefore, the user is able to convert between event-based and snapshot based views of the underlying data. You can learn more about this the UTG paper.
In TGM, we provide a method on DGData called discretize which allows you to coarsen your graph into different time granularities. The API looks like:
def discretize(
self, sime_deltat TimeDeltaDG
None, reduce_op op: 'first'
>> DGData:
"Return of the dataset discretized to coarser time granularity.
Args:
time_delta (TimeDeltaDG str None): Target time granularity. reduce_op (str): Aggregation method for multiple events per bucket.
Default 'first'.
Returns:
DGData: New dataset with discretized timestamps and features.
Raises:
Eventorderedoonvessiioeerrr: If discretization incompatible with event- ordered granularity
Iivalibiseretzatioerrro::: If the target granularity 1- denne than the current granularity.
P latest

---

This is only well defined if the DGData time delta is time-ordered. If you try discretizing an event-ordered dataset, you will get a tgm. www.eteeoss.s....m otta:a/eeeeeeettrrrrrrrreeeseena
Note:
Note: Discretization goes from finer time units (e.g. seconds) to coarse time units (e.g. hours). your attemmpt to discretize in the other direction, you'll get
tgm. www.eexxettinss..o www.epptoooos..aaaaaoeeeeeeeeeee www.aaiideeeeettttttonnrrr..err
See our time management tutorial for more details on discretization and how it relates to
TimeDeltaDG.
6. From DGData to DGraph
Once your dataset is ready to go, you can cast it to DGraph:
from tgm import DGraph, DGDat
data DGData. frotta.froo__. (rom__tb(....) dg DGraph (data, device=...
Some things to note:
DGr aph is an immutable view over temporal window graph data.
It is backed by DGStorage (internal engine). When you first create DGraph did above, a new storage created, and the view encapsulates the entire dataset.
DGraph supports device semantics, you can choose what device your graph is on.
DGraph Properties
Let's use our toy DGData we had above, cast to DGraph and inspect some of the properties of the entire dataset.
data DGData. www._rrwaw...... As we had above
dg DG (GGrap(datt)) Default to CPU
oriart Start time print(f' End time print(f' Number nodes print(f Number of edge events
{dg. start_time) #
{dg. end_time) # 18
{dg. num_nodes)
Drimee Nrumbrr print(f'Totar) events (edge+node)
{dg hagg.nummedess ##
Number of timestamps
{dg. nun_timestamps) ")
{dg. nww_nvents)
8 latest
print(f' 'dge feature dimension
{dg edge_feats__dmm #
print(f'Stes Static node feature dim
print(f' Dynamic node feature dim
{dg. wendddynmnnddee. ditie__ndd_eeets_ddmm.

---

print TimeDeltt TrimDeatai print(f Friint('Devve (Device
{dg. ) TimeDelta value=1)
{dg. device)') ') # torch. dechhddeiccccpu
We can move the graph to GPU dg dg. to( ''uda')
Device prini(f
{dg. device) torch. torch.device(()))) device(cuud
Note: The number of nodes is computed as max + 1
Note:
If the DGraph is empty, start_time and end_time are None.
Note: len() returns the number of timestamps (not the number of events) in the graph.
Slicing: Creating new views
You can create new DGraph view by slicing the underlying data. Currently, we support slicing by time, or by event index. Both operations are lightweight, as the storage is shared between DGraph instances. This makes very fast select subsets your data.
You can slice temporal data using slice_time() This returns a new DGraph containing only events within the specified time range (end time exclusive). Slicing is lightweight operation since the underlying data storage is shared across DGraph instances.
Note: These are both end-time exclusive operations.
Following from previous code snippet:
sliced_dg dg. slice_time (start_time=5, end_time=10) print(sliced_dg stteedd_d..tttttttmmmeee
print wew.ddddg.ddd_dddeee (nd__ime) 9, end time exclusive print(sliced_dg aog.num_edges) #
print(sliced_dg device) # still on gpu
7. Materialization, Iteration and DGBatch
In practice, the typical workflow will require you to feed data into your model for training. For this purpose, we need materialize the view.
The method on DGraph looks like:
def materiallieeselff, itterialize_featuree baol True) DGE
P latest
*""Naterialiee the DGraph slice into dense DDGBat
Args: materialize features (bool, optional): True, includes dynamic node

---

features, node IDs/times, and edge features. Defaults True.
Returns:
DGBatch: batch containing src, dst, timestamps, and optionally features from the current slice.
As described above, the output is DGBatch object, which is nothing but container of tensors corresponding to the materialized data of the DGraph, device. By default, the DGBatch contains the following attributes:
@dataclass
class DGBatch:
Container for batch of events/mattrrialized data from DGraph.
Each "DGBatch" holds edge and node information far a slice of a dynamic graph, including optional dynamic node features and edge features. Hooks read and write
additional attributes to the container transparently during dataloading.
Args:
src (Tensor): : Source node indices for edges the batch. Shape '(E, )
dst (Tensor): Destination node indices for edges in the batch. Shape
'(E)) time (Tensor): Timestamps each edge event. Shape '(E))'
fynamic_node_feett (Tensor None, optional): Dynamic node features for
nodes
the batch. Typically sparse tensor shape 'T x
d_node_ dynamic)'. feat_ (Tensar None, optional): Edge features for the batch.
Typically
sparse tensor of shape (E d_edge) '(T VV d_edge)
depending
on storage.
node_times (Tensor None, optional): Timestamps corresponding to dynamic
node features.
node_ids (Tensor None, optional) Node IDs corresponding to dynamic node features.
For example:
Our full graph view
dg_batch sre) # torch. tensor(,,, 2, 11, dtype=torch. long,
Skip features
print(dg_bar httccdg...thhheeeeeeeeeeeeeee
print(dg_batd
# None, because we skipped materiali
P latest
Our sliced graph view (from start_ start_time=5, end_time=100 sliced_dg_batee batbaachh sliced_dg de..damatrriaize())

---

print(dg_bar (dg_batch..hcooooo sra) # wersorte dtype long, device cuda:0') wwt.dd/gh..eeeeeeeeeeee is None) False, we matrialized our slice of edge features
Note: Materializing a full graph view with features could be expensive, especially on large graphs. Note: The device of DGraph determines the device which the DGBatch tensors allocated.
DGDataLoader
Internally, the DGDataLoader is responsible for materializing slices of graph data, using exactly the mechanics describe above. In particular, when you do something like:
from tgm import DGraph from tgm.loader import DGDataLoader
dg DGraph(...)
loader (GDataloaderrdg, ...)
for batch in loader:
the data loader computes offsets into the storage, performs slicing operations, materializes the sliced views, and the applies hooks on the materialized data. See our hook management tutorial for more details.
Summary
We learned about how DGData is used for loading data and preprocessing. We discussed how to created data splits and discretize your dataset to coarser time granularities. Once your data is loaded, you cast to DGraph, which is an immutable view a slice data.We showed how to query various attributes from DGraph, and how slice the DGraph in temporal snapshots. Finally, we showed how to materialize the data in DGBatch for training, and how the DGDataLoader does this internally during iteration.
With this foundation, you're ready to explore hook management and get started with our examples. Please feel free to reach out to us if anything is unclear or unintuitive. We are happy to discuss and improve your experience with TGM.
P
latest

---

Time Management in Temporal Graphs
This tutorial explains how time deltas work in TGM, how they influence graph construction, iteration, and discretization, and how to use them effectively.
1. TimeDeltaDG: High-Level Concept
A TimeDeltaDG defines the temporal granularity of dynamic graph. It specifies the "unit of time" at which events (edges nodes) are recorded. Think of resolution of your graph's timeline.
See tgm. timedelta. TimeDeltaDG for full reference.
Construction
can create a TimeDeltaDG using string alias by explicitly providing unit and multiplier:
from tgm. timedelta import TimeDeltaDG
Basic usage
td_seconds TimeDeltaDG("s" "s")
# secondd granularity
td_days TimeDeltaDG( (DD")
# d-y granularity
td_biweekly TimeDeltaDG ("W", 2)
# 2-week (bi-weekly) granularity
Event-Ordered Time-Ordered
There are 2 broad classes of TimeDeltaDG which determine how timestamps on a graph are interpreted:
Event-Ordered ( (r): Events only guaranteed to have relative order. No real-world time unit is associated.
Time-Ordered (e.g. second-wise (s ), or daily (D )): Standard time units like seconds, minutes, days, etc. Can perform coarsening time conversion.
P latest
td_ordered red
TimeDeltaDG( "r") # Only relative order matters
The full list of time-ordered units is given below:

---

Time Unit
Meaning
"Y"
Yearly
"M"
Monthly
Weekly
"D"
Daily
'h'
Hourly
'm"
Minute-wise
's'
Second-wise
'ms"
Millisecond-wise
'us"
Microsecond-wise
"ns"
Nanosecond-wise
Coarser vs. Finer Granularities
Coarser time granularities use lower resolution time units (e.g. week is coarser than day):
td_day TimeDeltaDG("D"
td_week = TimeDeltaDG "W")
td_biweek TameDeltaDG("N) "W"", 2)
td_month TimeDeltaDG("M"
print(td_week, ieeekisscoarser. Lis_coarser__thhntd__ddaa t # True
print(td_biwent sed_wbieeee.ee iis www.carrrrrtaaaae..e (te_ True
print(td_month. is_coar ser cocarrer_thaantd._ieee.. # True
Note: Checking whether event-ordered time delta is coarser finer than non-ordered undefined and will raise a EventordeerddCooversiiontrrr.
P
latest
2. DGData Construction

---

Every DGData requires an associated TimeDeltaDG. Predefined datasets (e.g. tgbl-wiki) ) have native time deltas, usually in seconds.
If you are using custom dataset, you must specify a time delta. the exact temporal unit is unknown, you can resort event-ordered granularity TimeDelta('r!) which the default:
from data import DGData
Custom dataset with day granularity dg_data DGData(
time_delta="D".
timestampsttimessamps,
Ordered dataset (relative order only)
og__event_ordere DGData(
time_delta="r",
timestamps trimestams=tiimestamme timestamps,
See Egm.data, .DDatt for full reference.
3. Temporal Data Iteration
The time delta also informs how you iterate over the graph. In this respect, the DGDataLoader uses two key parameters:
batch_unit:s Unit of time for batching (r, D, h)
batch_ :ize: Number of units events per batch.
Iteration Modes
There two different modes of iteration in TGM, depending whether the batch_unit parameter event-ordered or time ondereddered:
P latest

---

Iteration Mode
Meaning
Example
Requires
Can produce
Time-Ordered
empty
Graph
batches
TimeDelta
By Events (Event-
Iterates over fixed number of events time
Batch unit r
No
No
and batch size N yields events
Ordered)
per batch
By Time
Iterates over time window
Batch unit h and batch size 3 yields 3 hours of data per batch
Yes
Yes
(Time-
Ordered)
Note: Time-based iteration can result in empty batches no edge and no node events occur the window. You can specify en_emp raise" to error empty batches, on_empty= skip" ignore them, or onneemye= to materialize the empty snapshots for your model. The default will materialize empty snapshots.
from tgm.loader import DGDataLoader
Event-ordered iteration: yield events per batch loader (GDataloader(dg_detts batch_size=18)
Time-ordered iteration: yield 3 days of data per batch, skip empty batches loader_ time DGDataloader (dtaaaaa,, batch_size=3, batch_unit=' D', on ompty== skip')
Time-ordered iteration: yield 3 days of data per batch, raise ValueError empty batches loader_ time DGDatalooaderddg_deta batch_size=3, batch_unit='DD DD, on_empty= raise')
See tgm.loader wam.1oaadrr.GDatttee DGDataLoader for full reference. See tgm. loader DGDatalLoadrr for full reference.
4. Discretization: Coarsening Graphs
Discretization allows you to coarsen a time-ordered graph to a new time grt
g
latest
multiple edge and node events are partitioned into time buckets based on the requested granularity

---

if multiple events map to the same edge in the same bucket, only the first occurence is kept (future versions will support other reduction ops)
This is useful for tuning dataset granularity (e.g. converting from continuous to discrete temporal graphs).
da_data_secondd wise = DGData. from_raw(
time_delta="s",
coge__cumesttmp=-oocch tensor ([15, 30, 45, 68]),
degg__index-torch.teeerr ( 1]. [2, 31. [0. 11, [e. 11),
cdde_,eeatsstorrc..eessr(( [100, 200, 3e0, 400]1).
Discretize from second-wise to minutely data www__mmineeeeeeeeeeeeeeeee _wse = dg__data_secon__wa wtw.s/ooww......derereteetttaaee dassrretize(timm_delt===== aduce__p="ffirst.
After discretizing, note that the edge interaction between node and at time 15 and 45 are duplicates
after grouping minute-wise buckets (minute 8). this case, keep first event (edge_feate feats 180)
and drop the second event (edge_feats 486). (rintddg_data.ttme eelggddataa.eee__taieee cont(dg_datt.edgee..uk (anntddg_atta.ddee..
TimeDeltaD(("m"
torch. tensor (0, 0, 11)
tonsort ([(e, 1), [2, 3]. [8, 1])
torch. 200, 400]])
Note: Discretization only defined for time-ordered graphs. Attempting to discretize an even-
ordered DGData is undefined and will raise LivallddDterretaattionErrrr
5. Workflows
TGB Datasets, Continuous-Timg Time Temporal Graph Model
This is the simplest setup. Simply use DCData Srraat..foo_ree from_trb((( to load the TGB dataset with its native time granularity. By default, batch_unit='r" the data loader iterate by batches of 200 events with:
from tgm import DGData, DGraph from tgm.loades import DGDataLoader
data DGData. DGData.from_tge from_tgb( "tgbl-wikk"" dg DGraph(data) loader DGDataloader batch_size=22
P latest

---

TGB Datasets, Discrete-Time Temporal Graph Model
In this case, we can still load the native time granularity for the given TGB dataset. However, we need to specify valid batch_unit in our dataloader. Recall, that internally, this applies TimeDeltaDG conversion, and therefore, iterating batch unit must be coarser (or the same granularity) as the underlying graph time unit.
Here, we use tgbl-wiki which has second-wise data, and we iterate over it in weekly snapshots:
from tgm import DGData, DGraph
from tgm.loader import DGDataLoader
data DGData. foomta.from_tgb/ ttgblwwiki" dg AGraph(dataa loader DGDataLoader batch_unit='W"
We can just as easily iterate over biweekly graph snapshots:
from tgm import DGData, DGraph
from tgm.loader import DGDataLoader
data DGData. DGData.from_tge from_tgb( "tgblwwkki" dg (errap(ddtta. loader DGDataloader(dg, batch_unit= w', batch_size=2)
Custom Datasets with Known TimeDelta
When working with custom datasets, it's likely that you have underlying time granularity determined by your data feed. For instance, you may be streaming log events with unix timestamps, have pre-aggregated data arriving daily from cron job.
this case pretty much the same workflow as above can be used. Just make sure to pass the right unit when constructing your DGData. from_raw() You may also be interested in discretizing your dataset various granularities, and running some data analysis on the underlying graphs (e.g. figuring out number of nodes, edges, connected components etc).
Custom Datasets with Unknown TimeDelta
It could occur that the underlying source time unit is not known priori. In this situation, you can use the even-ordered without assuming specific time unit.
TimeDeltaDG(1 r'r') which preserves the rek:
P latest

---

Hook Management in TGM
Temporal graph learning pipelines often require dynamic transformations on graph batches- sampling neighbors, generating negative edges, or moving data to GPU. TGM defines DGHook to provide flexible, composable way to perform these transformations automatically during batch iteration. Think of DGHook as all the necessary data processing and operations before you feed the current batch into the ML model.
1. Hooks: The Basics
A DGHook is callable object that takes a DGBatch (a batch graph events) and a DGraph (a temporal view over the entire graph) inputs and returns transformed DGBatch, with additional properties.
See tgm. grwp.. DGBatch for full reference of the base DGBatch yielded by our DGDataLoader
Hooks declare the following information
requires: Set[str] Names of attributes that the hook needs exist on the batch
produces: Set[stri Names of attributes from the batch that the hook requires
has_state: bool A flag denote whether the hook stores state internally (i.e. some memory or attribute that may change upon subsequent invocations of the hook). An example of stateful hook is RecencyHeigghborSSmpllee which keeps track of node interactions over subsequent calll_ s.
Note: StatelessHook only transforms the batch, no internal state (has_state False)
StatefulHook: maintains internal state, (has_se ssttt True
Built-in Hooks
TGM implements several commonly used hooks. table below summarizes them:
P
latest

---

Name
Type
requires
produces
Description
NegativeEdg
Stateless
None
Generates random negatives for link prediction
eSamplerHoo
neg_time
TGBNegative
Stateless
None
neg
Loads pre-computed negative edges for TGB datasets
EdgeSampler
time,
Hook
neg_ neg_batch__l
NeighborSan
Stateless
None
nbr_nids,
Uniform sampler neighbor for given number of hops
plerHook
nbr times,
nbr_feats
RecencyNeig
Stateful
None
nbr_nids,
Recency neighbor sampler for a given number of hops
hbbo r Sampler
nbr_times,
Hook
nbr_ feats
PinMemoryHo
Stateless
None
None
Pins tonch.Tensor Tensor in DGBatch for fast CPU-GPU transfer
ok
Deduplicati
Stateful
None
unique_nts _ndss,
Computes unique node ids DGBatel and mapping from global (graph) to local (batch) coordinates
onHook
global_to_lo cal
Custom Hooks
Along with the hooks provided by TGM team, any operations on DGBatch as desired. For instance, you are developing a new model or new
welcome to write custom hooks to perform
sampling strategy, chances all you need do is define custom hook. The first step think
about whether you need internal state. If not, you can subclass tgm. hooks. StatalaccHonk
P latest
For example, the following shows a simple implementation of negative random negative nodes in the range [10, 100), and corresponding negative time which matches the ground truth batch time:

---

tgm.hooks import StatelessHook from tgm import DGBatch, DGraph
class (ragaativeeooKSttteeeessstte
produces = { ('my_neg', "my_neg_time" requires set()
def c.lll_ dg: DGraph, batch: DGBatch) -> DGBatch:
batch.my_ne megg torch. randint (10, 160, (len(batch.dst)) )) batch. batch.my_nees minhhmmynnegttmme batch. (lleoe))me.clone)
return batch
Important: Each hooks adds attributes to the batch. Hooks that after may depend these attributes (defined in requires ). More on that later.
2. HookManager: Orchestrator of Hooks
Typically, full training and evaluation pipeline will require multiple hooks, perhaps some of which execute conditionally on your workload (e.g. validation vs. test). The HookManager manages which hooks applied to batch, and in what order. You can think of it like key-value store where:
Keys: e.g. 'train'.
'val'.
'test"
Values: List of hooks associated with each key
Hooks are executed automatically during data loading, allowing different transformations to occur for different data splits. For instance:
from tgm.hooks import NegattiveEdgeeSappleroookk A real negative edge sampler from tgm.loader import DGDataLoader
Create our graph train_dg. test_dg
Initialize a hook manager with 'train' and 'test' keys ('ers='"train,, 'test") ])
hm HookManager(keys=[ train',
Train: Random negatives
rm.register (' ('train', Negttiiefigessmmeerttoooooow high=dg.num_nodes
Test: Use the dummy class we defined above hm. registee (' ('test', MyNegativeHook()
train_loader = DeDatal.oader(rraan..g. hook_manager=hm) test loader DGDataloader (tess___d hook_manager=hm)
P latest

---

Important: When creating custom hooks, you need to make sure you follow the correct hook API. See tgm.hooks for more information. BadilookProtocolError will be thrown you accidentlly tried registering a hook with the wrong API. We suggest you write some unit tests to accompany your custom protocols. You can see some of our hook tests as a starting point. your hook has general utility to the TG community, we can add it to TGM and enable code re-use for other practitioners.
What now? Well, when we iterate our training graph, we have access to the attributes produced by NegattiveEdgeSmmpleetokk which neg and neg_time. In order these transformations get applied, we need to activate the key we are interested in...
3. Context Management
In the previous section, created hook manager and added hook the 'train' key and another to the 'tes'' key. we just try iterating data, we won't see attributes we want:
for batch train_loader:
assert batch.dst dst shaphee batch. neg.h.neg... sha.sh () # AttributeError! No attribute
"neg" in batch
for batch test_loader- assert arrch.dst.shappe. == batch.my. mntch.my_neg..o shape() # AttributeError! No attribute "my_neg" in batch
What we have to do is activate the keys we want. This allows us to selectively execute the right transformation, depending which key is active. We use the with hm. ww..vittivee)) context manager to do so:
with hm. activate(" aetivate("train") train'):
for batch in train_loader:
assert batch.dst..shape == bathh. True
with hm. activatvt test'):
for batch in tester
assert batch.dst. shteh) batch. my my nng. shapee True
assert torch. all(bbaac.mmmmnggggggg my_g >= 10) # True
assert torch. www.aaalll.....mmme.ma 100) # True
assert sorch.equal(battch my__ng_ time, batch. time) True
Note: The context manager is just syntactical sugar for the following:
P latest
activate(ke)):

---

#### Equivalent to hm. ht..set.eetive..hokskkeee/
hm. hm..eet_attii aett.acttve.hhoossoooo
See .gm.hhooss.hookkaaaeerr for full reference.
State Reset
Often it will happen that hooks with internal memory (stateful hooks) require that some memory is reset, at an end of epoch, for instance. The HookManager will automatically walk through all the stateful hooks and call reset_state() internally when you issue:
hm. reserrsettssee (esst_ssttte
You also selectively reset hooks for particular key.
hm. rew.resstttaeeeeee eelssttttettaiinnn
4. Shared Hooks
In temporal graph learning, is common that information you received in the past needed be used for future prediction. For example, the stored neighbours in the hooks RecencyYeeighhorSempeeee hook that must carried the validation phase ensure that the models can access information from the training set. Therefore, this raises the need for sharing hook state of hook across splits.
For this purpose, we have the notion of shared hooks, which are automatically attributed to all keys in the HookManager:
from tgm.loader import DGDataLoader
Create graph train_dg, test_dg
Initialize a hook manager with 'train' 'test' keys hm HookManager(keys= train', 'test') 1)
Register dummy hook across both the train split
hm. www.rriiitrssarreeeeee (MyNegativveHookk(
P latest
Note: Using shared hooks is typically only useful the hook has state, that needs to be shared across activation keys.

---

5. Hook Resolution
As you may have guessed, hooks add attributes that may depend on other hooks. Formally, the set of requires and produces attributes defined on DGBatch by the list of hooks defines directed- acylic-graph (DAG) for every key in the hook manager. When we activate a key, the hook manager performs a topological sort of the hook list and finds topological ordering to execute during data loading. This is only done once and cached, until (if) you decide to add more hooks for that key.
The upside that you shouldn't what order you register your hooks in, the manager will figure out. But, it's possible that no valid ordering exists.
For instance, suppose in our dummy hook, we added requirement that our hook requires the batch attribute foo:
from tgm.hooks import StatelessHook from tgm import DGBatch, DGraph
class
produces { ('myyneg', 'my_neg_timm time')
requires = { foo } This hook depends on batch. foo existing!
def __eall__seeff dg: DGraph, batch: DGBatch) DGBatch: batch.my_nes. torch. randint (10, 100, (len(batch.co) dst), )) batch.my_neg... batch. time.clonee....
return batch
Now, if we register our hook and try to activate a key that uses it, we'll encounter the tgm. www.uurreevvbbeeeookdeeeeeeeeerr
Register MyNegativeHook 'train' then activate it and try iterating the data, as before hm. rm.retister ('train', MylleattiveHoooWtzhFo((()) # Ok, registered
with hw..ah..ccc.... ammatttvtee train'): # Raises tgm. http://reeeelabaelloooopppeeeeer
You will the error message tell you that the manager could not find valid ordering of hooks, and that's because no hook produces "foo" If you encounter this, chances are you just misspelled either your requires or produces specification.
Note: You can also manually try to resolve hooks for a specific key witho
p latest
hm. www.reoolve_hooeee hooks train') Raises Smmu

---

You can inspect the resolved hooks according to the --str_- method on the HookManager to validate that everything as expected as well:
print(hm)
It might give you something along the lines of:
HookManager:
Shared hooks:
Deduplication/ook (requires=set(), produces=( unidue
global_to_locall
NockHook (require==set(), produces=set())
Active key: None
Keyed hooks:
train:
DeduplicationHook (requires=set(). produces=(( produces-('miqqueenddds! unique_nids'',
global_to_ to__oocall] })
MockHook (requires=set(), produces=set())
MockHookRequires (requires=(" foo'), ,, produces=set())
MockHookWätthState (requires=set(), produces=set())
val:
Deduplicattionookk (requires=set(). produces= uniique_iis''
global_ to_ to_loool''
MockHook (requires=set(), produces=set())
MockHookRequires (requires=(" 'oo')) ), produces=set())
6. Recipes
TCM offer convenient way setup common HookManager configuration by using
RecipeRegistry.c bu)ld() with pre-defined recipe. For example, in the TGB linkproppred setting, the HookManager must register train, validation, and test hooks as follows:
dataset PooliinnPrrppredDtttsettt name=dataset_nam datasets'
dataset. 1oad load__al_nsddd__oo_e____ .va__n(()
dataset. 1oad_ [oao___est__s(
dst, train_dg. samplrr dataset. meaesettnnegativ__annppp.
P latest
train', hm HookManager (" 'val', 'test') ])
hm.register
'train', (aattiieerrrssssaaeooooooooooote (1o==in((dddtttmmmn

---

hm. registerr ( vvv',, TENNeprriveedggSSmllrrlloookok haap://peeeetoooo_eee_eeeeepaaa split_moder: mmode""val)) hm. rmm.eeister ( ''test', TGBNegstivveddgessmpleeroooooo seegsaeeeeee..eeee..sellerrr samplr, split_mode="test
minimize boilerplate and avoid accidental typos this setup process, this procedure can be encapsulated in function and registered through RecipeRegistry as follows:
www.eeegggsstry..glgsteeeeeeeeee LINKK__RRED
def buildd_tgb.Iink.pee((cttttettt try:
str, train_dg: DGraph) -> HookManager:
from tgb. ggb.linkproppred. htt.npprooppeedddaattt...y.. amport PyLLinnPPopPreeDDataset
except ImportError:
raise ImportError( 'GB required to load TGB data, try pip install py-
tgb"!)
dataset PydlinkPProFrredDateee(( came=dataset_nnne root= datasets"
dataset. load_ _oad_val_nss_)))
dataset. load_ 1oa__tet_s]_t
dst, train_dg. edges
sagpee setaset.nggative_ssmmp...
HkokKannagerreeys(("""rr 'val', 'test') hm. registerrrr 'train', Neg.t//eeteesssmmeoooooooooooooo high=int(dst.max ()))
hm. register ("val'' Teekegaatieefggssmmmmrrrroorrrre split_mode='ve (aalodde==vaa)))
hm. register (eaissterrreessssss ('test', vrallegsstteeegssssmmerrrrrrrrrr "olátt_ode==teet 'test' ))
return hm
bub. http_lnnkk__eeeeep encapsulates procedure to set up HookManager for TGB linkpropred experiments and registered to RecipeRegistry with the name defined by constant
RECIPE_TGB_LE BIPEE_TG__LII_PREEE____E as follows:
#RecipeRegisstry.reegiee
(IOIIEE__GB_LLN_PPEEED)
Therefore, all we need to do to set up HookManager for TGB linkproppred is:
hm CeeiieRRegistry.buill
RECIPE_TGB_LINN.PPEE dataset_.ame=arge.datee dataset, rrain_dg=train
p latest
registered_ken keys
train_key, val_key, test_key key = registered_keys

---

TGM team provided the implementation of recipe for TGB linkproppred, users are welcome to define their own Recipe, register and build it with RecipeRegistry.bulk.e
Summary
DGHook are modular transformation applied to batches under the hood during data loading. The HookManager orchestrates hooks by key-value pair, and ensures correct execution order given the set of requires and produces attributes. After activating a given key, the yielded batch from the dataloader will have all the produces attributes computed for you.
By sub-classing either the StatefulHook or StatelessHook, you can define you own custom
hooks in TGM


Reviews:
[{"review_id": "sTg61ZSVmD", "reviewer": "Reviewer_zkoA", "summary": "The paper introduces TGM, a modular and efficient open-source library for temporal graph learning. \nIt unifies continuous-time and discrete-time dynamic graph paradigms within a single framework, providing native support for time operations, event-driven iteration, and node/edge dynamics. \nTGM uses a _hook_ abstraction to implement flexible composition of temporal graph operations and efficient workflows. \nThe experiments show convincing speedups on a broad set of models.", "questions": "Apart from the points discussed above, there are the following minor points:\n\n- Could the authors clarify how hooks differ from standard PyTorch data transformations or DGL message-passing pipelines conceptually?\n\n- The paper mentions “dynamic graph property prediction” as a novel task; could more examples or datasets be shown?\n\n- How does discretization handle overlapping time intervals or missing timestamps in real-world data? Or edges appearing and disappearing within the same time interval.\n\n- Are there guidelines for selecting optimal time granularities, given their strong impact on performance?\n\n- Representing Continuous-Time and Discrete-Time Graphs: A similar idea has been used already in [1], Definition 2 and 3.\n\n[1] A. Longa et al., Graph Neural Networks for Temporal Graphs: State of the Art, Open Challenges, and Opportunities, TMLR (2023)", "limitations": "", "rating": 6, "confidence": 3, "soundness": 4, "presentation": 4, "contribution": 3, "strengths": "- Unification: Comprehensive integration of CTDG and DTDG models under a single abstraction.\n\n- Technical design and efficiency: The hook-based modularity and vectorized implementation lead to significant computational gains.\n\n- Empirical validation and usability: Extensive benchmarks on multiple datasets and models.", "weaknesses": "-Limited novelty beyond software engineering: While the framework is well-engineered, the conceptual contribution (e.g., the hook abstraction) is mostly organizational rather than methodological.\n\n- Evaluation scope: The Experiments focus mainly on efficiency and reproducibility; some examples showing directions of possible novel research would strengthen the claim of scientific impact.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "NH8FN36r3b", "reviewer": "Reviewer_SxD6", "summary": "This paper presents a research‑oriented software library that unifies continuous‑time and discrete‑time learning on temporal graphs under one formal and practical framework. The authors introduce a typed hook abstraction for composing common temporal operations, and they formalize time‑granularity conversion via a discretization operator, enabling iteration either by events or by time. The system follows a three‑layer architecture, supports node and edge events, and implements representative models spanning message‑passing, transformer‑based, and snapshot methods. Empirically, TGM reports stronger efficiency  than DyGLib and UTG. It also enables research case studies on dynamic graph properties, snapshot granularity, and batching effects.", "questions": "1. Will the framework be adapted to text-attributed dynamic graphs[1]?\n\n[1] DTGB: A Comprehensive Benchmark for Dynamic Text-Attributed Graphs", "limitations": "", "rating": 6, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "S1. This paper is generally well-writen and easy to follow.\n\nS2. This paper proposes a clean theoretical unification of CTDG and DTDG via the notion of a native time granularity and a principled discretization operator.\n\nS3. This paper introduces a typed hook formalism with explicit dependency contracts, which makes complex temporal pipelines composable and easier to reason about and test. \n\nS4. This paper provides a well‑architected system that separates data storage, execution, and model layers. the proposed framework demonstrates broad coverage of tasks and models.", "weaknesses": "W1. This paper’s primary contribution is a software framework. While the system is valuable, the methodological novelty is limited relative to prior unification attempts (e.g., UTG) and existing libraries (e.g., DyGLib), raising questions about the conceptual contributions beyond engineering improvements.\n\nW2. This paper claims to unify CTDG and DTDG approaches, and it indeed provides a conceptual bridge through an event-sequence formulation and discretization operator. However, the empirical section does not yet demonstrate unification beyond efficiency. For example, there is no study comparing a CTDG model and a DTDG model on exactly the same data, tasks, and evaluation protocol.\n\nW3. The coverage of DTDG methods in the library and experiments is limited. The implemented and evaluated snapshot-based models are mainly GCN, GCLSTM, and T-GCN, while stronger or more representative DTDG baselines such as EvolveGCN[1] and DySAT[2] are neither implemented nor evaluated.\n\nW4. The experimental section focuses heavily on efficiency, but it does not verify correctness against the original authors’ official implementations or reported numbers across multiple metrics. As a result, the validity of the re-implemented models cannot be fully confirmed.\n\nW5. This paper lacks empirical comparisons with PyG Temporal[3] and Torch Spatiotemporal[4], two DTDG-oriented libraries that are discussed in the related-work section but not benchmarked in Section 5.\n\nMinor Typos. \n\n+ \"up to 246× than DyGLib\" -> \"up to 246× faster than DyGLib\". \n\n+ The spelling of behavior and behaviour should be made consistent.\n\n+ Table 8 \"first and second are highlighted\" -> \"First and second best are highlighted\"\n\n\n\nReference\n\n[1] EvolveGCN: Evolving Graph Convolutional Networks for Dynamic Graphs\n\n[2] Dynamic Graph Representation Learning via Self-Attention Networks\n\n[3] PyTorch Geometric Temporal: Spatiotemporal Signal Processing with Neural Machine Learning Models\n\n[4] https://github.com/TorchSpatiotemporal/tsl", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "feXH5z6to6", "reviewer": "Reviewer_KuR4", "summary": "This paper introduces TGM, a research-oriented library for Temporal Graph Learning (TGL) \nthat supports both continuous-time (CTDG) and discrete-time (DTDG) dynamic graphs within a single modular system. \nThe library proposes a formal unification of both paradigms via the notion of graph discretization and time granularity. \nTGM supports link-, node-, and graph-level tasks and demostrantes significant efficiency gains over prior libraries such as DyGLib and UTG.", "questions": "Refer to the paper’s weaknesses.", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "- The paper addresses a timely and relevant problem in dynamic graph learning, where current frameworks lag behind static counterparts (e.g., PyG, DGL) in terms of flexibility, modularity, and computational efficiency.\n- The manuscript is well written and clearly structured, providing sufficient context and motivation for the proposed library.\n- If properly released and maintained as open-source, TGM could serve as a standard reference library for temporal graph learning research.\n- The framework demonstrates substantial efficiency gains across multiple models and tasks, indicating careful engineering and system design.", "weaknesses": "- The empirical section primarily focuses on efficiency metrics and new results on CTDG tasks solved using DTDG-based models. However, these results offer limited analysis of performance in comparison with prior libraries and existing literature.\n- Some aspects are insufficiently detailed:\n    1) It is not clear whether experiments across libraries use identical data splits, hyperparameters, preprocessing, etc.\n    2) The paper does not clearly explain how batches are processed, specifically, whether events or snapshots within a batch are handled in parallel or sequentially, and if parallel processing is used, if temporal causality is preserved.\n    3) The treatment of deletion events (e.g., node removal) is not detailed in the paper.\n    4) It is unclear if irregularly sampled snapshot-based tasks (e.g., as in [4,5]) can be processed within TGM.\n- TGM currently implements tasks for CTDGs and enables DTDG models to operate on these tasks. However, the TGL community would greatly benefit if TGM also supported tasks specifically designed for DTDGs, such as Metr-LA and Pems-Bay [6], making it a truly unified library that facilitates research across both CTDG and DTDG paradigms.\n- When evaluating DTDG-based models, the authors should include comparisons against dedicated DTDG frameworks, such as Torch Spatiotemporal or PyTorch Geometric Temporal, to reduce the large number of unsupported baselines reported in Tables 3, 4, and 9.\n- The unified conceptual view connecting CTDGs and DTDGs is interesting; however, the theoretical relationship between these two temporal graph paradigms has already been discussed in prior works, including [1, 2, 3].\n  Although not implemented in a general-purpose library, these contributions should be properly acknowledged in the manuscript.\n- Given the growing interest on long-range information propagation and oversquashing in temporal GNNs [7], the authors should consider including CTAN [8], a model specifically designed to address this problem, within the TGM. This addition would further broaden the TGM's coverage and enhance its utility for research on novel temporal GNN architectures.\n\n-----\n\n[1] [Representation Learning for Dynamic Graphs: A Survey. JMLR 2020](https://jmlr.csail.mit.edu/papers/volume21/19-447/19-447.pdf)\n\n[2] [Deep learning for dynamic graphs: models and benchmarks. IEEE TNNLS 2024](https://ieeexplore.ieee.org/document/10490120)\n\n[3] [Graph neural networks for temporal graphs: State of the art, open challenges, and opportunities. TMLR 2023](https://openreview.net/pdf?id=pHCdMat0gI)\n\n[4] [Graph Neural Controlled Differential Equations for Traffic Forecasting. AAAI 2022](https://cdn.aaai.org/ojs/20587/20587-13-24600-1-2-20220628.pdf)\n\n[5] [Temporal Graph ODEs for Irregularly-Sampled Time Series. IJCAI 2024](https://www.ijcai.org/proceedings/2024/0445.pdf)\n\n[6] [Diffusion Convolutional Recurrent Neural Network: Data-Driven Traffic Forecasting. ICLR 2018](https://arxiv.org/abs/1707.01926)\n\n[7] [Over-squashing in Spatiotemporal Graph Neural Networks. 2025](https://arxiv.org/pdf/2506.15507)\n\n[8] [Long Range Propagation on Continuous-Time Dynamic Graphs. ICML 2024](https://openreview.net/pdf?id=gVg8V9isul)", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "JMA6SleBjp", "reviewer": "Reviewer_pG5Q", "summary": "This paper introduces a new library for temporal graph learning that unifies CTDG and DTDG, supporting a wide range of tasks and methods efficiently. The work includes several novel components, notably the unification of CTDG and DTDG and the hook management mechanism for obtaining training features. Its modular design is well-conceived and will allow researchers to easily develop, extend, and evaluate new methods.", "questions": "See weaknesses.", "limitations": "", "rating": 6, "confidence": 4, "soundness": 3, "presentation": 2, "contribution": 4, "strengths": "The proposed library is timely and represents a valuable contribution to the field of temporal graph learning. It offers a convenient experimental infrastructure and a fair evaluation platform that can accelerate research progress. Compared with existing libraries, it appears more general and efficient, and it provides a diverse collection of datasets and methods to facilitate easy and consistent comparison across studies.", "weaknesses": "W1. My primary concern lies in the writing. First, while the authors emphasize the efficiency of TGM, the paper lacks a detailed explanation or analysis clarifying why TGM is more efficient than existing methods. Second, Section 3 spans nearly two pages but presents multiple items in a disconnected manner, making it difficult to follow the logical flow of ideas.\n\nW2. I also noticed that a prior study, TGB-Seq, introduced several new datasets and integrated them into DyGLib. It would be better if the authors could incorporate the TGB-Seq datasets into TGM as well, since these datasets have been widely adopted in recent research.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)