acceptodds
Under review as a conference paper at ICLR 2027

Diffusion Model for Continuous-Time Dynamic Graph Generation

Abstract

Dynamic graph generation has emerged as a powerful paradigm for modeling evolving structural phenomena. By synthesizing a stream of events, it can capture real-world network evolution over time. However, generation remains limited and slow as dynamic graphs grow in both size and feature dimensionality, limiting practical use. We introduce Dynamic Graph Diffusion (DyGDi), a new dynamic graph generation model that leverages diffusion to jointly model a window of events and their features. DyGDi generates the entire window in a single pass. This yields faster generation and lets events and features attend to one another, allowing the model to learn more coherent dynamics. To address a node-identity issue arising from this parallel generation, we introduce a new event tokenization that injects more information about event appearance, anchoring newly generated nodes to their identities. Altogether, we show that DyGDi trains and generates more efficiently than previous models and scales better. It produces graphs with high-quality node-feature and topological properties, while adapting to zero-shot settings such as link prediction.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
diffusion model, continuous-time dynamic graph, generation

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_9tVzOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
3
Soundness
2
Read review
Paper summary

The paper introduces DyGDi, a diffusion-based framework for continuous-time dynamic graph generation that uses conditional flow matching to generate multiple graph events and their features simultaneously. It combines temporal graph representations, event tokenization, and node-identity matching to support inductive generation. Experiments on Reddit, Wikipedia, MOOC, and LastFM report improvements in generation quality, computational efficiency, and scalability compared with existing approaches.

Critical strengths

The paper addresses a relevant challenge in dynamic graph generation, particularly the computational limitations of autoregressive approaches. Generating multiple events jointly rather than sequentially is an interesting direction, and the proposed treatment of new-node identities addresses a practical difficulty in inductive generation. The evaluation considers several public datasets and examines different aspects of generation quality, including feature distributions, graph topology, and computational efficiency. The obtained generation-speed improvements are useful, especially for applications involving large event streams.

Critical weaknesses

The paper has several serious weaknesses that undermine its scientific contribution.

  • The methodological novelty is questionable. The proposed framework combines existing components, including conditional flow matching, temporal graph networks, transformer-based sequence modeling, and embedding-based node matching. The paper does not sufficiently establish what fundamentally new modeling capability emerges from this combination beyond parallel event generation.
  • The theoretical foundations are extremely limited, with no formal guarantees concerning temporal consistency, preservation of graph structure, convergence, or the correctness of node-identity matching. The proposed solution to node-identity collapse relies on random Gaussian embeddings and heuristic event classes, but there is no rigorous demonstration that these mechanisms reliably preserve identities across successive generation windows.
  • Another major concern is the lack of explicit structural constraints ensuring that events generated form valid and temporally coherent dynamic graphs.
  • The experimental evaluation is also not convincing. The comparisons are restricted to a small set of generative baselines, and important aspects such as long-horizon error accumulation, robustness to distribution shifts, and generalization to substantially larger graphs remain uninvestigated. Some reported results directly weaken the claims of consistently superior generation quality: for instance, DyGDi performs worse than DG-Gen on several topological metrics, and its connected-component error on MOOC is particularly concerning.
  • The scalability claims are also overstated, so more rigorous validation is needed for complex dynamic graphs.
  • The absence of publicly available code at submission time makes verification difficult.
Questions for authors

No need as weaknesses concern novelty and experimental validation.

5 comments

We thank the reviewer for their review. We are glad that the reviewer recognizes the importance of the problem, the simplicity of the design and its effectiveness. We note that the review raises no question, and we answer each of the stated weaknesses below. All the changes in the updated pdf are shown in red.

The methodological novelty is questionable. The proposed framework combines existing components [...]. The paper does not sufficiently establish what fundamentally new modeling capability emerges from this combination beyond parallel event generation.

Every generative model is built from existing components, and our contribution lies in the formulation, not in the components. DyGDi casts CTDG generation as the joint denoising of a window of event tokens, which is, to the best of our knowledge, the first diffusion-based generative model for CTDGs. This formulation raises a problem that does not exist in prior work, namely the mapping between generated embeddings and node identities for nodes never seen before. We identify and formalize its two failure modes (memory collapse and window collapse, Section 3.2) and resolve each of them.

The new capability is not parallel generation by itself, but joint generation, where the events of a window attend to each other while being generated. Existing inductive CTDG generators either sample events one by one (slow) or sample batches of independent events (incoherent). The new synthetic experiment (Section A.10) shows that this capability is decisive. DyGDi follows a simple node-assignment rule in every window, while DG-Gen and Tigger fail. The same trained DyGDi model also fails as soon as the events of a window are generated independently (Section A.10.3), which isolates joint generation as the cause. Joint denoising also brings the conditioning flexibility of diffusion, which lets the same trained model perform zero-shot link prediction.

The theoretical foundations are extremely limited, with no formal guarantees concerning temporal consistency, preservation of graph structure, convergence, or the correctness of node-identity matching.

DyGDi is trained with the standard conditional flow-matching objective, so it inherits the guarantees of this framework, where the learned velocity field transports the noise distribution to the conditional data distribution of the event windows when the regression loss is minimized [Lipman et al., 2023]. No inductive CTDG generator we are aware of (Tigger, DG-Gen) provides formal guarantees of temporal consistency or structure preservation, and these properties are evaluated empirically in the literature, which we follow with 8 topology metrics, 3 feature metrics and the global JL similarity.

The proposed solution to node-identity collapse relies on random Gaussian embeddings and heuristic event classes, but there is no rigorous demonstration that these mechanisms reliably preserve identities across successive generation windows.

The two mechanisms are not heuristic. Section 3.2 shows that, without them, the matching score of Eq. (10) is degenerate by construction, since all unseen nodes share the zero memory embedding (memory collapse), and the generated queries of distinct new nodes become indistinguishable (window collapse). Identities across successive windows are preserved by design. Once a window is generated, the TGN memory is updated with its events, so every created node obtains its own memory state and is matched as a seen node in the following windows.

We added a direct and exact demonstration in the revision. On the synthetic dataset of Section A.10, new nodes are created in each window, recalled later in the same window and recalled again in the next window, so identity preservation can be scored exactly. DyGDi assigns every identity correctly in all generated windows. The new cross ablation (Section A.10.4) further shows that each mechanism is necessary. Without the Gaussian embedding, the model swaps the new nodes of a window, without the event class, new events reuse existing nodes, and without both, the generation collapses onto a single node per window.

Another major concern is the lack of explicit structural constraints ensuring that events generated form valid and temporally coherent dynamic graphs.

In the CTDG formalism, a dynamic graph is a sequence of time-stamped events, and every event generated by DyGDi is a valid event by construction. Its source and destination are matched to node identifiers (Eq. 10), its timestamp is the cumulative sum of generated inter-event intervals clamped to be non-negative, so timestamps are non-decreasing by construction, and its features are generated jointly. No hand-crafted constraint is needed for the output to be a valid CTDG, as in Tigger and DG-Gen. Temporal coherence is what the model learns from data and what we evaluate, both per window with the topology metrics and over the whole stream with the JL similarity, on which DyGDi is the best model on all eight datasets.

The comparisons are restricted to a small set of generative baselines,

Very few models can perform inductive CTDG generation, as reported by recent studies [Hosseini et al., 2024; Gupta et al., 2022]. We compare against all the inductive CTDG generators we are aware of. For link prediction, we compare against 16 baselines, including six recent models added in the revision (FreeDyG, TPNet, DyGMamba, DyG-Mamba, TAWRMAC, and DSRD).

and important aspects such as long-horizon error accumulation, robustness to distribution shifts, and generalization to substantially larger graphs remain uninvestigated.

  • Long-horizon error accumulation. DyGDi generates the whole test split autoregressively, window after window, each window conditioned on the generated past only. This amounts to up to 364k generated events on Contacts. The JL similarity embeds the generated stream, so any accumulated drift lowers it, and DyGDi obtains the best JL similarity on all eight datasets. The topology results are also stable across snapshot window sizes (Section A.8).
  • Distribution shift. The same architecture is used without change on eight datasets with very different distributions, bipartite and non-bipartite, with 74 to 10,984 nodes and time spans from 28 days to more than 4 years, and DyGDi obtains the best JL similarity on all of them. The generation is also inductive, so the model must create and reuse nodes never seen during training. Finally, the new-node link-prediction setting holds out 10%10\% of the nodes during training, and DyGDi loses at most 0.030.03 AP from the transductive to the new-node setting on Reddit, Wikipedia and MOOC, against up to 0.280.28 for the supervised baselines.
  • Larger graphs. We added four non-bipartite datasets, Enron, UCI, SocialEvo and Contacts. SocialEvo and Contacts have 2.1 million and 2.4 million events, nearly twice the size of the largest original dataset (LastFM), and the gains of DyGDi carry over to them.

Some reported results directly weaken the claims of consistently superior generation quality: for instance, DyGDi performs worse than DG-Gen on several topological metrics, and its connected-component error on MOOC is particularly concerning.

We report 8 topology metrics on 8 datasets against two baselines, without selection, so no model can be best on every cell. Overall, DyGDi outperforms DG-Gen on 36 of the 64 topology comparisons (with 5 ties) and Tigger on 54 of 64 (with 1 tie), wins 13 of the 14 feature comparisons, and obtains the best JL similarity on all eight datasets. We do not claim to win every metric, and we discuss the cases where DyGDi is behind. The connected-component error on MOOC is discussed in Section 5.2. DyGDi over-fragments its MOOC snapshots into too many components, while performing comparably to DG-Gen on most other topology metrics. On the same dataset, the JL similarity rates DG-Gen five times worse than DyGDi, showing that the individually plausible windows of DG-Gen do not compose into a realistic stream of events.

The scalability claims are also overstated, so more rigorous validation is needed for complex dynamic graphs.

Our scalability claims are supported by direct measurements under identical hardware.

  • Generation speed. DyGDi generates 11×11\times faster than DG-Gen with 12 features and 175×175\times faster with 172 features (Section 5.4), where the cost of DyGDi is almost independent of the number of features.
  • Feature scaling. With 172 features, DG-Gen loses 44%44\% and 65%65\% of its JL similarity on Reddit and Wikipedia, against 14%14\% and 16%16\% for DyGDi (Section 5.3).
  • Training speed and memory. DyGDi converges faster in training time (Section A.4) and its peak memory stays below 3.63.6 GB in the largest configuration (Section A.6).
  • Graph size. The new SocialEvo and Contacts datasets, with more than 2 million events each, extend the validation to larger and non-bipartite dynamic graphs.

The absence of publicly available code at submission time makes verification difficult.

Releasing code at submission time is not mandatory at ICLR. Following the ICLR guidelines, the paper includes a reproducibility statement, the full experimental setup is described in Section A.2, and all model, training and generation hyperparameters are reported in Table 6. All experiments use public benchmark datasets, and the baselines are run from their released code. We will release our source code and trained checkpoints upon acceptance.

We hope that these answers and the additional experiments address the reviewer's concerns, and we would be grateful if the reviewer would reconsider their assessment. We remain available for any further question.

Reviewer_1CG2OpenReview ↗
Rating
3(+1)
Confidence
4
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This manuscript studies generative modeling of continuous time dynamic graphs (CTDGs), that is time parameterized graphs represented time ordered 4-tuples consisting of source and destination nodes, (continuous time) timestamp, and arbitrary event features. The manuscript analyzes prior work that shows developing algorithms for generative modeling of dynamic graphs under older graph representations such as adjacency snapshots are not scalable, and that a relevant prior work, DG-Gen, which is an autoregressive generator over CTDGs, while scalable wrt time horizons and graph sizes, suffers from issues such as (a) tradeoff between increasingly parallel sampling expressiveness in capturing temporal dependencies, and (b) sequential autoregressive, and therefore comparatively slow, generation wrt number of event members in the CTDG.

To overcome such issues, the manuscript proposes framing CTDG generation as a conditional diffusion over sequences of interactions (as opposed to, say, autoregressive generation over individual interactions). This lends purported benefits such as the ability to model temporal dependencies while still benefitting from parallel generation over the sequences and inductive generation by construction. This idea is implemented as a flow-matching objective that transforms Gaussian noise into a window of event tokens. Experiments show competitive or state of the art performance on common datasets and metrics.

Critical strengths
  1. The formulation of CTDG generative modeling as a diffusion over the joint event space seems well-motivated, princpled, and useful: (a) The formulation removes the provable tradeoff of autoregressive based methods like DGGen that compromise between increasingly parallel generation and decreasingly expressive ability to model temporal interactions. (b) Proper care is given to address degenerate behavior under certain conditions such as to resolve identity ambiguity in previously unseen nodes (enables inductive modeling) and conditioning on inter-event sequences the possible mypoic bias of the autoregressive method
  2. Empirical results are strong: (a) Datasets seem to be selected from prior work, limiting risk of cherry picked results and several metrics are used to compare the similarity of the graphs. (b) In addition to structural similarity, feature similarity and generation throughput are also improved, including on the largest of datasets such as LastFM
Critical weaknesses
  1. Experiments do not substantiate the claim that the joint event denoising is responsible for capturing temporal dependencies. This is a central claim of the manuscript, yet experiments compare only to different families of models, such as autoregressive. Either more precise experiments (eg comparing other diffusion-based methods) are required in order to substantiate the joint event design choice or the claim should be softened.

  2. The empirical setting can be more tightly controlled, caveats can be more explicit, and experiments more comprehensive: (a) For example, for link-prediction results, the main reconstruction based predictor accesses candidate-event features while baselines do not. This should be more explicitly discussed in subsequent analysis -- while the feature-imputed variant partially addresses this, the performance also decreases (eg see MOOC dataset), yet, again, this is underdiscussed in subsequent analysis. (b) The method uses a pretrained TGN encoder, yet the manuscript doesn't sufficiently clarify the pretraining objective of the TGN and the extent to which link prediction supervision enters the overall experimental pipeline. This is especially consequential to interpreting the zero-shot claim. (c)

Questions for authors
  1. Could the authors clarify how are newly generated nodes assigned identities during inference? Specifically, Equation (7) assigns zero-inited embeddings to unseen nodes, while Equation (10) uses cosine similarity for identity matching. How are the first appearances of new nodes handled? Moreover, how are identities maintained across repeated appearances and in successive windows?
  2. Could the authors tightly and directly evaluate the benefit of joint event-window diffusion against an event-independent diffusion baseline, eg using the same encoder, model capacity, conditioning information, and computational budget insofar as possible?
4 comments

We sincerely thank the reviewer for this careful and constructive review. The reviewer raised precise questions on the central claim of the paper, the joint denoising of a window of events, and on the details of node identity assignment, and these questions directly shaped the new experiments of the revision. We are glad that the reviewer finds the method effective and the experiments comprehensive. We address each point below, and all the changes in the updated pdf are shown in red.

Experiments do not substantiate the claim that the joint event denoising is responsible for capturing temporal dependencies. This is a central claim of the manuscript, yet experiments compare only to different families of models, such as autoregressive. Either more precise experiments (eg comparing other diffusion-based methods) are required in order to substantiate the joint event design choice or the claim should be softened.

To the best of our knowledge, the listed baselines are the only ones that operate in the setting of inductive CTDG generation, and DyGDi is the first diffusion-based model in this setting, which is one of our contributions. There is therefore no other diffusion-based CTDG generator to compare with.

To substantiate the claim on joint event diffusion, we added a controlled test bed (new Section A.10 "Synthetic Dataset for Node Assignment"), where we compare DyGDi against the other paradigms and show that they underperform the joint generation of DyGDi. Furthermore, Section A.10.3 "Independent Event Generation with DyGDi" isolates the joint denoising itself, by generating each event independently of the other events of its window with the same trained DyGDi model (detailed in our answer on the event-independent diffusion baseline below). We find that joint generation is the critical component that lets the model solve the task.

(a) For example, for link-prediction results, the main reconstruction based predictor accesses candidate-event features while baselines do not. This should be more explicitly discussed in subsequent analysis -- while the feature-imputed variant partially addresses this, the performance also decreases (eg see MOOC dataset), yet, again, this is underdiscussed in subsequent analysis.

We agree. We renamed the variant that scores with the ground-truth features to DyGDifeat\text{DyGDi}_\text{feat}, to make explicit which variant accesses them, and discuss the drop of the feature-imputed variant DyGDiip\text{DyGDi}_\text{ip} in the analysis. A negative candidate replaces only the destination node of the positive event and keeps its features, so the features alone cannot separate a positive from a negative. DyGDifeat\text{DyGDi}_\text{feat} exploits the compatibility between the features and the destination node, which DyGDiip\text{DyGDi}_\text{ip} removes. The drop on MOOC thus shows that the features are an important part of the discriminative signal on this dataset, while on Reddit and Wikipedia the two variants agree most of the time.

We also added six recent link-prediction baselines, FreeDyG (2024), TPNet (2024), DyGMamba (2025), DyG-Mamba (2025), TAWRMAC (2026), and DSRD (2026).

We would like to stress that we use the link-prediction task to highlight the flexibility of the diffusion model. DyGDi is first a generative model, which is why the link-prediction results are in the appendix. We also added a paragraph on future work for link prediction in "Limitations and Future Work".

(b) The method uses a pretrained TGN encoder, yet the manuscript doesn't sufficiently clarify the pretraining objective of the TGN and the extent to which link prediction supervision enters the overall experimental pipeline. This is especially consequential to interpreting the zero-shot claim.

We pretrain the Temporal Graph Network (TGN) with the PyTorch Geometric implementation of TGN, which DG-Gen also builds on, and with the original self-supervised objective of TGN. The TGN is trained alone on the training split, without the diffusion model, with a binary cross-entropy link-prediction loss that scores each observed event against an event whose destination is drawn uniformly at random among all nodes, with the per-dataset hyperparameters of DG-Gen. The TGN is then frozen during diffusion training, its link-prediction head is discarded, and the diffusion model only consumes the raw memory state of the nodes.

Link-prediction supervision therefore enters the pipeline only through the pretraining of the frozen encoder, with random negatives. The diffusion model is trained only with the flow-matching loss, and the link-prediction score is its reconstruction error, without any parameter trained for link prediction. This is what we mean by zero-shot. We note that DG-Gen uses the same TGN encoder and keeps this link-prediction loss in its own training. We clarified this point in the implementation details.

(c) Could the authors clarify how are newly generated nodes assigned identities during inference? Specifically, Equation (7) assigns zero-inited embeddings to unseen nodes, while Equation (10) uses cosine similarity for identity matching. How are the first appearances of new nodes handled? Moreover, how are identities maintained across repeated appearances and in successive windows?

Equation (7) describes the TGN memory, where unseen nodes have a zero embedding. During training, DyGDi instead receives a random Gaussian embedding for each unseen node of the window (Eq. 12), which lets the model distinguish different unseen nodes.

At generation time, each generated node also receives a generated event class (Eq. 11), and identities are assigned as follows.

  • First appearance. When the model predicts the class "new", no matching is needed. A new node identifier is created, and it holds the embedding generated by DyGDi until all the nodes of the window are matched, after which it is replaced by its TGN memory state.
  • Repeated appearance in the same window. A node with the class "recall" is a new node already created earlier in the window. Its generated embedding is matched with Eq. (10) against the pool of the new nodes created in the window only.
  • Successive windows. Once a window is generated, the TGN memory is updated with its events, so every new node now has its own memory state and becomes a seen node. In the next windows, it is matched with Eq. (10) against the pool of seen nodes, like any other node of the graph.

See Section 3.2 "Generation Process" for further details on the matching process.

To further study first appearances and recalls of the created nodes, we added a synthetic dataset that precisely controls node appearance and reappearance, both within a window and in the next window (Section A.10 "Synthetic Dataset for Node Assignment"). DyGDi assigns every identity correctly in all generated windows, whereas DG-Gen matches more than half of the nodes it should create to an existing node instead.

Could the authors tightly and directly evaluate the benefit of joint event-window diffusion against an event-independent diffusion baseline, eg using the same encoder, model capacity, conditioning information, and computational budget insofar as possible?

We thank the reviewer for this suggestion, which we implemented in Section A.10.3 "Independent Event Generation with DyGDi". To keep the encoder, model capacity and conditioning strictly identical, we use the same trained DyGDi model. We generate LL windows from the same context, each from a different initial noise, and keep a single event from each of them, so that no kept event attends to another kept event, as in DG-Gen. We evaluate two variants, one keeping the first event of every window, and one keeping the ii-th event of the ii-th window so that each event retains its position.

In both cases, the independent generation fails, whereas the joint generation follows the rule exactly. The first variant collapses onto a single node. The second keeps the block structure and creates fresh nodes, but the events of a window no longer see each other, so they cannot agree on which new node carries which feature, and the order in which the new nodes are recalled falls to chance, whereas the joint generation recalls them in the right order in every window. This shows that the events of a window must attend to each other to perform precise conditioning, which the other methods do not do.

We thank the reviewer again for these questions, which substantially strengthened the paper. We hope that our answers and the new experiments address the reviewer's concerns, and we would be grateful if the reviewer would consider raising their score. We remain available for any further question.

Dear Reviewer 1CG2,

Thank you again for your careful review. As the discussion period ends tomorrow (AoE), we would like to check whether our response above addresses your concerns.

We would be glad to clarify any remaining point. If our answers resolve your concerns, we would be grateful if you would consider updating your assessment.

Thanks for the thorough rebuttal and additional experiments (and apologies for the delayed response). The controlled synthetic experiment and joint versus independent event-generation comparison largely address my primary concerns wrt further empirical justification of the proposed joint denoising formulation. Though extending such a comparison to real world data would further strengthen the claim, this, along with the several minor clarifications prompt me to raise my score.

Reviewer_dR5aOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies the problem of continuous-time dynamic graph (CTDG) generation. The authors propose DyGDi, a diffusion-based framework that jointly generates temporal events using historical graph representations. The model further introduces event-class information and random embeddings to handle newly appearing nodes.

Critical strengths

S1. The problem of generation for CTDG is important and worth exploring.

S2. The experiments demonstrate that the proposed method achieves better generation quality and higher efficiency compared with existing baselines.

Critical weaknesses

W1. The original DyGDi scoring function accesses the ground-truth edge features of candidate events, which are generally unavailable when predicting future links. This raises concerns about information leakage and comparison fairness, particularly given the substantial performance drop on MOOC after feature imputation. I suggest using the feature-imputed variant as the primary comparison and clarifying how edge features are assigned to negative candidates.

W2. All four evaluated datasets are small-scale bipartite interaction graphs, leaving the model's generalizability to larger and non-bipartite dynamic graphs unclear. I suggest the authors include larger-scale and non-bipartite datasets to further validate the generalizability of the proposed method.

W3. DyGDi relies on a frozen, pre-trained TGN encoder, but the experiments do not investigate how the choice of encoder affects generation quality. I suggest evaluating alternative temporal graph encoders, such as DyGFormer or CRAFT with appropriate adaptations, to assess the robustness and generalizability of the proposed framework.

Questions for authors

Q1. I am interested in how effectively the proposed mechanism handles new-node identities during graph generation. Although the authors provide related ablations, I suggest further evaluating whether the model can consistently match recurring new nodes and distinguish different new nodes.

Q2. The current ablation study cumulatively removes multiple components, making it difficult to assess their individual contributions. I would like to see independent ablations of the main components to better understand their respective effects on generation quality.

4 comments

We sincerely thank the reviewer for this thorough and insightful review. The reviewer pointed precisely at the questions that matter most for our method, and these remarks led to the main additions of the revision. We are glad that the reviewer finds the paper clear, the experiments comprehensive, and the method effective. We address each point below, and all the changes in the updated pdf are shown in red.

The original DyGDi scoring function accesses the ground-truth edge features of candidate events, which are generally unavailable when predicting future links. This raises concerns about information leakage and comparison fairness, particularly given the substantial performance drop on MOOC after feature imputation. I suggest using the feature-imputed variant as the primary comparison and clarifying how edge features are assigned to negative candidates.

We agree. We renamed the variant that scores with the ground-truth features to DyGDifeat\text{DyGDi}_\text{feat}, to make explicit which variant accesses them, and the feature-imputed variant DyGDiip\text{DyGDi}_\text{ip} never accesses the ground-truth features of the candidate event.

Regarding negative candidates, a negative event replaces only the destination node (and its event class) of the positive event, and keeps its edge features and Δt\Delta t. A positive event and its negatives therefore carry identical features, so the features cannot by themselves separate a positive from a negative. What DyGDifeat\text{DyGDi}_\text{feat} exploits is the compatibility between the features and the destination node, which is exactly the information that DyGDiip\text{DyGDi}_\text{ip} removes by imputing the features of every candidate, positive or negative, before scoring. The drop on MOOC thus shows that, on this dataset, the features are an important part of the discriminative signal.

All four evaluated datasets are small-scale bipartite interaction graphs, leaving the model's generalizability to larger and non-bipartite dynamic graphs unclear. I suggest the authors include larger-scale and non-bipartite datasets to further validate the generalizability of the proposed method.

We added four non-bipartite datasets from the DyGLib benchmark, Enron, UCI, SocialEvo, and Contacts. SocialEvo and Contacts are the largest datasets of the paper, with 2.1 million and 2.4 million events respectively. The findings on the smaller datasets carry over to these datasets.

  • Features. The gap widens, and DyGDi reduces the Wasserstein distance to the real features by more than an order of magnitude on both SocialEvo and Contacts, where most of the values generated by DG-Gen fall outside the range of the real feature.
  • Topology. DyGDi outperforms DG-Gen on 19 of the 32 topology comparisons (with 1 tie) and Tigger on 26 of 32 (with 1 tie). It leads on SocialEvo and Contacts, while DG-Gen obtains the best value on more metrics on UCI.
  • JL similarity. DyGDi obtains the best global JL similarity on all four new datasets, as on the four original ones, confirming the trend of the feature and topological metrics.

DyGDi relies on a frozen, pre-trained TGN encoder, but the experiments do not investigate how the choice of encoder affects generation quality. I suggest evaluating alternative temporal graph encoders, such as DyGFormer or CRAFT with appropriate adaptations, to assess the robustness and generalizability of the proposed framework.

We agree that this is an interesting direction. DyGDi needs a node-level embedding that does not depend on a query partner, both to tokenize an event and to match each generated embedding against every candidate node (Eq. 10). DyGFormer and CRAFT instead compute the representation of a node jointly with a candidate partner. Using them would require one encoder call per candidate node at each matching step, or a substantial adaptation to obtain pair-independent embeddings. Given the computation budget of the rebuttal period and the implementation this requires, we were not able to complete this study. We added it to the future work in "Limitations and Future Work", where we discuss the design space of the node encoder.

I am interested in how effectively the proposed mechanism handles new-node identities during graph generation. Although the authors provide related ablations, I suggest further evaluating whether the model can consistently match recurring new nodes and distinguish different new nodes.

We added a detailed experiment on a synthetic dataset, a test bed that allows fine control over the behaviour of the model (new Section A.10 "Synthetic Dataset for Node Assignment"). In each window, new nodes are created, then recalled later in the same window and in the next window, and random features fix the order in which they must reappear. The generated stream can thus be scored exactly on whether seen nodes, new nodes, and recalled new nodes are matched to the right identifier.

DyGDi follows the rule in every window, with high node and feature accuracies. It creates distinct fresh nodes, recalls them in the right order within the window and in the next window, and reads the order from the features rather than learning a fixed one. Tigger and DG-Gen struggle with this fine-grained conditioning, because they sample random walks or events independently.

The current ablation study cumulatively removes multiple components, making it difficult to assess their individual contributions. I would like to see independent ablations of the main components to better understand their respective effects on generation quality.

We agree that a cross ablation brings a better understanding. We added an independent ablation of the two components that identify the nodes of a window, the random Gaussian embedding ξ\xi and the event class c\mathbf{c}, on the synthetic dataset (Section A.10.4), where four models are trained with or without each component. The controlled test bed allows us to pinpoint the contribution of each component. The results show that each component is useful in isolation, and that only the full model follows the rule exactly. The event-class information lets the model know which events must create a node, and without it most new events reuse a node already in the stream. The Gaussian embedding gives distinct new nodes distinct targets, and without it the model swaps the two new nodes of a window in some windows. Without both, the generation collapses onto a single node per window. These results agree with the ablation on the real datasets, where removing both components triggers memory collapse on Wikipedia.

We thank the reviewer again for these constructive suggestions, which substantially strengthened the paper. We hope that our answers and the new experiments address the reviewer's concerns, and we would be grateful if the reviewer would consider raising their score. We remain available for any further question.

Dear Reviewer dR5a,

Thank you again for your detailed review. As the discussion period ends tomorrow (AoE), we would like to check whether our response above addresses your concerns.

We would be glad to clarify any remaining point. If our answers resolve your concerns, we would be grateful if you would consider updating your assessment.

Thank you for the detailed response and additional experiments. However, my concerns regarding the fairness of the link prediction evaluation and the dependence on the TGN encoder are not fully resolved. Therefore, I will maintain my original score.

Reviewer_R3RTOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduce the first diffusion-based continuous-time dynamic graph generation method, which generates windows of events at once. For solving the technical challenges during the generation process, including memory matching collapse and window matching collapse, the paper introduce a random Gaussian embedding and a time-related one-hot class vector, repectively. Extensive experiments show that this method achieves effective dynamic graph generation, and substantially faster training and generation than previous models. Moreover, the method can also used for link prediction without additional training.

Critical strengths
  1. Dynamic graph generation is an important problem and generating CTDGs rather than DTDG is an interesting idea.
Critical weaknesses
  1. The technical contribution is largely limited, which is the most serious problem in my opinion. The paper only use a random Gaussian embedding and a time-related one-hot class vector without any theoretical guidance, and it also does not explain why other methods do not work.
  2. Experimental results cannot show a stable performance improvement, which greatly reduces the credibility of the method. The method is not clearly stronger than the baselines on the metrics, and can even be weaker than the baseline, such as in Table 1, 2.
Questions for authors

Besides the Weaknesses, I also have two questions.

  1. Can you explain why DyGDi achieves zero-shot link prediction? It seems that DyGDi still needs topology input, which contains information about other link connections.
  2. Can you provide results of more baselines and datasets in the link prediction evaluation? The link prediction evaluation lacks dynamic graph link prediction baselines from the recent three years, and evaluating on only four datasets is not enough.
6 comments

We thank the reviewer for their time and for their feedback. We are glad that the reviewer finds that we tackle an important problem with a simple design. We address each concern below, and all the changes in the updated pdf are shown in red.

The technical contribution is largely limited, which is the most serious problem in my opinion. The paper only use a random Gaussian embedding and a time-related one-hot class vector without any theoretical guidance

We believe our technical contribution is significant. We bring a simple and principled solution to important open problems of the generative CTDG community.

  1. Previous generative models do not scale to datasets of the size we study, both in number of events and nodes [Tigger] and in number of features (see the scaling experiment in Section 5.3 "Scaling to More Features").
  2. Generation with previous models remains slow [Tigger, DG-Gen] (see Section 5.4 "Quality vs. Generation Efficiency").

The random Gaussian embedding and the event class are not ad hoc. They follow from the two failure modes that we identify and formalize in Section 3.2 (memory collapse and window collapse), and each component resolves one side of the matching score. The new synthetic experiment (Section A.10.4) now isolates each of them. Without the Gaussian embedding, the model swaps the new nodes of a window. Without the event class, new events reuse existing nodes. Without both, the generation collapses onto a single node per window.

We see the fact that a difficult problem of the field is solved by a simple solution as a strength of our method. Furthermore, to the best of our knowledge, this is the first diffusion-based generative model for inductive generation on CTDGs.

it also does not explain why other methods do not work.

We explain why Tigger does not perform well for inductive CTDG generation in Section 4 "Related Work", paragraph "Inductive dynamic graph generation" (lines 271 to 274). As its authors state, the inductive variant of Tigger depends on static-graph methodologies and must train a WGAN, which they report does not scale to larger graphs. In addition, its random walks are sampled independently, which prevents fine-grained conditioning on individual events.

The main issue of DG-Gen is that it is trained and samples batches of events, where each event of a batch is sampled independently of the others. This impairs temporal consistency. This is illustrated by our new experiment on a synthetic dataset (Section A.10 "Synthetic Dataset for Node Assignment"), where DG-Gen and Tigger fail to reference the right nodes in a simple conditioning task, whereas DyGDi follows the rule in every window. Section A.10.3 further shows that DyGDi itself loses this ability when the events of a window are generated independently, which identifies independent event sampling as the cause.

Experimental results cannot show a stable performance improvement, which greatly reduces the credibility of the method. The method is not clearly stronger than the baselines on the metrics, and can even be weaker than the baseline, such as in Table 1, 2.

Several reviewers (dR5a, 1CG2, 9tVz) highlighted the performance improvement of our model. We believe that our results show both stable and stronger performance than the baselines.

  • Table 1. DyGDi already won 5 of the 6 feature comparisons. We updated Table 1 with four new datasets and the per-feature (1D) JS distance. DyGDi now wins 13 of the 14 comparisons. The only exception is the Wasserstein distance on MOOC, where DyGDi stays close to DG-Gen, whereas DyGDi reduces the Wasserstein distance by more than an order of magnitude on SocialEvo and Contacts.
  • Table 2. DyGDi outperforms DG-Gen on 36 of the 64 dataset–metric topology comparisons (with 5 ties), and Tigger on 54 of 64 (with 1 tie), and otherwise stays within the scale of the real-data statistics. Since we report 8 topology metrics on 8 datasets against two baselines, no model can be best on every cell, and we report all of them without selection. These metrics compare each generated window to the corresponding real window rather than comparing distributions, so differences that stay within the scale of the real statistic can be read as a noisy signal.
  • JL similarity. The Johnson–Lindenstrauss (JL) similarity embeds topology, features and time jointly over the whole stream, and DyGDi obtains the best JL similarity on all eight datasets. We consider this an important indicator that the gains of DyGDi on individual metrics compose into a realistic stream of events.

Can you explain why DyGDi achieves zero-shot link prediction? It seems that DyGDi still needs topology input, which contains information about other link connections.

The link prediction is zero-shot in the sense that DyGDi is never trained or fine-tuned for link prediction. The diffusion loss contains no link-prediction term and no parameter is added. The score is the reconstruction error of a candidate event after a forward diffusion step (Eq. 13). Like every temporal link predictor (and DG-Gen), DyGDi conditions on the past events of the graph, which is the information the task is defined on.

The reviewer is right that DyGDi denoises a whole window of LL events at once, so in the original protocol an event in the window can see the later events of its window. We therefore added an experiment in Section A.7.2 "Number of Scored Events per Window", where only the last ll events of each window are replaced by negatives and scored. With l=1l=1, the scored event has no later event in its window, so there is no leakage of future events. The AP stays stable down to l=1l=1 on Reddit and Wikipedia, and for DyGDifeat\text{DyGDi}_\text{feat} on MOOC, showing that DyGDi performs link prediction without information about future events. On MOOC, DyGDiip\text{DyGDi}_\text{ip} keeps its historical and inductive AP down to l=8l=8, while its random-sampling AP decreases as ll shrinks. On LastFM, the random-sampling AP also decreases as ll shrinks, so against random negatives part of the AP comes from scoring a window of negatives jointly. Its historical and inductive AP stays stable for every ll, so the ranking of hard negatives does not rely on future events. This also shows the flexibility of the framework, which can condition on the future as well when it is available, unlike purely autoregressive models.

Can you provide results of more baselines and datasets in the link prediction evaluation? The link prediction evaluation lacks dynamic graph link prediction baselines from the recent three years, and evaluating on only four datasets is not enough.

We added six recent link-prediction baselines, FreeDyG (2024), TPNet (2024), DyGMamba (2025), DyG-Mamba (2025), TAWRMAC (2026), and DSRD (2026). With these baselines, DyGDifeat\text{DyGDi}_\text{feat} still ranks first on Reddit and Wikipedia under the historical and inductive samplers, and on MOOC only the recent DSRD leads. We also added four non-bipartite datasets, Enron, UCI, SocialEvo, and Contacts, to the generation benchmark, where SocialEvo and Contacts are the largest datasets of the paper with more than 2 million events each.

We would like to stress that we use the link-prediction task to highlight the flexibility of the diffusion model. DyGDi is first a generative model, which is why the link-prediction results are in the appendix, and on generation the gains of DyGDi carry over to the new datasets (Tables 1 and 2). We also added a paragraph on future work for link prediction in "Limitations and Future Work".

We hope that these answers and the additional experiments address the reviewer's concerns. If so, we would be grateful if the reviewer would consider raising their score, and we remain available for any further question.

Thank you for the rebuttal. Two concerns remain. I will raise my score if both are fully addressed.

  1. I understand the advantages you claim for the random Gaussian embedding and the event class. I am still unsure why such a simple design is sufficient to solve the problem. Could later methods do better? Can you theoretically prove that the random Gaussian embedding and the event class are sufficient?

  2. The new experiments do not resolve my concern about a stable performance improvement. You write that “differences that stay within the scale of the real statistic can be read as a noisy signal.” Does this mean the metric gains cannot clearly exceed the variation caused by noise? Can you use a statistical significance test to show that the improvement is significant?

Comments on the paper

4 comments
AuthorsOpenReview ↗

Thank you for your reviews

We thank the reviewers for carefully reading our paper and for their constructive feedback, which helped us improve the manuscript.

We are pleased that the reviewers find that we tackle an important and under-explored problem for generative CTDGs (R3RT, dR5a, 9tVz). The reviewers acknowledge the simple design of the method (R3RT, 9tVz) and its effectiveness (dR5a, 1CG2, 9tVz), with improvements in generation quality, scaling and speed. We particularly appreciate the recognition of the clarity of the manuscript (dR5a, 9tVz) and of the comprehensive experiments (dR5a, 1CG2, 9tVz).

Main contribution. To the best of our knowledge, DyGDi is the first diffusion-based generative model for inductive CTDG generation. It casts generation as the joint denoising of a window of event tokens, and solves the node-identity problem this raises (memory collapse and window collapse) with two simple components, a random Gaussian embedding and an event class. Previous generators do not scale in number of events, nodes and features, and remain slow. DyGDi scales to graphs with millions of events and hundreds of features, obtains the best JL similarity on all eight datasets, and generates up to 175×175\times faster than DG-Gen. We see a simple solution to a difficult open problem of the field as a strength of the method.

Link prediction. Link prediction was a concern of several reviewers (R3RT, dR5a, 1CG2). We stress that DyGDi is first a generative model, and that its main results are the generation benchmarks of Section 5. We use link prediction to illustrate the conditioning flexibility of diffusion, since the same trained model scores candidate events zero-shot, without any loss or parameter for this task. This is why these results are in the appendix. We nevertheless addressed each concern on this task.

We have addressed the reviewers' comments through additional experiments on four new datasets, a new controlled synthetic benchmark, a direct comparison of joint and independent event generation, a cross ablation, six recent link-prediction baselines, a study of future-event leakage in link prediction, and several clarifications. All the changes in the updated pdf are shown in red. Specifically, we made the following changes.

1. Four new, larger and non-bipartite datasets (R3RT, dR5a, 9tVz). We added Enron, UCI, SocialEvo and Contacts from the DyGLib benchmark to the generation experiments (Tables 1, 2 and 5, Section A.8). SocialEvo and Contacts, with 2.1 and 2.4 million events, are the largest datasets of the paper. The conclusions carry over to these datasets. DyGDi reduces the Wasserstein distance of the features by more than an order of magnitude on SocialEvo and Contacts, and obtains the best JL similarity on all eight datasets.

2. Per-feature JS distance (R3RT). Table 1 now also reports the per-feature (1D) JS distance. Over the five datasets with features, DyGDi wins 13 of the 14 feature comparisons.

3. Synthetic dataset for node assignment (R3RT, dR5a, 1CG2, 9tVz). The new Section A.10 introduces a deterministic test bed, where new nodes are created in each window and recalled later in the same window and in the next window, in an order fixed by random features. It scores exactly whether seen nodes, new nodes and recalled nodes receive the right identity. DyGDi follows the rule in every generated window, whereas Tigger and DG-Gen fail, since they sample random walks or events independently (Section A.10.2).

4. Joint versus independent event generation (1CG2, R3RT, 9tVz). Section A.10.3 compares the joint denoising of a window with an event-independent generation that uses the same trained DyGDi model, hence the same encoder, capacity and conditioning. Independently generated events cannot perform the precise conditioning of the task, and the order accuracy falls to chance, which directly supports the joint event-window design.

5. Cross ablation of the node-identity components (dR5a, R3RT, 9tVz). Section A.10.4 ablates the random Gaussian embedding and the event class independently. Each component is necessary, and only the full model follows the rule. Without the Gaussian embedding, the new nodes of a window are swapped. Without the event class, new events reuse existing nodes. Without both, the generation collapses onto a single node per window.

6. Link prediction (R3RT, dR5a, 1CG2).

  • We added six recent baselines, FreeDyG, TPNet, DyGMamba, DyG-Mamba, TAWRMAC and DSRD.
  • We renamed the variant scoring with the ground-truth features DyGDifeat\text{DyGDi}_\text{feat}, to make explicit which variant accesses them, as opposed to the feature-imputed variant DyGDiip\text{DyGDi}_\text{ip}.
  • A new study scores only the last ll events of each window, so that with l=1l=1 no future event leaks into the score. The AP stays stable on Reddit and Wikipedia, and under historical and inductive sampling on all datasets down to a few scored events per window, so the ranking of hard negatives does not rely on future events. Against random negatives on MOOC and LastFM, part of the AP comes from scoring a window of negatives jointly (Section A.7.2).

7. Clarifications (1CG2, 9tVz). We clarified the pretraining objective of the frozen TGN encoder (Section A.2), and we detail in our answers how node identities are assigned at their first appearance, within a window and across successive windows.

8. Limitations and future work (R3RT, dR5a, 1CG2). We extended this section with the design space of the node encoder (dR5a) and with future work on link prediction with diffusion-based generative models.

We hope that these revisions address the reviewers' concerns, and we remain available for any further question during the discussion period.

AuthorsOpenReview ↗

Second revision

Following the new questions of Reviewers R3RT and 9tVz, we updated the pdf a second time. The second-round changes are shown in blue, and those of the first revision remain in red.

1. Sufficiency of the event class and the random Gaussian embedding (R3RT, 9tVz, and related to the questions of dR5a and 1CG2 on node identities). The new Section A.11 gives formal guarantees for the node-identity mechanisms.

  • Within a window (Proposition 1). When the memory keys of the seen nodes are distinct, the node matching recovers almost surely every seen node and every repeated new node of a window, and this recovery is stable under small errors of the generated tokens. Each decoded window therefore converges to the real one whenever the generated token windows converge to the real ones.
  • Across windows (Corollary 1). The memory is updated from the generated events alone, so the nodes created in a window keep their identity in the following windows. If each generated window is within total-variation distance ε\varepsilon of the real one, the generated stream of KK windows is within KεK\varepsilon of the real stream, up to a renaming of the new nodes. An exact generator thus yields the real stream.
  • Necessity of each component. Without the Gaussian embedding, distinct new nodes become indistinguishable (window collapse), and without the event class, new nodes are matched to seen nodes (memory collapse), in agreement with the synthetic ablation of Section A.10.4.

2. Statistical significance of the improvements (R3RT). One-sided Wilcoxon signed-rank tests on Tables 1 and 2 show that the improvements of DyGDi over DG-Gen and Tigger are significant at the 5% level on the JL similarity, the feature metrics and the topology metrics.

AuthorsOpenReview ↗

Third revision

3. Distribution distances on the topology metrics (R3RT). The new Section A.12 compares, for every topology metric, the distribution of the per-window values of the generated stream with that of the real stream, using the Wasserstein distance and the KS statistic, for all models and window sizes (Tables 28 to 31). Unlike the median error of Tables 2, 21 and 22, these distances do not pair the generated and real windows by position, so they are not biased by the natural variability of a single real stream. With them, the advantage of DyGDi over DG-Gen on topology becomes clearer, and it is significant under the one-sided Wilcoxon signed-rank test.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.