acceptodds
Under review as a conference paper at ICLR 2027

Graph-dependent pooling: adaptive granularity in hierarchical graph neural networks

Abstract

Graph Neural Networks are widely used to learn structural representations of relational data. Hierarchical graph pooling learns multi-level representations by progressively coarsening graphs; however, prior methods rely on predefined cluster numbers or fixed pooling ratios, limiting adaptability to individual graphs. We propose Graph-Dependent Pooling (GDPool), which dynamically determines pooling granularity for each graph. We analyze optimization conflicts among layer-wise objectives through gradient alignment, showing that layer-wise objectives at different pooling levels can send conflicting gradients to shared parameters. GDPool uses self-attention to select graph-specific anchors representing structurally important nodes and constructs coarse graphs through soft node assignment. Experiments on metal-organic framework and molecular graph benchmarks show that GDPool consistently achieves the best predictive performance across all benchmarks. Evaluations using modularity and the effective number of clusters show that GDPool achieves consistently higher modularity than existing methods while the number of active clusters decreases monotonically with depth. Sensitivity analyses confirm stable behavior across hyperparameter and architectural choices.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Graph neural networks, hierarchical graph pooling, adaptive graph coarsening, molecular property prediction, metal-organic frameworks

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_sJEhOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

The paper proposes a novel hierarchical pooling operation for graph neural networks, Graph-Dependent Pooling (GDPool) that aims to automatically learn a pooling granularity for each graph using self-attention and soft node assignment. To reach better agreement across multiple pooling layers, GDPool uses hierarchical supervision, applying the pooling objective to the cumulative assignment across pooling levels, and identifies anchors of important nodes in the original graph that define the pooling assignment and the number of nodes in the pooled graph. Performance is evaluated on 4 graph regression tasks compared to three baseline methods, showing that GDPool reaches superior or comparable performance to baseline models.

Critical strengths

Evaluating and learning the best granularity for each graph across multiple pooling levels is of interest for graph pooling overall and the work presents a novel perspective on not just adaptively selecting an appropriate pooling ratio for each graph, but also optimising the hierarchical pooling jointly across multiple pooling layers. Overall, the execution is convincing and the results are easy to follow and appear to be promising.

Critical weaknesses

Comparison with a wider set of baseline methods. It would be useful to compare with a wider range of pooling layers, for example as implemented in the tgp (Torch Geometric Pool), specifically to compare with nontrainable pooling layers using different pooling mechanisms or with further adaptive pooling layers, such as ASAGPool. As it stands, GDPool is mainly compared to dense attention-based pooling methods, such as DiffPool. Further, as suggested below, it would be useful to also compare GDPool to using no pooling layer, or to randomised ablations, to assess which components of GDPool influence or improve performance.

Tuning the coarsening levels of the baseline methods. Further, to ensure consistence, it might be fair to investigate the granularity GDPool selects per graph, and tune the pooling layers it is compared to coarsen graphs to the same or higher numbers of nodes, so that the performance differences are not just driven by the fact that GDP learns consistently lower pooling ratios, e.g. uses less extreme coarsening. For example, if other pooling methods use a pooling ratio of 0.5 for each graph, but GDPool generally uses 0.8, this could already cause substantial performance differences. Based on Figure 3 this does not necessarily seem to be the case for pooling-ratio based methods on hMOF for the first pooling layer. But for fixed cluster-based methods, it might be worth increasing the number of clusters to evaluate whether tuning the number of clusters selected, the baseline methods could not also reach more comparable performance to GDPool. Similarly, it would be useful to repeat such ablations for more datasets and for the 2nd and 3rd pooling layers as well, to track whether the degree of coarsening remains broadly comparable to the baselines or not.

Modularity depending on the pooling mechanism. Could you report Table 2 for a wider range of pooling methods, e.g. also including edge pooling or sparse pooling operations? There is reason to believe that hard rather than soft node assignment methods might retain higher modularity.

Limited number of evaluated tasks. The main experiments evaluate 4 graph-level regression tasks, which by themselves show only a limited number of examples. It would be useful to compare across a wider range of tasks, for example graph-level classification tasks, which are commonly reported on. Especially datasets with larger graph sizes would be of interest.

Computational costs as a major limitation. GDPool itself seems to be relatively computationally expensive as reported in Table 3. It is known that as dense pooling methods, DiffPool and MinCutPool already scale relatively badly to large graphs, with GDPool reaching worse runtimes and higher memory usage. This is a clear limitation of the proposed method, likely ensuring that it will not scale to very large graphs.

Minor comments:

  • It would be useful to define the lower-level assignment S(l) in line 151 in terms of the pooling operation, especially for readers unfamiliar with graph pooling.
  • Conceptually, why would you think that layers should align? Is there one correct pooling objective per graph? Or would it not also still be possible to get a sensible pooling overall through conflicting objectives?
Questions for authors
  • Could you evaluate a random version of your Empool operator? Similar to the ablations reported in “Rethinking pooling in graph neural networks” by Mesquita et al. (2020), it would be interesting to evaluate a randomised version of your algorithm that instead of learning the node assignment, for example uses a random selection of anchor nodes and potentially also a random node assignment. Such ablations could reveal which components of GDPool influence performance.
  • Could you compare the performance of GDPool to the same GFFN architecture without using any pooling layers? That is, repeat the experiments without any pooling to see whether the proposed pooling operation increases or decreases performance.
  • Could you report further ablations on the choice of pooling ratio or cluster numbers for the baseline pooling methods compared across your experiments, and how they match your own method’s node selection?
2 comments

We thank the reviewer for the detailed review. We understand "Empool" in the questions to refer to GDPool.

  1. Wider set of baselines: From tgp, we added two non-trainable pooling operators with different mechanisms: Graclus, which merges matched node pairs, and LaPool, which selects a graph-dependent number of leaders. We also added ASAGPool, which learns its retention ratio, implemented following the original paper. GDPool performs best on all five regression tasks and both classification tasks (Tables 1 and 7); the table in our common comment lists their MAE.
  2. Model without pooling and randomized variants:
    • GFFN-only performs worse than GDPool on every task (Table 17).
    • Random, degree, and PageRank anchors and the random-assignment variant also perform worse than GDPool in every setting (Table 18).
    • Even with a fixed random assignment, GDPool outperforms GFFN-only on hMOF and QM9. Hierarchical coarsening and the learned assignment therefore each contribute to the performance.
  3. Matching the granularity of the baselines:
    • At the first level, GDPool keeps about 15% of the nodes as anchors (C ≈ 0.15N), a much stronger coarsening than the default ratio of 0.5 (Appendix G.1). The gain of GDPool therefore does not come from milder coarsening.
    • We set the number of clusters of the baselines to 20/10/6 and their pooling ratio to 0.15/0.5/0.5, matching the mean number of anchors of GDPool (19.7/10.0/5.7) at all three levels. No baseline reaches GDPool (Table 16, Appendix J).
    • Conversely, the results of GDPool with a fixed K or ratio are given in Table 9.

MAE on hMOF CO₂@0.1, mean ± std over three seeds (Table 16). Default: K = 32/16/8 or r = 0.5 at every level. Matched: K = 20/10/6 or r = 0.15/0.5/0.5.

MethodDefaultMatched
DiffPool0.159 ± 0.0020.154 ± 0.017
MinCutPool0.129 ± 0.0010.130 ± 0.001
MemPool0.129 ± 0.0000.130 ± 0.001
BN-Pool0.130 ± 0.0010.130 ± 0.001
TopKPool0.137 ± 0.0020.144 ± 0.001
SAGPool0.137 ± 0.0010.141 ± 0.005
ASAPool0.422 ± 0.0000.327 ± 0.160
ASAGPool0.142 ± 0.0100.145 ± 0.012
MaxCutPool0.347 ± 0.0160.343 ± 0.028
GDPool0.125 ± 0.002–
  1. Modularity across pooling mechanisms (Section 5.2, Table 2):
    • For Graclus, EdgePool, and MaxCutPool, we use the hard partitions they produce. For node selection methods, we form a partition by assigning each node to its nearest kept node. To compare soft and hard assignments on the same basis, we also compute the argmax partition of GDPool.
    • On hMOF, the modularity of all hard methods is 0.21 or lower, whereas the argmax partition of GDPool reaches 0.44/0.47/0.35 and is the highest at every level.
  2. Classification and larger graphs: We added Peptides-func (151 nodes on average) and REDDIT-MULTI-12K (391 nodes on average, up to 3,782) as benchmarks (Table 7). GDPool achieves the best performance on both added benchmarks.
  3. Computational cost: We agree that this is a limitation.
    • To evaluate only the training cost, we re-measured all methods under identical settings. The training time per epoch of GDPool is at most about 1.2 times that of any other method; it is faster than MaxCutPool and LaPool and about 11 times faster than EdgePool.
    • Its peak memory of 9.82 GB is the highest (Table 3).
    • According to Figure 5, GDPool can be trained on a single GPU for graphs with up to a few thousand nodes, whereas larger graphs would require extensions such as sparse attention. We state this limitation in Appendix C.
  4. Minor comment 1: In Section 3.1, we now define S(l)S^{(l)} as the assignment matrix with which the corresponding pooling level maps its input nodes to coarse nodes.
  5. Minor comment 2 (why layers should align):
    • We do not assume that there is a single correct objective per graph.
    • However, all levels are built from successive assignments of the same original graph and share parameters. When the gradients of the level-wise objectives conflict, an update that improves one level can degrade another.
    • With the same GDPool architecture on ARC-MOF (Table 11):
      • Layer-wise supervision: MAE 0.250, modularity 0.00 at all levels
      • Hierarchical supervision: MAE 0.151, modularity 0.42/0.41/0.23
      • Supervision of the final level only: similar accuracy (0.152), but the first level uses about 54 anchors and its modularity drops to 0.16
    • Training remains possible with conflicting objectives, but in this setting both accuracy and hierarchy quality deteriorate.

We hope that our responses and the revisions address the reviewer's concerns, and we would appreciate it if the reviewer could reconsider the evaluation.

Update to our reply. Tables 17 and 18 now cover the same six datasets. This revises three statements above:

  • Following reviewer jejw's suggestion, REDDIT-MULTI-12K is removed from the accuracy tables, so Table 7 reports Peptides-func only, on which GDPool remains the best (AP 0.599 against 0.488).
  • In Table 18, GDPool has the best mean on four of the six datasets; PageRank anchors are slightly better on ZINC and random assignment on Peptides-func, both within one standard deviation.

Our common comment summarizes all changes in the revision.

Reviewer_jejwOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
3
Soundness
1
Read review
Paper summary

This paper proposes Graph-Dependent Pooling (GDPool), which is a hierarchical graph pooling algorithm that is based on two main components: (1) soft assignment of nodes to anchors, which are defined as nodes whose cumulative attention scores are greater than the mean attention score for each graph and (2) hierarchical supervision with link prediction and entropy regularization losses. The authors argue that existing methods suffer from gradient conflict between hierarchical layers, occurring when gradients coming from layer-wise objectives are misaligned while sharing parameters. GDPool solves this issue and outperforms clustering-based, node selection-based, and edge contraction-based methods across four benchmark datasets, spanning metal-organic frameworks and molecular graphs.

Critical strengths
  1. The paper is very well-written, enjoyable to read, and fits the chosen primary area. The idea of comparing cumulative attention scores to choose anchor nodes is simple and elegant. I believe this non-parametric design choice is a plus given the complexity of hierarchical pooling.
  2. The paper is rigorous in terms of experiments, results, and ablations. It provides comprehensive benchmarking against the main hierarchical graph pooling operators in the literature, reports the mean as well as the standard deviation in tables, and the existing analysis is executed meticulously.
Critical weaknesses

The reviewer is critically concerned about the central premise motivating the work, which is the necessity of hierarchical graph pooling, especially for the chosen datasets. The reviewer kindly advises the authors to read the following papers:

  • [1] Sbicego, Luca, et al. "On the Role of Structure in Hierarchical Graph Neural Networks." I Can't Believe It's Not Better: Challenges in Applied Deep Learning. 2025.
  • [2] Mesquita, Diego, et al. "Rethinking Pooling in Graph Neural Networks." NeurIPS. 2020.
  • [3] Bechler-Speicher, Maya, et al. "Position: Graph Learning Will Lose Relevance Due to Poor Benchmarks." ICML. 2025.

[1] extends the work of [2], showing that in the DD and PROTEINS datasets, graph structure is uninformative since a randomized pooling operator works on par with MinCutPool and Top-K, and in commonly benchmark datasets including NCI1 and COLLAB, the graph structure is learned after the initial convolutions, indicating that their respective tasks may not critically depend on the graph at hand. Similarly, [3] demonstrates that, in certain datasets, using Cayley graphs instead of the original graphs sometimes leads to performance improvements.

In light of the above evidence, the reviewer believes that an in-depth analysis proving that the evaluated datasets are indeed the right evaluation playground for graph pooling is of utmost importance, and encourages the authors to provide:

  • An analysis, following the experimental design in [1], showing whether or not the graph structure is informative given the tasks in the benchmark datasets.
  • An analysis of the performance of simple structure-unaware baselines, such as, but not limited to, MLPs and DeepSets, that do not take the graph edges into account.
  • An analysis of the performance of flat-GNNs, including GCN, GAT, and GIN, to understand whether the hierarchical step is necessary.
Questions for authors

Please see the weaknesses above. What is the performance of structure-unaware baselines, randomized graphs, and flat-GNNs on the four benchmark datasets? After this comparison, is the performance difference of GDPool still convincing? Are the benchmark datasets the right setting for the problem?

6 comments

We thank the reviewer for raising this important point and for the references. Following the suggestion, we added Section 5.6 and cite [1]–[3]. The table below summarizes the results.

MAE, mean ± std over three seeds (Tables 17 and 18). Random assignment is the GDPool variant without anchor selection.

ModelARC-MOF CO₂@0.15hMOF CO₂@0.1hMOF CH₄@0.9ZINCQM9
MLP0.522 ± 0.0010.341 ± 0.0040.323 ± 0.0020.663 ± 0.0010.927 ± 0.000
DeepSets0.516 ± 0.0010.345 ± 0.0020.321 ± 0.0010.664 ± 0.0030.879 ± 0.001
GCN0.169 ± 0.0010.138 ± 0.0010.118 ± 0.0000.311 ± 0.0010.433 ± 0.001
GAT0.166 ± 0.0010.136 ± 0.0010.116 ± 0.0010.262 ± 0.0230.404 ± 0.001
GIN0.889 ± 0.0000.423 ± 0.0000.362 ± 0.1680.234 ± 0.0120.410 ± 0.002
GFFN-only0.167 ± 0.0010.137 ± 0.0010.118 ± 0.0010.255 ± 0.0120.409 ± 0.002
Random assignment–0.127 ± 0.0000.107 ± 0.001–0.406 ± 0.003
GDPool0.151 ± 0.0000.125 ± 0.0020.106 ± 0.0010.240 ± 0.0150.402 ± 0.003
  1. Structure-unaware baselines: As the case in which structural information is removed entirely, we evaluate MLP and DeepSets, implemented as in Errica et al. (2020), which use no edges at all. Both have more than twice the MAE of GDPool on all five tasks. Unlike DD and PROTEINS in [1], the graph structure carries essential information on these benchmarks.
  2. Flat GNNs: We compare with GCN, GAT, and GIN with the same encoder, width, and readout and matched depth.
    • The gap is clear on MOFs and small on the molecular graphs. On ZINC, GIN reaches 0.234, slightly below the 0.240 of GDPool but within one standard deviation.
    • On MOFs, GIN is worse than even the structure-unaware models. MOF nodes have about 12 neighbors, far more than the about two in molecules, and unlike GCN and GAT, GIN sums neighbor features without normalization. On MOFs, this sum appears to inflate the feature scale over the four layers and destabilize training, which is consistent with the large variation across seeds on hMOF CH₄ (0.362 ± 0.168).
  3. Contribution of the hierarchical step: GFFN-only, which removes only the pooling step and has nearly the same number of parameters, has a higher MAE than GDPool on every task. This indicates that hierarchical pooling itself contributes to the performance.
  4. Randomization analysis following [1]: Similar to [1] and [2], we evaluate two variants (Table 18).
    • The first uses a fixed random assignment without anchor selection, and the second selects anchors randomly, by degree, or by PageRank.
    • Even the random-assignment variant has a clearly lower MAE than GFFN-only on hMOF (0.127 vs. 0.137), so hierarchical coarsening itself is beneficial on these benchmarks.
    • The learned assignment and the attention-based anchors of GDPool are consistently better than the random alternatives in every setting.
  5. Suitability of the benchmarks: MOF graphs have 140–160 nodes on average and contain substructures such as metal nodes and linkers. On HKUST-1, the first-level anchors fall on the Cu paddlewheels and the branch points of the linkers (Appendix G.4). The gain from hierarchical pooling is also largest on these large MOF graphs. In addition, we added two graph classification benchmarks (Table 7).

In summary, graph structure is essential on these benchmarks, and the hierarchical pooling of GDPool provides a further gain on top of it. We hope this analysis addresses the reviewer's concern and would appreciate it if the reviewer could reconsider the evaluation.

Reviewer_jejwOpenReview ↗

Response to rebuttal by authors

Thank you for taking the suggestions into account and running these additional experiments. The reported results only partially answer my concerns.

After reading both your response here and the respective sections in the revised manuscript, I would like to mention the following points:

  • Table 17 indeed demonstrates that GDPool outperforms structure-unaware baselines and flat-GNNs (except GIN on ZINC). This answers my second and third points.
  • Table 18, however, raises certain doubts and confirms my concerns. First of all, I would like to ask why there is a mismatch between the datasets used in Table 17 and Table 18. Second, is there a justification for the missing random-assignment results for the ARC-MOF and ZINC datasets in the table above? If the experiments are still running, I would be willing to wait for their results. Third, as shown in Table 18 in the revised manuscript, the random assignment configurations perform on par with GDPool (within std) across all reported datasets. Unfortunately, these results remain unsatisfactory regarding the suitability of these datasets for the question at hand.
  • Thank you for the new graph classification benchmarks in Table 7. Prior work [1] has shown that the graph structure in REDDIT-MULTI-12K is learned after at most two convolutions (please see Figure 3 in [1]). Therefore, I believe this dataset should not be included. In fact, in Table 18, all the random assignments, along with GDPool, perform very similarly on this dataset.

While I appreciate the partial clarification on some points, the distinction between randomized and original graphs remains a critical concern, as it directly impacts the validity of the setup for the core research question. I keep my current score for now, however, I prefer to lower it if this fundamental issue is not satisfactorily resolved.

Thank you for the follow-up. As you noted, our ARC-MOF and ZINC experiments were still running at our previous reply, so we made the new tables from the completed datasets, causing the dataset mismatch between Tables 17 and 18. All experiments are now complete. Following your suggestion and prior work [1], we removed REDDIT-MULTI-12K, which now remains only in the cost analysis of Appendix C, so all tables use the same six benchmarks. The revised PDF also adds randomized input graphs and a cluster analysis (Section 5.6; Tables 17–19 in Appendix K).

1. Randomized vs. original graphs

We trained GDPool on degree-preserving random rewirings of the input graphs. Edges exchange endpoints within each graph so that every node keeps its degree, edge features move with their edges, and each graph is rewired once per run and kept fixed. Training, validation, and test graphs are all rewired; all other settings are unchanged.

GDPoolARC-MOFhMOF CO₂hMOF CH₄ZINCQM9Peptides-func AP ↑
Original graphs0.1510.1250.1060.2400.4020.599
Randomized graphs0.1730.1400.1160.5870.7320.389

MAE unless noted; all std ≤ 0.015 (Table 17).

  • Randomization raises the MAE by 145% on ZINC and 82% on QM9 and lowers the AP on Peptides-func to 0.389, below MLP (0.445) and DeepSets (0.520). These benchmarks thus depend on the original graph.
  • On MOFs, the MAE rises by 9–15%, to about the level of the flat GNNs. The MOF encoder also receives atomic coordinates, which the rewiring leaves unchanged.
  • On all six benchmark datasets, the gap is significant (Welch's t-test, p < 0.01).

2. Randomized pooling (Table 18)

ARC-MOFhMOF CO₂hMOF CH₄ZINCQM9Peptides-func AP ↑
Random assignment0.154 ± 0.0020.127 ± 0.0000.107 ± 0.0010.264 ± 0.0070.406 ± 0.0040.603 ± 0.014
GDPool0.151 ± 0.0000.125 ± 0.0020.106 ± 0.0010.240 ± 0.0150.402 ± 0.0030.599 ± 0.006
  • Random assignment is worse on all five regression tasks, but no single difference is significant, and it is slightly better on Peptides-func. We agree that accuracy alone barely separates the two on these benchmarks and state this in Appendix K. Together with point 1, this matches the observation in [1] that randomized pooling stays competitive even where the input structure matters.
  • Against random, degree, and PageRank anchors, GDPool has the best mean on five of the six datasets; PageRank anchors are slightly better on ZINC, within one std.

3. Where they differ: the clusters (new Table 19)

  • Random assignment has a modularity of 0.000 to −0.008 on every dataset, as expected for an assignment independent of the graph. Its near-100% activation only reflects that the fixed random logits spread every node over many clusters, which then receive nearly equal mass.
  • The attention-based assignment of GDPool makes the clusters follow the graph: GDPool reaches a modularity of 0.23–0.42, and the same assignment with random, degree, or PageRank anchors still reaches 0.20–0.44.
  • The attention-based anchors determine how many clusters are actually used. On MOFs, the other anchor rules select 1.7–2.0× as many anchors, of which only 52–58% are active, whereas GDPool activates 89–96% of its anchors on every dataset.
  • GDPool is thus the only rule whose clusters both follow the graph and are populated on every dataset, and the case study in Appendix G.4 shows that they are chemically meaningful: in all three training seeds, the first-level clusters split HKUST-1 into the coordination spheres of its Cu paddlewheels, which host the primary CO₂ binding sites, and the arms of its linkers.

4. GIN on ZINC

Thank you for raising this point. On ZINC, GIN reaches 0.234 ± 0.015 against 0.240 ± 0.015 for GDPool, well within one standard deviation, while GCN and GAT remain behind GDPool (0.311 and 0.262). Pooling has little to coarsen on these small graphs: with about 23 nodes per graph, the first level of GDPool already forms clusters of only two to three nodes (Table 19). The gain from pooling appears on the graphs with 140–160 nodes, where GDPool lowers the MAE by 8–9% over the best flat GNN on MOFs and raises the AP from 0.554 to 0.599 on Peptides-func. The best flat GNN also changes with the dataset: GIN, the best on ZINC, is the worst on MOFs, whereas GDPool is the best or on par on every dataset. Section 5.6 now states this.

Corrections to our first reply

  • "Similar to [1] and [2]" applies only to random assignment. The random, degree, and PageRank anchors are our ablation of the anchor selection.
  • "Consistently better in every setting" was overstated, as point 2 shows.
  • Random assignment beats GFFN-only on MOFs, QM9, and Peptides-func, but not on ZINC.

Your comments helped us find the limitations of our analysis and address them with new experiments, and we thank you again for the constructive discussion.

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

This paper proposes Graph Dependency Pooling (GDPool), a hierarchical graph pooling method that adapts pooling granularity to individual graphs. This method selects nodes whose total attention exceeds the graph-wide mean as anchors, and then soft-assigns all nodes to these anchors to construct a coarsened graph. Hierarchical supervision evaluates the cumulative assignment at each pooling level against the original graph to preserve cross-level structural relationships and alleviate conflicts among auxiliary objectives. Experiments on benchmarks report better prediction performance, as well as a coherent hierarchical structure with decreasing effective cluster numbers layer by layer, without the need for presetting the number of clusters or fixed pooling ratios.

Critical strengths
  1. The paper is clearly structured and easy to follow.
  2. GDPool determines the pooling granularity for each graph by selecting nodes whose total attention exceeds the average as anchors, avoiding predefined cluster counts or pooling ratios. It supervises the cumulative allocation of each layer to the original graph and provides a common structural reference for different pooling levels.
  3. The experiment covered four molecular and material benchmarks, and when compared with nine pooling baselines, GDPool achieved the lowest MAE on all five prediction targets. The ablation experiments on anchor selection and supervision methods, as well as the analysis of structural quality and robustness across random seeds, provided a detailed examination of the proposed method.
Critical weaknesses
  1. The contribution of attention scores to anchor selection has not been independently verified. Under the same number of anchors for each graph and each layer, how does task performance differ across different anchor selection methods, such as random selection, PageRank, or degree-based methods?
  2. The downstream tasks and datasets used for evaluation are still limited. The current experiments focus only on graph regression, and the performance of GDPool on other downstream tasks, such as graph classification, remains unclear.
  3. The paper has already reported theoretical complexity, training time, and memory usage, but the analysis of scalability is still limited. In particular, it is necessary to further explain how the computational time and memory cost of GDPool change as the graph size increases, and whether the high memory usage may limit its applicability to large-scale graphs.
Questions for authors

See the weakness.

3 comments

We thank the reviewer for the positive assessment and the concrete suggestions.

W1. Contribution of attention to anchor selection

  • For each graph and level, we keep the number of anchors selected by GDPool and choose the anchors randomly, by degree, or by PageRank instead (Section 5.3, Table 18).

MAE on hMOF and QM9 (lower is better) and accuracy on REDDIT-MULTI-12K (higher is better), mean ± std over three seeds (Table 18).

Anchor ruleAssignmenthMOF CO₂@0.1hMOF CH₄@0.9QM9REDDIT Acc (%)
RandomGDPool0.126 ± 0.0010.107 ± 0.0000.410 ± 0.00045.907 ± 0.172
DegreeGDPool0.126 ± 0.0010.107 ± 0.0010.405 ± 0.00146.130 ± 0.532
PageRankGDPool0.127 ± 0.0000.107 ± 0.0010.404 ± 0.00346.326 ± 0.732
NoneRandom0.127 ± 0.0000.107 ± 0.0010.406 ± 0.00346.438 ± 0.362
GDPoolGDPool0.125 ± 0.0020.106 ± 0.0010.402 ± 0.00347.443 ± 1.134
  • Overall, the attention-based anchors of GDPool perform best in every setting. The differences are on the order of one standard deviation on hMOF and larger on QM9 and REDDIT-MULTI-12K. We see two reasons why they are not larger:
    • Fixed number of anchors: This experiment fixes the number of anchors to that of GDPool. The rule that sets this number affects both accuracy and the hierarchy (Table 9): a ratio of 0.5 raises the MAE to 0.131, a fixed K leaves more than half of the first-level anchors unused, and even a fixed ratio matched to GDPool uses only 71% of its first-level anchors, against 89% for GDPool. Table 18 holds this factor fixed and isolates the effect of which nodes are chosen.
    • Learned assignment: All variants keep the attention-based soft assignment of GDPool, in which every node is assigned to all anchors without locality constraints, so the learned assignment largely compensates for less suitable anchors.
  • The role of anchor selection lies more in forming an interpretable hierarchy than in accuracy. The attention-based anchors are selected consistently across seeds (Jaccard similarity 0.581, against 0.071 for random sets of the same size; Table 8), and on HKUST-1 they fall on the Cu paddlewheels and the branch points of the linkers (Appendix G.4).

W2. Graph classification

  • We added Peptides-func and REDDIT-MULTI-12K, and GDPool achieves the best result on both (Section 5.1, Table 7).

Graph classification, mean ± std over three seeds (Table 7).

MethodPeptides-func AP ↑REDDIT-MULTI-12K Acc (%) ↑
Graclus0.483 ± 0.00643.755 ± 0.365
LaPool0.483 ± 0.00344.901 ± 0.430
DiffPool0.378 ± 0.00630.651 ± 1.126
MinCutPool0.479 ± 0.01445.124 ± 0.269
MemPool0.488 ± 0.00645.236 ± 0.317
BN-Pool0.467 ± 0.00446.186 ± 0.365
TopKPool0.436 ± 0.01243.364 ± 1.433
SAGPool0.427 ± 0.00342.414 ± 0.871
ASAPool0.324 ± 0.13844.733 ± 0.491
ASAGPool0.393 ± 0.07142.833 ± 1.050
MaxCutPool0.220 ± 0.01441.017 ± 1.970
EdgePool0.486 ± 0.00645.823 ± 0.256
GDPool0.599 ± 0.00647.443 ± 1.134

W3. Scalability

  • On REDDIT-MULTI-12K, whose graphs have 2 to 3,782 nodes, we measured the time and memory of one training step per graph-size bin (Figure 5, Appendix C).
  • When graphs are processed one at a time, the time of most methods, including GDPool, stays nearly constant up to about 2,000 nodes.
  • GDPool uses more memory than the other dense methods, but even for the largest bin a training step on 16 graphs requires about 9.8 GB.
  • GDPool can therefore be trained on a single GPU for graphs with up to a few thousand nodes, while larger graphs would require extensions such as sparse attention. We state this limitation in Appendix C.
  • On hMOF, the training time per epoch of GDPool is at most about 1.2 times that of any other method, and its peak memory of 9.82 GB is the highest (Table 3).

We are happy to answer any further questions.

Update to our reply. Table 18 now covers all six datasets, and the new Table 19 reports the clusters of each rule. This revises three statements above:

  • The anchor variants do not keep the number of anchors of GDPool. Each sets its number of anchors with the same attention-based rule, and on MOFs they select 1.7–2.0× as many anchors as GDPool, of which only 52–58% are active, against about 89% for GDPool (Table 19).
  • In Table 18, GDPool has the best mean on four of the six datasets; PageRank anchors are slightly better on ZINC and random assignment on Peptides-func, both within one standard deviation. The claim "best in every setting" was therefore overstated.
  • Following reviewer jejw's suggestion, REDDIT-MULTI-12K is removed from the accuracy tables (Tables 7 and 18). It remains only in the cost analysis of Figure 5, which our answer to W3 refers to.

Our common comment summarizes all changes in the revision.

Thank you for responding to my comments clarifying the requested aspects. I appreciate the additional analysis but I maintain my initial (positive) score, in light of other only partially addressed concerns raised by the other reviewers.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.