When labels are scarce, a common recipe is to have a large language model (LLM) guess labels for an unlabeled corpus, train a smaller classifier on those guesses, use the classifier to relabel the corpus, and repeat. The recipe works, but each round retrains a model from scratch, and no round can start until the previous one finishes. Refinement therefore costs roughly R full training runs and R sequential waits. We propose to collapse those rounds into a single training run. Each unlabeled example keeps a soft label, a probability vector over classes. A multiplicative update rescales each class probability by an exponential of its gradient, so the vector stays a valid distribution without any projection step. These soft labels are updated continuously while the classifier trains.
The obvious version of this idea fails for a known reason. A model that relabels its own training data drifts toward its own mistakes. Two things keep our updates honest, and both are cheap. First, each half of the data is relabeled only by a model trained on the other half. Second, a prior-matching term is anchored by the 50 to 100 gold labels that this regime already uses to estimate class proportions. We claim this matches the accuracy of decoupled multi-round refinement at the cost of about one run. We also claim that a per-example stopping rule, which freezes labels once they stop changing, saves additional compute without hurting accuracy.
Why this, and what is already known
The motivating evidence comes from two recent label-refinement pipelines. Self Iterative Label Refinement via Robust Unlabeled Learning treats noisy LLM labels as two unlabeled mixtures with unknown class proportions and trains a separate classifier with a robust risk estimator. It relabels and retrains over discrete rounds. On Green Patent classification it reaches over 80% accuracy, while GPT-4o refining its own labels degrades from about 68% to about 61%. Iterative Label Refinement Matters More than Preference Optimization under Weak Supervision reaches a similar conclusion for LLM fine-tuning: cleaning the dataset across rounds beats preference optimization. That paper also retrains from scratch each round and names this cost as its main drawback. Both papers show that refinement helps under label scarcity. Neither attacks the round structure, which is where the cost and the wall-clock delay come from.
The refinement-cost literature tells us how many rounds are worth paying for. Deliberation Networks and EffiLearner find that gains saturate after two or three passes. Extrapolative Controlled Sequence Generation via Iterative Refinement spells out the sequential barrier: pass t+1 cannot start before pass t is fully materialized. We read these results as a budget. If most of the benefit arrives within a few rounds, a method that delivers a few rounds' worth of correction inside one run captures nearly all the value.
The multiplicative-update literature supplies the mechanism and also constrains it. Exponentiated Gradient Algorithms for Large-margin Structured Classification uses these updates on dual variables and observes a slow start from uniform initialization. Towards Decoding as Continuous Optimisation in Neural Machine Translation finds that exponentiated-gradient decoding fails from uniform or random starts and needs a discrete warm start. Our setting provides a warm start for free in the LLM's label. Constrained Structure Learning for Scene Graph Generation shows that entropic mirror descent on categorical distributions converges in about 10 iterations, which suggests few label updates per example will suffice. Incomplete Label Distribution Learning notes that repeated projections are a recurring cost, and the multiplicative form avoids them.
The closest existing method is Exponentiated Gradient Reweighting (EGR). EGR places a weight per training example on a simplex and downweights high-loss examples multiplicatively, raising ResNet-18 from 65.36% to 67.44% on ImageNet with 40% label noise. EGR decides how much to trust an example; it never changes the example's label. It also updates weights from the model's own loss, which is exactly the self-referential loop that Asano et al. argue leads to collapse. We move the simplex from example weights to per-example label distributions, and we cut the self-reference by cross-fitting.
Core Claim
Let $q_i \in \Delta^{K-1}$ be the soft label of unlabeled example $i$ over $K$ classes. It is initialized at the LLM's label smoothed by a small amount. Let $f^{(-s)}$ be the classifier trained on the split that does not contain $i$. Every few classifier steps, we update
$$q_i \leftarrow (1-\alpha)\,\frac{q_i \odot \exp(-\eta\, g_i)}{\langle q_i, \exp(-\eta\, g_i)\rangle} + \alpha\, q_i^{0}, \qquad g_i = -\log f^{(-s)}(x_i) + \lambda\, \nabla_{q_i}\big\lVert \bar q - \hat\pi \big\rVert^2 .$$
In this update, $\odot$ is elementwise product, $\eta$ is the step size, and $q_i^0$ is the initial LLM-derived label. The leakage weight $\alpha$ prevents a class from being trapped at zero probability, the failure mode EGR handles with entropy regularization. The term $\bar q$ is the mean soft label over the pool, $\hat\pi$ is the class proportion estimated from the gold labels, and $\lambda$ weights the prior-matching penalty. Each classifier trains on its own split with soft cross-entropy against the current $q$.
An example stops being updated once its total-variation change stays below a threshold for a fixed window. This is the dynamic-stopping mechanism that static refinement schedules lack. The claim is that this single run reaches the accuracy of Asano et al.'s multi-round pipeline at a fraction of the GPU-hours and wall-clock time. We also predict that removing either cross-fitting or the prior term reproduces the degradation seen with self-refinement.
Research Program
We will build the method on the open-source classifier backbones and LLM pseudo-labels used for the Asano et al. task suite. That suite covers Green Patent, Corona Sentiment, Fake News, Saroco, Safety, and the 50,000-sample COVID-19 binding task, with the same 50 to 100 gold labels per task for estimating class proportions.
The analysis has three parts. First, we will characterize how label accuracy on the unlabeled pool evolves over the run, compared against the accuracy after each discrete round of the multi-round pipeline. Second, we will map the failure region by corrupting the LLM labels to set initial accuracy anywhere from near chance to 85%. Asano et al. prove that refinement cannot work near chance; we want to know whether one-run refinement collapses earlier, later, or at the same point. Third, we will measure how much the LLM warm start matters compared with a uniform start. The prediction from Bartlett et al. and Hoang et al. is that a uniform start produces the slow-start lag.
As a second domain, we will run the method on noisy partial-label CIFAR-10. There each example comes with a candidate set of possible labels that may omit the true one, so $q_i^0$ is spread over the candidate set and leakage lets mass reach labels outside it. This tests whether continuous label refinement can replace IRNet's discrete rule of adding labels to the candidate set.
Baselines
The naive reference points are the LLM's zero-shot labels and a single classifier trained once on those labels with no refinement. Every method must beat these to justify its cost. We will also run the LLM self-refinement loop. Asano et al. report this loop degrading on Green Patent, and it serves as the negative reference.
The strongest competitor is the decoupled robust-unlabeled-learning pipeline of Self Iterative Label Refinement via Robust Unlabeled Learning. It was designed for exactly this regime and reports over 80% accuracy on Green Patent. For the other tasks in its suite, the file gives no numbers; there is no reported result found on Lacuna for Corona Sentiment, Fake News, Saroco, Safety, or the binding task. We will rerun the pipeline ourselves with the same backbone, pseudo-labels, gold labels, and hyperparameter search budget, and sweep its number of rounds. Beating it means equal or higher test accuracy at no more than half its GPU-hours and wall-clock time. Matching its accuracy at roughly one run's cost is the main success criterion. Merely matching its cost is not.
Exponentiated Gradient Reweighting is the strongest multiplicative-update competitor. It will run on the same backbone with its recommended entropy regularization and step-size warm-up, under the same tuning budget. Beating it isolates the value of correcting labels rather than discounting examples.
On partial-label CIFAR-10, IRNet reports 86.19% accuracy at ambiguity 0.5 and noise 0.3. We will reproduce that setting and treat parity or better as success.
Three ablations isolate the proposal's ingredients. The first replaces the multiplicative update with additive gradient steps followed by Euclidean projection onto the simplex. The second removes cross-fitting, so each model relabels its own data. The third removes the prior-matching term. A fourth variant runs with stopping disabled to price the stopping rule.
Why not just…?
Why not just warm-start each round of the multi-round pipeline instead of retraining from scratch? This is the most serious threat, because it might recover most of the savings with no new machinery. We will run it as a baseline with an identical budget. If warm-started rounds match our accuracy and cost, the honest conclusion is that the savings come from warm starting, not from the simplex updates. In that case the contribution narrows to the per-example stopping rule and the failure-region map. We expect a gap only when warm-started rounds inherit the previous model's overconfidence. That is testable by comparing the two methods' calibration on the pool.
Why not just reweight examples with EGR? Downweighting a mislabeled example throws away its feature information, whereas relabeling keeps it. EGR's own update also follows the model's loss, the self-referential signal Asano et al. show can spiral. The direct comparison and the no-cross-fitting ablation will show whether relabeling or decoupling carries the gain.
Why not just update softmax logits with ordinary gradient descent? Gradient descent on logits is close to a multiplicative update, so this alternative may perform about the same. That is why the additive ablation is included. If it ties, we will report that the geometry matters less than cross-fitting and the prior anchor. Hoang et al.'s finding that exponentiated gradient beat SGD on simplex relaxations makes us expect a modest edge, mainly near zero-probability classes.
Why not just spend the gold labels better, for example with vote-k selection? Selective Annotation shows that choosing which 18 examples to annotate gives a 12.9% relative gain over random choice. This is complementary rather than competing, since better-chosen gold labels sharpen $\hat\pi$. We will run vote-k selection under each method to check that our advantage survives.
Proposed Experiments
The decisive check is a Pareto plot of test accuracy against GPU-hours and wall-clock time on Green Patent and the other Asano et al. tasks. It will include every baseline, with the multi-round pipeline shown at each round count. The proposal succeeds if one-run refinement sits on the frontier at or above the multi-round pipeline's best accuracy. It fails if it needs more than two runs' worth of compute to get there.
The second check is the corruption sweep. It must show that the no-cross-fitting ablation degrades the way GPT-4o self-refinement does, while the full method holds until initial accuracy approaches chance. Third, we will plot label accuracy on the pool against update count, for LLM-initialized and uniform starts, to test the warm-start prediction. We will also record how many examples the stopping rule freezes by each epoch and what compute that saves. Finally, the partial-label CIFAR-10 run against IRNet's 86.19% tells us whether the method holds up outside LLM pseudo-labeling.
References
- Self Iterative Label Refinement via Robust Unlabeled Learning
- Iterative Label Refinement Matters More than Preference Optimization under Weak Supervision
- Deliberation Networks: Sequence Generation Beyond One-Pass Decoding
- EffiLearner: Enhancing Efficiency of Generated Code via Self-Optimization
- Extrapolative Controlled Sequence Generation via Iterative Refinement
- Exponentiated Gradient Algorithms for Large-margin Structured Classification
- Towards Decoding as Continuous Optimisation in Neural Machine Translation
- Constrained Structure Learning for Scene Graph Generation
- Incomplete Label Distribution Learning
- Exponentiated Gradient Reweighting for Robust Training Under Label Noise and Beyond
- IRNet: Iterative Refinement Network for Noisy Partial Label Learning
- Selective Annotation Makes Language Models Better Few-Shot Learners