Generative Dynamic Graph Model (GDGM)

• Generative Dynamic Graph Model (GDGM) is a family of probabilistic frameworks modeling evolving graph structures through stochastic, event-based generative mechanisms.
• It leverages diverse architectural motifs such as encoder-decoder separation, dynamic memory, and latent state evolution to capture temporal dynamics.
• Applications include continuous-time edge generation, dynamic community modeling, and anomaly detection, demonstrating robust predictive performance.

Generative Dynamic Graph Model (GDGM) denotes a class of generative frameworks in which graph structure, graph evolution, graph-conditioned latent dynamics, or graph-mediated outputs are modeled as stochastic processes rather than as fixed static objects. Across the cited literature, the term covers continuous-time temporal edge generation, sequential growth of attributed graphs, motif-driven temporal network synthesis, dynamic community models for brain graphs, diffusion models in block graph space, graph-conditioned latent ODE systems for anomaly detection, and dynamic expansion architectures for lifelong generative modeling. This breadth suggests that GDGM is better understood as a family of probabilistic design patterns than as a single canonical model class (Hosseini et al., 2024, Xiang et al., 7 Oct 2025, Xu et al., 2019, Zeno et al., 2023, Su et al., 20 Aug 2025, Ye et al., 2022).

1. Scope and representative formulations

The GDGM literature spans several distinct notions of “dynamic.” In some works, the graph itself evolves over time through node or edge events. In others, a dynamic graph is an internal computational object whose node features, edges, or edge weights are iteratively updated during generation. A further strand uses a generative graph prior to define the transition structure of an external dynamical system. The common element is that graph structure is not treated as static metadata: it participates directly in the generative mechanism.

Model	Dynamic object	Core mechanism
DGGN (Kim et al., 2017)	Relational graph from diagrams	GRU with dynamic adjacency tensor memory
SEDGE (Papoudakis et al., 2017)	Series of sparse digraphs	Preferential attachment with new-vs-all endpoint mixing
G-GCN (Xu et al., 2019)	Growing attributed graph	Sequential VAE with adaptive conditional prior
D2G2 (Zhang et al., 2020)	Dynamic graph sequence	Factorized VAE with static/dynamic and node/edge latents
GGP-GLDS (Kalantari et al., 2020)	Sparse random graph for LDS transitions	Graph gamma process with logical OR over community adjacencies
DBGDGM (Campbell et al., 2023)	Dynamic brain graphs	Time-evolving node/community embeddings with mixture-of-communities edge decoder
DYMOND (Zeno et al., 2023)	Temporal motif network	Exponential motif inter-arrivals and node-role sampling
DG-Gen (Hosseini et al., 2024)	Continuous-time dynamic graph	Autoregressive factorization over $(src,dst,t,e)$
SBGD (Su et al., 20 Aug 2025)	Diffusion graph generator	Block-space denoising with inter-block reconstruction
GDGM for spoofing (Xiang et al., 7 Oct 2025)	Dynamic trading-behavior graph	Neural ODE + GRU + pseudo-labeling + heterogeneous attention
DEGM (Ye et al., 2022)	Lifelong graph of generative components	Dynamic expansion with basic and specific nodes
3D part assembly (Huang et al., 2020)	Dynamic part-relation graph	Iterative GNN with dynamic relation reasoning

Chronologically, early work emphasized diagram-derived relation graphs and sparse evolving digraphs, then shifted toward sequential variational models for growing graphs, factorized latent-variable models, nonparametric Bayesian graph priors for dynamical systems, motif-based temporal generation, and, more recently, continuous-time autoregressive generators and diffusion in stochastic block space (Kim et al., 2017, Papoudakis et al., 2017, Xu et al., 2019, Zhang et al., 2020, Kalantari et al., 2020, Zeno et al., 2023, Hosseini et al., 2024, Su et al., 20 Aug 2025).

2. Probabilistic structure

A central GDGM theme is explicit factorization of the generative process. In continuous-time dynamic graph generation, DG-Gen models temporal interactions directly as a joint probability over event attributes rather than via snapshots:

$$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$

with

$$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$

This yields interpretable source selection, destination selection, inter-event time generation, and autoregressive feature generation (Hosseini et al., 2024).

Sequential growth models use a different decomposition. G-GCN treats graph expansion as a sequence of node-addition transitions indexed by an ordering $\pi$, and optimizes a variational lower bound with a graph reconstruction term and an adaptive Kullback-Leibler divergence regularization term. Its encoder consumes a candidate adjacency $\tilde A$ and attributes $X$, while the decoder reconstructs the previously observed adjacency. The conditional prior is adaptive: previously observed nodes use an encoder-informed prior, whereas the new node uses $\mathcal{N}(0,I)$ (Xu et al., 2019).

Factorized latent-variable GDGMs separate static and dynamic, and node and edge, factors. D2G2 posits a time-invariant latent $f$, edge-exclusive time-varying latent $z_t$, node-exclusive time-varying latent $z'_t$, and joint node-edge latent $$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$0, with

$$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$1

and

$$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$2

This explicitly enforces conditional independence between edge generation and node-exclusive dynamics, and between node generation and edge-exclusive dynamics (Zhang et al., 2020).

Dynamic community models replace direct edge factorization with latent assignment mechanisms. DBGDGM introduces a latent categorical assignment $$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$3 for each edge and factorizes target selection through source-to-community and community-to-target probabilities:

$$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$4

Time dependence enters through Gaussian Markov chains over node embeddings $$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$5 and community embeddings $$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$6 (Campbell et al., 2023).

Motif-centric GDGMs elevate higher-order structures to first-class generative objects. DYMOND assigns each triplet $$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$7 a motif type, estimates motif-type proportions

$$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$8

samples motif inter-arrival times from Exponential distributions, and places edges as a consequence of motif instances and sampled node roles (Zeno et al., 2023).

Nonparametric Bayesian constructions take the graph itself to be a latent prior over dynamical systems. In GGP-GLDS, community-specific adjacency matrices satisfy

$$p(src, dst, t, e) = p(src)\, p(dst|src)\, p(t, e|dst, src),$$9

and the overall adjacency is the logical OR

$$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$0

The resulting mask $$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$1 defines the sparsity pattern of the latent transition matrix $$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$2 in a linear or generalized linear dynamical system (Kalantari et al., 2020).

Not all works use “generative” to mean explicit likelihood-based generation. In the conspiracy spoofing framework, the generative dynamic latent space is realized through Neural ODE evolution and GRU updates, but the paper states that it “does not introduce an explicit probabilistic likelihood $$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$3 or a variational ELBO,” and trains discriminatively with cross-entropy (Xiang et al., 7 Oct 2025). This suggests that, within the literature, GDGM can denote either a fully probabilistic generator or a representation-learning model whose latent dynamics are generated continuously in time.

3. Architectural motifs

Despite their probabilistic diversity, GDGMs repeatedly reuse a small set of architectural motifs: encoder-decoder separation, dynamic memory, iterative message passing, latent state evolution, and modular graph decomposition.

DG-Gen uses a Temporal Graph Network encoder with a memory module and a transformer-based convolutional embedding module. Its decoder is a deep probabilistic estimator with separate modules for source scoring, pairwise interaction scoring, latent-state initialization, and sequential time-and-feature emission. The exact module forms are

$$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$4

$$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$5

$$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$6

A GRU-based Time+MSG module then outputs an inter-event time parameter and feature parameters (Hosseini et al., 2024).

The 3D part assembly model uses an iterative GNN backbone with $$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$7 iterations on a self-looped directed, fully connected graph. Its Dynamic Relation Reasoning Module predicts directional scalar relation weights

$$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$8

and its Dynamic Part Aggregation Module alternates between dense and sparse node sets by pooling geometrically-equivalent parts. This dynamic alternation is central to its coarse-to-fine assembly process (Huang et al., 2020).

DGGN introduces a dynamic adjacency tensor memory $$p(t, e|dst, src) = p(t |dst, src) \, p(e_1 |t, dst, src) \ldots p(e_n |e_{n-1}, \ldots, e_1, t, dst, src).$$9 whose first channel stores edge probabilities and whose remaining channels store pairwise hidden states. For candidate edge $\pi$0, retrieval is

$\pi$1

followed by a GRU update and memory write-back $\pi$2 (Kim et al., 2017).

The spoofing-detection GDGM combines continuous-time latent evolution with heterogeneous graph aggregation. A Neural ODE advances the hidden state between irregular timestamps, a GRU injects event observations at timestamp arrivals, BWGNN-based pseudo-label generation expands supervision, and a two-level heterogeneous attention module performs relation-specific intra-attention and relation/group-level inter-attention before MLP classification (Xiang et al., 7 Oct 2025).

Diffusion-based GDGMs replace autoregression with iterative denoising. SBGD first partitions a graph into disjoint blocks, diffuses block adjacencies and features independently, denoises them with graph transformers, then predicts sparse inter-block interactions with a separate network. The graph is represented as $\pi$3, with dense intra-block structure on the diagonal and sparse inter-block structure off-diagonal (Su et al., 20 Aug 2025).

DBGDGM and DEGM illustrate two further motifs. DBGDGM uses GRU-parameterized variational posteriors over evolving node and community embeddings, while DEGM constructs a dynamically expanding graph of generative components in which “basic nodes” handle dissimilar tasks and “specific nodes” reuse sub-encoders and sub-decoders from selected parents via mixture weights $\pi$4 (Campbell et al., 2023, Ye et al., 2022).

4. Learning, inference, and generation

Training objectives in GDGMs depend strongly on how stochasticity is introduced. Likelihood-based temporal edge generators typically optimize negative log-likelihood. DG-Gen minimizes

$\pi$5

uses Adam, mini-batching over interactions, candidate subset sampling for source and destination softmaxes, encoder memory updates after each batch, and Gaussian noise annealing on numerical features for stability (Hosseini et al., 2024).

Sequential VAE models optimize ELBO variants. G-GCN sums per-step lower bounds over graph-growth transitions and adds adaptive KL regularization to prevent overfitting when multiple new nodes are added in batch. DEGM generalizes this pattern to lifelong learning: basic nodes are trained with ELBO or IWELBO, while specific nodes are trained with the Mixture ELBO (MELBO),

$\pi$6

with expansion triggered by thresholded ELBO-score differences across existing basic nodes (Xu et al., 2019, Ye et al., 2022).

Some GDGMs rely on amortized variational inference with structured posteriors, while others use MCMC. DBGDGM employs Gaussian reparameterization for subject, node, and community embeddings, Gumbel-Softmax for discrete edge assignments, and Adam on the negative ELBO (Campbell et al., 2023). By contrast, GGP-GLDS uses a Gibbs sampler with Polya-Gamma augmentation for negative binomial observations, truncated Poisson and multinomial splitting for community edge counts, conjugate Gamma and Gaussian updates for latent factors, and CRT augmentation for hierarchy parameters (Kalantari et al., 2020).

Method-of-moments estimation appears in motif models. DYMOND does not optimize an explicit likelihood; it estimates node-arrival rate, motif-type proportions, motif inter-arrival rates, and role probabilities directly from motif counts and weighted edge-sharing statistics, then samples dynamic graphs by repeatedly sampling active nodes, motifs, motif timesteps, node roles, and induced edges (Zeno et al., 2023).

Generation procedures are equally heterogeneous. DG-Gen generates synthetic CTDGs event by event: sample $\pi$7, then $\pi$8, then an Exponential inter-event time, then edge features autoregressively, commit the sampled interaction, update encoder memories, recompute temporal embeddings, and repeat until a target interaction count or time horizon is reached (Hosseini et al., 2024). SBGD instead initializes noisy block graphs, denoises block adjacencies and features over $\pi$9 diffusion steps, predicts inter-block matrices after $\tilde A$0, and assembles the full adjacency from block-diagonal and off-diagonal parts (Su et al., 20 Aug 2025).

5. Evaluation regimes and empirical evidence

GDGMs are evaluated on markedly different downstream criteria, reflecting the breadth of the family. Continuous-time dynamic graph generators are usually assessed by fidelity and prediction. DG-Gen reports feature fidelity via Jensen–Shannon distances between real and synthetic feature histograms and joint histograms, topology fidelity via median absolute errors on closeness centrality, mean degree, number of components, power-law exponent, and wedge count, and originality via edge overlap. The reported edge overlap with source graphs was empirically zero for both DG-Gen and TIGGER-I, and DG-Gen outperforms or matches Jodie, DyRep, TGAT, TGN, and CAWN on Average Precision for link prediction across four out of five datasets (Hosseini et al., 2024).

Growing-graph and dynamic-graph VAE models are typically judged by link prediction. G-GCN reports AUC/AP of 83.30/85.03 on Cora, 89.54/91.30 on Citeseer, and 87.49/87.24 on Pubmed for isolated new nodes, outperforming GCN-VAE and MLP-VAE; on observed graph nodes it reports 94.07/95.15 on Cora, 94.62/95.93 on Citeseer, and 96.96/97.27 on Pubmed (Xu et al., 2019). DBGDGM evaluates reconstruction with NLL and node-degree MSE, dynamic link prediction with AUROC and average precision, and graph classification with SVMs over averaged community embeddings; it reports reconstruction NLL 4.587 ± 0.045 on HCP and 4.586 ± 0.084 on UKB, and dynamic link prediction AUROC/AP of 0.768 ± 0.026/0.732 ± 0.032 on HCP and 0.786 ± 0.040/0.762 ± 0.038 on UKB (Campbell et al., 2023).

Models whose dynamic graphs are internal to a conditional generation task use task-specific metrics. In 3D part assembly, the full algorithm reports on Tables a Shape CD of 0.0050, Part Accuracy of 49.51, and Connectivity Accuracy of 39.96, outperforming progressively weaker ablations and three trained baselines under identical losses (Huang et al., 2020). DGGN reports mAP 44.08 on AI2D, versus 39.28 for a vanilla GRU baseline and 8.87 for a fully connected baseline, along with IoU_edge 25.86 versus 15.58 for vanilla GRU (Kim et al., 2017).

Motif-centric and sparse-digraph generators emphasize temporal structure and degree statistics. DYMOND is evaluated with KS statistics over time-varying graph metrics and node-aligned 2D KS tests on temporal IQR summaries; its structure MRR is 1.00 on EU Emails and 0.90 on CollegeMsg, and its node-behavior MRR reaches 0.93 on Enron and 0.85 on Facebook, exceeding edge-centric baselines on many datasets (Zeno et al., 2023). SDG and SEDGE use KS and MSD on in-degree and out-degree distributions, with experiments on software graphs showing SDG surpassing GDGNC and the Bollobás model on many static benchmarks and SEDGE remaining competitive on new-node evolution across version pairs (Papoudakis et al., 2017).

Detection-oriented GDGMs use supervised metrics and deployment studies. The spoofing-detection GDGM reports AUC 0.9029, Accuracy 0.8701, F1 0.8002, Precision 0.8508, and Recall 0.7702 offline, outperforming RTG-Trans and other baselines, and reports in the first 4 weeks of online deployment AUC 0.8614, ACC 0.8152, F1 0.6887, Precision 0.7624, and Recall 0.5623 (Xiang et al., 7 Oct 2025).

Diffusion-based GDGMs emphasize scalability and size generalization in addition to fidelity. SBGD reports up to $\tilde A$1 memory reduction relative to state-of-the-art diffusion baselines, and on OGBN-Products it is the only method that trains successfully while all baselines run OOM (Su et al., 20 Aug 2025). DEGM, although not a temporal graph generator in the usual sense, reports strong lifelong generative performance; on COFMI, DEGM-IWELBO-50 achieves average NLL −163.27, compared with −172.10 for IWELBO-GR-50 and −184.32 for LIMix (Ye et al., 2022).

6. Limitations, misconceptions, and open directions

A recurrent misconception is that GDGM denotes a single model family with a fixed probabilistic meaning. The literature shows otherwise. Some models are explicit likelihood-based generators; some are discriminative systems with generative latent dynamics; some generate graphs directly, whereas others generate outputs by reasoning over dynamically updated graphs. This suggests that GDGM is a unifying descriptor for graph-centric generative dynamics rather than a standardized architecture.

Several limitations recur across the literature. DG-Gen models inter-event times with an Exponential distribution, which imposes a memoryless gap assumption conditioned on current embeddings; the paper explicitly notes that richer time models may be needed when fine-grained hazard functions or self-exciting processes are essential (Hosseini et al., 2024). DYMOND is restricted to 3-node motifs, assumes motifs do not transform across types over time, and uses memoryless exponential inter-arrivals (Zeno et al., 2023). SBGD depends on block or community structure and uses Gaussian noise on adjacency as a continuous surrogate for discrete edges; graphs without discernible blocks may not benefit from block-space diffusion (Su et al., 20 Aug 2025). D2G2 assumes a fixed maximum number of nodes $\tilde A$2, so births and deaths are not part of the original experiments (Zhang et al., 2020).

Domain-specific models also exhibit domain-specific failure modes. The 3D part assembly model lacks hard physical and joint constraints, so floating or misaligned parts can occur (Huang et al., 2020). The spoofing-detection GDGM states that its “generative” latent dynamics are deterministic and that no explicit uncertainty modeling such as an ELBO is included in training (Xiang et al., 7 Oct 2025). DBGDGM fixes the number of communities $\tilde A$3, uses first-order Gaussian Markov dynamics, and models thresholded unweighted undirected graphs rather than weighted connectivity (Campbell et al., 2023). SEDGE focuses on additions of nodes and edges; deletions are mentioned in the real data domain but are not part of the provided algorithm (Papoudakis et al., 2017).

Open directions are correspondingly diverse. The cited works suggest richer temporal models for continuous-time event generation, more expressive but still stable decoders for growing graphs, larger-motif or non-memoryless temporal processes, physics-aware constraints for graph-guided assembly, better block-granularity selection for diffusion models, nonparametric community counts in dynamic brain graphs, and stronger uncertainty modeling in ODE-based dynamic latent spaces (Hosseini et al., 2024, Xu et al., 2019, Zeno et al., 2023, Su et al., 20 Aug 2025, Campbell et al., 2023, Xiang et al., 7 Oct 2025). A plausible implication is that future GDGMs will continue to hybridize probabilistic generative modeling with graph neural operators, continuous-time state evolution, and modular structural priors rather than converging on a single dominant formalism.