RIPPLE++: An Incremental Framework for Efficient GNN Inference on Evolving Graphs

TL;DR

RIPPLE++ addresses the challenge of low-latency GNN inference on evolving graphs by introducing a streaming, incremental inference framework that propagates only the deltas caused by graph updates. It generalizes to various aggregators, supports attention-based architectures, and provides both single-machine and distributed deployment with a locality-aware routing strategy. The method substantially outperforms layer-wise recomputation and state-of-the-art InkStream in throughput while maintaining deterministic, exact embeddings, albeit with higher memory usage to store incremental state. The work demonstrates scalable, real-time GNN inference for large dynamic graphs, enabling practical deployment in finance, traffic, and social networks, and sets the stage for further improvements in routing, batching, and approximate extensions.

Abstract

Real-world graphs are dynamic, with frequent updates to their structure and features due to evolving vertex and edge properties. These continual changes pose significant challenges for efficient inference in graph neural networks (GNNs). Existing vertex-wise and layer-wise inference approaches are ill-suited for dynamic graphs, as they incur redundant computations, large neighborhood traversals, and high communication costs, especially in distributed settings. Additionally, while sampling-based approaches can be adopted to approximate final layer embeddings, these are often not preferred in critical applications due to their non-determinism. These limitations hinder low-latency inference required in real-time applications. To address this, we propose RIPPLE++, a framework for streaming GNN inference that efficiently and accurately updates embeddings in response to changes in the graph structure or features. RIPPLE++ introduces a generalized incremental programming model that captures the semantics of GNN aggregation functions and incrementally propagates updates to affected neighborhoods. RIPPLE++ accommodates all common graph updates, including vertex/edge addition/deletions and vertex feature updates. RIPPLE++ supports both single-machine and distributed deployments. On a single machine, it achieves up to $56$K updates/sec on sparse graphs like Arxiv ($169$K vertices, $1.2$M edges), and about $7.6$K updates/sec on denser graphs like Products ($2.5$M vertices, $123.7$M edges), with latencies of $0.06$--$960$ms, and outperforming state-of-the-art baselines by $2.2$--$24\times$ on throughput. In distributed settings, RIPPLE++ offers up to $\approx25\times$ higher throughput and $20\times$ lower communication costs compared to recomputing baselines.

Figures (19)

• Figure 1: GNN inference on static graphs for vertex $D$. $h^2_D$ is the final layer embedding that maps to a predicted label.
• Figure 2: Vertex-wise vs. Layer-wise inference on static graphs.
• Figure 3: Effect of neighborhood sampling on vertex-wise inference accuracy and latency (Reddit graph, 3-layer SAGEConv).
• Figure 4: % of affected vertices and inference latency per batch-update, for RIPPLE++ (RP) and baseline RC, with differing batch sizes (3-layer GraphConv).
• Figure 5: Cascading effect on the vertex embeddings due to an edge addition during 2-layer GNN inference.