Data basics: formats, chat templates and checks before you train

Most fine-tuning failures are data failures. This lesson gives you the vocabulary and a validation script, so the labs are about learning, not debugging files.

#The vocabulary

#The standard chat format

{"messages": [
  {"role": "system", "content": "You extract the city from a sentence."},
  {"role": "user", "content": "I flew into Lisbon on Monday."},
  {"role": "assistant", "content": "Lisbon"}
]}

One such object per line is a JSONL file. The labs and most training libraries (including TRL) accept this shape directly. The chat template of the base model then converts the messages to the text it expects.

#Validate before you train

Save this as validate.py. It writes a small file, reads it back and checks each line:

import json

examples = [
    {"messages": [
        {"role": "system", "content": "You extract the city from a sentence."},
        {"role": "user", "content": "I flew into Lisbon on Monday."},
        {"role": "assistant", "content": "Lisbon"}]},
    {"messages": [
        {"role": "user", "content": "She lives in Osaka."},
        {"role": "assistant", "content": "Osaka"}]},
]
with open("train.jsonl", "w") as f:
    for e in examples:
        f.write(json.dumps(e) + "\n")

bad = 0
with open("train.jsonl") as f:
    for n, line in enumerate(f, 1):
        row = json.loads(line)
        roles = [m["role"] for m in row["messages"]]
        if roles[-1] != "assistant" or any(r not in ("system", "user", "assistant") for r in roles):
            bad += 1; print("problem on line", n, roles)
print("examples:", n, "problems:", bad)

chars = sum(len(m["content"]) for e in examples for m in e["messages"] if m["role"] == "assistant")
print("assistant characters:", chars)

Expected output: examples: 2 problems: 0 and assistant characters: 11. On your own data, extend the checks: empty replies, duplicates, over-long examples, and a final role that is not assistant.

#Quality checklist

• Every example shows the exact behaviour you want. If a few are sloppy, the model learns sloppy.
• Consistent format. If half the answers are JSON and half are prose, the model will mix them.
• No leakage. Do not let evaluation questions appear in the training file.
• Diversity. Cover the real range of inputs, including awkward ones.
• No private data you would not want a model to reproduce (privacy).
• Length sanity. Check the longest examples against your maximum sequence length so they are not silently cut.

#Splitting

Hold out 5 to 20 percent as a validation set, chosen at random, and keep an even smaller test set that you do not look at until the end. If your data has natural groups (the same customer, the same document), split by group so near-duplicates do not appear on both sides.

#Chat templates in practice

Each model family has its own template with special tokens around roles. In Hugging Face tokenizers it is applied with tokenizer.apply_chat_template(messages, tokenize=False). Two rules:

1. Use the template of the model you fine-tune. A template from another family changes the tokens the model sees.
2. Use the same template at inference. The model learned the format it was trained on; sending a different one at serving time loses much of the benefit (serving adapters).

#How much data

More is not always better; quality and coverage matter more, and the data lessons show how to generate and filter synthetic examples (synthetic data lab).

#Exercise

1. Add a third example to the script with the wrong last role (user) and run it. What is reported?
2. Why must the system message be the same at training and inference time if the training data always includes one?

Answers: 1. problems: 1 with the line number and the roles list. 2. The model learned to respond conditioned on that prompt; changing or dropping it shifts the input distribution, so behaviour can differ from what you evaluated.

Next: when to fine-tune, and when not to.