Curriculum Learning SLM Fine-Tuning Tutorial [2026]

Curriculum learning is one of the simplest ways to make a small language model look smarter in a narrow domain. Instead of mixing every example together, you stage training from easy to hard so the model first locks onto vocabulary, formats, and baseline reasoning before it sees exceptions. In this tutorial, we will fine-tune Qwen/Qwen2.5-1.5B-Instruct with QLoRA, a three-phase curriculum, and a lightweight verification loop built for technical knowledge tasks.

Prerequisites

pip install -U "transformers>=4.37.0" datasets peft trl accelerate bitsandbytes

Build the Curriculum Dataset

1. Define what “easy” and “hard” mean

The original Curriculum Learning idea is simple: order examples by difficulty so optimization starts on smoother ground. For domain-specific technical expertise, difficulty should be operational, not subjective.

• Easy: single-fact answers, stable terminology, short context, one correct procedure.
• Medium: short multi-step tasks, configuration tradeoffs, or one exception path.
• Hard: ambiguous incidents, long context windows, conflicting evidence, or edge-case remediation.

2. Store the score in your dataset

Keep the schema minimal. You want data that can be filtered by phase and evaluated later on a held-out hard split.

{"prompt":"What does BGP graceful restart do?","response":"It lets a router preserve forwarding state during a control-plane restart so peers can recover sessions with less traffic disruption.","difficulty":0,"split":"train","checks":["forwarding state","restart"]}
{"prompt":"A node fails after a kernel upgrade. Give a rollback checklist.","response":"1. Drain the node. 2. Reboot into the previous kernel. 3. Verify container runtime and CNI health. 4. Rejoin and watch workloads.","difficulty":1,"split":"train","checks":["drain","previous kernel","CNI"]}
{"prompt":"Intermittent packet loss appears only after failover. Diagnose likely causes and order the checks.","response":"Start with route convergence, then ARP or neighbor state, health probe timing, MTU mismatches, and asymmetric return paths.","difficulty":2,"split":"eval-hard","checks":["route convergence","MTU","asymmetric"]}

3. Score difficulty with rules first

Do not wait for a perfect automatic scorer. A rules-based first pass is enough for most internal knowledge bases.

def difficulty_score(row):
    score = 0
    score += min(len(row["prompt"].split()) // 40, 2)
    score += 1 if any(token in row["prompt"].lower() for token in ["why", "diagnose", "tradeoff"]) else 0
    score += 1 if len(row.get("checks", [])) >= 3 else 0
    score += 1 if any(token in row["response"].lower() for token in ["if", "unless", "except"]) else 0
    return min(score, 2)

This is also the point where formatting matters. If you are cleaning prompt templates or examples by hand, a utility like TechBytes' Code Formatter is useful for keeping training snippets consistent.

Fine-Tune in Phases

Step 1. Load the model with QLoRA

The Hugging Face quantization docs explicitly recommend NF4 for training 4-bit base models. We will use that configuration and attach LoRA adapters.

import torch
from datasets import load_dataset
from peft import LoraConfig
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from trl import SFTConfig, SFTTrainer

MODEL_ID = "Qwen/Qwen2.5-1.5B-Instruct"
SYSTEM_PROMPT = "You are a senior platform engineer. Give precise, production-safe answers."

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)

quant_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=quant_config,
    torch_dtype="auto",
    device_map="auto",
)

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    task_type="CAUSAL_LM",
)

Step 2. Format examples as chat

dataset = load_dataset("json", data_files="data/domain_train.jsonl", split="train")
train = dataset.filter(lambda x: x["split"] == "train")

def format_example(row):
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": row["prompt"]},
        {"role": "assistant", "content": row["response"]},
    ]
    return tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=False,
    )

Step 3. Train easy, then medium, then hard

The key move is cumulative exposure. The model sees difficulty=0 first, then 0-1, then the full set.

phases = [
    ("easy", train.filter(lambda x: x["difficulty"] == 0)),
    ("medium", train.filter(lambda x: x["difficulty"] <= 1)),
    ("hard", train),
]

for i, (phase_name, phase_ds) in enumerate(phases):
    trainer = SFTTrainer(
        model=model,
        args=SFTConfig(
            output_dir=f"runs/{phase_name}",
            num_train_epochs=1,
            per_device_train_batch_size=4,
            gradient_accumulation_steps=4,
            learning_rate=2e-4,
            logging_steps=10,
            bf16=True,
            max_length=2048,
        ),
        train_dataset=phase_ds,
        processing_class=tokenizer,
        formatting_func=format_example,
        peft_config=lora_config if i == 0 else None,
    )
    trainer.train()
    model = trainer.model

model.save_pretrained("artifacts/domain-curriculum-adapter")
tokenizer.save_pretrained("artifacts/domain-curriculum-adapter")

Why not shuffle everything once and call it done? Because small models often overfit brittle phrasing before they fully absorb the domain frame. A curriculum helps the model learn naming, syntax, and preferred answer shape before you expose it to ambiguous incident-response prompts.

Verify Results

Step 4. Evaluate hard examples explicitly

Average loss is not enough. Your real question is whether the tuned model performs better on the hardest domain tasks than the untuned baseline.

from transformers import pipeline

pipe = pipeline(
    "text-generation",
    model="artifacts/domain-curriculum-adapter",
    tokenizer="artifacts/domain-curriculum-adapter",
)

eval_hard = dataset.filter(lambda x: x["split"] == "eval-hard")

passed = 0
for row in eval_hard:
    out = pipe(row["prompt"], max_new_tokens=180)[0]["generated_text"].lower()
    ok = all(term.lower() in out for term in row["checks"])
    passed += int(ok)

print({
    "hard_examples": len(eval_hard),
    "passed": passed,
    "pass_rate": passed / max(len(eval_hard), 1),
})

Expected output

• Your saved adapter directory should contain adapter_config.json and adapter_model.safetensors, which matches the PEFT adapter workflow.
• Training logs should show a generally downward loss trend across phases, even if the hard phase is noisier.
• The hard-split pass rate should improve over the untuned model on the same rubric.
• Generated answers should use your domain vocabulary earlier and hallucinate less often on edge cases.

Troubleshooting and What's Next

Top 3 issues

1. The model parrots definitions but fails at diagnosis. Your easy phase is too large or too narrow. Reduce its share and add more medium examples with ordered procedures and conditional branches.
2. Loss falls, but hard-task accuracy does not move. Your difficulty labels are weak. Re-score examples using ambiguity, context length, and exception handling instead of topic labels alone.
3. OOM or unstable training. Shorten max_length, keep loadin4bit enabled, reduce batch size, and verify your environment supports bitsandbytes properly for your hardware.

What's next

• Add a better difficulty scorer based on retrieval depth, answer length, and number of mandatory facts.
• Compare your curriculum run against a same-budget random-order baseline so you can quantify the lift.
• Introduce preference tuning only after supervised curriculum tuning is stable; otherwise you will optimize style before factual grounding.
• If your domain evolves weekly, rerun only the medium and hard phases on fresh documents instead of retraining from scratch.

If you already have a clean domain corpus, this workflow is one of the fastest ways to make a 1.5B model more useful. The practical lesson is straightforward: better ordering can act like cheaper scale.