A June 30, 2026 paper from the University of Copenhagen's Pioneer Centre for AI measured, instead of assumed, where an active learning run stops favoring one sampling strategy and starts favoring another. On CIFAR-10 the switch points land at 5,000 and 8,300 labeled images out of a 50,000-image pool. On CIFAR-100 with plain supervised features they land at 6,700 and 37,900, and adding SimCLR self-supervised embeddings to the same pool pulls those same two points down to 700 and 11,000.
The paper is "A Mechanism-Driven Theory of Phase Transitions in Active Learning," posted to arXiv on June 30, 2026 (arXiv:2607.00144) by Julia Machnio, Mads Nielsen and Mostafa Mehdipour Ghazi at the Pioneer Centre for AI, University of Copenhagen. The authors' own code repository labels it an ECCV 2026 preprint; this article does not claim a confirmed acceptance decision, only the arXiv posting date and the content of the paper itself. Code, with a build on the TypiClust, SCAN and Deep-AL codebases, is released under the MIT license at github.com/juliamachnio/PALM.
The same group published a precursor at ICCV 2025, "To Label or Not to Label: PALM" (arXiv:2507.15381, submitted July 21, 2025), which fit a four-parameter curve to active learning accuracy trajectories. The June 2026 paper goes further: instead of fitting one curve to the whole run, it tracks six measurable signals during labeling and uses segmented regression to find the exact label counts where the dominant signal changes, then checks which sampling strategy wins in each segment.
Four benchmarks carry the measurement: CIFAR-10 (50,000 training images, 10,000 test), CIFAR-100 (same split sizes), ISIC 2019 (25,331 clinical skin-lesion images), and ImageNet subsets of 50, 100 and 200 classes drawn from ImageNet-1K. Labeling strategies compared include TypiClust (representativeness), Coreset (geometric coverage), and Entropy, BADGE and UHerding (uncertainty and hybrid methods).
| Dataset | Pool size | Breakpoint 1 (labels) | Breakpoint 2 (labels) | Phase III winner | Source |
|---|---|---|---|---|---|
| CIFAR-10 | 50,000 train images | 5,000 | 8,300 | Entropy / BADGE / UHerding | arXiv:2607.00144, Table 1 |
| CIFAR-100, supervised features | 50,000 train images | 6,700 | 37,900 | Entropy / BADGE / UHerding | arXiv:2607.00144, Table 1 |
| CIFAR-100 + SimCLR embeddings | 50,000 train images | 700 | 11,000 | Entropy / BADGE / UHerding | arXiv:2607.00144, Table 1 |
| ISIC 2019 | 25,331 lesion images | 7,000 | 10,000 | Entropy / BADGE / UHerding | arXiv:2607.00144, Table 1 |
| ImageNet-100, MoCov3 embeddings | subset of ImageNet-1K | not reported | not reported | TypiClust clears 50% accuracy at a low budget | arXiv:2607.00144, Section 4 / Fig. 6 |
| ImageNet-100, BYOL embeddings | subset of ImageNet-1K | not reported | not reported | TypiClust barely clears random sampling | arXiv:2607.00144, Section 4 / Fig. 6 |
The breakpoints come from fitting a shared segmented regression (dynamic programming over candidate breakpoints, segment count chosen by BIC) to six proxies recorded every labeling round: label-space discrepancy, feature-space discrepancy and geometric coverage track how well the labeled set represents and covers the pool, while empirical risk reduction, model complexity and a confidence term track the model's own state. The fit quality reported for the three-segment model is R-squared above 0.93 on every benchmark, including 0.998 on CIFAR-10.
In the earliest segment (Phase I, below roughly 5,000 to 6,700 labels on the two CIFAR sets) the labeled subset barely represents the full pool yet, so label-space and feature-space discrepancy dominate the model's remaining error. TypiClust, which picks typical points near dense regions of the feature space, closes that gap fast and holds roughly a 2 percentage point accuracy edge in this regime.
Once the labeled set already looks like the pool, more of the same kind of sampling stops helping: TypiClust keeps picking near-centroid points that add little new coverage. Geometric coverage becomes the bottleneck in the middle segment (Phase II), and Coreset, which explicitly maximizes the minimum distance between labeled points, takes over.
Past the second breakpoint (Phase III), both representativeness and coverage are largely satisfied, and the remaining accuracy gains come from resolving the model's own uncertainty near its decision boundary. That is exactly the regime uncertainty-based and hybrid methods, Entropy, BADGE and UHerding, are built for, and they produce the largest empirical-risk reductions and the highest final accuracy in the paper's late-phase results.
The same three-phase structure appears on CIFAR-100 whether or not the pool has self-supervised features, but the label counts at which it happens are not fixed properties of the dataset. With plain supervised features, the first breakpoint sits at 6,700 labels and the second at 37,900. Add SimCLR embeddings (500 epochs of pretraining, a 512 or 2,048-dimensional embedding depending on the backbone) over the identical CIFAR-100 pool, and the first breakpoint moves to 700 labels, about 9.6 times earlier, and the second to 11,000, about 3.4 times earlier.
That is a meaningful operational fact for anyone budgeting a labeling campaign: a pretrained encoder does not just make representativeness sampling work better, it shrinks the window in which representativeness sampling is the right choice at all. Teams that keep running TypiClust past 700 labels on an SSL-pretrained pool, assuming it still has 6,000 more labels of runway because that number holds for raw features, are running the wrong strategy for most of that stretch.
The paper's ImageNet-100 result adds a sharper caveat: the choice of self-supervised method matters as much as whether one is used at all. With MoCov3 embeddings, TypiClust clears 50% accuracy at a low label budget. With BYOL embeddings on the same architecture and budget, TypiClust barely exceeds random sampling. "Self-supervised" is not one setting, it is a family, and the early-phase advantage reported for SimCLR and MoCov3 does not transfer automatically to every encoder in that family.
Below roughly 5,000 to 10,000 labels on a pool this size, and without strong pretrained features, defaulting straight to uncertainty sampling (entropy, BALD-style methods, BADGE) is working against the paper's own measurements: representativeness or diversity-first sampling held the advantage in that regime across every benchmark tested.
If the pool already has a self-supervised encoder behind it, the window where diversity-first sampling wins is much shorter than the raw-feature numbers suggest. On CIFAR-100 that window shrank from about 6,700 labels down to about 700. Teams reusing a fixed schedule tuned on raw features risk staying in the wrong phase for most of a labeling run once they add pretrained embeddings.
Which self-supervised encoder is in use is not a detail to skip. MoCov3 and BYOL embeddings produced very different outcomes for the same strategy (TypiClust) at the same ImageNet-100 budget, one clearing 50% accuracy, the other barely beating random. A "we use SSL features" line in a project's documentation is not enough to predict where its phase boundaries fall.
The honest limit of this study: every breakpoint in the table above was found after the fact, by fitting segmented regression to a labeling run that had already finished. The paper's own hard-switch experiment, which fires TypiClust, then Coreset, then uncertainty sampling at the measured CIFAR-10 thresholds of 5,000 and 8,300 labels, beats single-strategy baselines run end to end, but it still uses breakpoints computed with hindsight. The authors describe a proxy-monitoring system that could detect a phase change while labeling is still underway as future work, not something this paper validates. Treat the specific label counts as evidence that phases exist and roughly where they sit for these pools and architectures, not as a calibrated schedule to copy onto a different dataset without checking.
The paper and the breakpoint table are public, and the measurement code is released:
# Read the paper's segmented-regression breakpoints (Table 1)
# and the phase-to-strategy mapping (Section 4.2-4.4)
open https://arxiv.org/abs/2607.00144
open https://arxiv.org/pdf/2607.00144
# Clone the released toolkit (MIT license)
git clone https://github.com/juliamachnio/PALM
cd PALM
# Entry points named in the repository:
# deep-al/tools/train_al.py --record-mechanistic-proxies
# records the six proxies (ER, LD, FD, GC, model complexity, confidence)
# every labeling round and writes pooled_phase_records.csv
# analyze_phases.py
# fits the shared segmented regression (dynamic programming + BIC)
# and writes global_phase_analysis.json with the breakpoints
# export_schedule.py
# turns breakpoints into a hard-switch sampling schedule
# The hard-switch example cited in the repo uses fixed thresholds
# of 5,000 and 8,300 labels for CIFAR-10 and writes a per-episode
# hard_switch_diagnostics.json you can compare against Table 1.For the precursor curve-fitting model, see the ICCV 2025 paper and its own repository referenced in that paper's abstract page at openaccess.thecvf.com.
The retrospective curve fit is already public and reproducible from the released code and Table 1. The open question is whether the phase boundaries are useful in real time, not just after the fact. If, by October 31, 2027, no published method built on these six proxies (or an equivalent set) can detect a phase change using only data available up to that point in an active labeling run, without first fitting segmented regression to the finished trajectory, and show that an online switch beats a single static strategy run end to end by a margin comparable to the roughly 2 percentage point edge TypiClust holds in Phase I, this framework will remain a description of what happened rather than a scheduling tool teams can deploy on a new, unlabeled pool. A second, narrower test: if an independent group reruns the CIFAR-10 segmented regression with different random seeds or a different model architecture and gets breakpoints more than, say, 50% off from 5,000 and 8,300 labels, the claim that these are stable properties of the dataset and pool size, rather than artifacts of this paper's specific training setup, would also not hold up.