Many methods that adapt an image classifier to a new visual domain, such as moving from product photos to clip-art or from one camera trap to another, use a curriculum. Training starts on data close to what the model already knows and moves step by step toward the target. These curricula have two hidden costs. The first is the stepping stones themselves: recent systems build them by running a diffusion model offline, a generator that turns noise into images through dozens of denoising steps, and that synthesis can cost more compute than training the student. The second is the schedule: how fast to move toward the target is set by hand-picked epoch counts and thresholds, which must be re-tuned whenever the size of the domain gap changes. Every re-tuning is another full training run.
This note proposes removing both costs together. The stepping stones are built analytically by blending the feature statistics of source and target images inside the network, at essentially zero cost. The blend is moved toward the target by a feedback rule tied to the model's own current competence, not to the epoch counter. The claim that makes the work worth doing is about robustness to tuning, not peak accuracy. A curriculum whose pace is expressed in the model's own units should need far less re-tuning across domain gaps. Once the cost of tuning runs and synthesis is counted honestly, that robustness should win at a fixed total compute budget.
Core Claim
In few-shot multi-source transfer, a style-interpolation curriculum is closed-loop if it advances each source domain's blend weight toward the target only while the model keeps a fixed fraction of its clean-source accuracy on the blended samples. We predict that such a curriculum matches the best hand-tuned open-loop schedule at that schedule's own optimum. We also predict that it varies several times less across settings of its own hyperparameters and across targets with different shift sizes. At matched tuning-inclusive compute, it should beat both hand-scheduled interpolation and diffusion-generated curricula.
The interpolation operator is taken from Domain Generalization with MixStyle. MixStyle normalizes an early-layer feature map and then re-scales and shifts it using a blend of two images' per-channel means and standard deviations. That paper shows domain shift is largely stylistic and that the blend must stay in early residual blocks to avoid damaging class information. We keep that operator and that restriction. Because only style statistics are mixed, the source image's content and label stay valid. This avoids the label-mixing ambiguity that motivated MetaMixUp.
What is new is how the blend weight is chosen. MixStyle draws it at random from a fixed Beta distribution. Progressive Mix-Up for Few-Shot Supervised Multi-Source Domain Transfer (P-Mixup) moves it along a preset epoch-driven progression, monitored by a Wasserstein distance. P-Mixup is the closest existing work: it already shows that a structured progression beats random mixing, with 74.99% mAP on Office-Home and 75.50% mAP on 10-class DomainNet. But its pacing is open-loop, it uses one trajectory for all sources, and its sensitivity to schedule settings across domain topologies is never examined. We replace that schedule rather than compete with its mixing design.
Research Program
For each source domain $d$ we keep a blend weight $\lambda_d \in [0,1]$. Here 0 means pure source style and 1 means the style statistics of the few labeled target images. At each step, source images from $d$ are restyled using a weight drawn from a narrow distribution centred on $\lambda_d$. The model is trained on these restyled images with their source labels, plus the few target labels. After each window of steps, the weight is updated:
$$\lambda_d \leftarrow \mathrm{clip}_{[0,1]}\big(\lambda_d + \eta\,(\hat r_d - r^\ast)\big),$$
In this update, $\hat r_d$ is the model's running accuracy on restyled samples from $d$ divided by its accuracy on unmodified samples from $d$. The set point $r^\ast$ is the fraction of clean competence we require the model to keep, and $\eta$ is a step size. When the model handles the current blend almost as well as clean data, the blend moves toward the target. When accuracy on the blend collapses, it retreats.
The rule draws its motivation from CurES. CurES showed, for language-model reinforcement learning, that the learning signal peaks at intermediate difficulty, and it paced prompts to stay near that point with no epoch schedule. We carry that "stay at the frontier" logic into a continuous interpolation variable. The ratio form of $\hat r_d$ is deliberate. It normalizes away the dataset's base accuracy, so one value of $r^\ast$ should mean the same thing on a 7-class and a 65-class problem.
Using a separate weight for each source lets an easy source, such as Product when the target is Real-World, reach the target quickly while a distant source such as Sketch lags. This addresses the single-trajectory limitation P-Mixup acknowledges. The rule still has two hyperparameters, $r^\ast$ and $\eta$. The measurable question is whether they are less sensitive than epoch-based schedule parameters, which the failure analyses in CLNode and Uncertainty-Aware Unsupervised Domain Adaptation in Object Detection show must be recalibrated per dataset pair.
A secondary question comes from a tension in the file. A Generalized Theory of Mixup for Structure-Preserving Synthetic Data proves that convex blending shrinks variance. It proposes an expanded weight distribution, EpBeta, that extrapolates slightly past the endpoints to keep covariance intact. Curriculum By Smoothing, by contrast, finds that suppressing high-frequency variance early in training helps. That paper supplies evidence that early variance suppression can be beneficial, and so constrains how aggressively we extrapolate early.
We therefore test one variant. It keeps the blend convex while the controller is advancing, and lets the weight extend past 1 with EpBeta-style support once a source's weight has saturated. This asks whether variance preservation matters late in a curriculum even though it may hurt early.
The overhead direction becomes the accounting rule for every comparison. Each method's cost is reported in GPU-hours, including offline synthesis, filtering, and every training run spent choosing its hyperparameters. Accuracy is then reported as a function of that total.
Baselines
The naive reference points are two. The first is fine-tuning on pooled source data plus the few labeled target examples, with no mixing. The second is MixStyle with its standard random Beta weights, drawn across source and target statistics with no curriculum. The second is the more dangerous: it costs nothing, has one hyperparameter, and Domain Generalization with MixStyle reports 83.7% average accuracy on PACS in the domain generalization setting. No reported result was found on Lacuna for MixStyle in the few-shot multi-source transfer setting used here, so we run it ourselves. Beating it means a gain on held-out targets larger than the seed-to-seed standard deviation over five seeds.
The strongest existing method is P-Mixup (Progressive Mix-Up for Few-Shot Supervised Multi-Source Domain Transfer). It reports 74.99% mAP on Office-Home and 75.50% mAP on DomainNet in its 10-class, one-shot setting. We reproduce it under its own protocol, including the meta-learning outer loop, and first confirm we land within about a point of those figures before comparing. The fair comparison swaps only P-Mixup's epoch-driven weight progression for our feedback rule, holding the pixel-plus-feature mixing, backbone, data splits and epochs fixed.
Both methods get the same tuning budget. This is a fixed number of full runs, used to pick schedule parameters on one validation target pair, after which the choice is frozen and evaluated on the other target pairs. Beating P-Mixup means matching its mAP at the setting tuned for each target and exceeding it once hyperparameters are transferred across targets.
We also include MetaMixUp, which learns the blend weight by bilevel optimization against a validation loss. It reports reducing ImageNet top-1 error from 55.06% to 47.35%. It represents the adaptive alternative without explicit curriculum structure, and its per-step meta-gradient cost is counted in the compute ledger.
For the synthesis-overhead comparison we use Diffusion Curriculum (DisCL) on iWildCam. DisCL reports a 2.7% out-of-distribution macro-accuracy gain from diffusion-generated stepping stones at fixed guidance levels, together with an adaptive selection rule. Here, beating it means reaching comparable macro-accuracy at a small fraction of its total GPU-hours, or higher accuracy at equal GPU-hours.
The key ablation feeds our training loop the exact sequence of blend weights recorded from a closed-loop run, but re-orders them randomly in time. The model sees the same distribution of blends without the feedback timing. If this matches the closed-loop run, the benefit comes from which blends are visited, not from pacing.
Why not just…?
Why not just use random MixStyle with no curriculum? P-Mixup's comparisons suggest structured progression beats random mixing by up to 8.6% in few-shot transfer. But those were whole-system comparisons, not a same-operator ablation. So this remains a real threat, especially on PACS where the style gap is what MixStyle was built for. Our first experiment settles it directly. If random MixStyle matches the closed-loop curriculum within noise on held-out targets, we will report that the curriculum adds nothing in this regime and narrow the claim to the largest-gap targets.
Why not just tune a linear schedule once and reuse it? If one well-chosen linear progression transferred across shift sizes, the controller would be pointless. The file's evidence points the other way. UgCL's gating threshold needs manual recalibration between Cityscapes-to-Foggy and VOC-to-Clipart, and CLNode's gains disappear under wrong pacing durations. Neither measured this for interpolation schedules, though. Our tune-once-transfer protocol measures it directly. A small drop for the transferred linear schedule would falsify the core claim.
Why not just generate the stepping stones with a diffusion model? Zero Shot Domain Adaptive Semantic Segmentation by Synthetic Data Generation and Progressive Adaptation shows that global diffusion editing moves layouts and distorts cars and riders. It also shows that the patch-wise fix multiplies synthesis time. DisCL must render and store images at discrete guidance levels. Generated images can contain content that no amount of style blending produces, such as new poses or backgrounds. So generation may win on accuracy for some targets. That is why we compare at matched total compute, not claim unconditional superiority.
Why not just learn the weight with meta-gradients? MetaMixUp adapts to the instantaneous validation gradient, pays a bilevel cost every step, and was never tested across domains. With only one to five target labels per class, its validation signal is extremely thin. We run it under the same tuning and compute ledger. If it matches our method's robustness, the finding becomes that any adaptive rule suffices, and the cheaper one should be preferred.
Proposed Experiments
The main study uses Office-Home and DomainNet in P-Mixup's few-shot multi-source protocol, holding out each domain in turn as the target. PACS uses the same protocol; no reported result was found on Lacuna for P-Mixup's PACS few-shot number, so we establish it. Targets are grouped by gap size, with a nearby target such as Office-Home Real-World next to far ones such as DomainNet Quickdraw and PACS Sketch.
For every method we sweep its pacing hyperparameters over a five-point grid. For P-Mixup this is the progression duration and step. For ours it is $r^\ast$ and $\eta$. From each sweep we report three numbers: peak accuracy, worst-case accuracy over the grid, and the spread between them.
The decisive check has three parts. Our spread should be several times smaller than P-Mixup's on large-gap targets, with peak accuracy within noise. The re-ordered-weights ablation should fall below the closed-loop run. The tune-once-transfer protocol should show a gap in our favor. If the spreads are similar, the central claim fails.
The iWildCam experiment treats camera locations as domains and compares against DisCL. It plots out-of-distribution macro-accuracy against total GPU-hours, including DisCL's diffusion synthesis and every tuning run. The convex-then-expanded variant is reported on all benchmarks as a secondary result. It tells us whether late-curriculum variance preservation, which EpBeta's theory predicts should matter, measurably helps final target accuracy once pacing is handled.
References
- Domain Generalization with MixStyle
- MetaMixUp: Learning Adaptive Interpolation Policy of MixUp with Meta-Learning
- Progressive Mix-Up for Few-Shot Supervised Multi-Source Domain Transfer
- CurES: From Gradient Analysis to Efficient Curriculum Learning for Reasoning LLMs
- CLNode: Curriculum Learning for Node Classification
- Uncertainty-Aware Unsupervised Domain Adaptation in Object Detection
- A Generalized Theory of Mixup for Structure-Preserving Synthetic Data
- Curriculum By Smoothing
- Diffusion Curriculum: Synthetic-to-Real Generative Curriculum Learning via Image-Guided Diffusion
- Zero Shot Domain Adaptive Semantic Segmentation by Synthetic Data Generation and Progressive Adaptation