GCcore beats random pathology tile picks by 12 points at 20 tiles and by under 1 point at 50 to 200

What Yin and Dhont posted on 5 October 2026

Tuo Yin and Jennifer Dhont (Institut Jules Bordet, Hôpital Universitaire de Bruxelles, and Université Libre de Bruxelles) posted Label-Free Coreset Selection with Foundation Models for Efficient Annotation in Computational Pathology as arXiv:2610.05987v1 (cs.CV, 32 pages) on 5 October 2026. The question is the one every annotation lead with a pathologist's calendar faces: given N unlabelled slides or tiles and a budget of k annotations, which k go to the expert?

The method, GCcore, embeds every image with a frozen pathology foundation model and greedily adds the sample that most reduces the mean distance from every image to its nearest selected one (L1 distance by default). The paper calls the normalised objective global coverage, GC = 1 - mean nearest-selected distance / maximum pairwise distance. That objective is the classical facility-location function, so the greedy pick carries the Nemhauser 1978 guarantee of at least 1 - 1/e (about 63.2%) of the optimal GC at every budget. GCcore has no hyperparameters and is deterministic.

The evaluation covers 10 public datasets across WSI classification (PANDA, IMP-CRS, TCGA-BRCA), tile classification (WSSS4LUAD, SICAP, CRC-100k, DeepHP) and segmentation (BEETLE, panCK, CAMELYON16), at four low budgets each, against 14 label-free baselines. Each baseline is run at five settings of its main hyperparameter, or five seeds for Random, K-center and ZCore, and the paper reports the mean and SD. The headline: GCcore has the best mean rank, 2.2 of 15, first on six datasets and top three on nine. Code is at github.com/OncoAI-ULBHUB/GCcore.

How far ahead of random is GCcore in the paper's own tables?

Random selection is the baseline that annotation teams actually run, and in this paper it is also the second-best method of 15: mean rank 4.3 in Table 1, ahead of K-means (4.6) and K-center (5.7). We retyped Tables 1 and 2 from the PDF and recounted. The rank claims hold: by Table 1 GCcore places first on six datasets and in the top three on nine; by Table 2 it has the best score on seven of 10 and trails the leader by at most 3.9 points. What the headline does not show is the size of the margin over random.

Paper values from arXiv:2610.05987v1, Table 2 (lowest retention per dataset, values x100) and Section 4.2. Random SD is across seeds 17, 83, 146, 271 and 394 (App. F.1). GCcore's own variation across the five training seeds is averaged away and not reported. Gaps computed by BLOMEGA on 7 October 2026.

Three things stand out. First, random beats GCcore outright on TCGA-BRCA, 89.8 against 85.9. Second, on PANDA, SICAP and panCK the gap is smaller than one SD of random across seeds (0.43, 0.45 and 0.33 SD), so a single lucky random draw would have matched GCcore. Third, CRC-100k carries the headline: 12.0 of the 31.1 summed gap points. Without it the mean gap falls from 3.1 to 2.1 points.

The budget question is answerable for CRC-100k only. Per-budget scores beyond the smallest one appear in Figure 4 as plotted boxes, not in a table. But the runtime paragraph of Section 4.2 gives the four-budget mean balanced accuracy: 0.905 for GCcore, 0.868 for random, 0.875 for K-center. Subtracting the 20-tile gap (12.0 points) from four times the mean gap (14.8 points) leaves 2.8 points spread over the 50, 100 and 200 tile budgets: about 0.9 points each on average. The paper's own Table 1 points the same way, since GCcore's mean rank on CRC-100k over the four budgets is 3.0, behind K-means at 1.3, although it is first at the smallest budget.

What does greedy coverage buy at 20 tiles that random does not?

GCcore's gain for a candidate tile is the sum over all tiles of how much closer that candidate would bring them than their current nearest pick. A tile in a dense region of embedding space has many neighbours and a large gain; a tile next to an existing pick has little. The first picks therefore land in the centres of the big modes, one per mode, before any mode gets a second. K-center greedy, the Sener and Savarese 2017 rule, minimises the single worst distance instead, which sends its first picks to the edges of the cloud.

In a 9-class tissue set, one pick per dense mode is close to one pick per class. That is the whole low-budget story in our rerun: 67% of random 20-tile draws missed at least one class (64%, 66% and 72% across three pools), while GCcore covered all nine every time. The authors' own released 200-tile coreset for CRC-100k, made with H-optimus-1 embeddings and L2 distance, covers eight classes in its first nine picks and all nine by pick 10. A linear classifier cannot output a class it never saw, so missing one of nine classes caps balanced accuracy near 89% before any other error.

The guarantee is a statement about the coverage objective, not about accuracy. In our pools GCcore's GC at 20 tiles was 0.750 against 0.712 for random draws, a 5% relative difference that came with an 11.7-point accuracy gap. At 200 tiles the GC gap was similar (0.778 against 0.760) while the accuracy gap was 1.0 point. We also computed the data-dependent upper bound on the optimum (the selected set's value plus the k largest remaining marginal gains), and it certified the greedy GC at 98.3% or more of optimal at every budget, far tighter than 63.2%. So the greedy step is near-optimal for its objective; whether that objective tracks downstream accuracy is an empirical question, and above about 50 tiles the answer in both our data and the paper's CRC-100k averages is "barely".

Does the low-budget advantage reproduce on public tiles with a generic encoder?

Yes at 20 tiles; mostly not beyond. We could not use H-optimus-1 (gated, and too slow on CPU for 100,000 tiles), and the full NCT-CRC-HE-100K zip is 11.7 GB. Instead we took the MedMNIST+ PathMNIST 64x64 version of NCT-CRC-HE-100K (CC BY 4.0), sampled three pools of 10,000 tiles (seeds 0, 1 and 2), and tested on the first 2,394 tiles of CRC-VAL-HE-7K, which comes from different patients. Embeddings were 512-dimensional ImageNet ResNet18 features. Each budget used a standardised logistic-regression probe with balanced class weights. We compared GCcore with L1 (paper default) and L2 (repo default), K-center greedy over 5 start seeds, and random over 50 draws per pool. Total compute: about 6 minutes on one laptop CPU.

Balanced accuracy x100. Pools: 10,000 tiles drawn with seeds 0, 1, 2 from PathMNIST-64 train shard 0 (44,998 tiles). Test: 2,394 CRC-VAL-HE-7K tiles resized to 64x64. Random: 50 draws per pool and budget. K-center: 5 random starts, L2. Full-pool probe: 80.3, 80.5 and 83.3.

At 20 tiles GCcore beat the random 95th percentile in all three pools (63.5 against 59.4, 62.2 against 61.5, 61.8 against 60.1). At 50 tiles the result depended on the pool: in pool 0, 68% of random draws matched or beat GCcore; in pool 2, none did. At 100 and 200 tiles the per-pool gaps ran from -1.0 to +4.3 points, and between 10% and 66% of single random draws did as well. The paper's CRC-100k numbers (12.0 at 20 tiles, about 0.9 averaged above) and ours (11.7 at 20, 1.0 to 3.0 above) have the same shape although the encoder, image size and probe differ.

Two side results. K-center was the worst method at every budget, 19.8 points below random at 20 tiles, consistent with the paper's argument that it favours outliers. And L1 against L2 moved results by up to 4.3 points in one pool at 100 tiles (77.3 against 73.0), in both directions across pools, so "hyperparameter-free" still leaves the distance choice open; the paper's ablation (Table 10) puts L1 at mean rank 2.7 and L2 at 3.4.

Is the released code enough to run GCcore on your own cohort?

For a demo on CRC-100k, yes. For the paper's other nine datasets, no. We queried the GitHub API on 7 October 2026. The repository OncoAI-ULBHUB/GCcore was created on 30 September 2026 and last pushed on 6 October 2026. It has 13 commits, all web uploads or README edits, 0 stars, and no licence (the API returns license: null). Without a licence, the default is all rights reserved, which matters for a commercial annotation vendor.

The tree holds four scripts (extract_embeddings.py, select_coreset.py, train_test_probe.py, run_pipeline.py), a figure and one result file, results/coreset_global_coverage_l2_k200.xlsx, the 200-tile CRC-100k selection with its GC trajectory (0.350 after one tile, 0.494 at 20, 0.600 at 200). There are no embeddings, no baseline implementations and no code for slides or segmentation. The released selector uses L2 distance, while the paper's default and reported results use L1. The README's sample output at 20 tiles, 0.8678, is close to the paper's 86.6 but comes from the L2 code path.

The selector builds the full N x N float32 distance matrix in memory; its docstring says about 40 GB for 100,000 tiles. At the training-set sizes in the paper's Table 5 that is 399 GB for DeepHP, 463 GB for BEETLE and 533 GB for CAMELYON16, while the paper's runtime machine had 256 GB of RAM. The paper does not say how the larger sets were handled. A team with a 300,000-tile cohort will need to chunk the computation or subsample the pool themselves.

Licences for the inputs vary. NCT-CRC-HE-100K and CRC-VAL-HE-7K are CC BY 4.0 on Zenodo (record 1214456, 7 April 2018); one Hugging Face mirror (owkin/nct-crc-he) labels its copy CC BY-SA 3.0. H-optimus-1, the tile encoder behind seven of the ten experiments, is a gated model tagged CC BY-NC-ND 4.0, and Virchow2 carries the same tag. Prov-GigaPath is tagged Apache-2.0. The paper states that all datasets are public but lists no licences.

What should an annotation lead do with GCcore?

Use it for the first batch, where it pays. When the budget is tens of samples and the label space has several classes of uneven size, coverage-based ordering is the cheapest insurance against a missing class. In our rerun it removed a 67% chance of missing a class at 20 tiles. The ordering is also a stopping rule: label in GCcore order and the first k items are always the greedy k-subset, so a pathologist who stops early leaves a usable set.

Do not budget on the headline gain past the first batch. By 50 tiles in our data, and by 50 to 200 tiles in the paper's CRC-100k averages, the expected gain over random is a point or two and single random draws often match it. Plan expert hours from a learning curve, not from the 20-tile number. Our judgement: past a few hundred labels, uncertainty-driven active learning or plain stratified sampling on cheap metadata (site, scanner, slide) is where the next gains should be sought, and this paper does not test those.

Keep a random audit slice. GCcore's set is deliberately unrepresentative of class frequency: in the released 200-tile coreset, muscle has 37 tiles and mucus 10. That is fine for training, but prevalence estimates, calibration checks and error rates should come from a separate uniform sample. Random was also the second-best of the paper's 15 methods; a small random batch is a strong control, not a strawman.

Pick the encoder for its licence as much as its rank. The selection quality ships with the encoder. If the downstream model is commercial, a CC BY-NC-ND encoder is a problem even for selection-only use, depending on counsel's reading. The paper's Figure 6 reports GCcore first or second with Prov-GigaPath on BEETLE, which is Apache-2.0 tagged.

Reimplement rather than wait for a licence. Greedy facility location is about 20 lines (our version is in the next section) and well known since Nemhauser, Wolsey and Fisher (1978). Run it in chunks for large pools.

Check it yourself

Repository and licence status (no auth needed):

curl -s https://api.github.com/repos/OncoAI-ULBHUB/GCcore | python3 -c "import json,sys;d=json.load(sys.stdin);print(d['created_at'],d['pushed_at'],d['license'])"
# 2026-09-30T11:09:07Z 2026-10-06T06:42:37Z None
curl -s "https://api.github.com/repos/OncoAI-ULBHUB/GCcore/commits?per_page=100" | python3 -c "import json,sys;print(len(json.load(sys.stdin)))"
# 13
curl -s https://huggingface.co/api/models/bioptimus/H-optimus-1 | python3 -c "import json,sys;d=json.load(sys.stdin);print(d['gated'],[t for t in d['tags'] if 'license' in t])"
# manual ['license:cc-by-nc-nd-4.0']

Implied CRC-100k gap above 20 tiles, from Section 4.2 and Table 2: (4*(0.905-0.868) - (0.866-0.746)) / 3 = 0.0093, so 0.9 points.

Class coverage of the released coreset (file names start with the class code):

curl -sLO https://raw.githubusercontent.com/OncoAI-ULBHUB/GCcore/main/results/coreset_global_coverage_l2_k200.xlsx
python3 -c "import pandas as pd;c=pd.read_excel('coreset_global_coverage_l2_k200.xlsx').image_name.str.split('-').str[0];print([c[:k].nunique() for k in (9,10,20,200)])"
# [8, 9, 9, 9]

The rerun. Data: 64/train-00000-of-00002.parquet from Hugging Face jafermarq/pathmnist (396 MB, mirror of MedMNIST+ PathMNIST-64, Zenodo 10519652) and data/crc_val_he_7k-00000-of-00003-a44b36e006c0b9b1.parquet from owkin/nct-crc-he (318 MB). Fields used: image, label. Embeddings: torchvision resnet18(weights=IMAGENET1K_V1), fc removed, tiles bilinear-upsampled 64 to 112 pixels, ImageNet normalisation. Pools: np.random.default_rng(seed).choice(44998, 10000, replace=False) for seeds 0, 1, 2. The selection and scoring core:

D = torch.cdist(X, X, p=1).numpy()          # X: 10000 x 512 pool embeddings
H = D.max() - D; cov = np.zeros(N); order = []
for _ in range(200):                          # GCcore = greedy facility location
    g = np.maximum(H - cov[None, :], 0).sum(1); g[order] = -1
    j = int(g.argmax()); order.append(j); cov = np.maximum(cov, H[j])
# k-center: start at a random index, then repeatedly add argmax of min distance to picks
# random: np.random.default_rng(1000+s).choice(N, k, replace=False), s = 0..49
# probe per subset S: standardise on S, LogisticRegression(max_iter=3000, class_weight='balanced'),
#   sklearn balanced_accuracy_score on the 2,394 test tiles
# certified ratio: F(S) / (F(S) + sum of the k largest marginal gains given S)

Expected output, mean of three pools: GCcore L1 62.5, 68.8, 73.9, 77.8; random 50.8, 65.8, 72.6, 76.8 at 20, 50, 100, 200 tiles. Embedding took about 70 seconds per pool and selection plus all probes about 40 seconds on a laptop CPU. Exact values will shift slightly with library versions; the 20-tile gap should stay near 11 to 13 points.

What would prove this wrong

Our claim is that GCcore's advantage over random selection is concentrated at budgets small enough that random draws miss classes, and is within random's seed spread above that. It would be wrong if per-budget tables showed a sustained gap.

Prediction: if the authors or anyone else publish per-budget numbers for CRC-100k at 50, 100 and 200 tiles with the paper's setup by 31 March 2027 (a v2 table or released result files), GCcore's lead over the random mean will be under 2.0 points at each of those three budgets, and under one random-seed SD at two of the three. A lead of 3 points or more at 100 or 200 tiles would refute us. A second test: on a binary or 2-class-dominant task, where random draws of tens of samples rarely miss a class, GCcore's 20-sample lead over random should be under 3 points; TCGA-BRCA in Table 2, where random wins by 3.9, is consistent with that so far.

Sources

1. Yin, T., Dhont, J. Label-Free Coreset Selection with Foundation Models for Efficient Annotation in Computational Pathology. arXiv:2610.05987v1, 5 October 2026. Tables 1, 2, 5, 10; Sections 3, 4.2; Appendices D, E, F.1, G.1, G.2.
2. OncoAI-ULBHUB. GCcore repository, created 30 September 2026, 13 commits, no licence. Checked via the GitHub API on 7 October 2026.
3. Kather, J. N., Halama, N., Marx, A. 100,000 histological images of human colorectal cancer and healthy tissue. Zenodo record 1214456, 7 April 2018, CC BY 4.0.
4. Yang, J. et al. MedMNIST+ (PathMNIST 64x64). Zenodo record 10519652, 16 January 2024, CC BY 4.0; Hugging Face mirror jafermarq/pathmnist.
5. Owkin. owkin/nct-crc-he (CRC-VAL-HE-7K shards), Hugging Face, card licence CC BY-SA 3.0. Accessed 7 October 2026.
6. Bioptimus. H-optimus-1 model card, gated, CC BY-NC-ND 4.0 tag. Paige. Virchow2, CC BY-NC-ND 4.0 tag. Prov-GigaPath, Apache-2.0 tag. Accessed 7 October 2026.
7. Sener, O., Savarese, S. Active Learning for Convolutional Neural Networks: A Core-Set Approach. arXiv:1708.00489, 2017.
8. Nemhauser, G. L., Wolsey, L. A., Fisher, M. L. An analysis of approximations for maximizing submodular set functions, I. Mathematical Programming 14(1), 265 to 294, 1978.

FAQ

How much better than random selection is GCcore for pathology annotation?

At the smallest budget per dataset, arXiv:2610.05987 Table 2 puts GCcore above the random-selection mean on 9 of 10 datasets, by 3.1 points on average and a median of 2.85; random wins on TCGA-BRCA by 3.9 points. On CRC-100k the gain is 12.0 points at 20 tiles, but the paper's four-budget averages (0.905 against 0.868) imply only 0.9 points on average at 50, 100 and 200 tiles. BLOMEGA's rerun on public NCT-CRC-HE tiles gave +11.7 points at 20 tiles, +3.0 at 50, +1.2 at 100 and +1.0 at 200.

Why does GCcore help most at very small annotation budgets?

In BLOMEGA's rerun, 67% of random 20-tile draws from a 9-class colorectal pool missed at least one tissue class, and a classifier cannot predict a class it never saw. GCcore covered all 9 classes at 20 tiles in all three pools. At 50 tiles only 3% of random draws missed a class, and the accuracy gap shrank to a few points with wide overlap. The released H-optimus-1 coreset in the GCcore repository covers all 9 classes by its 10th pick.

Can GCcore be used commercially?

Not from the repository as released. On 7 October 2026 the GitHub API reported no licence for OncoAI-ULBHUB/GCcore, which by default reserves all rights. The default encoder, H-optimus-1, is gated and tagged CC BY-NC-ND 4.0 on Hugging Face, as is Virchow2. Prov-GigaPath is tagged Apache-2.0, and the paper reports GCcore ranked first or second with it on BEETLE. The algorithm itself is greedy facility location, which is short to reimplement.