Adapting Precomputed Features for Efficient Graph Condensation

We thank the reviewer for the examination of our work and the thoughtful comments provided. Kindly find our responses to the raised comments and questions below.

Q1: Some recently proposed efficient GC are not discussed, including SimGC[1], EXGC[2], and CGC[3].

We thank the reviewer for highlighting the recent efficient GC methods. We set the smallest condensation ratios and present accuracy with total running time. Considering the inconsistent time measurements (e.g., CGC reports only the condensation time), we uniformly run evaluation to measure total running time. Our method consistently outperforms the baselines, while the efficient baselines underperform GEOM. We will revise the manuscript to incorporate these methods. (For fair comparison, we adopt the new baselines’ finer hyperparameter search and update GCPA results accordingly, which slightly differ from those in the paper.)

Q2: The novelty of the paper is limited. It seems that the structure-precomputation only uses the graph diffusion operators which is widely used to perform message passing, and semantic precomputation is a simple average operation.

Our work is motivated by the need to maintain strong structural and semantic guidance from the precomputed features. In many existing methods, precomputed features serve only as temporary constraints—initializing the learnable condensed features $Z'$—which can then vanish from the original signal as training progresses. In contrast, our approach employs a permanent constraint, where the precomputed features $\hat{X}'$ continuously guide the adaptation: $Z' = f_{adapt}(\hat{X}')$, ensuring their influence remains intact throughout training.

We illustrate this distinction using a variant of GCPA, replacing $f_{adapt}$ with learnable condensed features $Z'$. The performance drop indicate that our permanent constraint is effective in preserving critical information.

Q3: A lack of theoratical analysis on why the method is effective. The proposed method appears to be very simple. Could the author provide a theoratical analysis on how the proposed GCPA can achieve comparative or even superior data utility (i.e., classification performance) than the previous GC methods?

We appreciate the reviewer’s question and provide theoretical insight below.

[Under SGC model, graph condensation reduces to feature set condensation]

In Appendix G, we establish that, for the Simple Graph Convolution (SGC) model, the node embeddings can be precomputed as $X'=(\tilde{D}^{-0.5}\,\tilde{A}\,\tilde{D}^{-0.5})^KX$. Hence, replacing $A$ by an identity adjacency $I$ while using $X'$ is equivalent to using $A$ with the original features $X$. Thus, condensing a graph under SGC is essentially condensing the precomputed features $X'$.

[Contrastive loss increases mutual information]

Our contrastive loss uses logistic cross-entropy to distinguish positive (same-class) pairs from negative (randomly sampled) pairs. This is known to maximize a lower bound on $\mathrm{JS}(p^+\|p^-)$, where $p^+$ and $p^-$ are the positive and negative pair distributions. As $\mathrm{JS}(p^+\|p^-)$ increases, $X'$ and the condensed features $Z'$ become more class-discriminative, thereby increasing their mutual information on class-relevant signals. Combined with the SGC equivalence, it follows that condensing $X'$ under this contrastive loss effectively preserves and amplifies the class-relevant information in the original graph features $X$.

To support the claim on the effectiveness of our method, we present KSG mutual information (MI) [a] with accuracies below. The results show a clear increase in mutual information during both stages, along with improved accuracies. This trend highlights the importance of class separation in the adaptation process, thereby contributing to the strong performance of GCPA by helping to preserve class boundaries.

[a] Estimating mutual information

We thank the reviewer for the examination of our work and the thoughtful comments provided. Kindly find our responses to the raised comments and questions below.

Q1: Can you ablate the adaptation stage to the other expensive matching processes? The precomputation stage seems like a normal trick.

Thank you for the suggestion. We would like to clarify that our framework—precomputation followed by adaptation—is fundamentally different from existing methods, which typically follow an initialize-then-learn paradigm. The key difference lies in where message passing—the operation that captures graph structural information—is performed, as shown below:

Existing methods (e.g., CTRL, GEOM):

• Initialization: random sampling, clustering, etc.
• Learning: GNN training with repetitive message passing (the main source of computational cost)

Ours:

• Precomputation: one-time message passing
• Adaptation: MLP training (without message passing)

Our framework replaces the costly, repeated message passing (in the learning stage) in existing methods with a one-time message passing step (in the precomputation stage), achieving both efficiency and strong performance. This is not just a simple preprocessing trick, and we believe it constitutes a meaningful contribution.

As for replacing adaptation with existing matching processes, such changes may lead to redundant message passing (since precomputation already involves message passing, and existing matching processes involve repeated message passing during learning) and defeat the purpose of our efficiency gains. Nonetheless, we believe it deserves future exploration.

Q2: I cannot fully understand the setting of Appendix D.

Thank you for the question. In Appendix D, we highlight the effect of precomputation by comparing two settings:

• GCPA (Ours):
  1. Structurally precompute features $H$
  2. Semantically precompute condensed features $\hat{X}'$
  3. Adapt condensed features $Z'=f_{adapt}(\hat{X}')$ with precomputed features $H$
• GCPA without Precomputation (Ours with Random Initialization):
  1. Randomly initialize condensed features $X_{rand}'$,
  2. Adapt condensed features $Z'=f_{adapt}(X_{rand}')$ with original features $X$

Table 9 shows that removing precomputation leads to loss of structural information, and hence significantly worse performance. We conclude that precomputation is not merely an initialization step—it plays a critical role by embedding structural information and guiding adaptation learning. This ablation confirms that precomputation meaningfully contributes to performance, beyond what adaptation alone can achieve.

Q3: A deep explanation of the effectiveness of your methods? Clear motivation why you use such a precomputation stage and contrastive learning technique? Not that convincing, just a combination of the data process to me, better inspiration is expected.

The two stages–precomputation and adaptation–are motivated by the need to maintain strong structural and semantic guidance from the precomputed features. In many existing methods, precomputed features serve only as temporary constraints—initializing the learnable condensed features $Z'$—which can then vanish from the original signal as training progresses. In contrast, our approach employs a permanent constraint, where the precomputed features $\hat{X}'$ continuously guide the adaptation: $Z' = f_{adapt}(\hat{X}')$, ensuring their influence remains intact throughout training.

We illustrate this distinction using a variant of GCPA, replacing $f_{adapt}$ with learnable condensed features $Z'$. The performance drop indicate that our permanent constraint is effective in preserving critical information.

Besides, we provide theoretical insights on the effectiveness of our method from the perspective of mutual information. We kindly refer to Reviewer rs1P Q3 for this discussion.

We thank the reviewer for the examination of our work and the thoughtful comments provided. Kindly find our responses to the raised comments and questions below.

Q1: Code cannot be opened.

We apologize for the inconvenience. It appears there was a temporary issue. We have refreshed the repository and it is now accessible.

Q2: The authors do not discuss the effect of many hyperparameters.

Thank you for pointing this out. In the extended experiments, we tune the key hyperparameters below on the validation set and analyze their impact:

• Semantic aggregation size $M$
• Negative sample size $S$
• Damping factor $\alpha$
• Precomputation hops $K$
• Residual coefficient $\beta$

The results below show that the model is generally robust to these settings. Some hyperparameters ($M$, $S$) benefit from larger values, while others ($\alpha$) have stable optimal choices. A few others ($K$, $\beta$) require more careful tuning. We will clarify these findings in the revised version.

Q3: Does it truly make sense to coarsen the graph using only non-learnable message passing, with the learning component restricted to (the updated) node features?

Thank you for the thoughtful comment. We agree that relying on non-learnable message passing can introduce limitations and may not generalize to all datasets. However, in many real-world datasets—such as those used in graph condensation benchmarks—non-learnable message passing combined with MLPs (e.g., SIGN [a]) have shown competitive or even SOTA performance. A likely reason is that these benchmark datasets exhibit strong homophily or stable neighborhood patterns, allowing fixed message passing to capture key structural information effectively.

Our method follows a similar principle—non-learnable message passing combined with MLP adaptation—and achieves strong results, suggesting that this design can be effective in practice.

Q4: The margin between the best result of the proposed method and the strongest baseline remains relatively small in almost all cases.

Thank you for the observation. Our method is primarily designed for efficiency rather than solely maximizing performance. Given that current SOTA methods can be impractical (e.g., requiring up to 452 hours), our goal is to offer a more efficient alternative while aiming to match, not necessarily surpass, SOTA performance. Notably, our approach achieves significant speedup and even delivers leading results, which we find both promising and encouraging.

Q5: The condensed graph has no edges, so why would it make sense to apply GNN on it?

Your are correct that the condensed graph has no edges. This setup was first investigated in SFGC [b], where only self-loops are available for GNN message passing. Although counterintuitive, these methods—including ours—have shown superior performance. A potential reason is that the model learns to encode structural information into the condensed features for GNN to learn effectively, even without edges. We follow this established setting and believe it’s an interesting direction for further investigation.

Q6: Does GCN backbone play a role in the condensation process of the proposed method?

You are correct that GCPA does not rely on GCN during condensation. We appreciate your observation and will clarify this in revised version:

• Condensation: All methods except GCPA use GCN to guide learning.
• Evaluation: All methods including GCPA use GCN for evaluation.

Q7: Why adaptation has only a minor impact in some cases? Intuitively, I would have expected adaptation to play a more significant role than precomputation.

Thank you for the observation. The impact of adaptation indeed varies in a large range, affected by the quality of the precomputed features, which in turn is influenced by factors like data noises. We illustrate this by adding noise below. When the data is clean, precomputed features are already strong, so adaptation yields modest improvements. When we add noise and degrade the precomputed features, the adaptation becomes much more beneficial.

[a] SIGN: Scalable Inception Graph Neural Networks

[b] Structure-free Graph Condensation: From Large-scale Graphs to Condensed Graph-free Data

We thank the reviewer for the examination of our work and the thoughtful comments provided. Kindly find our responses to the raised comments and questions below.

Q1: The performance on Citeseer is unexpectedly high, surpassing even the most advanced GNNs on the original Citeseer graph.

Thank you for your observation. We note that on Citeseer, both baseline methods and our method have shown improved results compared to GCN trained on the original graph. This enhancement is likely due to the condensation process reducing noise in the data. The reproducible code is available here. We note that 75.4 remains within a reasonable range considering recent GNNs achieving 77.5 on Citeseer [a].

Q2: GCPA shows higher variability on Pubmed and Products. Addressing sampling randomness or imposing additional constraints within the contrastive learning process could help.

Thank you for your valuable feedback. To address the instability, we apply constraints including AdamW [b] and L2 regularization to the adaptation model, which constrains the impact of random samples. The updated results are presented below. We will update these changes in the revised manuscript.

Q3: Some important baselines focused explicitly on efficient graph condensation methods are omitted, notably references [1] and [2].

Thank you for your feedback. We kindly note that the references are missing, so we follow Reviewer rs1P Q1 to compare with SimGC [c], EXGC [d], and CGC [e]. We set the smallest condensation ratios and present accuracy with total running time. Considering the inconsistent time measurements (e.g., CGC reports only the condensation time), we uniformly run evaluation to measure total running time. Our method consistently outperforms the baselines, while the efficient baselines underperform GEOM. We will revise the manuscript to incorporate these methods. (For fair comparison, we adopt the new baselines’ finer hyperparameter search and update GCPA results accordingly, which slightly differ from those in the paper.)

Q4: In Line 168, the claim regarding the "non-learning process leading to sub-optimal representations" may not always hold true.

We acknowledge the misleading claim and revise the paragraph:

Our precomputation stage effectively captures the structural and semantic features of the original graph. Since the precomputation stage is not directly optimized for the final objective, we further integrate an adaptation learning stage that adjusts the class-wise representations.

Q5: Unclear term "SF".

Thank you for pointing this out. In Figure 2, "SF" stands for "structure-free", indicating that the condensed graphs possess no edges.

Q6: Inconsistent term "anchor".

Thank you for pointing out the inconsistency. To clarify, anchors refer to the sampled features $H_i \in H$, where $H$ denotes the precomputed features. The anchors serve as learning targets during the adaptation stage, preserving the original feature distributions.

Q7: Figure 3’s caption is not organized by different modules.

We appreciate your suggestion and revise the caption:

Overview of GCPA framework. (1) Structure-based precomputation: Neighborhood aggregation is performed to capture structural dependencies. (2) Semantic-based precomputation: Nodes are grouped by semantic relevance using uniformly sampled representations. (3) Adaptation learning: Synthetic features v1 and v2 are pushed away through diversity constraints, while v2 and v3 are pushed away through sampled negative pairs.

[a] From cluster assumption to graph convolution: Graph-based semi-supervised learning revisited

[b] Decoupled Weight Decay Regularization

[c] Simple graph condensation, ECML-PKDD 2024

[d] Exgc: Bridging efficiency and explainability in graph condensation, WWW 2024

[e] Rethinking and accelerating graph condensation: A training-free approach with class partition, WWW 2025

python train.py --dataset citeseer --reduction_rate 0.25 --use_test 1 \
--eval_runs 5 --eval_interval 10 --norm_feat 1 --select_mode random --nlayers_adjust 1 \
--wd_adjust 3e-5 --bn_adjust 1 --hidden_adjust 128 --residual_ratio_adjust 0.7 \
--dropout_adjust 0.3 --dropout_input_adjust 0.7 --lr_adjust 0.0003

train expert
Epoch: 384, Test acc: 0.715
expert acc: [100.0  73.2  71.5], std: [0.0 0.0 0.0]
eval init
Epoch: 566, Test acc: 0.743
Epoch: 547, Test acc: 0.731
Epoch: 300, Test acc: 0.724
Epoch: 258, Test acc: 0.740
Epoch: 399, Test acc: 0.719
init acc: [74.5 74.2 73.1], std: [4.5 1.3 0.9]
adapt epoch 10
Epoch: 25, Test acc: 0.747
Epoch: 22, Test acc: 0.744
Epoch: 36, Test acc: 0.747
Epoch: 6, Test acc: 0.728
Epoch: 69, Test acc: 0.752
acc: [70.2 76.0 74.4], std: [2.7 0.5 0.8]
adapt epoch 20
Epoch: 75, Test acc: 0.746
Epoch: 13, Test acc: 0.741
Epoch: 28, Test acc: 0.747
Epoch: 34, Test acc: 0.752
Epoch: 5, Test acc: 0.743
acc: [71.0 76.4 74.6], std: [1.6 0.5 0.4]
adapt epoch 30
Epoch: 15, Test acc: 0.755
Epoch: 7, Test acc: 0.748
Epoch: 38, Test acc: 0.751
Epoch: 423, Test acc: 0.760
Epoch: 12, Test acc: 0.748
acc: [70.7 77.2 75.2], std: [1.4 0.3 0.5]
adapt epoch 40
Epoch: 12, Test acc: 0.747
Epoch: 143, Test acc: 0.757
Epoch: 136, Test acc: 0.759
Epoch: 337, Test acc: 0.755
Epoch: 509, Test acc: 0.756
acc: [69.7 77.8 75.5], std: [1.5 0.2 0.4]
adapt epoch 50