ETDNet: Edge-Type Decoupling in Temporal Graphs

• ETDNet is a temporal-graph neural architecture that decouples intra-time-step and inter-time-step edges to preserve distinct structural and temporal semantics.
• It constructs a full-history graph where nodes represent entity occurrences and separate edge types capture local context and temporal propagation.
• Empirical results on Waymo and Elliptic++ demonstrate that dedicated attention modules for structure and time yield improved prediction accuracy.

Searching arXiv for the ETDNet paper and closely related context papers mentioned in the provided data. arXiv Search Query: "Full-History Graphs with Edge-Type Decoupled Networks for Temporal Reasoning" Edge-Type Decoupled Network (ETDNet) is a temporal-graph neural architecture introduced alongside the full-history graph (FHG) representation for reasoning over evolving relational data in which prediction depends jointly on who interacts with whom and how those interactions unfold over time. Its motivating applications are driver-intention prediction in traffic and fraud detection in Bitcoin transaction networks. The defining premise is that temporal graphs should not be handled merely as a sequence of snapshots, because same-time interactions and cross-time continuity encode different semantics. ETDNet therefore operates on a single graph containing the entire observed history, and processes two disjoint edge families with separate modules: intra-time-step edges for structural context and inter-time-step edges for temporal propagation (Mohammed et al., 5 Aug 2025).

1. Conceptual basis and problem setting

ETDNet is designed for temporal reasoning on evolving relational data where plain sequence models are inadequate because each entity’s trajectory is influenced by other entities, while many temporal graph methods remain constrained by a sequence of snapshots. In a typical snapshot pipeline, one runs a GNN separately at each time step and then feeds snapshot embeddings into an RNN or Transformer. The ETDNet paper argues that this is limiting for two stated reasons: aggregating events into snapshots can blur fine-grained ordering and long-range temporal signals, and distant temporal dependencies may require many stacked graph or temporal layers, aggravating over-smoothing and over-squashing (Mohammed et al., 5 Aug 2025).

A second motivation is semantic heterogeneity. ETDNet treats instantaneous relational structure and temporal continuity as fundamentally different categories of edges. Same-time interactions encode local relational context, such as nearby vehicles or contemporaneous transaction flow. Cross-time edges encode persistence, causality, or propagation. The architecture’s central claim is therefore not merely that edges matter, but that different edge semantics should not be forced through the same message function.

A common misconception is to conflate ETDNet with the full-history graph itself. The paper distinguishes them explicitly. The full-history graph is the graph construction that internalizes time into topology, whereas ETDNet is the neural encoder that learns on that graph. The representation and the network are separate contributions, although the paper’s empirical argument is that they are most effective when aligned.

2. Full-history graph formulation

The full-history graph unfolds the entire observation window into a single graph. Time is defined on a discrete set

$T=\{0,1,\dots,\tau_{\max}\}.$

Entities are partitioned into dynamic entities $U$ and static entities $S$. For each dynamic entity $u\in U$ and each time step $t\in T_u\subseteq T$ where it exists, the graph contains a node $u^t$ with feature vector

$\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$

Each static entity $s\in S$ is represented once with feature $\mathbf{x}_s$. The intended node set is

$$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$

The graph contains two disjoint edge families. Intra-time-step edges

$U$0

connect entities coexisting in the same time step. Inter-time-step edges

$U$1

connect temporally successive events. The canonical case is a self-link $U$2, but the paper explicitly generalizes temporal edges to cross-entity hand-offs such as $U$3. The resulting graph is

$U$4

This construction internalizes time into graph topology itself. Paths along $U$5 are acyclic and ordered forward in time, while $U$6 remains local to a time step and may contain cycles. A plausible implication is that temporal causality becomes explicit at the graph level rather than being imposed only by recurrent or Transformer-style ordering outside the graph.

Element	Formal definition	Semantics
Dynamic node	$U$7	Entity occurrence at time $U$8
Static node	$U$9	Time-invariant context
Intra-time-step edge	$S$0	Same-frame structure
Inter-time-step edge	$S$1	Temporal continuity or propagation

The distinction between self-temporal edges and cross-entity temporal hand-offs is especially important. In traffic, $S$2 is used as a self-chain across frames. In Elliptic++, $S$3 connects a transaction to later transactions that spend its outputs. ETDNet is therefore not restricted to per-entity temporal traces; it can encode directed temporal flow between distinct entities.

3. Architecture and update mechanism

ETDNet stacks $S$4 identical layers. The initial embedding is

$S$5

At each layer, one branch performs structural aggregation over $S$6, another performs temporal aggregation over $S$7, and a fusion layer combines both messages with the previous embedding. The architecture is called edge-type decoupled because the two edge families are processed with separate modules and separate parameters rather than inside a single aggregation rule (Mohammed et al., 5 Aug 2025).

Component	Operates on	Function
Step Attention (SA)	$S$8	Structural aggregation within a time step
History Attention (HA)	$S$9	Temporal attention over reachable history
Fusion Layer (FL)	Previous state + SA + HA	Residual learned combination

Step Attention

For a dynamic node $u\in U$0, the intra-step neighborhood is

$u\in U$1

SA uses $u\in U$2 stacked sublayers, each with $u\in U$3 attention heads, so a single ETD layer can expand the same-timestep receptive field to $u\in U$4 hops. For head $u\in U$5 and sublayer $u\in U$6, the attention score is

$u\in U$7

with normalization

$u\in U$8

and head-specific message

$u\in U$9

After concatenating heads, SA applies output projection, residual addition, and LayerNorm:

$t\in T_u\subseteq T$0

After $t\in T_u\subseteq T$1 sublayers, the structural message is

$t\in T_u\subseteq T$2

The module is GAT-like in form, but its scope is restricted to the intra-time-step edge family $t\in T_u\subseteq T$3, and its internal $t\in T_u\subseteq T$4-stack is intended to capture richer same-frame structure before temporal fusion.

History Attention

For the current node $t\in T_u\subseteq T$5, HA attends over a bounded predecessor set

$t\in T_u\subseteq T$6

This is not limited to the same entity’s past when $t\in T_u\subseteq T$7 contains cross-entity temporal flow. The reachable predecessors are ordered by time and zero-padded to length $t\in T_u\subseteq T$8, forming a $t\in T_u\subseteq T$9 sequence tensor $u^t$0.

For each temporal head $u^t$1,

$u^t$2

followed by scaled dot-product attention

$u^t$3

The final temporal message is

$u^t$4

Causality is not enforced by an explicit Transformer mask. It is enforced structurally, because only predecessors with $u^t$5 are included in $u^t$6. This makes HA a local-window temporal self-attention over the node’s reachable history in $u^t$7, not a global all-node temporal attention.

Fusion Layer

The fusion layer combines the previous embedding, the structural message, and the temporal message:

$u^t$8

The paper describes this as a learned, concatenative, residual, nonlinear fusion. It is not a purely additive merge and not an explicit sigmoid gate, even though the prose refers informally to adaptive weighting.

A concise schematic summary given in the paper is

$u^t$9

This is schematic rather than the exact layerwise recurrence, but it captures the intended decomposition.

4. Optimization, implementation, and computational profile

ETDNet is trained in a supervised, task-dependent manner. On Waymo, the task is joint driver-intention classification with two outputs per dynamic node at the current frame: speed class and direction class. The loss is described as the sum of two cross-entropy losses, one for speed and one for direction. On Elliptic++, the task is binary node classification over transactions with unknown-labeled nodes masked out, and the optimization objective is described as masked binary cross-entropy. The algorithm section summarizes this as “dual-CE for traffic; masked-BCE for fraud” (Mohammed et al., 5 Aug 2025).

The paper states default hyperparameters

$\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$0

with dropout $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$1 after each fusion layer. Optimization uses Adam with learning rate $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$2, weight decay $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$3, batch size $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$4 for traffic and $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$5 for fraud, dropout $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$6, and early stopping on validation macro-F1 with patience $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$7. Unknown nodes in Elliptic++ remain in the graph but are excluded from the loss, which is important for transductive learning under partial labels.

The manuscript also contains an implementation inconsistency. In the sensitivity discussion, the authors state that they “therefore set $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$8, heads $\mathbf{x}_{u,t}\in\mathbb{R}^{d}.$9, $s\in S$0” for Waymo and similarly $s\in S$1, heads $s\in S$2, $s\in S$3 for Elliptic++. An earlier Waymo implementation paragraph instead states $s\in S$4, $s\in S$5, $s\in S$6, $s\in S$7. The discrepancy is explicit in the paper and should be noted in any reproduction.

The computational profile is described as sparse attention over $s\in S$8 and window-bounded attention over $s\in S$9, with time complexity

$\mathbf{x}_s$0

and memory complexity

$\mathbf{x}_s$1

per dynamic entity. The comparison table also contrasts ETDNet’s memory as

$\mathbf{x}_s$2

against memory-bank methods such as TGN with

$\mathbf{x}_s$3

Empirically, the paper reports $\mathbf{x}_s$4M parameters for ETDNet versus $\mathbf{x}_s$5M for TGN and $\mathbf{x}_s$6M for TGAT, and states that ETDNet is faster per epoch than those temporal baselines on both datasets.

5. Datasets, tasks, and empirical evidence

The paper evaluates ETDNet on two domains with markedly different temporal semantics: traffic maneuvers and financial transaction flow (Mohammed et al., 5 Aug 2025).

Waymo Open Motion Dataset

Scenes are sampled at $\mathbf{x}_s$7 Hz and last $\mathbf{x}_s$8 seconds. The first $\mathbf{x}_s$9 seconds ($$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$0 frames) are used as history, and the future $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$1 seconds are used to derive maneuver labels. Each scene becomes a full-history graph with about $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$2 nodes on average: $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$3 dynamic vehicle instances across time and $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$4 static lane elements. Intra-time-step edges number about $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$5k per frame and connect vehicle pairs within $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$6 meters plus vehicle-lane contacts. Temporal edges are self-chain links connecting each vehicle across consecutive frames. Node features are $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$7-dimensional, comprising $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$8 kinematic and $$\widetilde V = \{\,u^{t}\mid u\in U,\; t\in T_u\,\}\;\cup\; S.$$9 map-relative features. Labels use speed classes $U$00 and direction classes $U$01. Evaluation uses macro-F1 for speed and direction plus joint accuracy.

Elliptic++

The graph contains $U$02 monthly Bitcoin transaction snapshots. Each node is a transaction with $U$03 static features and labels licit, illicit, or unknown. The temporal split is months $U$04–$U$05 for training, $U$06–$U$07 for validation, and $U$08–$U$09 for test. The paper states that it builds “one full-history graph per month,” including all transactions up to and including the current month. A transaction appears once and is never deleted. Domain edges $U$10 connect each transaction bidirectionally to the $U$11 addresses that spend its outputs in that month. Temporal edges $U$12 connect a transaction $U$13 to every transaction $U$14 that spends an output of $U$15 in the following month. This dataset therefore uses cross-entity temporal edges rather than self-links. Metrics are ROC-AUC, AUPRC, and illicit-class F1, with the F1 threshold selected on the validation window.

Quantitative results

Dataset	ETDNet	Strongest baseline noted
Waymo	$U$16 speed F1, $U$17 direction F1, $U$18 joint accuracy	TGN: $U$19 joint accuracy
Elliptic++	$U$20 ROC-AUC, $U$21 AUPRC, $U$22 illicit F1	DyGFormer: $U$23 ROC-AUC; stronger than TGN on F1

On Waymo, the gain over the strongest baseline is $U$24 percentage points in joint accuracy, with gains of $U$25 and $U$26 points in speed and direction F1 respectively. On Elliptic++, the most pronounced improvements appear in class-imbalance-sensitive metrics: AUPRC rises from $U$27 to $U$28, and illicit F1 from $U$29 to $U$30. The abstract compares ETDNet to TGN at $U$31 F1, whereas the main table shows DyGFormer as slightly stronger than TGN on F1; in either case, the ETDNet result remains substantially higher.

Ablations and sensitivity

The ablations support the decoupled design. On Waymo, full ETDNet achieves $U$32 joint accuracy, compared with $U$33 for SA only, $U$34 for HA only, $U$35 for late fusion, and $U$36 when HA is replaced by mean pooling. On Elliptic++, full ETDNet achieves $U$37 illicit F1, compared with $U$38 for SA only, $U$39 for HA only, $U$40 for late fusion, and $U$41 for HA mean pool. These results indicate that both edge families matter, the temporal-attention mechanism matters beyond mean aggregation, and fusing after every layer is better than late fusion.

The paper does not include a standalone ablation directly comparing the full-history graph representation against a snapshot-graph representation under an otherwise identical architecture. It also states in discussion that “mixing all edges in a single kernel drops performance,” but there is no explicit all-edges-single-aggregator ablation table beyond branch-removal and late-fusion comparisons. This absence is important when interpreting what has been demonstrated directly.

Sensitivity analyses indicate relative robustness to the number of layers, attention heads, and history length. On Waymo, $U$42 performs best, while $U$43 and $U$44 are slightly worse. On Elliptic++, $U$45 months is best, with only small drops at $U$46 and $U$47. The paper interprets this as evidence that performance improves until the window covers the most informative real-time span, after which older history dilutes attention.

6. Interpretation, related paradigms, and limitations

The paper’s clearest conceptual claim is that ETDNet addresses heterogeneous relational semantics by decoupling them at the level of message computation. Structural relations and temporal relations are handled by different modules because they demand different inductive biases: dense local aggregation for $U$48, and sparse temporally ordered credit assignment over $U$49. In Elliptic++, this is especially visible because temporal edges represent cross-transaction hand-offs rather than self-history. In Waymo, the paper reports a qualitative reduction in confusion between lane changes and turns, suggesting that temporal history helps disambiguate maneuvers that are spatially similar in the current frame (Mohammed et al., 5 Aug 2025).

This emphasis on edge-type decoupling distinguishes ETDNet from other edge-aware models. EGAT treats edges as first-class learnable entities and introduces parallel node and edge attention blocks, but it uses a shared edge-aware attention mechanism rather than relation- or type-specific propagation channels; it is therefore better characterized as node–edge dual-state coupled propagation than as edge-type decoupling (Chen et al., 2021). EdgeStereo, despite its title, belongs to a different problem domain entirely—dense stereo matching—and uses a disparity estimation branch plus an edge detection branch, with generic edge feature embedding and an edge-aware smoothness loss rather than typed temporal-graph message passing (Song et al., 2019). A common misconception is therefore to read “edge-type” in ETDNet as referring to generic edge features or image-edge maps. In ETDNet, it refers specifically to the semantic separation between intra-time-step and inter-time-step edge families.

The paper’s limitations are explicit. Step Attention over all intra-time-step links can dominate runtime in crowded scenes because it still performs dense multi-head attention over local neighborhoods in $U$50. The authors suggest sparse-attention kernels or neighborhood sampling as future work. More broadly, the current formulation assumes a discrete timestep index, a fixed history window $U$51, and temporal edges constructed on that grid. The authors mention adaptive history-window learning and extensions to irregular or continuous-time events via time-aware positional encodings as future directions.

A further limitation concerns evidence rather than mechanism. The ablations strongly support the dual-branch encoder, but they do not isolate the representational contribution of the full-history graph against a strictly controlled snapshot alternative. This suggests that the strongest empirical claim directly established by the paper is about the effectiveness of the combined FHG-plus-ETDNet design, with particularly strong support for the decoupled structural and temporal branches.

In summary, ETDNet consists of a dual-branch encoder aligned to a full-history graph representation. The representation contributes one node per entity-time occurrence and two explicit edge families, $U$52 and $U$53. The network contributes GAT-like Step Attention for $U$54, Transformer-style History Attention for $U$55, and residual learned fusion after every layer. The empirical argument is that temporal reasoning improves when structural and temporal relations are represented explicitly and processed separately rather than collapsed into a single graph operator (Mohammed et al., 5 Aug 2025).