Looped GNNs Beyond Fixed Depth: Graph Size Generalization and Parameter-Efficient Adaptation

Zhiyang Wang, Zhishang Luo, Yusu WangarXiv 2026 · arXiv

TL;DR

This paper tackles the challenge of graph size generalization—making GNNs trained on small graphs work accurately on much larger ones. The authors propose using Looped GNNs that extend their computational depth at deployment and introduce Loop-Freeze-Steer (LFS), a parameter-efficient adaptation method that steers a frozen pretrained processor to handle larger scales with ~97% fewer trainable parameters than full fine-tuning.

What Problem Does This Paper Address?

Standard Graph Neural Networks (GNNs) typically have a fixed depth ($K$). However, for many tasks, the "effective dependency radius"—the amount of neighborhood information needed for an accurate prediction—grows as the graph gets larger. A fixed-depth GNN trained on small graphs suffers from an information floor: it simply cannot "see" far enough to make accurate predictions on massive deployment graphs, no matter how much you fine-tune its parameters.

While one could simply increase the number of layers, this usually requires retraining and adds significant parameter overhead. The authors ask: Can we reuse a local update rule learned on small graphs and simply run it for more iterations on larger ones?

Methods

The authors formalize the concept of a Looped GNN, where a single parameter-shared processor is applied iteratively. To make this work across sizes, they separate the effects of depth extension and parameter adaptation across six schemes:

Figure 1: (a) The six schemes categorized by depth (Fixed vs. Loop) and adaptation strategy. (b) The architecture of Loop-Freeze-Steer (LFS).

The standout contribution is Loop-Freeze-Steer (LFS). Instead of fine-tuning the entire network (which is computationally expensive and can "break" the learned local logic), LFS:

  1. Freezes the pretrained encoder and the core iterative processor.
  2. Learns a tiny, size-conditioned controller ($C_\phi$) and a new readout ($D_\eta$).
  3. The controller uses FiLM-style (feature-wise affine) modulation to "steer" the hidden states between each iteration of the frozen processor.

This approach allows the model to adapt to the numerical shifts that occur in larger graphs while preserving the fundamental local update rules learned during pretraining.

Datasets

The researchers evaluated their framework on both synthetic and real-world benchmarks:

  • Synthetic Iterative Tasks: They generated Random Geometric Graphs (RGG) with node-level targets based on iterative operators (like damped diffusion). They created four task families—CONST, LOG, POLY, and DIAM—where the required computational horizon grows at different rates relative to the graph diameter.
  • VLSI Chip Placement: A real-world engineering task where the goal is to predict the $(x, y)$ coordinates of circuit cells in a netlist to minimize wirelength. They used synthetic netlists for pretraining and the 2023 MLCAD FPGA macro-placement benchmark for real-world evaluation.

Key Insights and Ideas

  • The Information Floor is Real: Theoretical analysis (Proposition 1) proves that fixed-depth models eventually hit a hard limit on accuracy as graph size increases because their receptive field is too small.
  • Operator Alignment Matters: For a looped GNN to generalize, the processor must learn the local update rule itself, not just map inputs to final targets. The authors show that "operator-aligned" pretraining (supervising intermediate steps) is crucial for the optimal deployment depth to actually grow with graph size.
  • Preserving the "Physics" of the Task: LFS works because it treats the pretrained processor as a useful "prior" for the task's dynamics. By freezing it, the model avoids the "forgetting" or instability that often plagues full fine-tuning when moving to out-of-distribution graph sizes.

Key Results

  • Depth Extension Success: On synthetic tasks, models trained with operator-aligned supervision successfully "tracked" the required horizon. As seen in Figure 2, the risk-minimizing depth grows naturally with graph size.
  • LFS vs. Fine-Tuning: In the "DIAM" task (where the dependency radius grows fastest), LFS eventually overtakes full fine-tuning (Loop-Tune) as the deployment size increases (Figure 3).
  • Efficiency in Chip Placement: On real-world MLCAD netlists, LFS achieved an RMSE of 6.24, significantly beating fixed-depth models (7.18) and performing within 4% of full fine-tuning (6.01). Crucially, LFS used only 2.9% of the trainable parameters compared to fine-tuning, representing a 97.1% reduction in the adaptation budget.

Limitations and Future Work

  • Contractive Dynamics: The theoretical guarantees rely on the task having "contractive" updates (where errors don't explode over time). The authors show that for non-contractive tasks like Shortest Paths, all current schemes—including LFS—fail to generalize as size increases.
  • Depth Selection: Currently, the best deployment depth ($K$) is chosen using a small labeled validation set of intermediate-sized graphs. A promising future direction is developing "label-free" methods to automatically determine the optimal number of loops at test time.
  • Scaling: While tested on graphs up to 28,000 nodes, applying these techniques to billion-node graphs remains an open challenge for future engineering.

Summary updated

Abstract

Generalizing from small graphs to larger ones can require computation beyond the depth of a neural model used during training. We study target tasks that admit a common local iterative computation and whose effective dependency radius grows with graph size. The central idea is to learn a local update rule through GNN pretraining, then repeatedly apply the same learned processor beyond the training depth to extend information reach on larger graphs without retraining. Calling such parameter-shared architecture a \emph{looped GNN}, we categorize six schemes for looped GNNs to separate the effects of depth extension, fine-tuning, and freeze-and-steer adaptation. Our analysis establishes fixed-depth information limits and sufficient conditions under which accurate iterative reuse overcomes them. To improve beyond unadapted reuse, we introduce \emph{Loop-Freeze-Steer} (LFS), which freezes the pretrained processor and learns a small controller to steer its repeated application, using much fewer trainable parameters than full fine-tuning. Our finite-sample analysis gives sufficient conditions for adaptation to improve performance on larger graphs. Experiments on synthetic tasks and chip placement evaluate depth extension and adaptation, highlighting LFS's accuracy--trainable-parameter trade-off for size generalization.
BibTeX
@misc{wang2026looped,
  author = {Zhiyang Wang and Zhishang Luo and Yusu Wang},
  title = {{Looped GNNs Beyond Fixed Depth: Graph Size Generalization and Parameter-Efficient Adaptation}},
  year = {2026},
  eprint = {2610.24112},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2610.24112},
}
Figure