Hierarchical Coreset (HierCore)

• Hierarchical Coreset (HierCore) is a multi-level data summarization method that recursively compresses weighted data, ensuring task-relevant approximations.
• It is implemented across diverse settings—streaming, relational learning, and image anomaly detection—balancing efficiency with theoretical error guarantees.
• The approach emphasizes both representativeness and hierarchical diversity, preserving structural nuances to enable scalable and robust performance.

Hierarchical Coreset, commonly abbreviated “HierCore,” denotes a family of hierarchical data summarization and subset-selection schemes in which a small weighted representation is organized across levels so that downstream objectives can be approximated without retaining the full dataset. In the classical coreset literature, this idea appears as the merge-and-reduce tree or coreset tree for streaming, distributed, and dynamic data, with guarantees defined over a query space $(P,w,X,f)$ and a weighted summary $C$ that preserves $f(P,Q)$ for every query $Q \in X$ (Feldman, 2020). More recent work uses the name or an equivalent construction in narrower settings, including hierarchy-aware subset construction based on RK-core strata and a hierarchical memory-bank framework for multi-class image anomaly detection that clusters semantic embeddings and then builds cluster-specific patch coresets (Lu et al., 2023, Heo et al., 4 Aug 2025).

1. Formal definitions and conceptual scope

In the updated coreset survey, a query space is a tuple $(P, w, X, f)$ where $P$ is the input set, $w: P \to [0,\infty)$ is a weight function, $X$ is the set of queries, and $f: P \times X \to [0,\infty)$ is the loss. The total cost of a query $Q \in X$ on $C$0 is

$C$1

A coreset is a small weighted set $C$2 with weights $C$3 such that, for every query $C$4, the coreset cost

$C$5

approximates $C$6; the standard multiplicative guarantee is

$C$7

for all $C$8 (Feldman, 2020). The same survey distinguishes strong coresets, which approximate all $C$9, from weak coresets, which approximate a restricted query family $f(P,Q)$0, and it identifies composability as the property that unions of coresets are themselves coresets for unions of inputs and can be recursively recompressed (Feldman, 2020).

Within this classical usage, “HierCore” is effectively synonymous with a coreset tree or merge-and-reduce framework. The survey states this explicitly: “HierCore = coreset tree = merge-and-reduce framework” (Feldman, 2020). In this sense, hierarchy refers to the recursive organization of summaries across levels of a tree, not to semantic class structure.

A second, learning-centric definition appears in the 2025 coreset selection survey. There, the primary objective is to choose a subset $f(P,Q)$1 of a training set $f(P,Q)$2 such that a model trained on $f(P,Q)$3 generalizes similarly to one trained on $f(P,Q)$4:

$f(P,Q)$5

That survey does not use the name “Hierarchical Coresets” or “HierCore,” but it frames hierarchical constructions through composable and multi-stage procedures in streaming, continual, distributed, and staged selection settings (Moser et al., 23 May 2025).

A third usage is more specialized. In the RK-core paper, hierarchical structure is induced by refined k-core decomposition over sample affinity graphs, and the resulting strata are used to motivate a hierarchy-aware coreset that preserves “hierarchical diversity” rather than selecting only the most representative points (Lu et al., 2023). In the 2025 anomaly-detection paper, “Hierarchical Coreset (HierCore)” is the explicit name of a two-level semantic clustering and patch-memory-bank method for multi-class image anomaly detection (Heo et al., 4 Aug 2025).

2. Merge-and-reduce coreset trees

The canonical hierarchical construction partitions a dataset or stream into blocks, computes a small coreset for each block, and organizes these summaries in a tree. When two coresets of the same level are present, they are merged by weighted union and then reduced by recompressing the union into a new coreset of bounded size. The active nodes across all levels summarize all data seen so far (Feldman, 2020).

The streaming update pattern is standard:

1. insert incoming points into a level-$f(P,Q)$6 buffer;
2. when the buffer reaches size $f(P,Q)$7, compute a coreset for that block;
3. whenever at least $f(P,Q)$8 coreset nodes exist at the same level, merge their weighted unions and reduce to a new coreset at the next level;
4. optionally reduce the union of active nodes into a final top-level coreset (Feldman, 2020).

Error accumulation is controlled per level. For additive guarantees,

$f(P,Q)$9

For multiplicative guarantees,

$Q \in X$0

so choosing $Q \in X$1 yields overall $Q \in X$2 behavior (Feldman, 2020). Composability follows from additivity: if $Q \in X$3 and $Q \in X$4 approximate $Q \in X$5 and $Q \in X$6, then $Q \in X$7 approximates $Q \in X$8 (Feldman, 2020).

The 2016 framework of Feldman, Schmidt, and Sohler refines the hierarchical picture by showing that sensitivity-based sampling can reduce coreset size from $Q \in X$9 to

$(P, w, X, f)$0

where $(P, w, X, f)$1 is total sensitivity and $(P, w, X, f)$2 is the VC-dimension of the induced function class. In a merge-and-reduce hierarchy with $(P, w, X, f)$3 levels, overall memory becomes $(P, w, X, f)$4, and per-level errors $(P, w, X, f)$5 preserve end-to-end approximation (Braverman et al., 2016). For k-means and k-median, the same framework yields $(P, w, X, f)$6 and coreset sizes of order

$(P, w, X, f)$7

with probability at least $(P, w, X, f)$8 (Braverman et al., 2016).

This hierarchical model is directly suited to streaming computer vision. An early application proposed “a compact, constant size representation of all the data that was seen until a given moment,” constructed “using a parallelized algorithm,” then used a coreset tree to learn “an adaptive object appearance model” in “constant time and logarithmic space” for tracking-by-detection. The method reported results on “three standard datasets over more than 100 videos” and outperformed several algorithms on the TLD dataset, whose videos average 2685 frames (Dubey et al., 2015).

3. Hierarchical diversity via RK-core

RK-core starts from a data-centric premise: when a dataset is modeled class-wise as a graph of sample-to-sample affinities, hierarchical structure can be exposed through coreness. Let $(P, w, X, f)$9 be the samples of one class, let $P$0 be a pre-trained model, and let $P$1 be the spatially averaged feature vector of sample $P$2. Pairwise cosine affinity is

$P$3

Thresholding at $P$4 yields an undirected sparse graph $P$5 (Lu et al., 2023).

Classical k-core decomposition defines the $P$6-core $P$7 as the maximal subgraph in which every vertex has degree at least $P$8, and the coreness of a vertex $P$9 is

$w: P \to [0,\infty)$0

RK-core refines this by recording the pruning round $w: P \to [0,\infty)$1 from onion decomposition and defining

$w: P \to [0,\infty)$2

which breaks ties within a coreness level by incorporating neighborhood pruning information (Lu et al., 2023). The peeling and neighbor updates are $w: P \to [0,\infty)$3, and the additional pass for $w: P \to [0,\infty)$4 is also $w: P \to [0,\infty)$5.

The empirical motivation is representativeness. On CIFAR-10, class-balanced subsets containing $w: P \to [0,\infty)$6 per class and stratified by coreness gave:

• High coreness: $w: P \to [0,\infty)$7
• Medium coreness: $w: P \to [0,\infty)$8
• Low coreness: $w: P \to [0,\infty)$9

On CIFAR-100 with $X$0 samples per class, the corresponding values were:

• High: $X$1
• Medium: $X$2
• Low: $X$3 (Lu et al., 2023)

The same analysis shows that a high-quality coreset should not be concentrated solely at the highest coreness levels. The paper reports that existing coreset methods on CIFAR-10, including DeepFool, Uncertainty, k-Center Greedy, GraNd, Glister, and Random, select samples with a spread of coreness values. At $X$4, for example, k-Center Greedy reaches $X$5, whereas a “high-coreness-only” subset of the same budget reaches $X$6 (Lu et al., 2023).

The paper does not name a specific algorithm “HierCore,” but its analysis implies a recipe that balances representativeness and hierarchical coverage. The proposed hierarchy profile for a subset $X$7 is defined over coreness bins $X$8 by

$X$9

with analogous $f: P \times X \to [0,\infty)$0 for the full dataset. Diversity and fidelity can then be quantified by

$f: P \times X \to [0,\infty)$1

$f: P \times X \to [0,\infty)$2

and

$f: P \times X \to [0,\infty)$3

A representative scoring function is

$f: P \times X \to [0,\infty)$4

and the coreset can then be selected to maximize representativeness subject to constraints such as $f: P \times X \to [0,\infty)$5 and $f: P \times X \to [0,\infty)$6 (Lu et al., 2023). This formulation makes the hierarchical claim precise: preserving dataset structure means retaining multiple coreness strata rather than only the most central samples.

4. Aggregation trees and pseudo-cubes for relational data

A different hierarchical coreset construction appears in relational learning, where the data matrix is not materialized explicitly but defined by a join of $f: P \times X \to [0,\infty)$7 relational tables. If

$f: P \times X \to [0,\infty)$8

the empirical risk objective is

$f: P \times X \to [0,\infty)$9

with a continuity assumption

$Q \in X$0

for constants $Q \in X$1 and $Q \in X$2 (Chen et al., 2022).

The paper defines a weighted set $Q \in X$3 to be an $Q \in X$4-coreset if, for all $Q \in X$5,

$Q \in X$6

where $Q \in X$7 is the diameter of $Q \in X$8 and

$Q \in X$9

This guarantee combines multiplicative and additive error terms (Chen et al., 2022).

The hierarchical structure is an aggregation tree built bottom-up. Each node $C$00 carries a subset of represented tables $C$01, a product subspace

$C$02

and a set of $C$03 centers $C$04 (Chen et al., 2022). The key geometric primitive is the pseudo-cube:

$C$05

Because pseudo-cubes are Cartesian products of Euclidean balls in each participating subspace, their counts can be computed under acyclic joins without additive inequalities (Chen et al., 2022).

At the leaves, Gonzalez is run on $C$06 to produce $C$07 centers per table. At an internal merge, two child center sets form a $C$08 grid $C$09. Empty grid points are removed by COUNT tests over products of pseudo-cubes, and Gonzalez is then run on the nonempty set $C$10 to compress back to $C$11 centers. The per-level covering radius satisfies

$C$12

and the paper proves

$C$13

where $C$14 is the doubling dimension (Chen et al., 2022).

The resulting size theorem states that if

$C$15

then the root centers with appropriate weights yield a $C$16-coreset satisfying

$C$17

for all $C$18 (Chen et al., 2022). Because pseudo-cubes can overlap, the paper adds a sampling-based overlap-resolution stage; if

$C$19

then with probability at least $C$20 the final coreset satisfies the full $C$21 guarantee (Chen et al., 2022).

The total tree-construction time is

$C$22

with

$C$23

for acyclic counting, and overlap resolution costs $C$24 (Chen et al., 2022). The same framework is instantiated for k-means, k-median, k-center, logistic regression, and SVM. In this setting, hierarchical coreset construction is not merely a storage device; it is the mechanism that makes learning over unmaterialized joins tractable.

5. HierCore for multi-class image anomaly detection

In multi-class unsupervised image anomaly detection, the 2025 paper formally introduces Hierarchical Coreset (HierCore) as a hierarchical memory-bank method intended to satisfy two deployment requirements: training should be agnostic to class-label availability, and evaluation should maintain comparable performance whether class labels are available or not (Heo et al., 4 Aug 2025). The paper distinguishes four scenarios: $C$25, $C$26, $C$27, and $C$28, where $C$29 and $C$30 denote known and unknown class labels at training or inference.

The method uses a pre-trained Wide-ResNet-50. Semantic embeddings are taken from the fourth layer,

$C$31

while local patch features are taken from the second and third layers and then processed by a patch-extraction operator using a $C$32 window with stride $C$33 (Heo et al., 4 Aug 2025). The hierarchy has two levels.

At Level 1, semantic embeddings of normal images are clustered by FINCH. The hierarchy level with the highest Silhouette score is selected, yielding $C$34 clusters without pre-setting $C$35. Cluster centroids are

$C$36

and image assignment uses Euclidean distance:

$C$37

At Level 2, each semantic cluster has its own patch memory bank:

$C$38

Redundancy is reduced by k-center coreset selection. The paper writes the Euclidean covering objective as

$C$39

with a sampling ratio $C$40 in the experiments (Heo et al., 4 Aug 2025).

Inference first assigns a test image to the nearest semantic centroid,

$C$41

then computes patchwise nearest-neighbor distances to the corresponding cluster-specific coreset memory:

$C$42

The patchwise anomaly map is upsampled bilinearly, and the image-level anomaly score is the maximum patch score:

$C$43

Known evaluation can use per-class thresholds $C$44, whereas unknown evaluation can use a single global threshold $C$45. The paper also states that the architecture conceptually supports per-cluster thresholds $C$46 via pseudo-class assignment, but the reported evaluation uses optimal thresholds chosen post hoc by

$C$47

It does not provide a label-free threshold estimation formula (Heo et al., 4 Aug 2025).

The reported complexity makes the hierarchical effect explicit. If $C$48 is the total number of patches, $C$49 the local feature dimension, $C$50 the coreset sampling ratio, $C$51 the number of images, and $C$52 the number of patches in cluster $C$53, then

$C$54

whereas

$C$55

The patch count is

$C$56

and the paper remarks that typically $C$57, so FINCH overhead is negligible relative to patch-level computations (Heo et al., 4 Aug 2025).

Empirically, the method is evaluated on MVTec AD, VisA, MPDD, and BTAD, using mean AUROC, mean AP, mean F1 at optimal threshold, mean AUPRO, and mean IoU at optimal threshold, with the aggregated score $C$58 defined as the unweighted average of metrics in the corresponding block (Heo et al., 4 Aug 2025). Under known evaluation, HierCore reports image-level and pixel-level $C$59 values of:

• MVTec AD: image $C$60, pixel $C$61
• VisA: image $C$62, pixel $C$63
• MPDD: image $C$64, pixel $C$65
• BTAD: image $C$66, pixel $C$67

Robustness to label availability is one of the central claims. In the $C$68 versus $C$69 comparison, the Diff. Ratio (Unknown/Known F1) is:

• MVTec AD: image $C$70, pixel $C$71
• VisA: image $C$72, pixel $C$73
• MPDD: image $C$74, pixel $C$75
• BTAD: image $C$76, pixel $C$77

In the $C$78 versus $C$79 comparison, the corresponding Diff. Ratios are:

• MVTec AD: image $C$80, pixel $C$81
• VisA: image $C$82, pixel $C$83
• MPDD: image $C$84, pixel $C$85
• BTAD: image $C$86, pixel $C$87 (Heo et al., 4 Aug 2025)

Efficiency gains relative to PatchCore are also reported. On MVTec AD, memory-bank construction decreases from $C$88 minutes to $C$89 minutes, evaluation time from $C$90s to $C$91s, and FPS increases from $C$92 to $C$93. On VisA, memory-bank construction decreases from approximately $C$94 minutes to $C$95 minutes, evaluation time from $C$96s to $C$97s, and FPS increases from $C$98 to $C$99. Averaged across datasets, the paper reports approximately $f(P,Q)$00–$f(P,Q)$01 faster memory-bank construction, approximately $f(P,Q)$02 faster inference, and approximately $f(P,Q)$03 higher FPS (Heo et al., 4 Aug 2025).

6. Terminological range, related hierarchies, and limitations

The literature does not use “HierCore” in a single uniform sense. In survey-style coreset theory, the term denotes the classical merge-and-reduce tree over weighted summaries (Feldman, 2020). In the RK-core setting, it denotes a hierarchy-preserving subset strategy derived from coreness strata and refined rankings, and the paper explicitly argues that “a high-quality coreset should exhibit hierarchical diversity instead of solely opting for representative samples” (Lu et al., 2023). In relational learning, the hierarchy is an aggregation tree with pseudo-cubes over joins (Chen et al., 2022). In anomaly detection, the term is the proper name of a specific semantic-clustering and cluster-specific memory-bank framework (Heo et al., 4 Aug 2025).

The 2025 survey of coreset selection literature places these usages in a broader context of composable, dynamic, and multi-stage pipelines. Although it does not use the name “Hierarchical Coresets” or “HierCore,” it treats hierarchical behavior as arising in composable streaming and distributed coresets, filter-then-select pipelines such as FASS, PRISM, and SIMILAR, label-free staged strategies such as ELFS, and bilevel continual-learning or streaming methods such as those of Borsos et al. and Wang et al. (Moser et al., 23 May 2025). In that survey, the theoretical guarantees are typically per stage rather than global hierarchy-wide formulas: submodular maximization retains the greedy bound

$f(P,Q)$04

while CRAIG-style gradient approximation is controlled by

$f(P,Q)$05

(Moser et al., 23 May 2025).

Several misconceptions can therefore be excluded. Hierarchical coresets are not restricted to one objective class: the cited literature covers clustering, subspace approximation, regression, SVM, logistic regression, tracking-by-detection, active learning, continual learning, semi-supervised learning, and anomaly detection (Feldman, 2020, Chen et al., 2022, Moser et al., 23 May 2025). Nor does hierarchy necessarily mean class labels; the anomaly-detection HierCore is designed precisely to operate “even without class labels,” using semantic clustering to estimate pseudo-classes (Heo et al., 4 Aug 2025). Conversely, hierarchy does not automatically solve thresholding or robustness problems: the anomaly-detection paper reports optimal thresholds selected post hoc and does not specify a label-free threshold estimation formula, and the relational framework depends on acyclic joins, low intrinsic dimension, and sufficient sampling to resolve pseudo-cube overlap (Chen et al., 2022, Heo et al., 4 Aug 2025).

Taken together, the term “Hierarchical Coreset” refers to a common structural principle—multi-level compression that preserves task-relevant structure—implemented in materially different ways across classical coreset theory, hierarchy-aware subset selection, relational learning, and multi-class anomaly detection. The common thread is recursive or stratified reduction; the differences lie in what defines a level of the hierarchy, what objective is preserved, and what approximation or deployment guarantees are available.