LPS-GNN: Partition-Based Framework for Ultra-Large Graphs

• LPS-GNN is a partition-based framework that uses LPMetis and subgraph augmentation to make ultra-large graph representation learning practical.
• It decomposes giant graphs into balanced subgraphs for local GNN training while restoring global context with coarsened embeddings.
• Empirical evaluations show notable accuracy improvements and reduced training time compared to baseline scalable GNN methods on industrial datasets.

LPS-GNN is a partition-based large-scale graph neural network framework for deploying GNNs on graphs far beyond the scale typically handled by earlier scalable systems, including industrial graphs with up to $114.19$ billion edges. The title does not explicitly expand the acronym, but in the method description it is best understood as a framework centered on LPMetis—“Label Propagation with METIS”—together with subgraph augmentation and pluggable GNN backbones. Its stated goal is to make representation learning and downstream prediction on ultra-large graphs practical under strong cost constraints, including a reported deployment in which a $100$-billion-edge graph was trained on a single GPU in $9.73$ hours, with online performance lifts of $8.24\%$ to $13.89\%$ over deployed baselines (Cheng et al., 19 Jul 2025).

1. Problem setting and design objectives

LPS-GNN is motivated by the failure mode of standard iterative message passing at extreme graph scale. In the formulation used by the paper, standard GNN computation repeatedly expands a node’s receptive field through neighborhood aggregation, which creates coupled bottlenecks: neighbor explosion, severe GPU memory pressure, long training epochs, difficult inference, and an accuracy–scalability trade-off. These issues are especially acute on industrial graphs with hundreds of millions of nodes and billions to more than one hundred billion edges (Cheng et al., 19 Jul 2025).

The framework is positioned against three families of prior scalable GNN methods. Sampling-based systems such as GraphSAGE, FastGCN, GraphSAINT, and PinSage reduce full-graph computation but still suffer from neighbor explosion and costly graph access. Decoupled propagation methods such as SGC, APPNP, GAMLP, and FS-GNN are efficient, but the paper argues that they rely heavily on homophily assumptions and are less robust on noisy industrial graphs. Partition- and distributed-system methods such as Cluster-GCN, DistDGLv2, AliGraph, Angel Graph, PaGraph, Betty, and ByteGNN are efficient once partitioning is available, but the paper identifies the partitioner itself as the hidden systems bottleneck at $100$B-edge scale.

This framing is central to the method’s identity. LPS-GNN is not introduced as a new message-passing operator or a new supervised loss. It is introduced as a partition-first systems-and-data pipeline that restructures the learning problem so that ordinary GNNs can remain local while still receiving enough global information to preserve accuracy.

2. End-to-end architecture and execution model

The framework combines three components: a scalable graph partitioner, a subgraph augmentation strategy, and a pluggable GNN backbone. Its high-level workflow is given in Algorithm 1 of the paper and can be summarized in four stages (Cheng et al., 19 Jul 2025).

First, the input graph $G$ is partitioned into $K$ subgraphs $g_1,\dots,g_K$ by LPMetis. Second, those partitions are coarsened into a much smaller graph $\tilde{G}$. Third, an unsupervised or self-supervised GNN is run on $100$0 to obtain global embeddings. Fourth, sampled partitions are augmented with those global features and with refined structure, and each partition is then treated as one batch for a standard supervised GNN.

The pseudocode stated in the paper includes the following steps: $100$1

$100$2

For a sampled partition $100$3, the feature and structure augmentations are

$100$4

$100$5

and the supervised training step is

$100$6

The framework is deliberately backbone-agnostic. The paper explicitly mentions compatibility with GCN, GraphSAGE, GAT, DGI, and GraphMAE, and states that the selected GNN algorithm retains a consistent loss function. For the GNN stage, it uses the standard propagation form

$100$7

Accordingly, LPS-GNN should be read as an orchestration framework around existing GNNs rather than as a replacement for them.

Its execution model separates preprocessing from learning. Graph partitioning and coarsening are performed on distributed CPU infrastructure, while the actual GNN training runs on a single GPU machine. This CPU/GPU split is one of the method’s core engineering assumptions.

3. LPMetis and graph partitioning as the primary systems primitive

Graph partitioning is the framework’s enabling mechanism. The paper evaluates partitions with four metrics: $100$8

$100$9

$9.73$0

plus runtime. A usable partition is therefore one that is not only sparse in edge cuts, but also balanced enough for batch construction and fast enough to compute on giant graphs (Cheng et al., 19 Jul 2025).

LPMetis combines Multi-Level Label Propagation with a final METIS pass on a much smaller coarsened graph. Its stated purpose is to preserve the speed and message-passing affinity of label propagation while recovering the balancing ability of METIS. The crucial systems idea is that METIS is not run on the original graph. Instead, LPMetis repeatedly coarsens the graph and only applies METIS after that reduction step.

The paper states an overall time complexity of

$9.73$1

arguing that Multi-Level LP is near-linear per iteration, converges in only $9.73$2–$9.73$3 iterations empirically, and leaves a tiny coarsened graph for the final METIS stage.

Within Multi-Level LP, the paper defines a relative edge weight $9.73$4 intended to normalize an edge by the source node’s total outgoing edge weight and then retain strong edges deterministically while keeping weak edges with some random probability. It also uses a weighted label update rather than ordinary frequency-based label propagation, so that labels supported by larger weighted connectivity can dominate even when they are not the modal neighbor label. This is presented as a way to make partitioning more compatible with downstream information propagation in GNNs.

The framework uses two coarsening modes. In coarsening by edge, each coarse node value becomes the number of nodes in the current partition. In coarsening by node, coarse node values accumulate the underlying original-node counts. Edge weights between coarse nodes are sums of inter-partition edges: $9.73$5 This staged design is used to obtain both rapid graph reduction and a size signal useful for balanced final partitioning.

Empirically, LPMetis is presented as the practical alternative to standard METIS on very large graphs. On $9.73$6 with $9.73$7M edges, METIS is reported as OOM, whereas LPMetis runs in $9.73$8 minutes; on $9.73$9 with $8.24\%$0B edges, LPMetis runs in $8.24\%$1 minutes. On ogbn-products, replacing METIS with LPMetis improves downstream Cluster-based GNNs: Cluster-GCN rises from $8.24\%$2 to $8.24\%$3, Cluster-GAT from $8.24\%$4 to $8.24\%$5, and Cluster-SAGE from $8.24\%$6 to $8.24\%$7. On industrial dataset $8.24\%$8, LPS-GNN with RGP partitioning yields F1 $8.24\%$9, whereas LPS-GNN with LPMetis yields F1 $13.89\%$0 (Cheng et al., 19 Jul 2025).

A notable design choice is that LPMetis does not always minimize edge cut as aggressively as METIS. The paper treats this as intentional: it prioritizes execution speed and partition balance, accepting higher edge cut because the target graphs are redundant and noisy.

4. Subgraph augmentation and the local–global learning interface

Partitioning makes training feasible, but it also removes cross-partition context. LPS-GNN addresses this with subgraph augmentation, which has two components: feature augmentation through a coarsened global graph and structure refinement within sampled subgraphs (Cheng et al., 19 Jul 2025).

For feature augmentation, the framework constructs a coarsened graph $13.89\%$1 whose nodes correspond to graph partitions. Coarse edges aggregate inter-partition connectivity: $13.89\%$2 An unsupervised GNN, with DGI used by default in the paper, is run on $13.89\%$3 to obtain global embeddings $13.89\%$4. These embeddings are then concatenated to local partition features: $13.89\%$5 The intent is to restore global positional or contextual information lost during graph cutting.

For structure refinement, the paper computes PageRank inside each sampled subgraph: $13.89\%$6 with $13.89\%$7. Nodes whose PageRank falls in the bottom $13.89\%$8 are removed. The paper also evaluates node2vec-based refinement and random refinement, but reports PageRank as the most effective option.

The ablation on $13.89\%$9 quantifies the contribution of both components. Base LPS-GNN without feature augmentation or structure refinement yields F1 $100$0. Adding feature augmentation gives $100$1. Adding PageRank-based structure refinement gives $100$2. Combining both gives $100$3. In this study, structure refinement contributes more than feature augmentation.

The framework also uses aggressive subgraph sampling during training. Rather than train on all partitions, it samples a small fraction uniformly and treats each sampled partition as one batch. On $100$4, using all subgraphs requires $100$5 hours for $100$6 epochs and yields F1 $100$7. Using $100$8 of subgraphs requires $100$9 hours for $G$0 epochs and yields F1 $G$1. Using $G$2 of subgraphs requires $G$3 hours for $G$4 epochs and yields F1 $G$5. The paper interprets this as evidence of large-graph redundancy; a plausible implication is that subgraph sampling functions both as a systems optimization and as a denoising regularizer.

5. Empirical performance, scale, and production deployment

The evaluation spans one public benchmark and a sequence of Tencent industrial graphs. The public graph is ogbn-products with $G$6 nodes and $G$7 edges. The industrial datasets range from $G$8 at $G$9M edges to $K$0 at $K$1B edges. In particular, $K$2 has $K$3M nodes and $K$4B edges, $K$5 has $K$6B edges, and $K$7 has $K$8M nodes and $K$9B edges (Cheng et al., 19 Jul 2025).

On $g_1,\dots,g_K$0, the framework is compared with Angel GraphSAGE, Angel SGC, Angel GAMLP, and two LPS-GNN instantiations. Angel GraphSAGE achieves AUC $g_1,\dots,g_K$1, Angel SGC $g_1,\dots,g_K$2, Angel GAMLP $g_1,\dots,g_K$3, LPS-GNN (GCN) $g_1,\dots,g_K$4, and LPS-GNN (GraphMAE) $g_1,\dots,g_K$5. The efficiency contrast is similarly large: Angel GAMLP requires $g_1,\dots,g_K$6 seconds per epoch, LPS-GNN (GCN) $g_1,\dots,g_K$7 seconds, and LPS-GNN (GraphMAE) $g_1,\dots,g_K$8 seconds. Preprocessing takes $g_1,\dots,g_K$9 minutes for Angel GAMLP, $\tilde{G}$0 minutes for LPS-GNN (GCN), and $\tilde{G}$1 minutes for LPS-GNN (GraphMAE). GraphSAINT and PPRGo are reported as OOM on this dataset.

The production results are given for three online scenarios. In Social Recommendation on $\tilde{G}$2, XGBoost yields $\tilde{G}$3 and LPS-GNN (GCN) yields $\tilde{G}$4, a gain of $\tilde{G}$5. In Identification of Fraudulent Users on $\tilde{G}$6, PU-DNN yields $\tilde{G}$7, FS-GNN $\tilde{G}$8, and LPS-GNN (DGI) $\tilde{G}$9, a gain of $100$00 over PU-DNN. In User Acquisition on $100$01, DeepFM yields $100$02 and LPS-GNN (DGI) yields $100$03, a gain of $100$04, with total training time $100$05 hours.

The hardware and systems details are part of the contribution. Graph partitioning and preprocessing are implemented in Scala on Spark and stored in a distributed file system. The actual GNN training runs on a single Linux machine with $100$06 GB RAM, a P40 GPU, and a $100$07-core AMD CPU. In one resource comparison on $100$08, Angel baselines use $100$09 parameter-server workers, $100$10 Spark executors, and $100$11 GB memory, whereas LPS-GNN uses no parameter-server workers, $100$12 Spark executors in preprocessing, one GPU, and $100$13–$100$14 GB memory, with $100$15 less memory and $100$16 lower preprocessing time.

Taken together, these results support the paper’s central claim that the framework’s novelty lies not in a new neural operator, but in a reorganization of graph learning around scalable partitioning, local batch training, and lightweight restoration of global context.

6. Scope, limitations, and disambiguation

The framework is explicitly developed for homogeneous graphs, and the conclusion lists heterogeneous graphs as future work. It does not address dynamic graph updates; preprocessing is offline. The paper also notes that label imbalance across partitions is not deeply handled, especially when supervised global-feature extraction is considered. Its theoretical discussion is limited to standard bounded-Lipschitz assumptions for GNN convergence, and some exact LPMetis scoring rules are difficult to read because parts of the paper’s equations are poorly typeset (Cheng et al., 19 Jul 2025).

A further limitation is methodological rather than empirical. LPMetis deliberately tolerates higher edge cut than METIS in exchange for speed and scalability. This suggests that LPS-GNN is optimized for deployment practicality rather than for exact preservation of graph topology under classical partitioning criteria.

The name should also be distinguished from several nearby acronyms in the GNN literature. It is not LPGNAS, the quantization-and-architecture search method introduced in “Learned Low Precision Graph Neural Networks” (Zhao et al., 2020). It is not LSP, the locality-sensitive preprocessing sparsifier of “LSP: Acceleration and Regularization of Graph Neural Networks via Locality Sensitive Pruning of Graphs” (Kosman et al., 2021). It is not GraLSP, the anonymous-walk-based local-structural-pattern framework “GraLSP: Graph Neural Networks with Local Structural Patterns” (Jin et al., 2019). Nor is it GLSP, the floor-plan line parser “Parsing Line Segments of Floor Plan Images Using Graph Neural Networks” (Chen et al., 2023).

In that sense, LPS-GNN occupies a specific niche within scalable GNN research. It is a production-oriented, partition-first framework for ultra-large graphs, designed around the claim that the true bottleneck in extreme-scale GNN deployment is not only message passing, but the inability of conventional graph partitioning and batching pipelines to preserve useful structure at $100$17B-edge scale.