acceptodds
Withdrawn from ICLR 2027

RAFT: Redundancy-Aware Input Filtering for Temporal Graph Neural Network Training

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Temporal graph neural networks (TGNNs) have shown strong performance on dynamic graph learning tasks by continuously updating node memories from evolving interactions (i.e., events) and leveraging these memories for downstream predictions. As graphs grow rapidly in modern applications, training requires processing an increasing number of events; meanwhile, each event can update node memories used by later events, creating dependencies that constrain parallel execution and limit the benefits of additional computing resources. These costs motivate an upstream question: Are all events, and the dependencies they introduce, necessary for learning? We investigate this question through two roles of temporal events: prediction targets and historical events sampled as inputs. We observe that targets involving stable node memories tend to exhibit lower prediction loss, while filtering historical events associated with stable memories can retain similar training-loss trajectories in several evaluated settings. Together, these observations suggest an opportunity to identify input redundancy through changes in node memories. Building on this opportunity, we propose RAFT, a redundancy-aware input-filtering framework for TGNN training. RAFT tracks memory changes during training and uses them to guide two filters: a root-event filter removes selected prediction targets before training, and a support-event filter excludes selected historical context during sampling. Filtering inputs before their downstream preparation and processing reduces the work they trigger. Across three TGNN models and five datasets, RAFT reduces training inputs by 35.23% on average and up to 97.11%, while reducing recorded training time by up to 52.56% with negligible changes to model precisions.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Dynamic Graph, Temporal graph neural networks, input redundancy, temporal neighbor sampling, efficient training

Reviews

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

RAFT reduces training costs for memory-based temporal graph neural networks by using node-memory stability to filter prediction targets and sampled historical interactions. A loss-based controller adjusts when filtering is enabled. Experiments across three models and five datasets report 35.23% fewer inputs and 17.80% lower recorded training time on average, with small changes in validation performance. The contribution is a lightweight filtering mechanism that complements existing training systems, though its effectiveness depends on whether memory stability reliably indicates redundancy.

Critical strengths
  1. The filtering mechanism avoids work early in the training pipeline. RAFT uses information from already executed memory updates, so selecting inputs does not require an extra prediction pass. Filtering before downstream preparation and computation makes the approach practically useful and complementary to existing training optimizations.

  2. The experiments demonstrate meaningful savings across several settings. Evaluation covers three models, five datasets, and two training frameworks, with generally small changes in validation performance. The stage-level profiling also shows where the savings come from, providing evidence of actual computational benefits beyond simply processing fewer inputs.

Critical weaknesses
  1. Filtering may miss changes involving previously stable nodes. RAFT uses past memory updates to decide whether to process a new event. If both endpoints were previously marked as stable, RAFT may skip a new event even when it reflects a change in interaction patterns. The loss-based controller may not detect this promptly, since it only observes losses on retained events.

  2. Memory stability is not sufficient evidence that historical context is redundant. An interaction can remain informative even when its source node’s memory changes little; stable long-term preferences are one example. The reported loss curves show that filtering can work, but do not establish that stability identifies dispensable context.

Questions for authors
  1. How can nodes marked as stable resume memory updates if their subsequent events keep being filtered?

  2. At the same removal rate, how does filtering stable-source historical events compare with random filtering or filtering unstable-source events? This comparison would help establish whether memory stability identifies redundant context beyond the benefits of simply using less history.

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

RAFT studies an upstream question: are all events necessary for training memory-based temporal graph neural networks (TGNNs)? The authors observe that root events (prediction targets) whose endpoint memories are stable tend to have lower prediction loss, while removing support events (historical context) with stable source nodes still yields a near-identical training loss curve. Based on this, RAFT uses the cosine similarity before and after a node's memory update to flag "stable" nodes, and applies stability-guided two-level filtering — a root-event filter removes prediction targets with both endpoints stable before training, and a support-event filter prunes historical events with stable source nodes during sampling; an adaptive controller starts/stops the filters based on the loss trend over K=5 consecutive batches. Validation covers 3 TGNNs × 5 datasets , cutting training inputs by 35.23% on average , reducing recorded training time by 17.80% on average , with average absolute relative changes in AP/AUC of only 0.13%/0.14%.

Critical strengths

RAFT is a lightweight filtering layer added upstream of the memory-based TGNN training pipeline. Can composability with existing systems. The two-level filters are complementary, The root and support filters are independent; their combination strictly exceeds either alone, and the combined AUC relative drop is ≤0.49%, proving that "deleting targets" and "deleting context" are complementary rather than redundant opportunities.

Critical weaknesses

The "recorded training time" metric is favorably scoped and lacks an end-to-end wall-clock comparison. The paper explicitly states this metric "subtracts the separately timed filtering and updater regions from the cumulative training interval" . That is, the up-to-52.56% time saving is measured on the residual interval after subtracting filtering bookkeeping, while whether overheads like stability tracking and controller decisions are counted in the actual training loop is not given as end-to-end wall-clock. The largest gains concentrate in under-trained settings. The two largest graphs GDELT and SX-FULL train only 5–20 rounds, whereas WIKI/REDDIT train 100 rounds; the up-to-93–97% input reduction comes precisely from these far-from-converged runs. It is unclear whether the redundancy opportunity and accuracy preservation still hold under a full training budget, so the generalizability of the headline gains is questionable.

Questions for authors

Can you provide end-to-end wall-clock training time that includes stability tracking, controller decisions, and in-loop filtering bookkeeping, rather than the "recorded training time" that subtracts the filtering/updater regions? If end-to-end speedup is significantly below 52.56%, I would lower my assessment of practical utility.

GDELT/SX-FULL train only 5–6 / 20 epochs. If the training budget is raised to the same 100 epochs as WIKI/REDDIT, do the input reduction and AP/AUC preservation still hold? If not, the largest savings may not transfer to standard training configurations.

Reviewer_YMg2OpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

This paper studies training acceleration for memory-based temporal GNNs. The proposed method filters potentially redundant training events and sampled historical interactions based on node-memory stability. Experiments on TGN, JODIE, and APAN show that this filtering can reduce training time while largely preserving predictive performance.

Critical strengths

S1. The motivation is intuitive and the method is straightforward. RAFT addresses training cost by filtering potentially redundant inputs before they trigger downstream computation.

S2. The writing is clear and easy to follow.

S3. The experiment results demonstrate substantial training-time reductions in several large-scale settings, accompanied by small changes in the reported validation metrics.

Critical weaknesses

W1. The method’s applicability is limited to architectures with explicit node-memory updates. Its practical competitiveness relative to more recent methods, such as CRAFT [R1], DyGFormer [R2], and GraphMixer [R3], remains unclear. Comparisons with recent methods and a clearer characterization of the supported model class would strengthen the practical relevance of the contribution.

W2. The root-only and support-only ablations identify the contributions of the two filtering stages, but do not establish whether memory stability is a better selection criterion than simpler strategies. Comparisons against random root-event dropping and random or recency-based support subsampling, matched for input reduction or computational budget, are needed.

W3. The evaluation uses one negative interaction per positive and reports AP and AUC, with several results already close to saturation. This relatively easy discrimination setting may not reveal whether removing training events and historical context harms more challenging ranking decisions. Evaluation using MRR with multiple negative candidates, following protocols such as those in TGB[R4] and TGB-Seq[R5], would provide stronger evidence that filtering preserves predictive quality, particularly for previously unseen links.

[R1] Future Link Prediction Without Memory or Aggregation

[R2] Towards Better Dynamic Graph Learning: New Architecture and Unified Library

[R3] Do We Really Need Complicated Model Architectures For Temporal Networks?

[R4] Temporal Graph Benchmark

[R5] TGB-Seq benchmark: challenging temporal gnns with complex sequential dynamics

Questions for authors

How are stale stability flags refreshed for nodes whose subsequent root events are repeatedly filtered out? Since the flags are updated only after executed memory updates, could filtering prevent the model from detecting renewed activity or behavioral changes in previously stable nodes?

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

Related papers

Discussion (0)

Sign in to comment.