Hierarchical Clustering Aggregation

• Hierarchical clustering aggregation is a family of methods that build multiscale hierarchies by successively merging lower-level units, such as singleton clusters, graph clusters, or summary features.
• It encompasses diverse strategies including classical linkage approaches, probabilistic distance measures, and objective-driven rules to ensure regularity and interpretability in the resulting dendrograms.
• These techniques are applied across various domains like document clustering, 3D instance segmentation, and federated learning, demonstrating flexible aggregation from raw data to compact representations.

Hierarchical clustering aggregation denotes a family of procedures that build, refine, or combine hierarchies by successively aggregating lower-level units into coarser structure. In the narrow agglomerative sense, it is the bottom-up merge sequence that starts from singleton clusters, repeatedly merges the closest pair, and encodes the resulting hierarchy as a dendrogram (Bonald et al., 2018). In broader usage, the aggregated units need not be raw points: they may be graph clusters defined by node-pair sampling, document clusters together with shared feature sets, point-cloud sets, clusterlets transmitted by federated clients, compact data summaries such as cluster features, or even entire dendrogram description matrices [(Vaithyanathan et al., 2013); (Chen et al., 2021); (Cai et al., 10 Jan 2026); (Schubert et al., 2023); (Rashedi et al., 2018)]. This broader usage suggests that hierarchical clustering aggregation is best treated as a unifying design pattern for multiscale structure construction rather than as a single linkage rule.

1. Scope, representations, and hierarchy semantics

A common formal core is the hierarchy itself: a nested family of partitions, a rooted binary tree, or an equivalent ultrametric representation. In agglomerative graph clustering, a hierarchy is the sequence $C_0,\ldots,C_{n-1}$, where $C_0$ is the partition into singleton clusters and $C_t$ has $n-t$ clusters; the merge sequence is encoded as a dendrogram, and the merge distances are required to be non-decreasing for a regular dendrogram (Bonald et al., 2018). In ontology-regularized clustering, a rooted prior tree $T$ is converted into an ultrametric

$$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$

making the prior hierarchy directly usable as a distance matrix (Ma et al., 2018).

Not all hierarchical aggregation outputs are classical dendrograms. In one-shot federated clustering, the server-side hierarchy is represented as

$$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$

where $\mathbf{Q}_\delta$ is an object–cluster assignment matrix at granularity $\delta$ and $k_\delta$ is the corresponding number of clusters (Cai et al., 10 Jan 2026). In 3D instance segmentation, the hierarchy is explicitly two-level: point aggregation generates sets, and set aggregation merges those sets into complete instances (Chen et al., 2021). In consensus hierarchical clustering, multiple dendrograms are first converted into matrix descriptions and only later recovered as a single hierarchy (Rashedi et al., 2018).

This diversity matters because the meaning of “aggregation” changes with the representation. In some cases it means cluster merges inside a single tree; in others it means aggregation of summaries, priors, or multiple pre-existing hierarchies.

2. Agglomerative distance mechanisms and linkage design

Classical hierarchical agglomerative clustering is specified by an inter-cluster linkage. Standard examples are single linkage,

$C_0$0

complete linkage,

$C_0$1

average linkage,

$C_0$2

and Ward’s linkage, defined by the increase in within-cluster sum of squares when merging $C_0$3 and $C_0$4 (Gowda et al., 11 Feb 2026). A persistent limitation is that HAC does not optimize a single explicit global objective; the linkage function therefore controls the entire aggregation behavior (Gowda et al., 11 Feb 2026).

A graph-specific formulation replaces geometric linkage by a probabilistic cluster distance. For a weighted, undirected graph with adjacency matrix $C_0$5, node weights $C_0$6, and total weight $C_0$7, node-pair sampling defines

$C_0$8

For clusters $C_0$9,

$C_t$0

and the aggregation distance is

$C_t$1

The update formula after merging $C_t$2 and $C_t$3 into $C_t$4 is

$C_t$5

so the new distance is a weighted harmonic mean of the old distances. This immediately yields reducibility,

$C_t$6

which guarantees non-decreasing merge distances and therefore a regular dendrogram, and also enables a nearest-neighbor chain implementation (Bonald et al., 2018).

A more recent linkage proposal replaces all-pairs or extremal distances by the asymmetric Chamfer distance,

$C_t$7

Its interpretation is representational: $C_t$8 is a good merge partner for $C_t$9 if every point of $n-t$0 finds a nearby representative in $n-t$1. The asymmetric version satisfies the min-monotonicity property

$n-t$2

and admits an $n-t$3-time, $n-t$4-space HAC algorithm for the asymmetric and normalized asymmetric variants (Gowda et al., 11 Feb 2026).

A recurrent misconception is that hierarchical aggregation distances must be metrics. The graph-sampling distance $n-t$5 is explicitly “not guaranteed to be a metric,” and Chamfer variants likewise do not satisfy the triangle inequality (Bonald et al., 2018, Gowda et al., 11 Feb 2026).

3. Objective-driven and probabilistic aggregation

One strand of work derives aggregation from an explicit probabilistic model rather than from a linkage heuristic. In model-based hierarchical clustering for documents, the data model is a mixture of multinomials with Dirichlet priors, and the hierarchy is built while partitioning features into noise features $n-t$6 and useful features $n-t$7 (Vaithyanathan et al., 2013). In the hierarchical version, each internal node $n-t$8 has a node-specific noise set $n-t$9 and useful set $T$0, with the nesting constraint $T$1 whenever $T$2 is an ancestor of $T$3. The algorithm is two-stage: a flat EM-based model selection stage followed by modified hierarchical agglomerative clustering. Each merge is evaluated by the change in Bayesian log marginal likelihood,

$T$4

which depends only on the features chosen to become shared noise at that node. Feature selection is greedy: candidate shared features are ordered by increasing $T$5, and features are added while $T$6 increases (Vaithyanathan et al., 2013). Aggregation here is therefore simultaneous cluster merging and parameter tying.

A different optimization-centered line derives agglomerative rules from a general bi-partial objective

$T$7

or, in dual form,

$T$8

where $T$9 and $$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$0 represent opposing within-cluster and between-cluster terms (Owsiński, 24 Feb 2026). The hierarchy is obtained by tracking, as $$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$1 varies, the earliest merge that becomes favorable. In the Marcotorchino–Michaud-type example, cluster-level quantities

$$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$2

lead to the critical merge value

$$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$3

The pair with smallest $$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$4 is merged, producing a minimum-distance hierarchical aggregation rule with an explicit optimization rationale (Owsiński, 24 Feb 2026). The same framework is extended to facility-location-style costs and to bi-partial $$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$5-means, where the merge condition is written in terms of $$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$6 and $$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$7 (Owsiński, 24 Feb 2026).

Graph aggregation via node-pair sampling also admits an objective interpretation. The merge distance $$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$8 is inversely related to the modularity-gain threshold, and the hierarchy can be read as a greedy modularity-maximizing scheme with a sliding resolution parameter $$u_T(x_i,x_j)=\frac{|\mathrm{leaves}(T[x_i\lor x_j])|}{|\mathrm{leaves}(T[\mathrm{root}])|},$$9. Since the merge distances $$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$0 are non-decreasing, the implied resolution sequence $$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$1 is non-increasing (Bonald et al., 2018).

4. Aggregation units beyond raw points

In several important settings, hierarchical aggregation does not operate directly on the original observations. Instead it aggregates intermediate sets, prototypes, representatives, or sufficient statistics.

In 3D instance segmentation, HAIS makes this explicit. A sparse 3D network predicts semantic labels and center shift vectors $$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$2, producing shifted coordinates

$$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$3

Point aggregation constructs a graph in shifted space and extracts connected components using a fixed point-level bandwidth $$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$4, yielding primary instances and fragments. Set aggregation then merges fragments into primary instances using a dynamic set-level bandwidth

$$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$5

with same-class nearest-primary assignment if the fragment–primary centroid distance is below $$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$6. The design is NMS-free because the final masks are non-overlapping by construction (Chen et al., 2021).

In one-shot hierarchical federated clustering, the local aggregated unit is the clusterlet. Each client $$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$7 holds $$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$8 and runs Fine-grained Competitive Penalized Learning to produce clusterlets

$$H=\{(\mathbf{Q}_\delta,k_\delta)\mid 1\le \delta\le \Delta\},$$9

with feature-weighted similarity

$\mathbf{Q}_\delta$0

Only the clusterlet centroids are uploaded once to the server. The server stacks all clusterlets into $\mathbf{Q}_\delta$1, repeatedly clusters them to obtain the hierarchy

$\mathbf{Q}_\delta$2

then encodes the hierarchy as a representation $\mathbf{Q}_\delta$3 via

$\mathbf{Q}_\delta$4

and performs a final feature-weighted clustering on that representation. Aggregation is therefore prototype-level, one-shot, and multi-granular (Cai et al., 10 Jan 2026).

For scalable HAC under resource constraints, BETULA aggregates data into numerically stable cluster features

$\mathbf{Q}_\delta$5

with merge updates

$\mathbf{Q}_\delta$6

$\mathbf{Q}_\delta$7

$\mathbf{Q}_\delta$8

HAC then runs on leaf CFs instead of raw points. The paper makes the correspondence explicit: $\mathbf{Q}_\delta$9 matches UPGMA, $\delta$0 matches centroid linkage, and $\delta$1 matches Ward linkage. Because the expensive stage depends on $\delta$2 rather than the original $\delta$3, the overall cost can become near-linear in $\delta$4 when $\delta$5 is bounded (Schubert et al., 2023).

A representative-based variant uses sub-minimum-spanning-trees. SRSC builds sub-MSTs by nearest-neighbor chains, identifies reciprocal nearest-neighbor pairs $\delta$6 with $\delta$7, scores each node using degree, average neighbors’ degree, path-based centrality, and distance-based centrality, and keeps one root per sub-MST as the representative for the next level. The reported complexity is $\delta$8 time-complexity and $\delta$9 space-complexity (Xie et al., 2021).

These constructions show that aggregation units can be designed to fit the computational and statistical structure of the domain: sets in point clouds, clusterlets in federated systems, cluster features in scalable HAC, or scored roots in graph-like spatial structure.

5. Combining hierarchies, incorporating priors, and attaching uncertainty

Hierarchical aggregation also includes the aggregation of hierarchies themselves. In boosting-based multi-clustering for hierarchical clusterings, each iteration draws a weighted bootstrap sample, builds a dendrogram $k_\delta$0, converts it to a dissimilarity description matrix, and combines the resulting matrices into a consensus one. The weighting is updated by

$k_\delta$1

where $k_\delta$2 is the correlation between the Euclidean distances of sample $k_\delta$3 in the original dataset and the corresponding distances in the aggregated hierarchy. Matrix aggregation is based on the Rényi divergences entropy approach; setting parameter $k_\delta$4 to $k_\delta$5, $k_\delta$6, or $k_\delta$7 yields minimum, average, or maximum combination, respectively. The final output is the consensus dendrogram $k_\delta$8 (Rashedi et al., 2018).

Prior knowledge can be aggregated with empirical dissimilarities instead of with other trees. Given a prior tree $k_\delta$9, the ultrametric

$C_0$00

is combined with a problem-specific dissimilarity $C_0$01 as

$C_0$02

When the underlying distance is ultrametric, single, complete, and average linkage recover the encoded hierarchy, and single linkage offers stability in the sense of small Gromov–Hausdorff perturbations under small perturbations of the distance matrix (Ma et al., 2018).

A different form of hierarchy aggregation is post-processing of an arbitrary initial tree. Anytime hierarchical clustering starts from any $C_0$03, checks a local $C_0$04-homogeneity condition at each grandchild cluster, and applies nearest-neighbor interchange (NNI) moves until the tree becomes $C_0$05-homogeneous. For single linkage, $C_0$06-homogeneity is equivalent to the tree produced by batch $C_0$07; for NNI-reducible linkages the procedure terminates in finite time (Arslan et al., 2014).

Uncertainty can also be attached directly to the merge process. A randomized hierarchical clustering scheme replaces the deterministic greedy merge by a softmax over candidate merges: $C_0$08 with a step-specific scale $C_0$09. This randomization supports valid node-wise p-values for testing whether a merge should be performed, and an adaptive $C_0$10-spending procedure yields an estimate $C_0$11 of the number of clusters with a probabilistic guarantee on overestimation. Repeated randomized runs also produce co-occurrence matrices and stability summaries across runs (Wu et al., 6 Dec 2025).

6. Theory, scalability, and limitations

Several recurring theoretical motifs organize the field. Reducibility is central in agglomerative graph clustering because it guarantees non-decreasing merge distances and regular dendrograms (Bonald et al., 2018). In point-process clustering, hierarchical nearest-neighbor constructions such as $C_0$12, $C_0$13, and $C_0$14 operate on countably infinite point sets. For the homogeneous Poisson point process, $C_0$15 produces almost surely finite clusters at each fixed level, while the limiting structure is a one-ended forest; for $C_0$16, the limiting graph is a subgraph of the Minimal Spanning Forest (Khaniha et al., 24 Mar 2025). In scalable agglomerative clustering, the SCC algorithm organizes merges by thresholded sub-cluster components; under $C_0$17-separability it recovers the optimal flat partition and also provides a two-approximation to the non-parametric DP-Means objective, and it was demonstrated on a dataset of 30 billion queries (Monath et al., 2020).

Scalability is achieved by different means in different formulations. SCC uses sparse nearest-neighbor graphs and connected components (Monath et al., 2020). BETULA compresses data into cluster features before running HAC (Schubert et al., 2023). Paris maintains aggregate adjacency structures with space complexity $C_0$18 on graphs and exploits nearest-neighbor chains (Bonald et al., 2018). HAIS keeps aggregation algorithmically simple and reports only 410ms per frame on ScanNet v2, without non-maximum suppression (Chen et al., 2021). Fed-HIRE removes iterative communication altogether by using one-way prototype-level communication (Cai et al., 10 Jan 2026).

The main limitations are likewise heterogeneous. Some formulations are domain-specific: HAIS is tailored to 3D point clouds, and Fed-HIRE assumes a federated non-IID prototype setting (Chen et al., 2021, Cai et al., 10 Jan 2026). Some impose graph or likelihood restrictions: Paris assumes weighted, undirected graphs, while the document model-based hierarchy assumes a multinomial likelihood with Dirichlet priors [(Bonald et al., 2018); (Vaithyanathan et al., 2013)]. Some rely on greedy local moves rather than global optimization, even when an objective interpretation exists (Owsiński, 24 Feb 2026). Some hierarchical outputs are not classical dendrograms at all, but sequences of partitions or feature encodings (Cai et al., 10 Jan 2026).

A common misconception is therefore that hierarchical clustering aggregation is simply linkage-based HAC on raw points. The literature instead spans probabilistic graph distances, Bayesian feature-sharing merges, consensus of multiple dendrograms, pre-aggregation by sufficient statistics, representative-based MST aggregation, point-to-set and set-to-instance aggregation, randomization with valid inference, and prototype-level federated aggregation [(Bonald et al., 2018); (Vaithyanathan et al., 2013); (Rashedi et al., 2018); (Schubert et al., 2023); (Xie et al., 2021); (Chen et al., 2021); (Wu et al., 6 Dec 2025); (Cai et al., 10 Jan 2026)]. Another misconception is that every hierarchy is automatically an ultrametric with a formally established proof; in the Paris graph-clustering formulation, the paper explicitly does not prove the induced leaf distance is an ultrametric, even though the merge heights can be used that way (Bonald et al., 2018).

Taken together, these works show that hierarchical clustering aggregation is not one method but a technical family of aggregation mechanisms. What unifies them is the progressive construction of multiscale structure through merges, summaries, representatives, or combined hierarchy descriptions, together with an increasing emphasis on regularity, interpretability, statistical justification, and scalability.