Instruction Fine-Tuning SmolLM 135M into a Tiny Assistant

What you'll build

Take the base SmolLM 135M model — a 135-million-parameter pretrained language model that does not follow instructions out of the box — and fine-tune it into a tiny chat assistant via Supervised Fine-Tuning (SFT) on an Alpaca-style instruction dataset. At this scale, a full fine-tune is genuinely feasible on a single small GPU (no LoRA needed), so the team gets to feel the complete instruction-tuning loop end-to-end: chat templates, the SFT training loop, generation, and a blind side-by-side evaluation against the un-tuned base.

What goes in, what comes out

[
  {
    "instruction": "Explain what a recursive function is in one paragraph.",
    "input": "",
    "output": "A recursive function is a function that solves a problem by calling itself on a smaller version of the same problem, with a base case that stops the recursion. Each call works on a smaller input until it reaches the base case, at which point the partial results are combined back into the final answer."
  },
  {
    "instruction": "Translate to French.",
    "input": "The library closes at six in the evening.",
    "output": "La bibliothèque ferme à six heures du soir."
  },
  {
    "instruction": "List three reasons to use version control on a software project.",
    "input": "",
    "output": "1. It tracks every change so you can revert mistakes. 2. It lets multiple people work on the same codebase without overwriting each other. 3. It documents the history of why each change was made."
  }
]

Prompt: "Explain what a list comprehension is in one sentence."

Base SmolLM-135M (no instruction tuning):
  "What is a list comprehension? A list comprehension is a way to
   create a list from another list. List comprehensions are useful
   because they are more concise than for loops..."
  (continues text without following the instruction format)

Fine-tuned SmolLM-135M:
  "A list comprehension is a concise Python syntax for building a
   list by writing the expression and the loop on a single line,
   such as `[x*x for x in range(10)]`."
  (follows the instruction, stops at the right place)

Blind ratings on 50 held-out prompts (1=bad ... 5=excellent):
  Approach                        Avg. quality   Follows instruction
  -----------------------------   ------------   -------------------
  SmolLM-135M base                    2.1              28%
  SmolLM-135M instruction-tuned       3.6              92%

Datasets

Tools you'll need

These are suggestions, not requirements. If your team is more comfortable with a different library, model, or framework that achieves the same goal, use it — and briefly explain the choice in your README.

Python: Python 3.10 or newer. Compute: Colab T4 / Kaggle P100 (16 GB GPU) is comfortable for a full fine-tune of a 135M model. CPU is realistic for inference only.

• transformers — Loads HuggingFaceTB/SmolLM-135M and its tokeniser. The tokeniser carries the chat template.

• trl — Provides SFTTrainer — handles instruction formatting, packing, and the training loop without boilerplate.
• accelerate — Mixed-precision and device placement.
• torch — Underlying training backend.

• datasets — Loads Dolly / Alpaca and applies the chat template via map.
• sentencepiece — Tokeniser dependency for SmolLM.

• evaluate — For any automatic metrics on top of human ratings.

How to approach it

One reasonable path through the project. Specific tools (UMAP, HDBSCAN, BERTopic, etc.) are examples — feel free to swap them for alternatives you know better.

1. Load the base model. HuggingFaceTB/SmolLM-135M plus its tokeniser. Generate a few responses to confirm it does not follow instructions — it just continues text. This is the "before" snapshot.
2. Prepare the dataset. Load Dolly-15k. Map each row to a chat-template-formatted string using tokenizer.apply_chat_template with [{"role": "user", "content": instruction}, {"role": "assistant", "content": output}].
3. Configure SFT. Use trl.SFTTrainer. Suggested defaults: 2-3 epochs, learning rate 2e-5, batch size 8 (with gradient accumulation if needed), bf16 if your GPU supports it, max sequence length 1024.
4. Train. Should take ~30-60 minutes on a T4 for 15k examples × 2 epochs. Watch the loss curve.
5. Save the checkpoint. The whole fine-tuned model is ~500 MB on disk (full weights, not adapters).
6. Build a 50-prompt eval set. The team writes prompts that probe instruction following: definitions, list generation, format following, refusals, translations.
7. Generate from both models. Same prompts, same decoding settings (greedy or low-temperature sampling), one notebook per model.
8. Blind side-by-side rating. Shuffle the (base, tuned) pairs so raters do not know which is which. Each team member rates every response 1-5 on quality and on "did it follow the instruction".

What to deliver

• The fine-tuned SmolLM-135M checkpoint (upload to a HuggingFace repo or save in the project artifacts).
• A reproducible training notebook + an inference notebook that loads either model and chats interactively.
• A 50-prompt eval set with the team's blind ratings for base and tuned models, plus the average scores.
• A short README documenting the dataset, hyperparameters, training time, and what changed between base and tuned.

References

• SmolLM 135M model card
• SmolLM blog post (HuggingFace)
• TRL SFTTrainer guide
• Dolly-15k dataset card
• HuggingFace chat-template guide
• Alpaca paper / project page