Zero-Label Coreset Selection Edges Out a Labeled Baseline on ImageNet at 10%

What changed, and when

"Zero-Shot Coreset Selection via Iterative Subspace Sampling" first went up as an unreviewed preprint on 22 November 2024 (arXiv:2411.15349v1). A revised version, v2, posted 24 November 2025, added a line most preprints never get to add: accepted to WACV 2026. The paper then went through the IEEE/CVF Winter Conference on Applications of Computer Vision's official proceedings, appearing on CVF Open Access at pages 2114 to 2124, and was presented as a poster, number 67, in WACV 2026's first poster session on 8 March, 4:00 to 5:45pm.

The authors are Brent A. Griffin and Jacob Marks, both at Voxel51 (the open-source computer vision data tooling company behind FiftyOne), and Jason J. Corso, who holds appointments at Voxel51 and the University of Michigan. Voxel51 posted its own walkthrough of the paper, including a video presentation by Griffin on his personal YouTube channel, and put the full implementation up at github.com/voxel51/zcore, a public repository that has drawn 108 stars and 20 commits as of this writing.

The method, which the authors call ZCore, is evaluated on four datasets: ImageNet (1.28 million training images), CIFAR-10 and CIFAR-100 (50,000 images each), and four splits of EuroSAT (EuroSAT80, 40, 20 and 10, ranging from 21,600 down to 2,700 images). What makes it worth tracking for anyone doing active learning or data selection work: it is, in the authors' own words, "the only method to make selections without labels or data training," at a time when, as they put it, "state-of-the-art coreset methods increasingly use data labels and training prior to selection."

The evidence table

The headline comparison is on ImageNet, where a ResNet trained on the full 1.28 million images reaches 73.54% top-1 validation accuracy, the ceiling every reduced-data method is chasing. At three keep rates, the gap between ZCore and TDDS (a 2024 labeled, trained coreset method) narrows or flips depending on how much data survives the cut.

Read the 10% row carefully: ZCore's 1.36-point edge over Random (53.99% vs 52.63%) is the whole basis for the "zero labels beats a labeled method" claim, since ZCore's 0.08-point edge over TDDS (53.99% vs 53.91%) is inside normal run-to-run noise for a single ImageNet training run. At 20% and 30%, TDDS pulls back ahead by 1.25 and 0.26 points. The pattern reverses as more data is kept: the less data you can afford to label and look at, the more a label-free method has room to compete.

On CIFAR-100, where the paper reports every rate from 70% down to 10% (Table 9 in the arXiv v2 PDF), the same shape holds but the margins are larger. A ResNet18 trained on the full 50,000 CIFAR-100 images reaches 78.21%.

On CIFAR-100, TDDS beats both ZCore and Random at every single rate, by 0.9 to 6.8 points. ZCore's real advantage on CIFAR-100 is over Random, not over TDDS: at the 10% rate, ZCore's 52.11% beats Random's 46.68% by 5.43 points, the widest margin in the paper.

A thousand random 2D slices substitute for one trained proxy model

TDDS and similar methods score every candidate image by training a model (or tracking training dynamics) on the full labeled pool, then keeping the examples that model found hardest or most informative. ZCore skips the model entirely and scores examples by where they sit, geometrically, in an embedding space built from off-the-shelf foundation models.

No image is ever compared to its label, because there are no labels in the selection step. The only information ZCore uses is where each image's embedding sits relative to others, measured from a thousand different random 2D angles rather than one fixed high-dimensional comparison. Coverage rewards an example for being the closest point to an unexplored region of the space; the redundancy penalty stops near-duplicates of an already-covered region from dominating the top-scoring list.

The label-free method only leads at the lowest data rate tested

The accuracy gaps are small enough that the result depends on which keep rate you look at. ZCore's advantage over TDDS exists only at 10%; it disappears, then reverses, as the budget grows.

There is a second cost dimension the chart does not show: how many labels each method actually touches before training starts. TDDS has to run inference and track training dynamics on 100% of the candidate pool to produce its difficulty scores, then label and train again on just the selected subset. ZCore never looks at a label until the final subset is chosen. At a 10% keep rate, that means TDDS's total labeled-image consumption (100% of the pool, for scoring, plus training on the 10% subset) is roughly 10 times what ZCore touches; at 30%, about 3.33 times; at 70%, about 1.43 times. Those ratios come directly from dividing the full pool by the keep rate, and they match what the paper reports.

What it means for someone doing this work

If the constraint is annotation budget and the decision is which images to send to labelers in the first place, a zero-label selector like ZCore is the only category of method that can run before a single label exists. TDDS, ELFS and similar trained coreset methods need the full pool labeled (or at least a large labeled proxy set) before they can even start scoring, which defeats the point if the goal is to avoid labeling images you will throw away.

The tradeoff is accuracy, and it is small but not zero. On ImageNet, skipping labels costs nothing at 10% (ZCore actually edges ahead) but costs 1.25 points at 20% and 0.26 points at 30% relative to TDDS. On CIFAR-100 it costs 0.90 to 2.40 points at every single rate from 70% down to 10%. Anyone choosing between these methods is trading a specific, bounded accuracy gap (under 3 points in every result reported here) against a specific, bounded cost gap (10x to 40x in compute and label volume, depending on the comparison).

The EuroSAT results complicate a clean "ZCore wins when you keep less" story: the paper reports ZCore beating TDDS on the EuroSAT40 split at a 10% rate, but trailing both TDDS and Random on the EuroSAT20 and EuroSAT10 splits at low rates. Domain and dataset size appear to matter as much as keep rate. A satellite-imagery dataset with only 2,700 to 21,600 images behaves differently from a 1.28-million-image web-photo corpus, and the paper does not offer a rule for predicting which regime a new dataset falls into before running the comparison.

Our judgement: the WACV 2026 acceptance, the camera-ready numbers, and a public, runnable 108-star repository make this a real, peer-reviewed, reproducible result, not a lab demo or a cherry-picked blog claim. But the "zero labels beats a labeled baseline" headline rests on one data point, ImageNet at a 10% keep rate, where the margin over TDDS is 0.08 points, smaller than typical run-to-run training variance. At every other rate and on every other dataset the paper reports, the labeled, trained method wins. We would call this strong evidence that zero-label selection is a viable, much cheaper alternative at very aggressive keep rates, not evidence that labels are now optional for coreset selection generally.

Check it yourself

The implementation, data splits, and default hyperparameters are public. These commands come directly from the repository's own README.

# 1. Read the paper and the official WACV 2026 proceedings version
# https://arxiv.org/abs/2411.15349  (v2, posted 2025-11-24, accepted WACV 2026)
# https://openaccess.thecvf.com/content/WACV2026/html/Griffin_Zero-Shot_Coreset_Selection_via_Iterative_Subspace_Sampling_WACV_2026_paper.html

# 2. Clone the official implementation
git clone https://github.com/voxel51/zcore
cd zcore
pip install fiftyone

# 3. Run zero-shot coreset selection on EuroSAT10 (smallest split, fastest to reproduce)
python zeroshot_coreset_selection.py --dataset eurosat10 --data_dir ./data \
  --results_dir ./results --embedding clip resnet18 --num_workers 10

# 4. Train a model on the resulting coreset at a 70% prune rate and check the accuracy
python train_coreset_model.py --prune_rate 0.7 --dataset eurosat10 \
  --data_dir ./data --score_file \
  ./results/eurosat10/zcore-eurosat10-clip-resnet18-1000Ks-2sd-ri-1000nn-4ex-0/score.npy

# 5. The score-file name itself encodes the method's parameters:
#    1000Ks = 1,000,000 iterations, 2sd = 2D subspace dimension,
#    1000nn = 1,000 nearest neighbors (alpha), 4ex = distance exponent (beta=4)

To check the ImageNet numbers quoted here directly, read Table 6 and Table 9 (CIFAR) of arXiv:2411.15349v2, or watch the authors' own walkthrough: youtube.com/watch?v=c3AvXhF7Jg8, posted by co-author Brent Griffin.

What would prove this wrong

The claim at risk here is narrow: that a zero-label method can match or beat a labeled, trained coreset method at a specific, low keep rate on a specific dataset. If an independent group, not Voxel51 and not using the authors' own code path, reruns the ImageNet 10% comparison between ZCore and TDDS (or a newer labeled baseline) by 31 December 2027 and finds TDDS ahead by more than 0.5 points, a gap too large to attribute to training-run noise, that would mean the single data point this finding rests on does not replicate outside the original paper. If, instead, ZCore is shown to beat a labeled, trained baseline at a 20% or 30% keep rate on any dataset, not just 10% on ImageNet, that would strengthen the finding beyond what is currently reported.

Sources

1. Brent A. Griffin, Jacob Marks, Jason J. Corso. "Zero-Shot Coreset Selection via Iterative Subspace Sampling." arXiv:2411.15349, v1 posted 22 November 2024, v2 posted 24 November 2025, accepted to WACV 2026.
2. IEEE/CVF. WACV 2026 Open Access proceedings page, pp. 2114-2124.
3. Voxel51. "Voxel51 @ WACV 2026", poster session 1, 8 March 2026, poster #67.
4. Voxel51 / github.com. zcore repository, README and score-file naming convention.
5. Brent Griffin. "Zero-Shot Coreset Selection via Iterative Subspace Sampling | WACV 2026", YouTube, author walkthrough.
6. BLOMEGA. Coreset selection under a wall-clock budget: when random still wins. (related internal article)
7. BLOMEGA. SASS: active learning that targets rare structures. (related internal article)
8. BLOMEGA. Active learning for object detection vs. the random baseline gap. (related internal article)