Self-Adaptive Curriculum Learning

• Self-adaptive curriculum learning is a dynamic approach that adjusts training criteria based on real-time learner performance signals.
• It integrates methods such as self-paced learning, bandit scheduling, and evaluator feedback to refine learning progression.
• The strategy enhances model performance by continuously recalibrating task difficulty and training allocation in non-stationary environments.

Self-adaptive curriculum learning is a form of curriculum learning in which the sequence of training criteria, data weights, tasks, or learning paths is updated from learner-dependent signals rather than fixed a priori. In the general curriculum formulation, a curriculum is a sequence $\mathcal{C}=\langle Q_1,\dots,Q_T\rangle$ with $Q_t(z)\propto W_t(z)P(z)$, and curriculum design can be decomposed into a Difficulty Measurer + Training Scheduler; predefined curricula hand-design both components, whereas automatic curricula learn one or both from data and model feedback (Wang et al., 2020). Contemporary work makes this model-relative view explicit: difficulty can shift during training, category utility can be non-stationary, and the curriculum must therefore be revised as the learner changes (Zhang et al., 13 May 2025, Chen et al., 20 May 2025).

1. Conceptual foundations and scope

Within the literature, self-adaptation does not denote a single algorithmic family. It includes self-paced sample weighting, bandit-based category scheduling, evaluator-mediated reallocation, start-state modification in reinforcement learning, and personalized pathway recomputation in educational systems. The unifying property is that curriculum state is coupled to learner state.

The survey literature draws a useful distinction between classical easy-to-hard curricula and broader generalized curriculum learning. Under the narrow formulation, curriculum learning gradually increases entropy and eventually reaches the full target distribution. Under the broader formulation, a curriculum is any sequence of training criteria over training steps, including dynamic reweighting, hard-example emphasis, or changing loss functions (Wang et al., 2020). This broader view is essential for self-adaptive systems, because many adaptive methods do not preserve a fixed monotone easy-to-hard order.

A recurrent clarification in recent work is that not every dynamic or progressive schedule is fully self-adaptive. PointSmile changes augmentation intensity $\lambda_k$ and hard-sample proportion $N_k^c=\lambda_k\cdot N$ according to a hand-designed schedule driven only by training step $k$; the paper explicitly states that it is better described as a progressive curriculum schedule rather than a fully feedback-driven self-adaptive curriculum (Li et al., 2023). CASSL is similarly data-driven in design but stationary in execution: variance-based global sensitivity analysis determines an order over control dimensions, after which uncertainty sampling acts only within the current stage (Murali et al., 2017). This distinction separates genuinely closed-loop curricula from static curricula whose order was merely estimated automatically once.

2. Adaptive signals, schedulers, and update rules

Self-adaptive curricula differ mainly in what they treat as evidence of readiness. In self-paced learning, the learner’s current loss acts as the easiness signal, and the canonical hard-threshold solution is $v_i^*=1$ if $l_i<\lambda$ and $v_i^*=0$ otherwise (Wang et al., 2020). ScreenerNet replaces analytic self-paced rules with an auxiliary neural network $\mathcal{S}$ that predicts continuous per-sample weights $w_{\mathbf{x}}=\mathcal{S}(\mathbf{x})\in(0,1)$, trained with

$Q_t(z)\propto W_t(z)P(z)$0

so that high-error samples receive larger weights and low-error samples smaller ones (Kim et al., 2018).

Other systems use different learner-state proxies. SEC treats curriculum selection for RL fine-tuning of LLMs as a non-stationary multi-armed bandit over predefined categories, uses absolute advantage as reward, samples with a Boltzmann policy $Q_t(z)\propto W_t(z)P(z)$1, and updates values by $Q_t(z)\propto W_t(z)P(z)$2 (Chen et al., 20 May 2025). In autonomous RL without task-specific knowledge, a success discriminator $Q_t(z)\propto W_t(z)P(z)$3 defines a medium-difficulty curriculum set $Q_t(z)\propto W_t(z)P(z)$4 (Lee et al., 2023). READ-C uses relative entropy between policies, with the discrete-action signal

$Q_t(z)\propto W_t(z)P(z)$5

and selects start states from regions of maximal policy uncertainty (Satici et al., 28 Feb 2025). CurEvo uses evaluator-verified dimension performance $Q_t(z)\propto W_t(z)P(z)$6 to update curriculum ratios by

$Q_t(z)\propto W_t(z)P(z)$7

thereby reallocating training mass toward weaker dimensions (Zeng et al., 29 Apr 2026). ADCL uses periodic re-estimation of problem difficulty $Q_t(z)\propto W_t(z)P(z)$8 for the next curriculum batch, rather than relying on a ranking frozen at initialization (Zhang et al., 13 May 2025).

Adaptive signal	Representative rule	Representative instantiation
Current loss	$Q_t(z)\propto W_t(z)P(z)$9 if $\lambda_k$0	Self-Paced Learning (Wang et al., 2020)
Current sample error	$\lambda_k$1	ScreenerNet (Kim et al., 2018)
Absolute advantage	$\lambda_k$2	SEC (Chen et al., 20 May 2025)
Success probability band	$\lambda_k$3	ARL curriculum without task-specific knowledge (Lee et al., 2023)
Relative entropy	$\lambda_k$4	READ-C (Satici et al., 28 Feb 2025)
Evaluator-verified dimension performance	ratio update for $\lambda_k$5	CurEvo (Zeng et al., 29 Apr 2026)
Re-estimated model accuracy	$\lambda_k$6	ADCL (Zhang et al., 13 May 2025)

This diversity of signals implies that self-adaptation is not tied to one ontology of difficulty. Some methods adapt on sample loss, some on task-level reward, some on policy uncertainty, some on evaluator confidence, and some on explicit knowledge-state or learner-profile updates.

3. Supervised, self-supervised, and multimodal formulations

In supervised deep learning, ScreenerNet is a canonical example of online adaptive weighting. It augments a main network $\lambda_k$7 with an attachable auxiliary network $\lambda_k$8, recomputes weights online, avoids hard sample rejection, and does not require storing historical priorities. The method improved convergence speed and usually final performance on MNIST, CIFAR-10, Pascal VOC 2012, and Cart-pole, and the paper reports better learning curves than Prioritized Experience Replay on all four evaluations (Kim et al., 2018). Its distinctive move is to replace manually defined easiness or hardness with a learned continuous weighting policy.

Self-supervised and multimodal work often occupies an intermediate position between static curricula and fully closed-loop adaptation. WeatherDepth uses three predefined weather stages—clear, relative adverse, and adverse—but introduces an adaptive curriculum scheduler that switches stages according to the epoch-to-epoch change in $\lambda_k$9, with a patience rule inspired by early stopping. This scheduler is combined with cross-curriculum depth consistency to reduce forgetting. On MonoViT, the full method improved WeatherKITTI absrel from 0.120 to 0.103, real rain from 0.175 to 0.158, and CADC snow from 0.297 to 0.279 (Wang et al., 2023). The difficulty definition itself remains manual, but stage duration is made learner-dependent.

HeuSCM pushes this further in unsupervised domain-adaptive semantic segmentation. Its curriculum unit is the semantic class rather than the sample. A GM-VAE and SKFEN encode a high-dimensional training state; a policy network outputs a class ranking; and a fairness-aware policy gradient reweights classes by $N_k^c=\lambda_k\cdot N$0 to avoid collapse onto already favorable classes. On Cityscapes $N_k^c=\lambda_k\cdot N$1 ACDC, the method reached 72.9 mIoU on the HRDA backbone, and the full scheduler improved a Refign baseline from 71.1 to 72.7 on ACDC val (Wang et al., 25 Mar 2026). Here, self-adaptation is expressed as recurrent re-ranking of semantic classes from latent training dynamics rather than from a fixed confidence heuristic.

CurEvo places curriculum control inside an autonomous self-evolution loop for video understanding. It decomposes supervision into perception, semantic recognition, and reasoning subsets; evaluates question quality by $N_k^c=\lambda_k\cdot N$2; evaluates answer reliability by $N_k^c=\lambda_k\cdot N$3; filters the retained training pool by $N_k^c=\lambda_k\cdot N$4; and weights optimization by $N_k^c=\lambda_k\cdot N$5 (Zeng et al., 29 Apr 2026). Across seven backbones, CurEvo consistently improved both benchmark accuracy and evaluator-based semantic score; for example, Video-LLaVA improved on ActivityNet-QA from 45.36 to 48.72, and Qwen2.5-VL improved from 67.84 to 69.91 (Zeng et al., 29 Apr 2026). In this setting, the curriculum is not a pre-sorted dataset but a control policy over generated supervision, evaluation thresholds, and dimension-wise allocation.

4. Reinforcement learning and autonomous agents

Reinforcement learning has supplied many of the clearest formalizations of self-adaptive curriculum learning. SPDL treats curriculum generation as probabilistic inference over a contextual family of tasks, learns a trainable task distribution $N_k^c=\lambda_k\cdot N$6, and optimizes

$N_k^c=\lambda_k\cdot N$7

The current policy’s estimated values and returns determine which contexts should be emphasized next, while the KL term gradually pulls the curriculum toward the target task distribution (Klink et al., 2020). This produces a genuinely closed-loop curriculum in contextual RL and was shown to improve learning performance across Point-Mass, Ant, and Ball-Catching with TRPO, PPO, and SAC (Klink et al., 2020).

SPALP modifies the Absolute Learning Progress family rather than replacing it. Rewards are normalized to $N_k^c=\lambda_k\cdot N$8, shifted to $N_k^c=\lambda_k\cdot N$9, transformed by

$k$0

and then used inside ALP as $k$1 (Niehues et al., 2023). The regularization strength is adapted through a reward bound $k$2, and the method can switch regularization on or off depending on recent mean reward. Empirically, SPALP achieved performance comparable to ALP-GMM in all three environments and reached it quicker in two of them (Niehues et al., 2023). Its contribution is a competence-aware regularization of learning progress rather than a new task-sampling architecture.

Autonomous RL without task-specific knowledge uses a self-supervised success discriminator $k$3 to select reset states with intermediate success probability, while a reset policy explores with Random Network Distillation (Lee et al., 2023). This yields an adaptive initial-state curriculum that expands as the forward policy improves. On maze2d-1way-v1, the method achieved SR 0.99 and MR 593.0, compared with MR 1887.6 for LNT and MR 1410.6 for R3L; on antmaze-4way-v2 it achieved SR 0.89 and MR 499.1 (Lee et al., 2023). The central idea is that diverse starts alone are insufficient; the starts must also be of the right current difficulty.

READ-C similarly constructs curricula through start-state modification, but does so from relative entropy. In the teacher-dependent version, the state with maximal $k$4 is selected as the next curriculum anchor; in the self-assessed version, a regressor predicts uncertainty from the learner’s past and current policies, entropy terms, Q-values, and visit counts (Satici et al., 28 Feb 2025). The paper provides a two-time-scale convergence argument for actor-critic updates and reports that READ-C outperforms randomly generated curriculum, direct target-task training, and Max Policy Change, while the simpler-than-target source environment works best for READ-C-SA (Satici et al., 28 Feb 2025).

Robotic control adds a distinct formulation in which the curriculum is over action dimensions rather than examples or tasks. CASSL computes Sobol-style sensitivity indices over control dimensions, derives an order $k$5, and then changes exploration rates per dimension during training (Murali et al., 2017). On novel-object grasping Set B, final CASSL reached 62.0% compared with 54.0% for staged learning and 48.0% for random exploration, but the paper explicitly describes the method as an offline, data-driven adaptive curriculum rather than a fully online self-adaptive curriculum (Murali et al., 2017).

5. LLMs and reasoning curricula

Recent LLM work has made self-adaptive curriculum learning especially explicit. SEC formulates curriculum selection during RL fine-tuning as a non-stationary multi-armed bandit over problem categories $k$6, uses average absolute advantage as reward,

$k$7

samples categories with a softmax over $k$8, and updates with TD(0) (Chen et al., 20 May 2025). Under GRPO with binary rewards, $k$9, so the curriculum implicitly favors categories with success rate near $v_i^*=1$0 (Chen et al., 20 May 2025). On Qwen2.5-3B, SEC improved Countdown OOD from 0.479 to 0.542, Zebra OOD from 0.285 to 0.345, ARC-1D OOD from 0.313 to 0.381, and AIME24 from 0.075 to 0.100 (Chen et al., 20 May 2025). The method also improved multi-skill balance and transferred to PPO and RLOO.

ADCL addresses the same setting from a different angle. Its starting point is Difficulty Shift, the claim that “a model’s perception of problem difficulty changes dynamically during training.” ADCL therefore computes an initial difficulty estimate $v_i^*=1$1, sorts the dataset, partitions it into $v_i^*=1$2 batches, trains on batch $v_i^*=1$3, and before the next stage re-estimates $v_i^*=1$4 only for $v_i^*=1$5 with the updated model (Zhang et al., 13 May 2025). On the main benchmark table, ADCL improved over plain RL from 72.40 to 76.20 on MATH500, from 26.67 to 33.33 on AIME24, from 16.67 to 30.00 on AIME25, and from 45.00 to 55.00 on AMC23 (Zhang et al., 13 May 2025). The paper also quantified curriculum drift through Normalized Inversion Rate, reporting 0.331, 0.363, and 0.369 after the first, second, and third re-estimations (Zhang et al., 13 May 2025).

A more static but still model-relative formulation appears in prompt-based NLU fine-tuning. Here the pretrained model itself defines difficulty through class-probability margins, using $v_i^*=1$6 for binary tasks or $v_i^*=1$7 for multiclass tasks (Feng et al., 13 Jul 2025). The paper studies six strategies—E2D, D2E, SME, SMD, PME, and PMD—and finds that PMD often performs best, especially on harder or few-shot settings. On RoBERTa, PMD achieved 87.47 accuracy and 87.49 F1 on XNLI, above random at 87.11 accuracy, while in 64-shot SST-2, SMD reached 90.86 versus random at 89.64 (Feng et al., 13 Jul 2025). This method is self-adaptive in the sense that difficulty is model-dependent, but the scores are computed before fine-tuning and not updated online.

EvoCurr transfers adaptive curriculum to inference-time decision-making with two LLM roles: a curriculum-generation LLM and a solver LLM that emits executable Python decision-tree code (Cheng et al., 13 Aug 2025). The curriculum designer observes performance $v_i^*=1$8, compares win rate to a threshold, and asks the curriculum LLM either to "increase" or "adjust" the next task. In experiments, curriculum stages were considered successful at 67% win rate, and only 1 of 5 curriculum paths solved the final StarCraft II task, yielding a final success rate of 20% (Cheng et al., 13 Aug 2025). The strongest evidence for self-adaptation in this setting is not asymptotic performance but the qualitative ability to fall back after failure, simplify the scenario, and then climb again toward the target task.

6. Personalized education and human learning systems

In educational technology, self-adaptive curriculum learning refers to dynamic sequencing for human learners rather than example ordering for model optimization. SEAL proposes a service-oriented personalized education architecture in which the syllabus is represented as a knowledge graph of topics, sub-topics, questions, and difficulty; a “student knowledge profile” is derived from that graph and past performance; and adaptive assessment, learning analytics, and recommender services select the next questions or learning content (Liu et al., 2020). The system is explicitly framed as “self-evolving” because student profiles and recommendations are updated as more interactions arrive. However, the paper provides no formal graph model, no knowledge-tracing equations, no explicit ranking formula, and no empirical evaluation; it is best read as an architectural scaffold for future adaptive curriculum systems (Liu et al., 2020).

ALS describes a higher-level closed-loop adaptive learning system powered by LLM analytics. The learner profile is updated by

$v_i^*=1$9

the revised curriculum is generated by

$l_i<\lambda$0

and learning-path optimization is formulated through

$l_i<\lambda$1

(Li et al., 25 Jul 2025). The paper reports LES/KRR gains and ablations such as “No Real-Time Adjustment,” but it also leaves most core functions $l_i<\lambda$2 unspecified, uses heterogeneous datasets and baselines, and provides no fairness, privacy, or governance mechanism (Li et al., 25 Jul 2025). In this branch of the literature, the curriculum concept is close to learner modeling and recommendation rather than to reproducible curriculum optimization.

7. Misconceptions, evidence, and unresolved questions

A persistent misconception is to equate any progressive schedule with self-adaptive curriculum learning. Several papers explicitly reject that equivalence. PointSmile is “better described as a manually scheduled progressive curriculum for self-supervised point cloud learning” rather than a strongly self-adaptive system (Li et al., 2023). The PLM-margin NLU method computes difficulty scores before fine-tuning and does not update them online (Feng et al., 13 Jul 2025). CASSL constructs a curriculum order adaptively from data, but then executes a stationary ordering (Murali et al., 2017). WeatherDepth adapts stage timing, but the difficulty itself is still predefined by weather severity and type (Wang et al., 2023). These distinctions matter because the term “adaptive” is often used loosely for any time-varying schedule.

A second unresolved issue concerns what signal should drive adaptation. SEC requires predefined categories and leaves automatic category discovery open, suggesting UCB or Thompson sampling as possible replacements for Boltzmann exploration (Chen et al., 20 May 2025). ScreenerNet may overweight mislabeled or corrupted samples because its objective treats large-error examples as important (Kim et al., 2018). SPALP is sensitive to the reward-bound hyperparameter $l_i<\lambda$3 and exhibits an on/off regularization cycle that the authors themselves identify as crude (Niehues et al., 2023). READ-C-SA removes the need for a target-task teacher but still depends on a simpler source environment and a regressor, so its self-assessment is not fully self-supervised in an absolute sense (Satici et al., 28 Feb 2025). CurEvo’s feedback loop depends strongly on evaluator quality; when the evaluator is weaker than the base model, gains shrink or reverse (Zeng et al., 29 Apr 2026).

Educational formulations expose a different set of open problems. SEAL leaves mastery estimation, prerequisite incorporation, pacing, and engagement modeling unspecified, and reports no classroom deployment or baseline comparison (Liu et al., 2020). ALS presents dynamic equations and favorable ablations, but its datasets are not authentic educational personalization benchmarks and it omits fairness, privacy, and institutional governance mechanisms (Li et al., 25 Jul 2025). More generally, the survey literature identifies difficulty estimation, scheduler design, computational overhead, theoretical grounding, and benchmarking as persistent challenges for automatic curriculum learning (Wang et al., 2020).

Across the field, the strongest contributions are those in which the adaptive signal, the update rule, and the training-time intervention are all explicit: current losses in self-paced learning, per-sample weights in ScreenerNet, category values in SEC, context distributions in SPDL, start-state uncertainty in READ-C, and evaluator-verified dimension performance in CurEvo. The weakest contributions are usually those that provide only an architectural vision, a fixed progressive schedule, or a heuristic notion of “easy” and “hard” without a closed feedback loop. This suggests that the central technical question is no longer whether curricula should be adaptive, but how learner-state estimation, curriculum intervention, and evaluation can be coupled without excessive cost, instability, or domain-specific handcrafting.