BN-Pool: Bayesian Nonparametric Pooling for Graphs
Authors: Daniele Castellana
Filippo Maria Bianchi
Venue: Accepted by TMLR ()

Abstract: We introduce BN-Pool, the first clustering-based pooling method for Graph Neural Networks that adaptively determines the number of supernodes in a coarsened graph. 
BN-Pool leverages a generative model based on a Bayesian nonparametric framework for partitioning graph nodes into an unbounded number of clusters. During training, the node-to-cluster assignments are learned by combining the supervised loss of the downstream task with an unsupervised auxiliary term, which encourages the reconstruction of the original graph topology while penalizing unnecessary proliferation of clusters. By automatically discovering the optimal coarsening level for each graph, BN-Pool preserves the performance of soft-clustering pooling methods while avoiding their typical redundancy by learning compact pooled graphs. 
The code is available at https://github.com/NGMLGroup/Bayesian-Nonparametric-Graph-Pooling

Published in Transactions on Machine Learning Research (04/2026)
BN-Pool: Bayesian Nonparametric Pooling for Graphs
Danicle Castellana Università degli Studi di Firenze
danicle. Somiccle.csseelann@@aanig
Filippo Maria Bianchi
filippo. m. bionchi@uit.re
UTI The Arctic University of Norway and NORCE Norwegion Research Centre AS
Reviewed OpenReview: https: // //wpreeveeeeeeeuee/e/ formm? id= 3B32r2affk
Abstract
We introduce BN-Pool, the first clustering- based pooling method for Graph Neural Networks that adaptively determines the number of supernodes in coarsened graph. BN-Pool leverages a generative model based on a Bayesian nonparametric framework for partitioning graph nodes into an unbounded number of clusters. During training, the node-to-cluster assignments are learned by combining the supervised loss of the downstream task with an unsupervised auxil- iary term, which encourages the reconstruction of the original graph topology while penalizing unnecessary proliferation of clusters. By automatically discovering the optimal coarsening level for each graph, BN-Pool preserves the performance of soft-clustering pooling methods while avoiding their typical redundancy by learning compact pooled graphs. The code is http://yyessaaannaaaaaaeeeeeee Pooorraa---oo-innggggggg--
available at https: //gi::///htttt com
1 Introduction
Graphs sit at the heart of drug-discovery pipelines, traffic-flow simulators, social-network recommenders, and growing list of web-scale systems. Thanks Graph Neural Networks (GNNs), powerful class of deep learning models designed to process graph-structured data, the state-of-the-art. those tasks has significantly improved over the past few years (Zhou al., 2020). Despite the numerous advances in their architectural design, GNNs still struggles to learn hierarchical represeniations that are compact and consistently optimal for wide range of downstream tasks.
Pooling, a fundamental component in computer vision architectures, becomes far trickier on irregular, non- Euclidean graphs, which are hard to down-sample without sacrificing structure or features. Popular and best-performing graph pooling operators (Wang et al., 2024) build coarse graphs by clustering nodes, but they hard-code the number of supernodes K for every input graph (Ying et al., 2018; Bianchi al., 2020a); thus, all the coarsened graphs have the same size. Moreover, tuning the value of K can be difficult: rather than employing expensive hyperparameter sweep, the common approach is to set it to value large enough to avoid information loss (e.g., a fraction of the average size of all the graphs in the dataset). This rigidity prevents the model from adapting dynamically to the graph structure and produces redundant and dense representations (see Figure 1), which are less interpretable and yield unnecessary computations.
To overcome these limitations, we introduce Bayesian Nonparametrie Pooling (BN-Pool), a novel graph pooling operator based on Bayesian Nonparametric (BNP) technique. We define generative process for the adjacency matrix of the input graph where the probability of having link between two nodes depends their cluster membership. thus ensuring that clusters reflect the graph topology. The BNP approach allows the number of clusters K to adapt to each input graph, rather than being fixed in advance. Within our Bayesian framework, the clustering function is the posterior of the cluster membership given the input graph. We approximate the posterior by employing a GNN; on the one hand, this permits capturing complex relations that appear between the hidden and the observable variables; on the other hand, we can jointly condition the posterior the graph topology, the node features, and the ream task. The GNN parameters are

---

Published in Transactions on Machine Learning Research (04/2026)
Fixed K
BN-Pool
BN-Pool
K
K
Figure 1: (Left) typical pooled graph computed by a clustering- based pooling approach with fixed K (left) and by BN-Pool (right). (Right) BN-Pool learns end-to-end the number of clusters K to pool cach graph independently.
trained by optimizing two complementary objectives: one defined by the loss of the downstream task (e.g., cross-entropy in graph classification), the other defined by an unsupervised auxiliary loss that derives from the probabilistic generative process.
Our main contributions are:
We introduce the first soft-clustering pooling operator capable of adaptively determining the number of supernodes for each input graph.
We adapt the Stochastic Variational Inference (SVI) framework training procedure that enables seamless integration of BNP with GNN architectures and supports end-to-end optimization.
We validate the effectiveness of our approach on both node clustering and graph classification tasks. In the former, our method successfully identifies communities and their interaction patterns. In the latter, it achieves performance on par with or superior to existing pooling methods, demonstrating the ability to generate compact graph reprosentations without compromising informative content.
The paper is organized as follows: in Section 2, we introduce the preliminary concepts relevant to our work, namely the Dirichlet Process (DP), GNNs, and graph pooling operators. In Section 3, we present the proposed methodology by defining the generative process, the training procedure, and the interpretation of the model's hyperparameters. Section discusses existing approaches that are related to our work, while Section 5 presents the results obtained on both node clustering and graph classification tasks. Finally, in Section 6, we conclude and outline possible directions for future work.
2
Preliminaries
2.1
Bayesian Nonparametric and Dirichlet Process
The BNP framework (Orbanz & Teh, 2010) aims to build nonparametrie models by applying Bayesian techniques. The term nonparametric indicates the ability a model to adapt its size (i.c., the mumber of parameters) directly to data. In contrast, the parametric approach, the model size is fixed in advance by setting some hyperparameters.
The BNP literature most relevant to work relates to the family of Dirichlet Process (DP) (Gershman & Blei, 2012). In its most essential definition, DP is stochastic process whose samples categorical distributions of infinite sizc. Thus, in the same way as the Dirichlet distribution is the conjugate prior for the categorical distribution, the DP is the conjugate prior for infinite discrete distributions. A classical use of the DP is the definition of mixture models that allow an infinite number of components, where the DP is used the prior distribution over the mixture weights. A key property of the DP its clustoring behavior: even if there is an infinite number components available, the DP tends reuse the components that have already been used.
2

---

Published in Transactions on Machine Learning Research (04/2026)
Let Gu be continuous distribution, and let app be positive real number. We write:
G ~ DP(aDP. Go),
(1)
where G is discrete distribution with the same support as Go, meaning that the probability of two samples of G being equal is non-zero, but has countably infinite number of point masses. Figure 2 shows an example of three different draws of G when the base distribution Go is a skewed Normal, and the value of opp is 10, 100, and 1000. As we can see from the figure, G represents a discrete approximation of Go, where the concentration parameter aDp indicates how much the mass in G is concentrated around a given point; the base distribution the expected value of the process, i.c., the DP draws distributions around the basc distribution Go, much like normal distribution draws real numbers around its mean.
The DP clustering property does not emerge from the previous formulation, which also does not tell us how to compute G. In the following, we describe the Blackuell-MacQuee urn scheme (Blackwell & MacQueen, 1973) and the stick breaking process (Sethuraman, 1994). While the former provides a good intuition of the clustering property of a DP, the latter offers a constructive formulation that we leverage in this work.
app 10
App 100
0.2
Go
0.6
Go
0.6
G
G
p(0)
0.02
0.2
0.2
2
3
0
2
0
0
Apr 1000
0.004
Go
0.6
G
p(0)
0.4
0.002
0.2
0.000
0.0
1
3
4
Figure 2: Three single draws from the DP using as Go a Normal skewed distribution and three different aDP values. Note that each plot has a different scale on the y-axis.
Blackwell-Macqueen urn scheme. Let us consider a sequence of i.i.d. random variables 0,, O2,... that are distributed according to G ~ (P(apP, Go). We can interpret the conditional distributions of 6, given the previous 0, 0 0-11, where G has been integrated out, as a simple urn model containing balls with distinct colors (Blackwell & MacQueen, 1973). The balls are drawn oquiprobably; when a ball is drawn, it is placed back in the urn logether with another ball. The color of the new ball is identical to the color of the drawn ball with probability proportional to the number of balls of that color already in the urn; otherwise, with probability proportional to aDP, choose a new color drawn from Gp- This model exhibits positive reinforcement effect: the more color is drawn, the more likely it is to be drawn again.
Let $1...., Ók be the distinct atoms drawn from Go (i.e., the colors) that can be taken by 0I,..., 0:11 (i.e., the balls), and let m, be the number of times the atom de appears in {0,...., b.-1). Formally, we can express the sampling procedure as:
Ox with probability 3-1-app 0--1=
0, 0,,0,,,., a new draw from Go with probability 7-1tapr
(2)
app
3

---

Published in Transactions on Machine Learning Research (04/2026)
1 R2
71g
k
1 1
72
71
k ==2
1- 11 n22 R2
R3
722
71
=
Figure 3: Graphical representation of the stick-breaking process.
Equivalently, we can write:
K
m&
ODP
8, 01,..,,0--1
0
+
Gu,
(3)
i 1 + aDP
i 1-1+ + aDP +DD
where døs is the Dirac measure concentrated at Φk.
Referring to Figure 2, the values m& proportional to the heights of the grey bars. When aDp is small, most of the probability mass is concentrated in few points. While the Blackwell-MacQueen urn scheme helps to understand the clustering property of DP, the sampling procedure does not provide an analytic expression of G that can be exploited.
Stick-breate breaking process. The idea the Stick- BreckBBeekiig Process (SBP) (Sethuraman, 1994) is to repeatedly break off "stick" of initial length Each time we need break the stick, we choose a value between 0 and that determines the fraction take from the remainder of the stick. In Figure 3, show the iterative breaking process, where the values of nı, T3.... represent the parts of the stick pieces broken in the first three iterations.
Formally, the stick-breaking construction is based on independent sequences of i.i.d. random variables (m()==
T app ~ Beta(1, app)
T = T(),
(4)
where the value T indicates the proportion of the remaining stick that we break at iteration k. To understand the stick analogy, we should first convince ourselves that the quantity II (1-x)) is equal to the length of the remainder of the stick Σk=1 my after breaking it - times. Thus, the length of the stick's piece ma is obtained by multiplying the stick fraction oi by the length of the remaining stick II mf) at the k-th step.
It important to note that the sequence π (TT)) constructod by Equation 4 satisfics Σ Te with probability one (Sethuraman, 1994). Thus, we may interpret a random probability measure on the positive integers. This distribution is often denoted as GEM, which stands for Griffiths, Engen, and McCloskey - see (Pitman, 2002).
Now we have all the ingredients to define a random measure G ~ DP(anp, Go):
&x Go Go
G
(5)
where (ox) are the atoms drawn from Go and 6ø2 the Dirac measure concentrated at dx. Sethuraman showed that as defined in Equation a random probability mcasure distributed according to (P Go) (Sethuraman, 1994). The stick-breaking process is related to the urn scheme since the length of each piece mi corresponds to the expected probability of drawing ball of color de from the urn.
4

---

Published in Transactions on Machine Learning Research (04/2026)
MP
(a) Flat GNN.
MP
Pool
MP
(b) Hierarchical GNN.
Figure 4: (a) sketch of "flat" GNN architecture, where each MP layer progressively combines the feature of one node with neighbors that are farther and farther away the graph. (b) Example of "hicrarchical" GNN archilecture that alternates MP with pooling layers.
2.2 Graph Neural Networks
Let G= EV,E) be a graph with node features X E RNFP, where | N, and [8] = F. Each row x² E FR of the matrix X represents the initial node feature the node i, Vi {I,...,,N) NJ. Through the Message Passing (MP) layers, a GNN implements a local computational mechanism to process graphs (Gilmer el al., 2017). Specifically, each feature vector X, is updated by combining the features of the neighboring nodes. After 1 iterations, xL, embeds both the structural information and the content of the nodes in the thhop neighborhood of With enough iterations, the feature vectors can be used to classify the nodes the entire graph. More rigorously, the output of the [-th layer of a MP-GNN is:
x = COMB (1) (x!-1 AG E (ell)
(6)
where (G is a function that aggregates the node features from the neighborhood W[x] at the 1)-th iteration, and COMB()) combines its own features with those of the neighbors.
Traditional GNN architectures "flat" and consist of a stack of MP layers followed by final readout (Back et al., 2021). For graph-level tasks, c.g., graph classification and regression, the readout includes a global pooling operation that combines all the node features at once by taking their sum or average. Such an aggressive pooling operation often fails to extract the global graph properties necessary for the downstream task. On the other hand, GNN architectures that alternate MP with graph pooling layers can gradually distill information into "hicrarchical" graph representations. An illustration of flat and hierarchical GNN architecture is reported in Figure 4. Hierarchical architectures offer several advantages, including the reduction of complexity in the MP operations occurring after pooling (Jin et al., 2021). In addition, by coarsening the graph, graph pooling quickly extends the receptive field of the MP operation, enabling exchanges with distant nodes using fewer MP layers.
2.3 Graph pooling
Graph pooling allows building hierarchical GNNs for tasks such graph classification (Khasahmadi et al., 2020), graph properties prediction (Xu et al., 2024; Leenhouts et al, 2025), node classification (Gao & Ji, 2019; Ma et al., 2020), node clustering (Hansen et al., 2025), graph matching (Liu et al., 2021), physics sinulations (Lino et al., 2022), generation with graph diffusion (Valencia el al., 2025), and spatio- temporal forcasting (Cini et al., 2024; Marisca et al., 2024). Existing graph pooling methods can be broadly (SRC), which provides a general framework describe different. graph pooling operators (Grattarola et al., 2022). According SRC, a pooling operator, denoted POOL (A, X) (A (Apnol: X p, is decomposed into three sub-operations:
described through Celect-Reduce-Comee
5

---

Published in Transactions on Machine Learning Research (04/2026)
Select (SEL): maps the original nodes of the graph to reduced set of nodes, called supernodes. The mapping can be represented by a selection matrix S E RNNK where N and K are the number of nodes and supernodes, respectively.
Reduce (RED): generates the features X pool E RRKF of the supernodes based on the selection matrix and the original node features. Usually, RED is implemented as X pool S X.
Connect (CON): constructs the new adjacency matrix Apool E kxk based on the selection matrix 20
and the original topology. A streamlined implementation of CON is Apool = S AS.
Pool
CDN
A X
pool
>
X
SEL
MP
pool
RED
Caux
Figure 5: Schematic depiction of graph pooling layer. The SEL operation defines the formation of the supernodes by computing the assignment matrix S from the node embeddings X'. The RED and CDN output the pooled node features X pool and the coarsened adjacency matrix Apool, respectively. Some pooling operators leverage one or more auxiliary losses, Lauxs to influence the formation of the selection matrix $ (and, potentially, other components of the GNN).
Figure reports a schematic depiction of a pooling layer showing the interaction of the different components. Different pooling methods are obtained by specific implementation of these operators and can be broadly categorized into three main families: score-based, one-every-K, and soft-clustering methods.
Score-Based methods compute score for each node using trainable function in their SEL operator. Nodes with the highest scores become the supernodes of the pooled graph. Representatives such as Top-k Pooling (Top-k) (Gao & Ji, 2019; Knyazev et al., 2019), ASAPool (Ranjan et al., 2020), SAGPool (Lee et al., 2019), PanPool (Ma et al., 2020), TAPool (Gao et al., 2021), CGIPool (Pang et al., 2021), and [Pool (Gao el al., 2022) primarily differ in how they compule the scores or in the auxiliary tasks they optimize to improve the quality of the pooled graph. These methods are computationally efficient and can dynamically adapt the size of the pooled graph, e.g., K, kN,, where is the pooling ratio and N; and K2 are the sizes of the i-th graph before and after pooling, respectively. Score-based methods tend to retain neighboring nodes that have similar features. As result, entire parts of the graph are under-represented after pooling, reducing the performance in tasks where all the graph structure should be preserved.
One-Every-K methods pool the graph by uniformly subsampling nodes, extending the concept of one-every- K to irregular graph structures. They are typically efficient and perform pooling inspired by objectives, such as spectral clustering (Dhillon et al., 2007), maxcut (Bianchi et al., 2020b), and maximal independent sets (Bacciu et al., 2023). Some of these methods lack flexibility because their SEL operator neither accounts for node odge features can adapt the size of the pooled graph K; to the original graph size N;, the pooling ratio k is determined by the graph-theoretical objective and cannot be specified explicitly.
be influenced by the downstream task's loss. Even if they
Soft-Clustering methods use SEL operators that compute a soft-clustering matrix S, which assigns each node to multiple supernodes with different memberships. Representatives such as Diffpool (Ying et al., 2018), MinCut Pool (MinCut) (Bianchi al., 2020a), and Structpool (Yuan & Ji, 2020), leverage flexible trainable functions guided by auxiliary losses to compute the soft assignments from the node features. As illustrated in Figure 5, the auxiliary loss influences the formation of the selection matrix S (and, potentially, other
6

---

Published in Transactions on Machine Learning Research (04/2026)
parameters of the GNN architecture), ensuring that the partition is consistent with the graph topology and that the clusters are well formed, e-g-; that the assignments are sharp and the clusters are balanced. Computing these auxiliary losses typically requires O(N²) operations because they require a dense representation of the imput adjacency matrix. The quadratic computational cost is generally acceptable in most graph-lovel lasks, such as graph classification and graph properties prediction, where the size of the graphs ranges from hundreds to few thousand nodes.
While soft-chustering methods generally achieve high performance due to their flexibility and ability to retain information from the entire graph, they face primary limitation: they require to predefine the size K of every pooled graph, which is fixed for each graph regardless of its size N, A typical choice is to set K =N, where is the average size of all the graphs in the dataset. Clearly, this might not work well in datasets where the graphs' size varies too much, especially if there are graphs where N₁ < k... In those cases, the pooling operator erponds the graph rather than coarsening it, which goes against the principle of pooling.
3 Bayesian Nonparametric Pooling for Graphs
We propose BN-Pool, novel soft-clustering pooling operator grounded in the Bayesian nonparametrie theory. The SEL function of BN-Pool addresses the main drawbacks of existing soft-clustering methods by learning, for each graph i, a pooled graph with variable number of supernodes K₃.
BN-Pool assumes that the observed graph structure can be explained by a latent partition of its nodes. In other words, it assumes that the imput adjacency matrix is generated by an underlying process where each node belongs to a (hidden) cluster, and the probability of finding an edge depends on these cluster memberships. To avoid fixing the number of clusters in advance, BN-Pool places DP prior over the cluster assignments, allowing the model to adaptively determine the number of clusters needed for each graph. Once the generative model is defined, the SEL operator is implemented by performing Bayesian inference: we estimate the posterior distribution of node-to-cluster assignments given the observed graph and node features. This posterior provides soft membership scores that drive the pooling operation.
To case the notation, we present the method by considering only a single graph. The pseudo-code Python for implementing all the main operations in BN-Pool is reported in Appendix A.
3.1 Definition of the Generative Process
CDP
π
μK
OK
Tu
K
U
N
N
A
U
N
Figure 6: Graphical representation of BN-Pool in plate notation. The orange dotted arrow indicates the stick-breaking construction.
BN-Pool defines a generative process for the adjacency matrix the input graph that similar to the Stochastic Block Model (SBM) (Holland et al., 1983): each node u is associated with vector n, whose entries indicate the probability that belongs to a given cluster. The edges are generated according to a block matrix K whose entry Kú represents the unnormalized log-probability of occurrence of an edge between
7

---

Published in Transactions on Machine Learning Research (04/2026)
node in cluster and node in cluster j. Unlike in the SBM, relax the requirement of specifying the number of clusters in advance and leverage the DP to define a prior over an infinite number of clusters. Note that, even if there is an infinite number of clusters, only few of them are used due to the clustering property of the DP, discussed in Section 2.1.
By exploiting the stick-breaking construction of DPs, we define the generative process of BN-Pool as:
((( if (N(-KK
K ~ p(j)))
The p(TT(a) Beta(L,
if
(7)
Tui
Tus
Tzg)
Pun = [ KT.);
Auo ~ p( = Bernoull((p..)
where u, E V are nodes in the input graph, i,j E N are cluster indices, and (-) is the sigmoid function: the hyperparamcters app E RR, MKK E Ekttoo E IR+ define the shape of the prior distributions. The prior distribution on the matrix K defined by p(j,)) encodes our assumption that most of the edges link nodes of the same group. The generative process is schematized in Figure 6.
3.2 Posterior Estimation
The BNP setting makes the computation of cluster assignments' posterior intractable, and it requires some approximations. We rely on truncated variational approximation of the posterior (Blei & Jordan, 2004): even if there is an infinite number of clusters, we truncate the posterior by considering a finite value C' representing the maximum number of clusters. It is worth highlighting that this does not imply that the model has a fixed number of clusters but, rather, that the model will choose suitable number of non-empty (i.e., active) clusters K; < C for the i-th graph.
Following the classical mean-field approximation', we define two variational distributions: to model the posterior of the stick fractions T', and one to model the posterior of the model parameter K. Note that we are interested in the cluster assignment vectors म,, which are fully determined by the stick-breaking construction given the stick fractions nτ. The posterior approximation is expressed as:
((T())) = (ettaQuui,e Bu)) q( (Kiy) = N(aaj, c);
(8)
(9)
where āui; But E IR+ Pig E for all u E V,j.j E (1...., C} are the variational parameters. The value of é is fixed priori, and is not optimized during the training. While puj are free parameters that we optimize directly, we employ a Multilayer Perceptron (MLP) with parameters OMLP to estimate ā and B
X' = MP (X,A). A). ā, 3 MLP (X').
(10)
The MLP is applied on the node embeddings X', which are computed by the MP layers with parameters OMP that are placed in the GNN before the pooling operator. This allows for representing complex relations between hidden and observable variables that usually appear in the posterior distribution by conditioning the posterior on the graph topology, the node (and potentially edge) features, and the downstream task at hand that drives the GNN optimization.
The estimation of variational parameters through a neural network closely resembles the architecture of a Variational Auto-Encoder (VAE). Specifically, the GNN responsible for approximating the posterior acts as the encoder the classical VAE framework, while the SBM serves as the decoder, reconstructing the adjacency matrix of the input graph. As discussed in the following, this reconstruction step is central to the training objective, ensuring that the latent node-to-cluste assignments are consistent with the obscrved structure.
The variational distribution factorized over the latent variables: p( K A, X) Re q(.,, K) R2 ((7)))9(K)))
8

---

Published in Transactions on Machine Learning Research (04/2026)
Variational parameters
Soft assignments
TRUNCATED SBP
X
ā
MP
MILE
Beta ()
11
RED,
1
Stick portion sampling
Stick length construction
SBM Decoder
Clusters connectivity K
aax C. a, (DD) + (x(K, (A,
Reconstructed adjacency
Figure 7: The SEL operation of BN-Pool and the components of the auxiliary loss. One or more MP layers (not part of the pooling operator) generate the node embeddings X', which are passed to the MLP that outputs the variational parameters and 3. These are used by the truncated SBP to gencrate the assignment matrix S, which is passed further the RED and CON operators to compute the pooled graph. S also fed into the SBM decoder for reconstructing the adjacency matrix Å, conditioned by the block matrix K. We note that K and A are necessary solely for the computation of the auxiliary loss Lauxs which influences the parameters of the MLP and all the trainable parameters of previous layers in the GNN.
3.3 Graph Pooling Operations
We conclude by casting BN-Pool in the SRC framework. Figure 7 expands Figure 5 by showing details of the SEL operation and the auxiliary loss, described in Section 3.4, implemented by BN-Pool. In particular, for each graph i, the SEL operator generates cluster assignment matrix S, E R NxC with K; columns containing non-zero values. The entry Suj = uaj represents the membership of node to cluster j, where we use Taj to denote a sample from its posterior (Ta)) to simplify the notation.
The RED and CON functions follow the standard implementation of other pooling methods, as described in Section 2.3: x = S X and Apool = S AS. In addition, following (Bianchi et al., 2020a), we set the diagonal elements of À Apool to zero to prevent self-loops from dominating the propagation in the MP layers pool Apool D-1/2 pool
after pooling, and we symmetrically normalize it by the nodes' degrec: Apoot = D-1/2
3.4 Training Procedure
All the neural parameters θ = (OMP, OMIP), and the variational parameters jú, are learned by maximising the Evidence Lower Bound (EIBO)):
log A)
Σ Σ ( Doog ((u ग., K)]
Eree
(11)
ΣΣ 14
(ku(g(TTr)) p(T((a)) -
DKLaa(K (((K))))
-Ex
The first term in Equation is the reconstruction loss that measures how well the model reconstructs the adjacency matrix. The last two terms measure the distances between the prior and the variational distributions and act regularisers. While the reconstruction loss free has a straightforward interpretation,
9

---

Published in Transactions on Machine Learning Research (04/2026)
can think of Lx the cost of having certain mumber of clusters active. Hence, 2x reflects the clustering property of the DP in reusing non-emply clusters. On the other hand, Lx penalizes the discrepancy from the connectivity across clusters described by the SBM prior.
In practice, instead of maximising the ELBO in Equation 11, we train the model by minimising the loss:
1 Laux N2 Crec + 7 NN Cr + N NeCK.
1
(12)
where N is the number of nodes in the input graph, and it is used to rescale the losses, while y is hyperparameter that balances the contrasting effect of free and L.. The interplay between all the loss terms is crucial for an effective adaptive nonparametrie method. The normalization and scaling parameters avoid a dominance of the KL divergence and have already been applied on VAEs (Higgins et al., 2017; Asperti & Trentin, 2020). We refer to the loss in Equation 12 as auziliary since, during pooling, is combined with the supervised loss of the downstream task. It important to note that these terms are not independent. auxiliary objectives but are intrinsically linked as they constitute the ELBO. Therefore, removing one of these terms would not be meaningful, as it would invalidate the derivation of the variational lower bound and the mo probabilistic foundation.
The training is performed by employing the Stochastic Gradient Variational Bayes (SGVB) framework (Kingma & Welling, 2014), where the expectation in the reconstruction term is approximated with a Monte Carlo estimate of the binary cross-entropy between the true edges and the probabilities predicted by the model:
T
Lroe R
ΣΣΣ 12 1
Au log - (1 - log(1 p(w));
(13)
where T is the number of samples used for the Monte Carlo approximation, and pla = ThpDgyr where nt and oh are the 1-th samples of the soft assignments nodes u and v, respectively. Each sampling step The ~ Beta (uis, Bus) needed to approximate free is not differentiable and prevents the gradient from being backpropagated to the neural parameters θ A common approach to solve this issue is the reparameterization trick (Kingma& & Welling, 2014), which, however, cannot be applied to the Beta distribution (Figurnov et al., 2018). Therefore, in BN-Pool, we implement the backpropagation by approximating the pathwise gradient of the sampled values w.r.t. the distribution parameters" (Jankowiak & Obermeyer, 2018).
Beta(auu,,
To reduce the stochasticity of the approximation, we assume that the variational distribution {() has a low variance (i.e., - 0 in Equation 9) and directly use the variational parameter ja rather than sampling the cluster connectivity from its variational distribution. Finally, we initialise the neural parameters OMLP by using the default initialisation of the backend (He et al., 2015), while the variational parameter fa of the cluster connectivity matrix is initialised by setting the elements on-diagonal (off-diagonal) equal to 7KK (-nk), where 1jK is a hyperparameter.
3.4.1 Lrec with OEE) complexity.
The computation of Lree requires O(N2) operations, as the number of samples T is negligible compared to N22 While this complexity is consistent with other soft-clustering pooling methods that rely on a dense representation of the input adjacency matrix (e.g., DiffPool (Ying et al., 2018)), we introduce a sparse variant of BN-Pool that roduces the complexity to OEE).
The sparse variant of BN-Pool operates only on the observed edges, i.e., the set of node pairs (u, v) such that Aux = 1, and on sampled set of missing edges, i.e., pairs such that A O. Concretely, let E- (u, v) (u,v) v) & E) be sampled set of missing edges such that |--1= E. We then define sparse surrogate of the reconstruction loss by restricting the summation in equation 13 to the positive edges and to the sampled negatives:
Lrec Rg
Σ
Σ (W.
log puu +
Σ
log(1 1 p(a)
(14)
(u.))EE-
Thhis approximation is already implemented the Pyrch library. See Appendix A for more details about our implementation.
10

---

Published in Transactions on Machine Learning Research (04/2026)
Note that, differently from equation 13, here the references to the adjacency matrix A are omitted, since Au, = 1 if and only if (u E &. By construction, the summation in equation 14 contains 2E terms. To ensure an overall complexity of O(E), we compute the values pi,, only for the node pairs appearing in the summation, avoiding materialization of the full N x N matrix. All other components of the training procedure remain unchanged, except. for the constant used to normalize the terms of Laux: instead of using N2, we normalize each term by |ε| + |
While this surrogate objective is conceptually simple, its implementation is not straightforward and must be done carefully. For example, sampling the set of negative edges E- must avoid O(N3) memory allocation and should be performed efficiently on the GPU to prevent performance degradation. We discuss the implementation details in Appendix A.4.
3.5 Prior Hyperparameters Interpretation
To fully define the BN-Pool model, we have to specify three hyperparameters: aDP, PK, and Øk- The probabilistic nature of our method allows for a direct interpretation that facilitates their tuning.
The value of aDp E + defines the shape of the prior over the cluster assignments; in particular, it specifies the concentration of the DP. To understand the effect of app, we recall that the loss L the cost to pay to have a certain nunber of clusters active. The value dpp is inversely proportional to the price to activate new cluster: low values force the model to use few clusters (only one in the extreme case). Conversely, higher values do not penalize the model when it uses more clusters to reduce the reconstruction loss. Since in practice we truncate the posterior to at most C' clusters, too high values of app can create degencrate solutions where the last. cluster is a always used.
The other two hyperparameters μK E R. and ок E R+ specify the prior over the block matrix K, which affects the reconstruction loss. Again, the most intuitive way to understand the effect of K is in terms of costs: if the value Kiy is positive (negative), the price of creating an edge between node in cluster and node in cluster j is low (high). Thus, to encode our prior belief that most of the edges appear between nodes in the same cluster, impose that the elements on the diagonal are positive with value μæ (i.e., intra-cluster edges are cheap), while the off- dfa-diaao elements are negative with value -μK (i.e., inter-cluster edges are costly). The hyperparameter d controls the strength of the prior: the lower, the more the posterior matches the prior rather than the data.
The values of μkK and ok also affect the number of active clusters. For example, the degenerate solution that assigns all the nodes to the first cluster satisfics the clusterization property of the DP. However, by referring to Equation 13, this means paying - log(1 (A11) matches our prior (i.e., jin & ,x); this results in high cost since jk >> O implies - log aoga(-"Kk' >> 0; thus, the model will likely prefer to reduce Cree at the price of having more clusters, i.e., a larger C. Finally, we note that while the other hyperparameters (truncation level C, number of samples T, and initialization of the neural and variational parameters and (k) influence the training procedure, they do not affect the model definition.
logo(-in1 every time Auv 0. If the posterior
4 Related work
BN-Pool belongs to the family of Soft-Clustering pooling methods discussed in Section 2.3 and the closest. approach Diffpool (Ying et al., 2018), which employs an auxiliary loss |S-SST ||r to align the assignments to the graph topology. In this work, we go beyond the formulation of such simple loss and define a whole generative process for the adjacency matrix.
Related to our work is the Dirichlet Graph Variational Auto-Encoder (DGVAE) (Li et al., 2020), which defines a VAE with a Dirichlet prior over the latent variables to cluster graph nodes. We extend DGVAE in different ways. First, we define a more flexible generative process for the adjacency matrix thanks to the block matrix K. Second, we allow an infinite number of clusters by specifying a DP prior over the latent variables. Finally, we do not rely on the Laplace approximation of the Dirichlet distribution, whose behavior is similar to Gaussian prior (Joo et al., 2020).
11

---

Published in Transactions on Machine Learning Research (04/2026)
The Stick-Breaking Variational Auto-Encoder (SB-VAE) (Nalisnick & Smyth, 2017) shares our idea of specifying a nonparametric prior over the hidden variables by using DP prior that leverages the stick- breaking construction, but does not focus on graphs. We also employ a different approximation of the posterior, which is based on pathwise gradients rather than the Kumaraswamy distribution (Kumaraswamy, 1980).
Another work that shares similarities with our method is (Mehta al., 2019). It introduces sparse VAE for overlapping SBM that also allows an infinite number of clusters, but uses different nonparametric prior: the Indian Buffet Process (IBP) (Griffiths & Ghahramani, 2011). The IBP is suitable to model multiple cluster membership, i..,, node can belong to more than one cluster, which is not desirable in the context of pooling, Moreover, Mehla et al. use for each node another dense latent variable with a Gaussian prior to gain more flexibility during the generation process of the adjacency matrix. Instead, in BN-Pool all the information useful for the generation is encoded in the soft cluster assignments S.
5 Experiments
The purpose of our experiments is twofold. Since BN-Pool is the first BNP pooling method, we start by analyzing its ability to detect communities on a single graph. Then, we test the effectiveness of BN-Pool in GNNs for graph-level tasks such as graph classification and graph regression. In all experiments, we use very simple GNN models better quantify the differences in performance between each pooling method. Indeed, while GNNs with larger capacity can achieve SOTA performance, it is harder to disentangle the actual contribution of the pooling operator in a more complex model.
In the following, we consider the configurations of the hyperparameters of BN-Pool specified in Table 1. As discussed in Section 3.5, the value of each parameter can be set according to the characteristics of the dataset at hand or by monitoring some performance metrics while training. In each experiment, we select the configuration that yields the lowest value of the reconstruction loss Lree in the node clustering task and the highest validation accuracy in the graph classification task.
Table 1: Values of the hyperparameters of BN-Pool considered.
Hyperparameter
Values
app
0.1, 1.0, 10.0, 30.0 0.1, 1.0, 10.0, 30.0 0.1, 1.0
PK
ok
We found that setting aDP 10.0, μkK- 1.0, and ок 1.0 yields generally good performance and, thus, it represents our default configuration. Regarding the other hyperparameters, we kept the truncation level C = 50, the number of particles T = 1, and the initialization of the variational parameter `KK 1.0 fixed in all experiments.
The code to reproduce all the experiments presented in this paper is publicly available 3, In addition, BN-Pool is available on the Torch Geometric Pool library (Bianchi et al., 2025)
5.1 Community detection
This task consists of learning a partition of the graph nodes in an unsupervised fashion, only based on the node features and the graph topology. Even if our primary focus is on graph pooling, this experiment allows us to evaluate the auxiliary losses in terms of the consistency between the node labels y and the cluster assignments.
The architecture used for clustering consists of stack of MP layers that generate the feature vectors X'. As MP layers we used two Graph Convolutional Network (GCN) layers (Kipf & Welling, 2017) with 32 hidden
hhtte://ggthub...oo//ttttttrtppp 4 http://ghht..ceoeeeee/ee/////raa
Pooling
12

---

Published in Transactions on Machine Learning Research (04/2026)
units and ELU activations (Clevert, 2015). The features X' are processed by the SEL operator that produces the cluster assignments S. Since clustering is an unsupervised lask, the GNN is trained by minimizing only the auxiliary losses. The architecture used for clustering is depicted in Figure 8.
A
GCN,
GCN2
X
SEL
S
X
Laux
Figure 8: Architecture used for node clustering task.
Before training, we apply to the adjacency matrix the same pre-transform used in Just-balane Graph Neural Network (JBGNN):
I L,
(15)
where L is the symmetrically normalized graph Laplacian and 5 is a constant that we set to 0.85 as in (Bianchi, 2023). As the training algorithm, we used Adam (Kingma & Ba, 2015) with initial learning rate 1e - 3. For BN-Pool, we incrcasod y defined in Equation 12 from to over the first 5, 000 epochs according a cosine scheduler. This scheduling procedure, often referred to as "KL anmealing" (Bowman et al., 2016; Sønderby et al., 2016), is standard practice when training VAEs to prevent the model from converging to degenerate solutions early in the training due to, e.g.,, posterior collapse.
During training, we monitored the auxiliary losses for early stopping with patience 1, 1,000. When the GNN was configured with BN-Pool, we monitored only Cree since Lx and Dn are regularization losses that usually increase and might dominate the total loss.
Clustering performance is commonly measured with Normalized Mutual Information (NMI), Completeness, and Homogeneity scores, which only work with hard cluster assignments. While the latter can be obtained by taking the argmax of a soft assignment, the discretization process can discard useful information. Consider, for example, a case where two nodes u and v have assignment vectors s, = [0, 0.5, 0.5, 0] and s, = 00, 0.5, 0, 0.5). Taking the argmax would map both nodes in the 2nd cluster, even if the two assignment. vectors are clearly distinguishable. This problem is exacerbated when we do not fix the number of clusters K equal to the true number of classes; in this case, there is no direct correspondence between the clusters and the classes, and nothing prevents different classes from being represented by partially overlapping assignment vectors with multiple non-zero entries.
Therefore, to measure the agreement between S and y, we first consider the cosine similarity between the cluster assignments and the one-hot representation of the node labels:
Eis [SST YY
cOS
(16)
+ Eis YY Jis
where Y one-hot(y). As second measure, consider the accuracy (ACC) obtained by training simple logistic regression classifier to predict from S.
We compare the performance of BN-Pool with the assignments obtained by four other soft-clustering pooling methods, DiffPool (Ying et al., 2018), MinCut (Bianchi et al., 2020a), Deep Modularity Network (DMoN) (Tsitsulin et al., 2023), and JBGNN (Bianchi, 2023), which are optimized by minimizing their own auxiliary losses. Importantly, we note that the other methods leverage supervised information by setting the number of clusters K equal to the number of node classes, while BN-Pool is completely unsupervised.
13

---

Published in Transactions on Machine Learning Research (04/2026)
Table 2: Mean and standard deviations of ACC and COS for vertex clustering.
Method
Community
Cora
CiteSeer
PubMed
DBLP
ACC
COS
ACC
COS
ACC.
COS
ACC.
COS
ACC
COS
DiffPool
81.921a
62.9
50.4
43
37.9
42.4
52.4107
59.8gan
49.5149
57.4200
MinCut
97.1=00
94.3=aa
57.0+21
40.1+11
54.3
36.9
61.3
46.62as
69.2+14
52.5+39
DMoN
96.2=
92.5+16
57.9
40.1+23
50.7+24
34,6=16
59.6+14
45.5=a7
63.7
45,4+11
JBGNN
83.92a7
83.0aas
55.4124
39.0128
48. 180
36.12sa
55.8
44.622n
68.6118
53.0
BN-Pool
98.5.10.
83.0+114
66.8+1.0
47.7=113
47.9+1.7
37.840.3
81.3=05
62.5
75.22007
58.5
As datasets, we consider Communityy, a synthetic dataset generated from a SBM, and four real-world citation networks. The details about the datasets are in Appendix B. Table 2 reports the results and shows that, despite not knowing the real number of classes, BN-Pool achieves excellent performance.
(a) BN-Pool
(b) MinCut
Figure 9: Clusters found on a 3-community graph.
Discussion. Figure 9a shows typical situation where BN-Pool splits community in two. This happens if there are few edges within the community, and increasing K yields more compact clusters. This cannot occur in other soft-clusterigg methods such as MinCut. The latter always finds the same predefined number of clusters (K = in this case, see Figure 9b) but creates more spurious clusters.
Figure shows the original adjacency matrix of the Cora dataset, visualization of the class labels (YYT), ) and the adjacency matrix reconstructions SKST and SS obtained by BN-Pool and MinCut, respectively. While the SKST produced by BN-Pool follows more closely the actual sparsity pattern of the adjacency matrix, in MinCut SS has block structure.
This difference explained by the different optimization objectives: while BN-Pool tries to reconstruct the whole adjacency matrix, MinCut recovers the communities by cutting the smallest number of edges. addition, MinCut uses regularization encourage clusters have the same size. This makes it difficult. isolate the two smallest clusters that, instcad, are distinguishable BN-Pool. Given that in Cora the average edge density between nodes of the same class is only 0.0065, natural way for BN-Pool to lower Lroe is to activate new clusters and generate assignments with multiple non-zero, yet low, membership values.
To better visualize this behavior, in Figure 11, we show the cluster assignments S, split according to the node classes, found by BN-Pool on Cora. We see that there is no direct correspondence between the classes and the clusters, since each class is assigned to multiple clusters. This is expected when we do not fix the number of clusters equal the number of classes, like in the case of BN-Pool that, potentially, can activate an infinite number of clusters. We also notice that the same clusters are active across different classes, albeit with different membership values. Despite such overlap, there is clear and consistent pattern in terms
14

---

Published in Transactions on Machine Learning Research (04/2026)
(a) Original adj. A
(b) Class labels YY
(c) BN-Pool SKS
(d) MinCut. Ss
Figure 10: Adjaccncy matrix of Cora, class labels visualization, and adjacency matrix reconstruction by BN-Pool and MinCut.
Class
Class
352
352
568
568
569
569
Class
Class
986
Class
Class
1804
1804 1805
1805
2230
2230
2528
2528
2708
2708
(a) BN-Pool
(b) MinCut.
Figure 11: Cluster assignments S found on Cora.
of cluster memberships for cach class. It is important to notice that the membership values are lower for the nodes of class 3, which the most populated in the graph. As discussed in Section 5.1, activating many clusters with low membership values is natural solution found by BN-Pool reduce Zree when the intra-class density is very low, like in Cora (0.0065).
The clusters found by MinCut Cora are very different, as shown in Figure 11b. MinCut relies on supervision to set the number of clusters equal to the number of class labels. While this provides good correspondence between the classes and the clusters, it limits the extent to which MinCut can split class into multiple clusters, encoding nodes of the same class differently. This implics that there is a significant variability within each class, MinCut might assign only some of its nodes to the right cluster.
5.2 Graph-level tasks
In graph classification and regression, target is assigned to the i-th graph (A,,,). Unlike in the community detection task, here the GNN is optimized by jointly minimizing the task loss (c.g., cross-cntropy or MSE) between the true and predicted targets and the auxiliary loss Laux- The architecture used for graph classificatiin and regression is depicted in Figure 12.
Before and after pooling, we use Graph Isomorphism Network (GIN) (Xu al., 2019) layer with 32 hidden units and ELU activations. The readout is an MLP with [32 32 16 Netess units, dropout 0.5, and ELU activation. For datasets with edge features, replace the first GIN layer with the MP operator proposed
15

---

Published in Transactions on Machine Learning Research (04/2026)
A
GIN,
CON
GIN2
Readout
SEL
X
X
RED
Caxx
Crask
Figure 12: Architecture for graph classification and regression.
by (Hu et al., 2019). For the MolHiv and Peptides-struct datasets, we use slightly modified architecture with two MP layers before pooling and two after pooling, each with 64 hidden units. After each MP layer, inserted dropout layer with probability 0.1 and batch normalization layer. In addition, use the standard AtomEncoder and BondEncoder provided by the OGB library" with embedding dimension 100 to transform the original node and edge features. Like in the node clustering selting, we apply the pre-transform in Equation 15. In those datasets containing edge features, we assign to the self-loops that we introduce zero vectors as surrogate features.
While BN-Pool can autonomously discover the number of nodes K, of each pooled graph, we need to specify the size of the pooled graphs K for the other Soft-Clustering pooling methods and the pooling ratio k. for the Score-Based methods. Therefore, for every dataset, set = 0.5 and K = 0.5N, where N represents the average number of nodes in a given dataset. We note that this is the standard rule of thumb used in the original papers proposing the competing methods. In Appendix C we report the results obtained by the Soft- Soft-Custoring methods for diffcrent values of K.
As an optimizer, we used Adam with an initial learning rate 5e 4. Regarding the callbacks, we monitored the validation accuracy and lowered the learning rate by a factor of 0.5 after a plateau of 30 epochs and performed carly stopping with patience 100 epochs. For BN-Pool, incrcased y from 0 to over the first 50 epochs using& cosine scheduler.
In addition to the poolers from Section 5.1, here we also compare against two additional operators, Higher-Order Clustering and Pooling (HOSC) (Duval & Malliaros, 2022) and EigenPooling (Figen) (Ma et al., 2019), and Score-Based and One-Every-K pooling operators, such as Top-k (Gao Ji, 2019; Knyazev et al., 2019), Edge- Contraction Pooling (ECPool) (Diehl, 2019), k Maximal Independent Sets Pooling (k-MIS) (Bacciu et al., 2023), Graclus (Defferrard et al., 2016), and Struetural Entropy Pooling (SEP) (Wu et al., 2022), which have auxiliary losses. We also consider baseline without hierarchical pooling, consisting only of stack of MP layers. As datasets, we consider TUDataset benchmark (Morris et al., 2020), including Colors3 (Knyazev et al., 2019), GCB-H (Bianchi et al., 2022), ogbg-molhiv (Wu et al., 2018), Peptides-struct (Dwivedi et al., 2022), and Multipartite (Abate & Bianchi, 2025). The details about the datasets are in Appendix B.
Discussion. We report the results in Table and Table 12. In general, BN--Poo performs on par or better than any other pooling operator, especially those from the Soft-Clustering family. This indicates that BN-Pool can effectively (i) find a meaningful number of clusters and (ii) learn more compact pooled graphs without sacrificing useful information. Noteworthy results are obtained on the datasets Colors-3 and Enzymes, where BN-Pool significantly out outperforms any other pooling method and sets the SOTA.
Figure 13 shows the actual node features from graph from the GCB-H dataset and the node- superrood assignments found by different pooling operators. Interestingly, BN-Pool creates clusters that match the node features well (Figure 13b). By contrast, MinCut, which is also a Soft-Clustering method, places nodes with
16

---

Published in Transactions on Machine Learning Research (04/2026)
(a) Original
(b) BN-Pool assignments
(c) MinCut assignments
(d) Top-k scores
(e) M-MIS assignments
20-
20
70-
20-
00
90
BN--Poo S
(g) MinCut S
(h) Top-k
A-MIS S
(i) BN-Pool {A', X')
(k) MinCut (A', X'}
()) Top-k (A'X')
(m) & {''X'))
Figure 13: Example from GCB-H.
17

---

Published in Transactions on Machine Learning Research (04/2026)
Table Mean and standard deviations the graph classification accuracy (ROC-AUG for MolHlv and MAE for Pep-struct).
Pooler
Collab
Colors3
Mutagenicity NCI1
RedditB MUTAG
Enzymes
Proteins
MolHiv
Pep-struct
Multip.
70
:4
78=1
732s
8621
78
13
71
7412
2295
14
Graclus
72
28
802:
77
901
821
33
732+
741a
264
48
RCPool
72
69
802:
77
911>
841
352*
74
7411
2662
51
k-MIS
71+2
84+1
79-2
75+3
90+2
83+10
33-s
73+5
74+2
.663+.00
63+2
Top-k
7222
78
75=3
73
77
82:10
29
74+5
7641
2666..000
45
SEP
7225
71
80
7723
9011
811s
40
7317
75:0
=00
61
DiffPool
70+2
65+1
78-2
75+2
90+2
81+11
36-7
75+3
70+4
276++015
56+3
MinCut
70
6921
78
732a
8717
81
34
77
7611
2655
56
DMoN
68#2
6942
80=2
73+3
88+2
82+1
37
76+4
77
2280=0011
62
JBGNN
72+2
68+2
80=2
78+3
90+1
87+14
39=6
75+5
73+2
2644
56+3
Rigen
73
4012
7921
7521
8911
691M
39
7214
7417
.266mm
61
HOSC
73+*
72+1
80-2
78+3
90+2
84+7
36-9
75+5
74+2
.283 0.000
49+7
BN-Pool
75
99.0
81:1
80
91
88
5447
75+4
78+1
.255 2.001
58
Mutagenicty
24 27
6
12
32
13
21
27 30
25 18
REDDIT-RINARY
ENZZYMES
PROTEINS
12
25
10
12
15
14
15
12
mohli
poptides
MuRtsorttte
12
22
Figure 14: Distribution of non-empty clusters found by Rool on different datasets.
different features in the same clusters (Figure 13c). In particular, MinCut finds clusters even though there are 5 different fcature values.
Top-k and A-MIS are pooling operators from different families "Score-Based and One-Every-K' that pool the graph in different ways. In particular, Top-k (Figure 13d) keeps only half of the nodes and drops the others, shown in black. On the other hand, k-MIS does not use the node features, so there is no direct match between the Teatures and the clusters it finds. Figures 13β-i show the different. assignment matrices S from these methods, and Figures 13j-m show the topology and node features of the pooled graphs.
BN-Pool uses only 5 clusters that match the types of features. As result, the pooled graph summarizes effectively the original, with just 5 supernodes, each one tied to certain feature. On the other hand, MinCut produces& denser assignment matrix S, where each node belongs to multiple supernodes, and several supernodes have the same role. This overlap is also visible in the pooled graph, which has many supernodes with similar features. Unlike BN-Pool, this pooled graph is less compact, is very dense, and, thus, more costly process.
Looking at Top-k, of the graph are left out. This is known to be potential issue in Score- Based methods it affects their expressivity (Bianchi & Lachi, 2023). Finally, k-MIS yields pooled graph that, like BN-Pool, is both small and very sparse. However, while it represents all parts of the graph, it does not match its supernodes to the node features, as does not consider them when creating the pooled graph.
that its pooled graph is simply subset of the original, which means some parts
Our experimental evaluation mainly focuses on homophilic scttings, which the one BN-Pool and most of the existing pooling methods are designed for. In homophilic graphs such as the one in Figure 13, nodes with the same features are strongly connected with each other, making perfectly reasonable to assign nodes with
18

---

Published in Transactions on Machine Learning Research (04/2026)
the same features to the same supernode in the pooled graph. To provide more comprehensive evaluation of our method and its limitations, we also consider a completely heterophilic: dataset: the Multipartite dataset. In this dataset, there are ten different types of node features, and each node is connected to all the nodes in the graph with a different feature. Thus, the topology is adversarial and should be overlooked to solve the task correctly. In such a heterophílic selting, BN-Pool does not perform well: its architecture and the losses implement homophilic bias that connected nodes should be clustered together.
Table 4: Mean and standard deviation of the non-empty clusters found by BN-Pool on different datasets.
Dataset
Collab
Colors3 31.0+11
Mutagenicity 24.1+2.8
NCI 6,5+10
RedditB 10.0=16
MUTAG 5.5=1.4
16.5+46
Dataset:
Enzymes
Proteins 6.3+.
MolHiv 5.7+1a
Peptides-struct 6.7+14
Multipartite 35,4+211
13.5+2.3
We conclude by noting that all Soft-Clusteingg methods pool each graph in the same predefined number of supernodes K. Instead, BN-Pool does not require specifying K and finds different K; for each graph, resulting in non-trivial distribution of the pooled graphs' sizes. Figure 14 shows the distributions of non-empty clusters found by BN-Pool on different datasets, which gives us further insights about the desired number of pooled nodes in each dataset. The statistics of the non-empty clusters found in each dataset are reported in Table
Sensitivity Analysis. In Table 5, we report the validation accuracy, averaged over 10 folds, for different configurations of the hyperparameters ,kx dK, and apr-
Table 5: Average validation accuracy for different hyperparameter configurations.
app
Enzymes
Colors3
0.1
59+a
98.6 +0.4
58+2
98.3 +0.4
10
57+3
98.5 +0.2
0.1
5912
98.8 20.3
1
58+2
98.5 20.3
1
1
10
59+4
98.6 #0.2
10
0.1
0.1
61+3
98.8 +0.2
10
0.1
1
6013
98.8 10.3
10
0.1
10
6013
99.1 10.9
10
0.1
6113
98.8 2.03
10
60
98.8
10
10
5714
99.1
30
0.1
0.1
6113
99.0
30
0.1
6113
99.1 10.3
59+s
99.2 +0.8
60+1
99.0 10.2
5912
98.9 10.3
10
5844
99.3 +0.2
As shown in Table 5, the average validation accuracy remains remarkably stable across different configurations. For both Enzymes and Colors3, the accuracy fluctuates only slightly, i.e., the differences are not statistically significant, indicating that the model is robust to changes in these hyperparameters. These results suggest that the proposed method does not require extensive hyperparameter tuning to achieve competitive performance, making it suitable for practical applications where computational resources or tuning time may be limited.
5.3 Computational resources
The experiments were performed using seven different servers equipped, respectively, with one Nvidia GeForce RTX 3090 (24GB VRAM), two Nvidia GeForee RTX 4090 (24GB VRAM), two Nvidia RTX A6000 (48GB VRAM), and two Nvidia RTX 6000 Ada Generation (48GB VRAM). In Tables and report. the
19

---

Published in Transactions on Machine Learning Research (04/2026)
Table Maximum usage the GPU VRAM (Gigabytes) and average training time (seconds per epoch) by different pooling operators on node-level tasks.
CiteSeer
Cora
DBLP
PubMed
VRAM (max GB)
time (s/epoch)
VRAM (max GB)
time (s (s/epoch)
VRAM (max GB)
time (s/epoch)
VRAM (max GB)
time (s/epoch)
DifiPool
0.59
0.91
0.49
0.78
5.43
1.22
6.52
1.16
MinCut
0.55
0,99
0.49
0.81
5.43
3.56
6.52
4.06
DMoN
0.55
0.93
0.49
0.82
5.43
1.10
6.52
1.00
JBGNN
0.55
0.88
0.49
0.79
5.43
1.07
6.52
0.95
BN-Pool
0.65
0.92
0.53
0.88
6.70
1.79
8.09
1.61
SP-BN-Pool
0.55
0.67
0.51
1.38
4.49
1.11
5.26
0.93
Table 7: Maximum usage of the GPU VRAM (Gigabytes) and average training time (seconds per epoch) by different pooling operators on graph-level tasks.
DD
RedditB
MolHiv
Pep-struct
VRAM
time (s/epoch)
VRAM (max GB)
time (s/epoch)
VRAM (max GB)
time (s/epoch)
VRAM (max GB)
time (s/epoch)
(max GB)
Graclus
1.05
0.48
1.06
0.47
1.00
22.74
1.03
23.88
ECPool
1.08
0.52
1.08
0.46
1.00
21.24
1.05
22.70
k-MIS
1.05
0.51
1.06
0,46
1.00
23.27
1.03
21.53
Top-k
1.08
0.48
1.07
0.46
1.00
23.61
1.03
23.78
DifiPool
2.58
0.53
6.39
0.55
1.00
22.03
1.09
22.11
MinCut
1.84
0.49
3.78
0.60
1.00
25.52
1.07
42.51
DMoN
1.37
0.48
3.35
0.50
1.00
22.33
1.05
22.17
JBGNN
1.45
0.46
2.43
0.47
1.00
22.83
1.05
22.72
HOSC
1.05
0.84
7.23
0.93
1.00
21.64
1.06
20.92
BN-Pool
2.53
0.61
5.97
0.82
1.01
24.05
1.13
37.05
SP-BN-Pool
1.13
0.88
1.14
0.83
1.00
20.72
1.05
20.83
maximum GPU memory usage and the average time to complete epoch for GNN configured with different pooling operators on node- and graph-level tasks, respectively. Pooling methods that pre-compute the coarsening of the graph (c.g., SEP and Eigen) are not considcred. Times are mcasured on an Nvidia GeFFrce RTX 3090.
Regarding the node-level tasks, on the two largest datasets, DBLP and PubMed, BN-Pool uses approximately 20% more GPU memory. The reason is that BN-Pool uses the binary cross-entropy the reconstruction loss: during backpropagation, the autograd framework retains the input of the sigmoid to compute the gradient. This extra operation also affects the average training times, but the results are comparable with other methods. Conversely, the sparse variant of BN-Pool (SP-BN-Pool) consistently reduces both memory footprint and training time across all datasets except Cora, being the dataset with the highest edge density. This behavior is expected since the negative edge sampling becomes less effective as the input graph density increases (sce Appendix A.4 for details).
In the case of graph-level tasks, process batches of size 16. We considered the three datasets with the highest average number of vertices (Pep-struct, RedditB, and DD), the dataset with the highest average number of edges (DD), and the datasct with the highest number of graphs (MolHiv). See Table 10 for the details. Soft-clustering methods use significantly more GPU memory only on DD and RedditB, as these datasets contain large and sparse graphs. In particular, Diffpool and BN-Pool require additional memory to compute the reconstruction loss over all non-edges. Although the memory footprint remains fully manageable on modern GPUs, -P-oNl drastically reduces memory usage, making it comparable to One- One-Evere Every- methods such as Top-k. Similarly, the training times of BN-Pool are higher datasets containing larger
20

---

Published in Transactions on Machine Learning Research (04/2026)
Table 8: Average number (and standard deviation) of epochs used to train the GNN in graph-level tasks when using different poolers.
GCB-H
Colors3
IMDB-BINARY
MolHiv
DD
Graclus
1205-1
2266+559
791+1m
609+ss
557+20
ECPool
162
1667
880
607
562
k-MIS
703
14:37:449
620
782
541 11
Top-k
1147=686
1813
760
845=181
552
DiffPool
998
1777 =550
111
877 =208
4:500
MinCut
1043=24a
1389
788
796=198
379
DMoN
1941 1284
1140
690
872=259
581+21 +:1
JBGNN
2096+1405
879
830
523
607
HOSC
792.s0
1459 1125
733
1016144
1 1:79
BN-Pool
2196
2127
958
_00
696
graphs (e.g., DD and RedditB). Conversely, on MolHiv and Pep-struct, the training times are comparable those of One-Every-K methods. Again, SP-BN-Pool reduces training time in most cases, except for DD, which is the dataset with the highest edge density. This result highlights that, while reconstructing the full adjacency matrix is negligible for small graphs and enables scalability datasets with large mumber of graphs, the sparse implementation of the reconstruction loss effectively reduces both memory footprint and training time on graphs with low edge density.
In Table we report statistics for the number of epochs needed to train the GNN for the graph-level tasks, configured with the different pooling operators. The statistics are computed over different weights initialization and dataset folds, which creates degree of variability. As discussed in Section 5.2, we use early stop with patience 100. We see that the number of epochs required by BN-Pool is comparable to the other methods, with the observed differences being largely attributable to the variability arising from different weight initializations and dataset folds.
6 Conclusions
We introduced BN-Pool, clegant graph pooling method that automatically discovers the number of supernodes in each input graph in a principled way. BN-Pool defines a SBM-like generative process for the adjacency matrix. By specifying a DP prior over the cluster memberships, our model can handle a thcoretically unbounded number of clusters, providing flexibility across datasets with graphs of hetorogencous sizes. Due to the probabilistic nature of BN-Pool, training is performed through the variational inference framework. We employ GNN to approximate the posterior of the node cluster membership, which allows conditioning the posterior on the node and edge features, and the downstream task at hand.
Experiments showed that BN-Pool can effectively find meaningful number of clusters across unsupervised node clustering, graph classification, and graph regression tasks. This is especially true in the homophilic setting, where the generative model assumptions align naturally with the data. Notably, on two graph classification datasets, it outperforms any other pooling method by a significant margin. We also provided a measurement of the computational resources required by our method. While the O(2)) complexity associated with the reconstruction loss is generally not bottleneck for typical graph-classffiation datasets, we additionally proposed a sparse implementation that reduces the complexity O(E), enabling the application of BN-Pool to datasets with substantially larger graphs.
To the extent of our knowledge, this is the first attempt to employ BNP techniques to perform graph pooling. This contribution opens the door to a broader integration of Bayesian methods in graph machine learning and GNNs in particular. The probabilistic framework underlying BN-Pool offers several promising directions for future research. First, it can be extended heterophilic graphs by modifying the prior on the generative process of the adjacency matrix to capture connectivity patterns that differ from homophily. Second, the approach can be adapted to dynamic graphs, where the input graph evolves. In this setting, the generative
21

---

Published in Transactions on Machine Learning Research (04/2026)
process could be conditioned previous time steps, following principles similar to hidden Markov models (Beal et al., 2001), thereby enabling temporal dependencies to be modeled in a principled way.
Acknowledgements
This work was supported by the Norwegian Research Council project 345017: RELAY: Relational Deep Learning for Eneryy Analytics. We gratefully thank NVIDIA Corporation for the donation of some of the GPUs used in this project. We also wish to thank Davide Bacciu for the initial discussions and for helping to establish the collaboration that made this work possible.
22

---

Published in Transactions on Machine Learning Research (04/2026)
A Implementation details
In this scction, we show how we implement the key operations in BN-Pool using PyTorch the backend. The code repository to reproduce this work is openly available" and an implementation of BN-Pool is available on Torch Geometric Pool" (Abate et al., 2026).
A.1 Priors and Posteriors Definition
Listing shows how we define the prior and the variational parameters, and how we compute the coarsened graph during the forward pass.
import torch. an functional as import torch as th from justom_layer. import MLP generic MLP
# --- Priors (hyperparaneters) # Prior for the Stick Breaking Process register_buffer ('alpha_DP', th. (nesun,cusseers 1) alpha_DP)
Prior for cluster-cluster prob. matrix
begfater_buffer anffer('ssigaaa ('sigma_K', tensooor (signaa_))
register, k', mu_K th. (y..eyenn,llueer n_clusters) n_clusters)))
mu_K (1-th.eye
13
14
Posteriors (paraneters) Transforms node embeddinga into posterior distributions for the sticke (alphe_ tilde and tiide) self.MB (eMmee__siz sidden_size, 2+ (If_cturres--1) bias=False)
15.
16
17
# variational parameters for the connectivity matrix K
self mu tilde th.nn. Paraneter (k_init th. eye n_clusters) k_init (1-th.oye (n_clusters, n_clusters)))
def forward (node_ embs, adj):
=adj size (-1)
Compute the node assignment matrix s, 9.pi get_ (node_embs)
Compute auxiliary rec rec_loss adj)
30
31
pi_kl kl pi.prior_loes (1.))))))oe((pp)) (q_pi)
32
k_k1 K_prior_lose()
33
aux loss rec gamma pi_k1 K_x1
34
36
# Rescale the loss aux lo8s aux_loss (1) a)
Compute the coarsened graph x_pool = th einsum b'b,k, bnf->bkf', 8, x) adj_pool natmul (th, matnul (8. transpose 2). adj). 8)
loss, adj_pool, x_pool
Listing 1: Priors hyperparameters and trainable parameters definition.
In particular, the hyperparameters representing the priors are defined as buffers since they are not optimized during the training. Conversely, the variational parameters are defined as parameters since they are modified by the training algorithm. The variational parameters ã, β are not defined explicitly since we compute them by applying an MLP to the node embeddings of size emb size generated by a GNN. The value of n_ clusters indicates the maximum number of clusters we consider (i.e., the truncation level C of the
23

---

Published in Transactions on Machine Learning Research (04/2026)
posterior approximation), and k init is the value used to initialize the variational parameter (i..., πeK in the main text).
In the forward function, we show how BN-Pool computes the coarsened graph and the auxiliary loss. The function has two input parameters: node_ node_embedee embeddings represents the node embeddings X' obtained by the previous MP layers, while adj represents the adjacency matrix A. First, we compute the posterior distributions q_pi, and the cluster-assinmment matrix S. Then, use these values to compute the auxiliary loss mux_loss, the coarsened graph adj_pool, and the pooled node features x_pool.
A.2 Cluster Assignments Computation
Listing 2 shows the key operations in the forward pass of our model: given the node embeddings produced by a GNN, we compute the cluster assignment matrix S. The forward pass also computes the variational distributions gr, which will be useful later to compute the losses.
def conptte_pi_given_stice. stricksssticsseeee (lstick.fractions).
# Conpute the sticks length given the stick fractions log_v th concat ([th log(stiikk.rractooss) th zeros (tsttttckkk..cttttooooo shape [:-1), 1)
1. dim=-1)
log_one_minus_y th. coneat conc (ww.ccccoccttticc.ttcctttcc shape(:-1] 1),
th. (1 stick_fractions)], din=-1)
pi th. (1og_v th. cunsum (log_one_mm) [log_one_minus_v minus__, dim=-1)) return pi has shape: [T, batch, N, c]
get_S (rndS((oo___eae n_particles, n_clusters): Conpute soft cluster assignnents. out
10
11
MMoel..MP(CC. MLP ((ode_eembs)) min-1e-3, max-1e3)
12
tipde_tiide, beta (eta(ssppaattilde, beta_tilde)
th.eplit (out, n_clustere-he -1, dim--1)
13
q_pi th, distriibbbtion
14
stick_fractions = p.p.. rsample (t..appl((..parrtcccee) s = pemputeepi.give..c stickssssiicsseeee (eick
return S, q-pi
Listing 2: Forward computation of the cluster assignments.
First, obtain the variational parameters à, 3 by applying the MLP to the node embeddings produced by the GNN. Note that both variational parameters should be greater than 0; thus, apply the softplus activation function. Moreover, to avoid numerical errors, we clamp the values between 10-3 and 10a.
Once we have the variational parameters, we define the variational distribution by employing the PyTorch class torch. distri butions. Beta. Then, we sample n_particles (i.e., in the main text) values that will be used approximate the reconstruction loss by using the rsample method. The in the rsample name stands for reparamelerization, that is, the trick that separates the distribution parameters from the randomness and allows to backpropagate the gradient from the samples to the distribution parameters. This technique is also denoted as a pathwise gradient estimator. As we mentioned in Section 3.4, the reparameterization trick cannot be applied to the Beta distribution explicitly. Therefore, we rely on an approximation of the pathwise derivative (Figurnov et al., 2018; Jankowiak Obermeyer, 2018), which does not require reparameterizing the Beta distribution explicitly. This approximation already implemented in the PyTorch framework: when we call the rsample method, the backend computes the pathwise derivative (if possible) or approximates it (as in case). Thus, the gradient flows from the reconstruction loss to the variational parameters o,, G, and then to the GNN parameters θ
The function soapuute_pigiven._ gisksssiisssckss sticks computes the stick length Ti,..., To given the stick fractions Tf...., T'c by applying Equation 4. The computation is performed in the log-space to avoid numerical errors.
A.3 Losses Computation
Listing 3 shows the computation of the losses froes Cx, Lk. The function rec loss computes the reconstruc- tion loss Lree- As shown Equation 13, the value of the loss corresponds the Binary Cross-Entree cosss-Entropy (BCE) loss computed between the adjacency matrix A and the probability to have edge for each node pair. Note
24

---

Published in Transactions on Machine Learning Research (04/2026)
that use BCE_with _ee_tst_llogiss rather than applying the sigmoid function to each n. jum. Since the number of edges is usually much smaller than the total number of possible edges, we assign different weights to the positive and negative classes to achieve class balancing. The weights for the positive class are computed in line 10 and stored the variable balance weights. balance_weights.
The loss f is equal to the KT, divergence between the prior p(TT..) and the variational posterior ((T(.)) for each node u and cluster Since all the distributions involved are Beta distributions, the KL divergence has closed form, and it is already implemented in PyTorc.. This loss is computed by the function pi_prior_lost loss.
def rec_lose (S, A):
3
Conpute percentage non-zers links и is the number of nodes
E is the number of edges
belihte_weighhe (N+1l E) A (N+N / (N+N E)) * (1 4)
Compute the probability of an edge for each node pair, i.e. S p_adj 8
mu_tile s. t-transpose(11.22 (-1,
loss - F. manaryy_rosae eropreerryy....rpy....o.. with logits (p_adj, A, weight-baleace. reduction='nowt none')
return 1oss
def pi_prior_ loss (self, (sel, 9-pi):
alpha__D self get get_buffer (naafferraalaaaaaaa alpha_DP')
p_pi Beta(th. onea_like (alpha_DP), alpha_DP)
loss a1_divergence (q.pi, p_pi).sur (-1)
return 19
20
21
def K_prior_los loss (seli):
22
mu_K, sigma_K self welf.get_teeeeee bet.teeeeeee k'), self get get_buffez ('eigma_
23
K_prior_les (0.5 (self.mu, mu_tide mu_K) sigma_K) kem
24
return x_prior_loes
Listing 3: Losses computation.
The last loss LK is equal to the KL divergence between normal distributions since ((;))) and p p(K;)) are Gaussian distributions for all clusters i and j. Since do not optimize the variance of the variational distribution, can ignore all the terms that do not involve the variational parameters j.. Thus, compute LK as the mean squared error between j and μæ scaled by the variance prior σk. This loss is computed by the function K X_proor_loo
A.4 Sparse Computation of the Reconstruction Loss
The implementation of the sparse reconstruction surrogate defined in equation 14 relies on efficient negative edge sampling. The goal is to generate non-existent edges (i.e., the "negative edges") that are used in the loss computation, avoiding the materialization of the full adjacency matrix. The elficiency of negative edge sampling relies on balancing memory usage and computational cost, depending on the sparsity of the graph. The critical factor is the relationship between the number of observed edges (E) and the total number of possible edges (N?).
For sparse graphs (E & N2), where the number of edges much smaller than the total possible edges, it is highly likely that randomly sampled edge is a negative one, i.e,, the edge is not present in the original graph. Thus, enumeaating all possible edges. This approach has significantly lower memory complexity and computational cost, as it operates only on the existing edges and avoids creating a dense adjacency structure.
efficiently sample negative edges by randomly generating node pairs without explicitly
As the graph density increases and E approaches N the probability randomly sampling a negative edge decreases. In this case, producing E. negative samples may require O(N2) sampling trials. Morcover, for dense graphs, the memory complexity of storing E edges already O(N2), meaning that the additional memory cost in explicitly enumerating all possible edges is lower. Therefore, in such scenarios, explicitly
25

---

Published in Transactions on Machine Learning Research (04/2026)
enumerate all possible edges, excluding the observed ones, and directly sample from the remaining set of negative edges.
To determine whether to use sparse sampling or dense enumeration, we employ a heuristic considering the sparsity of the input graph. The heuristic operates on the probability of sampling a valid negative edge, estimated as - (E/N2). Tf the probability is above a threshold (e.g.: 50%), sparse sampling is used; otherwise, the dense approach preferred. This adaptive mechanism ensures an optimal trade-off between computational and memory requirements.
All the operations are performed directly on the GPU to avoid unnecessary data transfer.
Datasets details
The details of the datasets used in the node clustering task are reported in Table We also report the intra-class and inter-class density, which the average number of edges between nodes that belong to the same class to different classes, respectively. The Community dataset is generated using the PyGSP library.. The other dalasets are obtained with the PyG loaders
Table Details of the vertex clustering datasets.
Dataset
Vertices
Edges
Vertex attr.
Vertex classes Intra-class density Inter-class density
Community
400
5,904
2
0.1737
0.0025
Cora
2,708
10,556
1,433
7
0.0065
0.0004
CiteSeer
3,327
9,104
3,703
0.0034
0.0003
PubMed
19,717
88,648
500
3
0.0005
0.0001
DBLP
17,716
105,734
1,639
0.0008
0.0001
Table 10: Details of the graph classification datascts.
Dataset
Samples
Classes Avg.
vertices Avg. edges Vertex attr. Vertex labels Edge attr.
GCB-H
1,800
148.32
572.32
Collab
5,000
74.49
4,914.33
Colors3
10,500
61.31
91.03
IMDB
1,000
19.77
96.53
Mutagenicity
4,337
30.32
61.54
yus
NCI
4,110
29.87
yes
RedditB
2000
429.63
497.75
110
D&D
1,178
284.32
1,431.32
y18
MUTAG
188
17.93
19.79
yts
Proteins
1,113
39.06
72.82
yus
Engymes
600
32.63
62.14
18
yes
MolHiv
41,127
2
25.5
27.5
9
n0
3
Pep-struct
15,335
150.9
307.3
9
no
3
Multipartite
5,000
10
99.79
4,477.43
3
The details of the datasets used in the graph classification lask are reported in Table 10. All datasets besides GCB-H, Multipartite, Pep-struct, and ogbg-molhiv are downloaded from the TUDataset repository using the PyG loader. For the GCB-H, we used the data loader provided in the original repository MolHiv is obtained from the OGB repository!? through the loader from the OGB library. The Multipartite dataset is
/0attps://chrmmrrs.. github. io/datasets/
http://gtttuu.occm///iiippp/oo Beeattmarrrdddtattttffrrrrr dataset_for htwp://www.....accc......ooooooa
PPtttps://obb.etantn http::///gg..ataaoooocc///////// http//docs/graaproop//
26

---

Published in Transactions on Machine Learning Research (04/2026)
obtained from the original repository', and Pep-struct is downloaded using the PyG loader for the Long Range Graph Benchmark datasets
B.1 Hyperparameters configuration
In Table 11 we report the optimal configuration of apr, μk, and оk in each dataset, i.., those that yield the best classification accuracy, MSE, AUROC the validation set.
Table 11: Optimal configuration of the hyperparameters of BN-Pool for each datasct.
Dataset
oDP
OK
GCB-H
10.0
30.0
1.0
Collab
1.0
10.0
0.1
Colors3
10.0
30.0
1.0
TMDB
10.0
10.0
0.1
Mutagenicity
10.0
30.0
1.0
NCI1
10.0
1.0
0.1
RedditB
1.0
1.0
1.0
D&D
30.0
1.0
1.0
MUTAG
1.0
10.
1.0
Proteins
1.0
1.0
0.1
Enzymes
1.0
30.0
0.1
MolHiv
10.0
1.0
0.1
Pep-struct
1.0
0.1
0.1
Multipart.
1.0
10.0
1.0
C
Additional experiments
In Table 12 we report the additional results that were omitted from the main body.
Table 12: Mean and standard deviations of the graph classification accuracy.
Pooler
GCB-H
IMDB
DD
Graclus
75+3
77+6
73+4
ECPool
75+4
75+7
73+3
k-MIS
7524
7447
75
Top-k
562s
7415
72t5
SEP
7422
7216
7713
DiffPool
51+s
72+6
75+4
MinCut
75
7340
78
DMoN
74=3
73+6
78+3
JBGNN
75+4
75+6
79+4
Eigen
62
7140
7411
HOSC
75
7415
7942
BN-Pool
75
7648
80
In Table 13 report the results obtained by other soft-clustering methods by sweeping the number of supernodes K over the values 0.25N and O.1.N.
htttpp//eendbo.rrrreeeeee//////
html
27

---

Published in Transactions on Machine Learning Research (04/2026)
Table 13:
Mean and standard deviations of the graph classification accuracy (ROC-AUC for MolHiv and MAE for Pep-struct) when using different pooling ratios K 0.25. and K 0.1N.
Pooler
Collab Colors3 Mutagenicity NCI1 RedditB MUTAG Enzymes Proteins MolHiv Pep-struct Multip.
DiffPool (0.25)
65
56
79+2
73+3
78
87
21
73
73+2
.300
54
DiffPool (0.1)
66+3
45
80+2
71+s
77+7
79=10
20+4
71
68
340=
58+1
MinCut (0.25)
71
68
81
781a
9021
862
341s
7426
754a
2270
58
MinCut (0.1)
70+2
75+1
80+2
78+2
90+2
85+9
36+6
74
72+s
.288 +0.00
60+s
DMoN (0.25)
694a
72=1
8243
79
90
882s
35
73
7642
.277 10.003
55
DMoN (0.1)
70
6921
8011
78
91
8519
40:9
74
7510
.306
62.1
JBGNN (0.25)
71+1
69+1
80+2
79+3
92+1
88+5
40+5
74-s
75+0
.317 .377+.00
51+3
JBGNN (0.1)
70
67
8017
77
9211
8519
37
73
7611
.317 1000
59
HOSC (0.25)
72+2
77=1
8042
77
90
87:5
37+7
74
76+1
.277 10004
24:3
HOSC (0.1)
70+1
78=1
80+2
77+2
91+1
87+5
36*8
74=6
75+2
18+5
References
Carlo Abate and Filippo Maria Bianchi. Maxcutpool: differentiable feature-aware maxcut for pooling in graph neural networks. In The Thirteenth International Conference on Learning Representations, 2025. URL https://openrevior net//oorumidd=xxltR..
Carlo Abate, Ivan Marisca, and Filippo Maria Bianchi. Torch geometrie pool v1.0 technical report. arXiv preprint arXit:2512.1066 1264,, 2026.
Andrea Asperti and Matteo Trentin. Balancing reconstruction error and kullback-leibler divergence variational autoencoders. IEEE Access, 1-199440-199448, 2020.
Davide Bacciu, Alessio Conte, and Francesco Landolfi. Graph pooling with maximum-weight k-independent sets. In Thirth-Seventh AAAI Conference on Artificial Intelligence, 2023.
Jinheon Back, Minki Kang, and Sung Ju Hwang. Accurate learning of graph representations with graph multisct pooling. In Proceedings of the 9th International Conference on Learning Representations, 2021.
Matthew Beal, Zoubin Ghahramani, and Carl Rasmussen. The infinite hidden markov model. Advances in neural information processing systems, 14, 2001.
Filippo Maria Bianchi. Simplifying clustering with graph neural networks. Proceedings of the Northern Lights Deep Learning Workshop, 4, Jan. 2023. doi: 00.7557/18.6777
Filippo Maria Bianchi and Veronica Lachi. The expressive power of pooling in graph neural networks. In Advances in Neural Information Processing Systems, volume 36, 71603-71618, 2023.
Filippo Maria Bianchi, Daniele Grattarola, and Cesare Alippi. Spectral clustering with graph neural networks for graph pooling. In International conference machine learning, pp. 874-887 PMLR, 2020a.
Filippo Maria Bianchi, Daniele Grattarola, Lorenzo Livi, and Cesare Alippi. Hierarchical representation learning in graph neural networks with node decimation pooling. IEFE Tronsactions Neural Networks and Learning Systems, 33(5):2115-222 2020b.
Filippo Maria Bianchi, Claudio Gallicchio, and Alessio Micheli. Pyramidal reservoir graph neural network. Neurocomputing. 470:389-404, 2022. ISSN 0925-2312.
Filippo Maria Bianchi, Ivan Marisca, and Carlo Abate. Torch Geometric Pool, 3 2025. URL https:
//github.com www.ttttttteeeeeeeo teegp-team/torchh http:p/tttaaoorrreeooeieiiiooooo geometric-pool.
David Blackwell and James B MacQueen. Ferguson distributions via polya urn schemes. The annals of slatislics, 1(2):353 355, 1973.
David M Blei and Michael I Jordan. Variational methods for the dirichlet process. Proceedings of the twenty-forst international conference Machine learning, pp. 12, 2004.
28

---

Published in Transactions on Machine Learning Research (04/2026)
Samuel Bowman, Luke Vilnis, Oriol Vinyals, Andrew Dai, Rafal Jozefowicz, and Samy Bengio. Generating sentences from a continuous space. In Proceedings of the 20th SIGNLL conference on compulational natural language learning, pp. 10 21, 2016.
Andrea Cini, Danilo Mandic, and Cesare Alippi. Graph-based Time Scries Clustering for End-to-End Hicrarchical Forecasting. International Conference on Machine Learning. 2024.
Djork-Arné Clevert. Fast and accurate deep network learning by exponential linear units (elus). arXiv preprint arXieo1511.079889, 2015.
Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast. localized spectral filtering. Advances neural information processing systems, 29, 2016.
Inderjit $ Dhillon, Yuqiang Guan, and Brian Kulis. Weighted graph cuts without eigenvectors multilevel approach. IEEE transactions on pattern analysis and machine intelligence, 29(11):1944-9957, 2007.
Frederik Dichl. Edge contraction pooling for graph neural networks. arXiv preprint 1rX:::1905.10000 2019.
Alexandre Duval and Fragkiskos Malliaros. Higher-order clustering and pooling for graph neural networks. In Proceedings of the 31st ACM international conference on information & knowledge management, pp. 426-435, 2022.
Vijay Prakash Dwivedi, Ladislav Rampášek, Mikhail Galkin, Ali Parviz, Guy Wolf, Anh Tuan Lau, and Dominique Beaini. Long range graph benchmark. In Thirty-siath Conference on Newral Information Processing Systems Datasets and Benchmarks Track, 2022.
Mikhail Figurnov, Shakir Mohamed, and Andriy Mnih. Implicit reparameterization gradients. Advonces in neural information processing systems, 31, 2018.
H. Gao, Y. Liu, and S. Ji. Topology-aware graph pooling networks. IEEE Tronsactions on Pattern Analysis and Machine Intelligence, 43(12):4512-4518, dee 2021. ISSN 1939-3539.
Hongyang Gao and Shuiwang Ji. Graph u-nets. In international conference machine learning, pp. 2083 2092. PMLR, 2019.
Xing Gao, Wenrui Dai, Chenglin Li, Hongkai Xiong, and Pascal Frossard. inool-informationneoooo based pooling in hierarchical graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 33 (9):5032-5044 2022.
Samuel J Gershman and David M Blei. A tutorial on bayesian nonparametric models. Journal of Mathematical Psychology, 56(1):1-12, 2012.
Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In International conference on machine learning, pp. 1263 1272. PMLR, 2017.
Daniele Grattarola, Daniele Zambon, Filippo Maria Bianchi, and Cesare Alippi. Understanding pooling in graph neural networks. IEEE Transactions on Neural Networks and Learning Systems, 2022.
Thomas L. Griffiths and Zoubin Ghahramani. The indian buffet process: An introduction and review. Journal of Machine Learning Research, 12 12(32):1185-122 2011.
Jonas Berg Hansen, Andrea Cini, and Filippo Maria Bianchi. On time series clustering with graph neural networks. Transactions on Machine Learning Research, 2025. ISSN 2835-8856. URL https: /ttpss///pperrevee set/foorumidd=MoQXfite.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human- level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026 1026-1034, 2015.
29

---

Published in Transactions on Machine Learning Research (04/2026)
Irina Higgins, Loic Matthey, Arka Pal, Christopher Burgess, Xavier Glorot, Matthew Botvinick, Shakir Mohamed, and Alexander Lerchner. beta-VAF: Learning basic visual concepts with a constrained variational framework. In International Conference on Learning Representations, 2017.
Paul W. Holland, Kathryn Blackmond Laskey, and Samuel Leinhardt. Stochastic blockmodels: First steps.
Social Networks, 5(2):109 137, 1983. ISSN 0378-8733. doi: https://doi..org/10..000 1111100111000--1111 (1378-8733383)90022-- URL hctps://www sciencedirect..
Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay Pande, and Jure Leskovec. Strategies for pre-training graph neural networks. arXiv preprint ar 1rXii:1905.12266 2019.
Martin Jankowiak and Fritz Obermeyer. Pathwisc derivatives beyond the reparameterization trick. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 2235-2244 PMLR, 10-15 Jul 2018.
Wei Jin, Lingxiao Zhao, Shichang Zhang, Yozen Liu, Jiliang Tang, and Neil Shah. Graph condensation for graph neural networks. arXiv preprint arXiv:21 10.07580, 2021.
Weonyoung Joo, Wonsung Lee, Sungrae Park, and Il-Chul Moon. Dirichlet variational auloencoder. Pallern Recognition, 107:107514, 2020.
Amir Hosein Khasahmadi, Kaveh Hassani, Parsa Moradi, Teo Lee, and Quaid Morris. Memory-based graph networks. In International Conference on Learning Representations, 2020.
Diedcrik P. Kingma and Jimmy Ba. Adam: A mothod for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015.
Diederik P. Kingma and Max Welling. Auto-Encoding Variational Bayes In 2nd International Conference Learning Representations, ICLR 2014, Banff, AB, Canada, April 14-16, 2014, Conference Track Proceedings, 2014.
Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional nelworks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.
Boris Knyazev, Graham W Taylor, and Mohamed Amer. Understanding attention and generalization in graph neural networks. Aduances in neuraa information processing systems, 32, 2019.
Ponnambalam Kumaraswany. A generalized probability density function for Couble-bounder random processes. Journal of hydrology, 46(1-2):79 1980.
Junhyun Lee, Inyeop Lee, and Jaewoo Kang. Self-attention graph pooling, In International conference on machine learning, pp. 3734-3743. PMLR, 2019.
Roel J Leenhouts, Tara Larsson, Sebastian Verhelst, and Florence H Vermeire. Property prediction of fuel mixtures using pooled graph neural networks. Fuel, 381:133218, 2025.
Jia Li, Jianwei Yu, Jinjin Li, Honglei Zhang, Kangfei Zhao, Yu Rong, Hong Cheng, and Junzhou Huang. Dirichlet graph variational autoencoder. Advances in Newral Information Processing Systems, 33:5274 5283, 2020.
Mario Lino, Stathi Fotiadis, Anil Bharath, and Chris D Cantwell. Multi-scale rotation-equivariant graph neural networks for unstcady culerian fluid dynamics. Physics of Fluids, 34(8), 2022.
Ning Liu, Songlei Jian, Dongsheng Li, Yiming Zhang, Zhiquan Lai, and Hongzuo Xu. Hicrarchical adaptive pooling by capturing high-order dependency for graph representation learning. IEEE Transactions on Knowledge and Data Fngineering, 35(4):3952 0-9592-39665, 3965, 2021.
30

---

Published in Transactions on Machine Learning Research (04/2026)
Yao Ma, Suhang Wang, Charu C Aggarwal, and Jiliang Tang. Graph convolutional networks with cigenpooling. In Proceedings of the 25th ACM SIGKDD international conference on knowledge discovery & dola mining, pp. 723 731, 2019.
Zheng Ma, Junyu Xuan, Yu Guang Wang, Ming Li, and Pietro Liò. Path integral based convolution and pooling for graph neural networks. Advances in Newral Information Processing Systems, 33:16421-16433, 2020.
Ivan Marisca, Cesare Alippi, and Filippo Maria Bianchi. Graph-based forccasting with missing data through spatiotemporal downsampling. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 34846-34440 34865- PMLR, 2024.
Nikhil Mchta, Lawrence Carin Duke, and Piyush Rai. Stochastic blockmodels meet graph neural networks. In International Conference on Machine Learning, pp. 1466-4474 PMLR, 2019.
Christopher Morris, Nils M. Kriege, Franka Bause, Kristian Kersting, Petra Mutzel, and Marion Neumann. Tudataset: A collection of benchmark datasets for learning with graphs. In ICML 2020 Workshop on Graph Representation Learning and Beyond (GRL+ 2020), 2020.
Fric Nalisnick and Padhraic Smyth. Stick-breaking variational autoencoders. In International Conference Learning Representations, 2017.
Peter Orbanz and Yee Whye Teh. Bayesian nonparametric models. Encyclopedia of machine learning, 1, 2010.
Yunsheng Pang, Yunxiang Zhao, and Dongsheng Li. Graph pooling via coarsened graph infomax. In Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval, pp. 2177-2181, 2021.
Jim Pitman. Poisson dirichlet and gem invariant distributions for split-and-merge transformations of an interval partition. Combinatorics, Probability and Computing, 11(5):501-514, 2002.
Ekagra Ranjan, Soumya Sanyal, and Partha Talukdar. Asap: Adaptive structure aware pooling for learning hierarchical graph representations. In Proceedings of the AAAI Conference on Arlificial Intelligence, volume 34, pp. 5470-544 5477, 2020.
Jayaram Sethuraman. A constructive definition of dirichlet priors. Statistica sinica, pp. 639 6599650,450 1994.
Casper Kaae Sonderby, Tapani Raiko, Lars Maaløe, Søren Kaae Sonderby, and Ole Winther. Ladder variational autoencoders. Advances in neural information processing systems, 29, 2016.
Anton Tsitsulin, John Palowitch, Bryan Perozzi, and Emmanuel Müller. Graph clustering with graph neural networks. J. Mach. Learn. Res., 12:17:11127:221 2023.
Mario Lino Valeccia, Tobias Pfaff, and Nils Thuerey. Learning distributions of complex fluid simulations with diffusion graph networks. In The Thirteenth International Conference on Learning Representations, 2025. URL
Pengyun Wang, Junyu Luo, Yanxin Shen, Siyu Heng, and Xiao Luo. A comprehensive graph pooling benchmark: Effectiveness, robustness and generalizability. arXiv preprint ar arXin:2406. 00000,090111 2024.
Junran WU, Xueyuan Chen, Ke Xu, and Shangzhe Li. Structural entropy guided graph hierarchical pooling. In International conference on machine learning, pp. 24017 24030. PMLR, 2022.
Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. Molcculenct: a benchmark for molccular machine learning. Chemical science, (2):513 530, 2018.
Fanding Xu, Zhiwei Yang. Lizhuo Wang, Deyu Meng, and Jiangang Long. Mespool: Molecular edge shrinkage pooling for hicrarchical molecular representation learning and property prediction. Briefings in Bioinformaticc, (233 2024.
31

---

Published in Transactions on Machine Learning Research (04/2026)
Keyulu Xu, Weihua Hu, Jure Leskovee, and Stefanic Jegelka. How powerful are graph neural networks? In International Conference on Learning Representations, 2019.
Zhitao Ying, Jiaxuan You, Christopher Morris, Xiang Ren, Will Hamilton, and Jure Leskovec. Hierarchical
graph representation learning with differentiable pooling. Advances in neural information processing systems, 31, 2018.
Hao Yuan and Shuiwang Ji. Structpool: Structured graph pooling via conditional random fields. In Proceedings of the 8th International Conference on Learning Representations, 2020.
Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang, Changcheng Li, and Maosong Sun. Graph neural networks: A review of methods and applications. Al Open, 1:57 81, 2020. ISSN 2666-6510.
32


Reviews:
[{"review_id": "VOWM3RQqMg", "reviewer": "Reviewer_V28m", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This paper proposes BN-Pool, a graph pooling operator that uses a Bayesian nonparametric formulation to adaptively choose the number of supernodes per input graph, rather than fixing a pooled size K across graphs. The method defines an SBM-like generative process for edges based on latent soft cluster memberships and a cluster-cluster connectivity matrix. Training combines the downstream supervised loss with an auxiliary variational objective derived from the ELBO. Empirically, the paper evaluates (i) unsupervised node clustering and (ii) graph classification/regression, reporting competitive or improved results compared to existing pooling operators on multiple benchmarks.\n\nStrengths:\n1. Clear, principled formulation that ties pooling to a probabilistic generative model and explains how adaptive K emerges.\n2. Broad experimental scope across node clustering and graph-level prediction, plus sensitivity and resource reporting.\n\nWeaknesses:\n1. Experiments can be improved; the hyperparameters of baselines can be tuned better, and more competitive pooling methods can be added.\n2. Claims about compactness/redundancy are not directly quantified in the main evaluations; the evidence focuses primarily on predictive performance.", "claims_and_evidence_yn": "Yes", "claims_explanation": "The method definition directly encodes the adaptive number of supernodes via a DP prior and a variational objective in which the KL term on stick-breaking variables functions as a cluster-usage regularizer; this is clearly described and mathematically grounded. Also the result tables support the competitiveness of the proposed method on various graph-level tasks. The paper includes GPU memory and time-per-epoch comparisons and concludes that the O(N^2) complexity is generally not limiting on typical benchmarks.", "audience_yn": "Yes", "audience_explanation": "Graph pooling is a central component in hierarchical GNNs, and choosing K is a persistent practical and conceptual pain point. BN-Pool provides a principled way to make pooled size data-dependent per graph (and potentially task-dependent through joint training), which is likely of interest to readers working on graph representation learning, probabilistic deep learning, and scalable/robust GNN architectures. The empirical results suggest BN-Pool can match or exceed existing pooling methods on standard benchmarks.", "requested_changes": "1. Add quantitative measures tied to the “compactness” claim: e.g., distribution of learned K_i per dataset, average pooled graph density/sparsity, etc.\n2. For more comprehensive comparison, consider adding (a) tuned K sweeps for soft-clustering baselines and (b) tuned \\kappa sweeps for score-based baselines\n3. Graph pooling was a popular area of study in graph neural networks. Compare with more pooling methods:\n[1] https://arxiv.org/abs/1904.13107\n[2] https://proceedings.mlr.press/v162/wu22b.html\n[3] https://dl.acm.org/doi/abs/10.1145/3511808.3557353\n[4] https://ojs.aaai.org/index.php/AAAI/article/view/25866", "broader_impact_concerns": "No ethical issues are found.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "rYHhcGDhrK", "reviewer": "Reviewer_21r7", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper introduces BN-Pool, a novel graph pooling operator for Graph Neural Networks (GNNs) based on Bayesian nonparametric modeling. Its core contribution is addressing a key limitation of existing soft-clustering pooling methods (e.g., DiffPool, MinCut): the need to predefine a fixed number of clusters (supernodes) for all graphs, thereby achieving superior performance.\n\n(+) Adaptive and data-driven pooling that eliminates the need to tune or guess the number of clusters or pooling ratios\n\n(+) Strong theoretical grounding in the Bayesian nonparametric framework\n\n(-) Additional probabilistic hyperparameters ($\\alpha_{DP}$, $\\mu_K$, $\\sigma_K$) make it unclear whether there is actually a benefit\n\n(-) The presentation is unclear, making it difficult to understand the details of the proposed method", "claims_and_evidence_yn": "No", "claims_explanation": "My major concerns are two-fold:\n- While the proposed method removes the need to explicitly tune the number of clusters, it is unclear whether this constitutes a net practical benefit. In particular, BN-Pool introduces several additional hyperparameters (e.g., $\\alpha_{DP}$, $\\mu_K$, and $\\sigma_K$), whose selection may be non-trivial and could potentially offset the advantage of eliminating the cluster-count hyperparameter. As a result, the overall complexity of model tuning may not be reduced and could even increase.\nThis issue also raises concerns regarding the experimental comparison: the proposed hyperparameters are tuned for BN-Pool, whereas the number of clusters for competing pooling methods appears to be fixed rather than similarly optimized. This asymmetry makes it difficult to attribute the reported performance gains to the proposed methodology itself, rather than to differences in hyperparameter tuning effort.\n- The presentation is also unclear. There is no clear definition of the proposed BN-Pool layer in Section 3: what are the inputs and outputs of the layer? What are its hyperparameters? How do one apply it to an existing GNN? How about the additional GNN? I also find there is a gap between the BNP theory and the proposed method and do not quite understand how it is used to design BN-Pool in detail.", "audience_yn": "Yes", "audience_explanation": "GNN and pooling layers are classic topics in machine learning and will be of interest to at least some individuals in TMLR's audience.", "requested_changes": "As mentioned above, I request changes in: 1) clarifying the benefits of the proposed method in terms of the additional hyperparameters introduced; 2) revising the experiments to ensure fairness against hyperparameter tuning and their burden, together with analysis/explanations of the new results; 3) rewriting the methodology part to facilitate understanding of the proposed method.", "broader_impact_concerns": "N/A", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "VzUe1sNbEr", "reviewer": "Reviewer_h9KQ", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "This work propose BN-Pool, the first soft-clustering pooling operator capable of adaptively determining the number of supernodes for each individual graph. Unlike previous methods that rigidly fix # of supernodes or set it as a fraction of graph size, BN-Pool utilizes a Bayesian Non-parametric framework with a Dirichlet Process prior to allow for a theoretically unbounded number of clusters. This is implemented via a variational autoencoder where a GNN approximates the posterior of node-to-cluster assignments, optimized by combining downstream task loss with an auxiliary reconstruction loss.\n\nIn node clustering tasks, e.g., community detection, this work effectively identifies communities and interaction patterns without prior knowledge of the number of classes, reconstructing adjacency matrices that better reflect the original graph sparsity compared to methods like MinCut. \n\nIn graph classification, the method performs on par with or superior to existing pooling operators, achieving state-of-the-art results on datasets such as Colors-3 and Enzymes. BN-Pool avoids the redundancy typical of other soft-clustering methods by generating compact pooled graphs that preserve informative content while discarding unnecessary clusters.", "claims_and_evidence_yn": "Yes", "claims_explanation": "Theoretically,  the core evidence for the model's ability to adaptively determine the # of nodes comes from the properties of DP, which dictates that even with infinite capacity, the process will favor reusing existing components, and using the Stick-Breaking Process to construct the mixing proportions.\n\nAdditionally, this work demonstrates effectiveness from multiple experimental perspectives, e.g., adaptive clutering ability, competitive performance and compact representations.", "audience_yn": "Yes", "audience_explanation": "This article is based on the classic DP scheme for graph clustering. This simple combination of traditional schemes with neural networks should be of interest to the audience.", "requested_changes": "The experimental validation would benefit from a more rigorous analysis of the model's robustness and the specific contributions of its components. Specifically, the paper lacks a sensitivity analysis for the hyperparameter $\\eta$ in Equation 12, which balances the reconstruction loss and clustering penalty; it is crucial to demonstrate whether extreme values of $\\eta$ cause the model to degenerate into trivial solutions, such as assigning all nodes to a single cluster. Furthermore, since BN-Pool introduces three distinct loss terms, an explicit ablation study is necessary to quantify the independent performance contribution of each term. Finally, while the paper highlights successful clustering on datasets like GCB-H, the discussion should be expanded to include failure cases or specific scenarios where the model struggles, such as on heterophilic graphs, to provide a more comprehensive evaluation of its limitations.\n\nRegarding complexity and scalability, the reliance on an $O(N^2)$ reconstruction loss poses a clear challenge for scaling to larger graphs, despite the authors' assertion that it is manageable for current benchmarks. The paper should discuss or propose specific optimization strategies to mitigate this, such as employing edge sampling or negative sampling to approximate the loss and potentially reduce complexity to $O(|E|)$ or $O(N)$. Additionally, the current runtime comparison relies solely on time-per-epoch, which may be misleading; given the complex variational inference and auxiliary losses involved, BN-Pool likely requires more epochs to converge than simpler baselines. Therefore, comparing the total time required to reach convergence would offer a more realistic and transparent assessment of the training costs.", "broader_impact_concerns": "there's no broader impact concerns.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)