acceptodds
Under review as a conference paper at ICLR 2027

Train Small, Deploy Large: Zero-Shot GNN Transfer Across Graph Scales

Abstract

Graph neural networks (GNNs) can operate on graphs of different sizes, yet weights learned at one resolution do not necessarily remain effective at another. We investigate whether training on a smaller replica allows zero-shot deployment on the full-resolution graph. We construct these replicas using geometric renormalization (GR), a previously proposed scale transformation designed to preserve latent geometry and self-similar multiscale organization. Across synthetic networks and eight real-world node-classification datasets, GCN, GraphSAGE, and GAT models trained on graphs compressed by factors up to 32 often retain much of the full-resolution accuracy while reducing training cost. Matched-compression randomization controls show that this effect cannot be explained by graph-size reduction alone: randomizing topology, latent geometry, or both breaks the relation between scales and substantially weakens transfer. CKA and orthogonal Procrustes analyses reveal cross-scale alignment of learned representations, while Jensen–Shannon comparisons show similar predictive trajectories during training. Comparisons with established coarsening methods show that GR remains competitive in transfer accuracy while generally preserving measured structural properties more faithfully. Together, these results identify self-similarity as a structural basis for cross-scale GNN transfer and position GR as a reusable training surrogate and controlled framework for studying cross-scale learning in graphs.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
graph neural networks, network geometry, network renormalization

Reviews

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

The paper studies whether GNNs trained on smaller graphs can be used on the original graph without retraining. It uses geometric renormalization to create smaller graphs while preserving important graph properties. The authors evaluate the method using three GNN models on synthetic and real-world datasets. They also compare GR with other graph coarsening methods and analyze the similarity of learned representations across different graph sizes. The results show that training on smaller graphs can reduce training time while maintaining good accuracy in many cases.

Critical strengths
  • The paper shows that GNNs can be trained on smaller graphs and used on the original graph without retraining, while keeping good accuracy in many cases. This can help reduce training time.
  • The paper evaluates the method on several datasets and GNN models. It also compares against existing graph coarsening methods, which helps demonstrate its effectiveness.
Critical weaknesses
  • The experiments mainly focus on homophilic graphs, with no systematic evaluation on heterophilic benchmarks.
  • Although training on smaller graphs reduces training time, hyperbolic embedding introduces significant additional cost. The authors provide some computational analysis, but the overall benefit is unclear when considering both the accuracy drop and total computation time.
  • It is unclear whether the improved transfer performance comes from preserving graph self-similarity or simply from grouping nodes with similar features and labels. The experiments do not clearly separate these effects.
Questions for authors
  • Could the authors include experiments on heterophilic datasets?
  • Could the authors compare their method with a randomly initialized GNN, where the message-passing layers are frozen and only the classifier is trained?
  • Could the authors explain why some datasets have larger accuracy drops than others and which graph properties affect transfer performance?
  • Could the authors show how accuracy and total computation time change as the graph is compressed further, including the cost of hyperbolic embedding?
5 comments

The experiments mainly focus on homophilic graphs, with no systematic evaluation on heterophilic benchmarks.

We thank the reviewer for this comment. We acknowledge that our experimental evaluation primarily focuses on homophilic graphs, and we have already identified the extension to heterophilic networks as a direction for future work in the Conclusion section. A systematic investigation of heterophilic benchmarks is beyond the scope of the present study.

We hypothesize that extending our approach to heterophilic networks may require developing a feature-aware renormalization protocol. In the current framework, node features are aggregated by taking the mean feature vector of the merged nodes. While this provides a simple aggregation strategy, it may not adequately capture the feature structure of heterophilic graphs, where neighboring nodes often exhibit dissimilar features. Consequently, directly applying the current aggregation scheme to such networks may lead to a loss of relevant feature information.

Addressing this limitation would require a more careful treatment of node features during renormalization, which we intend to investigate in future work.

Although training on smaller graphs reduces training time, hyperbolic embedding introduces significant additional cost. The authors provide some computational analysis, but the overall benefit is unclear when considering both the accuracy drop and total computation time.

In the revised manuscript, we have updated Table 9 to include the accuracy drop alongside the total computational cost. As shown below, the accuracy decreases by only 0.05 on both datasets, while the total runtime, including embedding and renormalization, is reduced by approximately 50% for Physics and 6% for PubMed.

The computational benefits become more pronounced with larger hyperparameter searches, as the embedding cost is incurred only once. We also note that GCN is relatively fast to train. For example, on synthetic networks with approximately 130,000 nodes, GCN training takes around 15 seconds, compared with 70 seconds for GraphSAGE, while embedding takes approximately 400 seconds (Figure 11b). Thus, for more computationally demanding architectures, even a modest hyperparameter search can yield substantial computational savings.

If accepted, we plan to extend this analysis with a more systematic evaluation of the trade-off between transfer accuracy and total computational cost.

Table 1. End-to-end runtime (seconds) for GCN on Physics and PubMed, evaluated over a grid of 4 depths × 4 hidden dimensions with 50 realizations each (800 training runs per dataset). Total time at l=5 includes embedding, renormalization, and training. The accuracy drop is measured relative to the original graph (l=0). Times are reported for A100 GPU.

MetricPhysicsPubMed
Train (l=0) [s]5665.473738.76
Embedding [s]450.59221.54
Renorm (l=5) [s]0.200.07
Train (l=5) [s]2397.963309.20
Total (l=5) [s]2848.743530.82
Accuracy drop0.050.05

It is unclear whether the improved transfer performance comes from preserving graph self-similarity or simply from grouping nodes with similar features and labels. The experiments do not clearly separate these effects.

We thank the reviewer for this important comment. We agree that distinguishing the contribution of structural self-similarity from the potential benefits of grouping nodes with similar features and labels is essential for understanding the mechanism underlying cross-scale GNN transfer.

First, we emphasize that geometric renormalization (GR) does not explicitly optimize feature or label similarity. Instead, supernodes are constructed by merging consecutive nodes in the latent similarity space, whose coordinates are inferred exclusively from the original network topology. Node features and labels are aggregated only after the geometric partition has been determined. Nevertheless, because latent geometry may correlate with feature similarity and label homophily, this observation alone does not rule out the alternative explanation raised by the reviewer.

Importantly, our experiments already include a control that directly addresses this concern: the Random-T baseline, presented in Appendix A.11.3 (Figures 21 and 22). In this baseline, the original latent coordinates are preserved while the network topology is randomized before renormalization. Because the geometric coordinates and the corresponding supernode assignments remain unchanged, GR and Random-T aggregate exactly the same groups of nodes, resulting in identical supernode features and training labels. The only difference lies in the connectivity structure of the resulting coarse-grained networks.

This comparison therefore isolates the contribution of network structure while controlling for the potential benefits of grouping nodes with similar features and labels. The differences in zero-shot transfer accuracy between GR and Random-T cannot be attributed to feature or label aggregation alone, since these are identical in both conditions. The generally superior transfer performance of GR thus provides evidence that preserving the network's structural organization contributes to successful cross-scale transfer beyond the effects of feature–label aggregation.

The Random-G baseline provides complementary evidence. In this case, the original network topology is preserved while the latent coordinates used to construct the supernodes are randomized. This disrupts the correspondence between the geometric partition and the network's connectivity structure. The resulting differences in transfer performance indicate that retaining the original network topology is not sufficient when the coarse-graining no longer respects the underlying geometric organization. Although Random-G also changes the supernode composition and therefore the aggregated features and labels, its comparison with GR further highlights the importance of the relationship between geometry and topology.

Taken together, these two controls, and especially Random-T, support the interpretation that successful transfer is not simply a consequence of grouping nodes with similar features and labels, but also depends on preserving the compatibility between the coarse-graining partition and the network's structural organization. This is consistent with our hypothesis that self-similar multiscale organization provides a structural basis for cross-scale GNN transfer.

We will revise the manuscript to clarify the role of these complementary controls and make the distinction between structural preservation and feature–label aggregation more explicit.

Could the authors include experiments on heterophilic datasets?

We addressed this comment in our response below.

Could the authors compare their method with a randomly initialized GNN, where the message-passing layers are frozen and only the classifier is trained?

We thank the reviewer for this suggestion. Comparing against a randomly initialized GNN with frozen message-passing layers and a trainable classifier would be an interesting additional experiment. However, our primary focus in this work is on understanding the transferability of learned GNN weights across different graph scales. In particular, our representational similarity experiments show that GNNs trained at different scales learn similar representations, providing insight into why weight transfer is effective. A randomly initialized GNN with frozen message-passing layers would instead evaluate the effectiveness of random feature representations, addressing a related but distinct question.

While this experiment is not included in our current evaluation, we have conducted additional analyses to investigate how learned GNN weights and representations are preserved across scales. Specifically, we compute linear CKA between the first-layer weights of GNNs trained on the original graph and its 32-fold compressed counterpart. Across all four evaluated datasets, geometric renormalization (GR) achieves the highest mean weight similarity, with generally lower values under Random-T, Random-G, and fully randomized renormalization. These findings provide complementary evidence that GR promotes consistency in learned weights and representations across scales.

Table 1. First-layer linear CKA between G0G_0- and G5G_5-trained models. The coarse-grain G5G_5 network is 32 times smaller compared to G0G_0. Values are mean and standard deviation across 10 repeats.

DatasetOriginal GRRandom-TRandom-GRandom
Photo0.298 ± 0.1170.197 ± 0.0940.217 ± 0.1120.206 ± 0.090
Physics0.447 ± 0.1100.232 ± 0.0670.122 ± 0.0590.076 ± 0.042
PubMed0.384 ± 0.1090.290 ± 0.1030.077 ± 0.0740.071 ± 0.083
Cora0.435 ± 0.0880.382 ± 0.0910.244 ± 0.0550.272 ± 0.077

Could the authors explain why some datasets have larger accuracy drops than others and which graph properties affect transfer performance?

We acknowledge that zero-shot GNN transfer is more challenging for some datasets than for others. One possible explanation lies in the complex relationships between network topology, node features, and node labels in real-world networks. Jankowski et al. showed that, for certain networks, topology-only embeddings yield lower node classification accuracy than feature-only embeddings [1]. We hypothesize that such differences in the relative importance of topology and node features may also contribute to the larger drops in transfer accuracy observed for some datasets. Synthetic networks provide a promising framework for systematically investigating these effects. In particular, the HypBench framework allows us to generate networks with varying degrees of topology-feature correlation while independently tuning structural properties. This would enable a more controlled analysis of which network characteristics influence transfer performance and under what conditions zero-shot transfer becomes less effective.

Another possible explanation concerns the choice of hyperparameters. In this work, we use fixed hyperparameters across all experiments to ensure consistency. However, it remains unclear whether optimizing hyperparameters for each dataset would also improve transfer test accuracy. We consider both the interplay between network topology and node features and the role of hyperparameter optimization to be important directions for future research.

[1] Jankowski, R., Hozhabrierdi, P., Boguñá, M., & Serrano, M. Á. (2024). Feature-aware ultra-low dimensional reduction of real networks. npj Complexity, 1(1), 13.

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

zero-shot GNN transfer across graph scales: training a GNN on a smaller version of a graph and applying its learned weights to the original graph without retraining. It uses geometric renormalization (GR) to merge nearby nodes in a similarity space while trying to preserve the graph’s structure and self-similarity. Supernode features are averaged, and labels are assigned using only training labels. Experiments use GCN, GraphSAGE, and GAT on synthetic networks and eight real-world datasets. Models trained on smaller graphs often perform well on the original graph, but accuracy decreases with greater compression on some datasets.

Critical strengths
  1. paper evaluates three GNN architectures on synthetic networks and eight real-world datasets, with comparisons against randomization controls and existing graph-coarsening methods.

  2. results show that standard GNNs trained on geometrically renormalized graphs can retain useful predictive performance on the original graph without changing the architecture or fine-tuning the weights.

Critical weaknesses
  1. The experiments do not include OGB or other large-scale benchmarks. Since geometric embedding is expensive, evaluation on larger graphs is needed to demonstrate practical benefits in total runtime, memory usage, and accuracy.

  2. Training on a coarsened graph and transferring the learned weights to the original graph has already been studied. Geometric renormalization is also an existing method, so the paper should clarify what new contribution it provides beyond combining these ideas.

Questions for authors

Q1 Can you evaluate on larger graphs, such as OGB datasets, and compare total runtime, memory usage, and accuracy with scalable baselines, including embedding and coarsening costs?

Q2 Do you use a separate validation set? Please clarify how you select hyperparameters, the final checkpoint, and when to stop training.

Q3 When you merge supernodes again, do you count the original training labels or use the labels already assigned to those supernodes?

3 comments

Critical Weaknesses 1.

We conducted experiments on two OGB datasets, ogbn-proteins and ogbn-arxiv, evaluating transfer performance, memory usage, and total runtime. The results are presented in the tables below. Although hyperbolic embedding introduces a substantial one-time cost, this overhead can be amortized over repeated training runs. Our results show that, for sufficiently extensive hyperparameter searches, training on coarsened graphs can reduce overall computational cost. If accepted, we plan to extend this work by adding additional OGB datasets.

Table 1. OGBN-Proteins transfer performance and resource usage. Each model has three layers, 256 hidden units, and no dropout. Models were trained for 1000 epochs with Adam (learning rate 0.01, weight decay 0), using binary cross-entropy loss and the official dataset split. *Embedding is a one-time preprocessing cost.

GNN modelMeasureOriginal network G0G_0G1G_1G2G_2G3G_3G4G_4G5G_5
GraphSAGETransfer ROC-AUC0.7770.7080.6410.6440.6190.585
GraphSAGETrain time [s]1636.76857.74511.17365.40281.37257.03
GraphSAGETraining GPU memory [GiB]78.7977.8977.5677.4077.3277.28
GraphSAGEEmbedding time [s]N/A50,081.6*50,081.6*50,081.6*50,081.6*50,081.6*
GraphSAGEEmbedding host memory [GiB]N/A7.29*7.29*7.29*7.29*7.29*
GATTransfer ROC-AUC0.6930.6480.6380.6160.6110.554
GATTrain time [s]1618.02763.60426.10281.21214.93182.77
GATTraining GPU memory [GiB]82.5925.619.407.937.857.81
GATEmbedding time [s]N/A50,081.6*50,081.6*50,081.6*50,081.6*50,081.6*
GATEmbedding host memory [GiB]N/A7.29*7.29*7.29*7.29*7.29*

Table 2. OGBN-Arxiv transfer performance and resource usage. Models have two layers, 32 hidden units, and no dropout. Training used Adam with learning rate 0.01 and weight decay 0.0005, for up to 1,000 epochs with patience 50. Each GiG_i-trained model was evaluated directly on G0G_0 using random 60/40 train/test splits. *Embedding is a one-time preprocessing cost.

GNN modelMeasureOriginal network G0G_0G1G_1G2G_2G3G_3G4G_4G5G_5
GraphSAGETransfer accuracy0.687 ± 0.0020.632 ± 0.0040.584 ± 0.0030.561 ± 0.0050.541 ± 0.0030.511 ± 0.006
GraphSAGETrain time [s]13.58 ± 0.158.07 ± 0.014.61 ± 0.012.84 ± 0.011.94 ± 0.011.75 ± 0.01
GraphSAGETraining GPU memory [GiB]1.6150.8970.5370.3600.2710.225
GraphSAGEEmbedding time [s]N/A2,473.7*2,473.7*2,473.7*2,473.7*2,473.7*
GraphSAGEEmbedding host memory [GiB]N/A0.52*0.52*0.52*0.52*0.52*
GATTransfer accuracy0.689 ± 0.0020.642 ± 0.0020.572 ± 0.0030.536 ± 0.0040.494 ± 0.0380.472 ± 0.017
GATTrain time [s]16.69 ± 0.209.86 ± 0.015.89 ± 0.023.88 ± 0.023.20 ± 0.022.98 ± 0.02
GATTraining GPU memory [GiB]2.3501.2640.7200.4530.3180.248
GATEmbedding time [s]N/A2,473.7*2,473.7*2,473.7*2,473.7*2,473.7*
GATEmbedding host memory [GiB]N/A0.52*0.52*0.52*0.52*0.52*

Critical Weaknesses 2.

We thank the reviewer for this comment. We agree that both graph coarsening for GNN weight transfer and geometric renormalization (GR) have been studied previously. Our contribution is instead to investigate self-similarity as a structural basis for cross-scale GNN transfer.

Previous coarsening approaches primarily seek to reduce computational cost while maintaining predictive performance. We ask a different question: what structural relationship between graphs at different scales allows learned GNN weights to remain transferable? GR offers a theoretically motivated framework because it is designed to preserve networks' self-similar organization across scales.

Beyond demonstrating transfer, we test this hypothesis using matched-compression randomization controls that disrupt topology, latent geometry, or both; CKA and OP representation-alignment analyses; and Jensen–Shannon divergence comparisons of predictive trajectories. We validate the findings on synthetic and real-world networks, three GNN architectures, and several established coarsening methods.

Our contribution is thus to link network self-similarity with cross-scale GNN learning and provide empirical evidence for its role in transferability, rather than propose another coarsening method. We will emphasize this conceptual and experimental distinction in the revised manuscript.

We also introduce cuMercator, a GPU-accelerated Mercator implementation achieving over 400× speedups on 10,000-node networks, enabling efficient large-scale hyperbolic embedding and practical GR.

Q1. Can you evaluate on larger graphs, such as OGB datasets, and compare total runtime, memory usage, and accuracy with scalable baselines, including embedding and coarsening costs?

We have evaluated our approach on two OGB datasets. The details are provided in the comment above.

Q2 Do you use a separate validation set? Please clarify how you select hyperparameters, the final checkpoint, and when to stop training.

In this work, we used only training and test sets, without a separate validation set. The hyperparameters, including the number of layers, hidden-layer dimensions, and learning rate, were fixed across the analyzed networks rather than optimized individually.

We acknowledge that these hyperparameter choices may not be optimal for every network and that further tuning could potentially improve the reported accuracy on the original-scale graphs. The reviewer's question also highlights an interesting direction for future research, which we have identified in the Conclusions section: whether hyperparameters optimized on a coarse graph remain optimal when transferred to the original graph. We plan to investigate this question in future work.

Regarding the training procedure, we employed early stopping based on the training loss, together with a cosine learning-rate scheduler. Thus, the stopping criterion did not require a separate validation set.

Q3 When you merge supernodes again, do you count the original training labels or use the labels already assigned to those supernodes?

At each successive renormalization step, we use the labels already assigned to the supernodes at the preceding level, rather than recounting the original training labels. Specifically, when merging supernodes, we apply majority voting over their existing labels, with ties broken uniformly at random. If only one constituent supernode is labeled, its label is propagated; if none are labeled, the resulting supernode remains unlabeled and is excluded from the supervised loss.

Thank you for the detailed responses and additional experiments. The explanations of training-loss-based early stopping and label assignment during repeated merging address my clarification questions. I also appreciate the addition of ogbn-arxiv and ogbn-proteins.

However, the practical benefit remains unclear. The new results show substantial embedding costs and noticeable performance drops as compression increases. Comparisons with scalable GNN training baselines, including total preprocessing and training costs, are still missing.

I understand that the intended contribution is to investigate self-similarity as a basis for cross-scale transfer. However, the current controls do not fully separate its effect from feature coherence and label purity within supernodes. While the additional analysis strengthens the paper, these concerns remain, so I maintain my rating of 2

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

This paper studies zero-shot GNN weight transfer between different resolutions of the same graph: a model is trained on a coarse-grained graph, and the learned weights are then applied directly to the original graph for node classification. The authors use the previously proposed GR transformation to construct coarse-grained graphs by merging nearby nodes in the latent similarity subspace, averaging their feature vectors, and assigning supernode labels by majority vote over the training labels within each block.

The experiments cover synthetic networks in the small-world and ultra-small-world regimes, eight real-world datasets, and three GNN architectures: GCN, GraphSAGE, and GAT. The authors evaluate transfer test accuracy and training cost at compression ratios up to 32×. They further examine cross-resolution compatibility through matched-compression randomization controls, comparisons with established coarse-graining methods, linear CKA, OP similarity, and Jensen–Shannon divergence between predictive trajectories. The paper also introduces cuMercator, a GPU implementation for hyperbolic embedding, and reports preprocessing costs, amortization across repeated training runs, and peak GPU memory usage. The results show that GR replicas can serve as reusable training surrogates in several of the evaluated settings, allowing weights learned on smaller graphs to be deployed directly on the original graph.

Critical strengths
  1. The cross-scale transfer study is reasonably systematic, and the evaluation directly addresses the stated problem.

The learned weights are transferred from the coarse-grained graph to the original graph without retraining, and performance is evaluated on the original test nodes. This directly tests the proposed train-small, deploy-large setting. The experiments cover two synthetic-network regimes, eight real-world datasets, three GNN architectures, and multiple renormalization levels. Results on real networks are averaged over ten random train/test splits, while the synthetic experiments additionally include independently generated network realizations. The observations therefore extend beyond a single favorable example.

  1. The diagnostics distinguish the effect of replacing the training graph from the stability of cross-resolution evaluation.

The two Jensen–Shannon diagnostics address different questions:

  • Training-graph divergence, DJSTGD_{\mathrm{JS}}^{\mathrm{TG}}, evaluates both the model trained on the original graph and the model trained on the coarse graph on G0G_0, measuring the predictive effect of replacing the training graph.
  • Evaluation-graph divergence, DJSEGD_{\mathrm{JS}}^{\mathrm{EG}}, holds the model trained on the coarse graph fixed and compares its predictions on the coarse and original graphs, measuring the effect of changing the evaluation resolution.

In the synthetic experiments, a model trained on a randomly coarse-grained graph can have a small evaluation-graph divergence while exhibiting a substantial accuracy loss. This demonstrates that stability under a change in evaluation resolution does not by itself establish the quality of a coarse graph as a training surrogate.

Critical weaknesses
  1. The evidence does not yet isolate self-similarity as the basis for cross-scale transfer

The paper's most distinctive claim is that preserving self-similarity provides a structural basis for cross-scale GNN transfer. However, the current controls simultaneously alter several factors that affect learning.

Random-G changes the geometric coordinates used for merging and therefore changes which nodes are assigned to each supernode. This also changes within-block feature coherence, the mixture of training labels, and the supervision retained by feature averaging and majority voting. Random-T changes the task relevance of neighborhoods and the statistics of message passing. Matching the compression ratio rules out graph-size reduction alone as an explanation, but it does not distinguish self-similarity from these more direct explanations.

The appendix also shows that the effect of randomization is conditional. In Figure 21, the GCN curves for Random-T remain close to those for GR across several renormalization levels in both the small-world and ultra-small-world regimes. Figure 22 shows similar behavior in some real-world settings. The statement that topology randomization substantially weakens transfer should therefore be qualified by architecture and dataset, and these exceptions should be incorporated into the mechanism analysis.

The representational-similarity analysis does not fully resolve this concern. CKA and OP compare the original representations with coarse representations lifted through the coarse-to-fine lifting operator, namely Z0Z_0 and UℓZℓU_\ell Z_\ell. This comparison is itself affected by the quality of the grouping: random grouping assigns the same lifted representation to originally dissimilar nodes and can consequently reduce similarity. Higher similarity under GR may therefore reflect both cross-resolution training compatibility and better preservation of task-relevant structure by the grouping itself.

  1. The evaluation protocol underlying the coarse-graining comparison needs clarification

The PubMed results contain an unexplained discrepancy:

Experimental resultOriginal-graph GCN accuracyGR transfer test accuracy
Table 1, page 80.88±0.000.88\pm0.0016× compression: 0.84±0.010.84\pm0.01
Figure 6(g), page 160.790.79Approximately 17× compression: 0.690.69

The caption of Figure 6 also specifies a two-layer GCN with 32 hidden dimensions. Differences between 16× and approximately 17× compression, or between single-step and multistep coarse-graining, may affect the coarse-graph results. They do not directly explain the difference of nine percentage points in the uncoarsened original-graph baseline. The manuscript does not state whether these experiments use different splits, feature preprocessing, optimizers, training durations, or model-selection procedures.

This discrepancy is consequential because Figure 6 and the related comparisons are used to assess the benefits of GR relative to Huang et al. and other coarse-graining methods. The available evidence does not establish whether the difference reflects an undocumented protocol change, a figure-version issue, or another implementation difference. It should not be treated as proof that the results are incorrect, but the relationship between the experiments needs to be explained before their consistency can be assessed with confidence.

In addition, Appendix A.5 explicitly states that the method of Huang et al. produces a weighted coarse graph, but the manuscript does not sufficiently explain how the three GNN architectures use these edge weights, or whether feature aggregation, label aggregation, and training masks are identical across methods. These choices can directly affect the fairness of the baseline comparison and should be clarified alongside the numerical discrepancy.

Questions for authors
  1. Why is the original-graph PubMed GCN accuracy 0.880.88 in Table 1 but 0.790.79 in Figure 6(g)? Please specify whether the splits, feature preprocessing, optimizer, training duration, and model-selection procedure are identical, and confirm whether all coarse-graining methods in Figures 5–10 are evaluated under a common protocol. How are the edge weights of weighted coarse graphs used and normalized by each GNN architecture?

  2. What exact operation is used for Random-T, and which statistics does it preserve? How do the authors interpret the settings in Figures 21–22 where Random-T barely reduces GCN transfer performance? Which existing experiment distinguishes the contribution of self-similarity from preservation of within-block feature coherence, label purity, and task-relevant neighborhood information?

  3. How are supernodes containing no training labels handled, and are they excluded from the supervised loss? Across successive renormalization levels, are supernode labels recomputed from the counts of all constituent original training labels, or obtained by another majority vote over the preceding level's supernode labels?

4 comments

Critical Weaknesses 1. The evidence does not yet isolate self-similarity as the basis for cross-scale transfer

We thank the reviewer for this comment. We agree that identifying the mechanism underlying cross-scale transfer is important and clarify the role of our controls.

First, Random-T controls for feature and label aggregation. With latent coordinates preserved, GR and Random-T have the same supernode partition, aggregated features, and training labels; only coarse-grained connectivity differs. Thus, transfer differences cannot be explained by feature-label grouping alone, indicating that network structure also contributes.

Second, Random-G probes the contribution of geometry-based coarse-graining to cross-scale transfer. By randomizing the latent coordinates while preserving the original topology, Random-G disrupts the correspondence between the geometric partition and network connectivity, generally reducing transfer performance. However, because this also changes feature and label aggregation, Random-G alone cannot isolate the contribution of self-similarity. Random-T provides a complementary control by preserving the geometric partition and aggregated features and labels while perturbing connectivity. Together, these experiments show that both geometry-based grouping and coarse-graph connectivity influence transfer, consistent with our hypothesis that self-similar multiscale organization facilitates cross-scale learning.

Randomization effects depend on architecture and dataset, as shown by the relatively strong GCN performance under Random-T. We will qualify our conclusions accordingly.

Regarding CKA and OP, we acknowledge that representational similarity may be influenced by the supernode partition. Nonetheless, GR produces representations more closely aligned across scales than random renormalization. Our Jensen-Shannon analysis provides complementary evidence: it compares predictions from models trained at different resolutions but evaluated on the same original graph, without lifting, further supporting functional compatibility across scales.

In our analysis, coarse-graph representations are lifted to the original graph, assigning identical representations to all nodes in each supernode. This grouping can influence CKA and OP scores.

To avoid this effect, we compare the GNN weights directly, without lifting the representations. Specifically, we compute linear CKA between the first-layer weights of models trained on G0G_0 and G5G_5 (where G5G_5 contains 1/321/32 as many nodes as G0G_0). As shown in Table 1, the weights learned at the two scales are most similar under the original geometric renormalization procedure, and their similarity generally decreases as randomization is introduced. Random-G usually produces a larger reduction in similarity, whereas Random-T tends to preserve more of the original cross-scale similarity. This further helps us disentangle the effects of the different baselines and provides evidence that geometric renormalization preserves learned representations across scales.

Table 1. First-layer linear CKA between G0G_0- and G5G_5-trained models (G5G_5 is 32× smaller). Mean ± SD across 10 repeats.

DatasetOriginal GRRandom-TRandom-GRandom
Photo0.298 ± 0.1170.197 ± 0.0940.217 ± 0.1120.206 ± 0.090
Physics0.447 ± 0.1100.232 ± 0.0670.122 ± 0.0590.076 ± 0.042
PubMed0.384 ± 0.1090.290 ± 0.1030.077 ± 0.0740.071 ± 0.083
Cora0.435 ± 0.0880.382 ± 0.0910.244 ± 0.0550.272 ± 0.077

We also evaluate representational similarity for Random-T and Random-G alongside GR and Random. Tables 2 and 3 report CKA and OP, respectively. Across datasets and both metrics, GR yields the highest similarity, followed by Random-T; geometry-randomized Random-G and Random yield the lowest.

Table 2. Linear CKA between G0G_0 and G5G_5 representations (G5G_5 is 32× smaller), evaluated on all original nodes. Mean ± SD, 10 repeats.

DatasetOriginal GRRandomRandom-TRandom-G
Photo0.223 ± 0.0200.006 ± 0.0000.052 ± 0.0160.006 ± 0.000
Physics0.749 ± 0.0110.002 ± 0.0000.169 ± 0.0120.003 ± 0.000
PubMed0.241 ± 0.0090.002 ± 0.0000.068 ± 0.0040.002 ± 0.000
Cora0.353 ± 0.0130.003 ± 0.0000.087 ± 0.0050.004 ± 0.001

Table 3. Normalized orthogonal Procrustes (OP) similarity between G0G_0 and G5G_5 representations (G5G_5 is 32× smaller), evaluated on all original nodes. Mean ± SD, 10 repeats.

DatasetOriginal GRRandomRandom-TRandom-G
Photo0.501 ± 0.0180.066 ± 0.0020.271 ± 0.0240.067 ± 0.002
Physics0.764 ± 0.0070.041 ± 0.0020.338 ± 0.0080.045 ± 0.002
PubMed0.464 ± 0.0090.041 ± 0.0060.263 ± 0.0050.046 ± 0.005
Cora0.497 ± 0.0060.050 ± 0.0030.252 ± 0.0080.052 ± 0.005

Critical Weaknesses 2. The evaluation protocol underlying the coarse-graining comparison needs clarification

We thank the reviewer for pointing out this discrepancy. In the main text (Table 1), we used a 60/40 train/test split consistently across all experiments. However, Figure 6 in the Appendix reports results obtained using the original dataset split, which consists of 60 training nodes, 500 validation nodes, and 1,000 test nodes. This difference in data partitioning explains the discrepancy in the reported results. Specifically, training the GNN on fewer labeled examples leads to a reduction in both predictive accuracy and transfer accuracy.

Regarding the method of Huang et al., the renormalization procedure produces a weighted graph. However, to ensure a consistent comparison with the other coarse-graining approaches, we use its unweighted counterpart. We have clarified this choice in the revised manuscript.

We have updated the caption of Figure 6 to explicitly specify the dataset split used in the experiments. We have also expanded the description of Huang et al.'s method to clarify how the resulting weighted graph is treated in our comparisons.

Questions For Authors 1.

As we mention in the comment above, in the main text (Table 1), we used a 60/40 train/test split consistently across all experiments. However, Figure 6 in the Appendix reports results obtained using the original dataset split, which consists of 60 training nodes, 500 validation nodes, and 1,000 test nodes. We have updated the caption of Figure 6.

Regarding the method of Huang et al., the renormalization procedure produces a weighted graph. However, to ensure a consistent comparison with the other coarse-graining approaches, we use its unweighted counterpart. We have clarified this choice in the revised manuscript.

Questions For Authors 2.

Random-T computes the embedding on the original graph G0G_0, so the geometry used to merge nodes is preserved: the blocks of merged nodes, and hence the feature and label aggregations, are identical to those of GR. Before building the coarse graphs, we randomize the edges of G0G_0 using degree-preserving double edge swaps, which preserve the degree of every node (and hence the degree distribution) but destroy other structural properties such as clustering. The edges between supernodes at each level are then derived from this randomized graph, so the models are trained on randomized connectivity at the coarse-grained levels. Evaluation is always performed on the original, non-randomized graph G0G_0.

The fact that Random-T barely degrades GCN transfer performance in these settings suggests that, for GCN, performance is driven mainly by the geometry-based node merging (computed on the original graph) and the averaged node features, rather than by the edges of the coarse-grained graphs. This is consistent with the edges contributing comparatively little in these cases, although we do not claim that the same holds for other architectures. Moreover, GR sometimes performs slightly worse than Random-T, which may indicate that, for these datasets, the connectivity of the coarse graphs is not particularly well suited to GCN message passing.

In our context, self-similarity means that the graphs obtained at different scales through GR retain the structural properties of the original graph (degree distribution, clustering spectrum, average neighbor degree, average clustering coefficient, average degree, and spectral gap, up to finite-size effects). This property arises from the latent geometry inferred by the embedding. The same geometry determines which nodes are merged into supernodes and, hence, the within-block feature coherence and the label purity of the resulting aggregations. These are therefore consequences of a single underlying object, and we agree that none of our controls separates self-similarity from them: perturbing the geometry (Random-G and Random) alters all of them simultaneously. Random-T, in contrast, keeps the geometry and the blocks fixed and varies only the edges from which the coarse graphs are built, so it separates the contribution of the edges, and the neighborhood information they carry, from that of the geometry-derived factors.

We have expanded the description of the random baselines in the main text (Experimental setup) and in Appendix A.11.3, including the exact operation used for each baseline.

Questions For Authors 3.

At each renormalization step, we assign supernode labels using the available training labels of their constituent nodes at the preceding level. For r=2r=2, if only one constituent node has a training label, we propagate that label to the supernode. If both have training labels, we apply majority voting, breaking ties uniformly at random. If neither has a training label, the supernode remains unlabeled and is excluded from the supervised loss.

Across successive levels, we repeat this procedure using the preceding level’s supernode labels. We do not recompute labels from the counts of all constituent original training labels.

Although geometric renormalization has a semigroup structure, recursive majority voting can produce labels that depend on the sequence of coarsening steps. With consistent block boundaries, one step with r=16r=16 and four steps with r=2r=2 group the same original nodes, but their assigned labels can differ. For example, consider a block containing 16 training nodes: 15 labeled A and one labeled B. A single (r=16) step always assigns A. Under four successive (r=2) steps, B can survive by winning a tie against A at each level. With independent, uniform tie breaking, the final label is therefore B with probability (1/2)4=1/16(1/2)^4=1/16.

To assess whether these differences in label assignment affect transfer performance, we conduct experiments on synthetic networks with N=131072N=131072 in the small-world regime (γ=2.5\gamma=2.5, β=1.5\beta=1.5). We compare two renormalization approaches: (a) five successive steps with r=2r=2 and (b) a single step with r=32r=32. The table below reports the transfer test accuracy of 3 GNN models, averaged over 10 realizations. Despite the potential differences in assigned labels, both approaches yield very similar transfer test accuracies across all three models.

Modelr=2r=2 five timesr=32r=32 once
GCN0.8888 ± 0.07100.8888 ± 0.0712
GAT0.8079 ± 0.07410.8143 ± 0.0715
GraphSAGE0.8786 ± 0.08080.8778 ± 0.0798

Thank you for the detailed responses and the additional experiments. I also appreciate the clarification of Random-T, the treatment of unlabeled supernodes, and the additional weight-CKA and OGB experiments.

Two concerns remain central to my assessment.

First, the clarification regarding Huang et al.’s method reveals that the comparison uses an unweighted adaptation of a method whose coarse edge weights are part of its construction and propagation scheme. Using a common unweighted representation is a legitimate controlled setting, but it does not establish the performance of the original method. Removing the weights changes the information available to message passing and potentially its normalization. A comparison retaining the native weights and corresponding propagation scheme, at least for GCN, is therefore important for assessing the claimed benefits relative to established coarsening approaches. The current results do not establish whether the conclusions would hold under that comparison.

Second, I acknowledge that Random-T holds the partition, aggregated features, and labels fixed, and that the additional weight-CKA analysis avoids the lifting issue. These additions strengthen the evidence for cross-resolution compatibility. However, they do not resolve the distinction between self-similarity and preservation of task-relevant information. Random-T measures the overall effect of changing connectivity, while the weight-similarity results characterize the outcome of training rather than identify its underlying mechanism. I appreciate the more qualified interpretation of self-similarity as a possible mechanism, but I remain unconvinced that the current analysis establishes a sufficiently distinct explanation beyond the benefits of geometry-informed grouping and task-relevant connectivity.

My remaining concerns therefore concern the strength of the scientific contribution and the comparative evidence, rather than the numerical discrepancy that has now been explained. Despite the useful clarifications and additions, I am maintaining my rating of 2.

Comments on the paper

1 comment

Hi Reviewers,

We are now near the end of the rebuttal period. If you haven't done so yet, please review the authors' responses and post a reply addressing whether their clarifications or new results resolve your concerns. Even if your score or recommendation remains unchanged, a brief note confirming what did or didn't shift your assessment—and why—is essential for the discussion and final decision. Thank you for your time and engagement.

Best regards,

Area Chair

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.