Define supervised fine-tuning (SFT) in one breath.

Flashcard·Easy·4.0 · 0·~30s·Asked atGong Stripe Tesla·Relevant atDatabricks

Attempt it

SFT is continued next-token training on a curated set of (prompt, response) demonstrations, run on top of a pretrained base model. Mechanically it is the same causal-LM cross-entropy loss as pretraining, but two things differ: the data is small and structured (instruction-following demos, chat conversations, tool-call traces) and the loss is typically masked so only response tokens contribute. The goal is not to teach new facts, the base already has them, but to teach the model the FORMAT and behaviour of being a helpful assistant: when to answer, how to structure replies, how to follow the chat template.

Your answer

**SFT** stands for Supervised Fine-Tuning. It is the post-training step that takes a pretrained base model and teaches it to behave like a helpful assistant. Mechanically, SFT is the same next-token cross-entropy loss as pretraining. The model predicts each token in a training example, the loss compares the prediction to the actual next token, and gradients update the weights. Nothing exotic about the math. What differs is the data and the loss masking. Pretraining feeds the model trillions of raw web tokens with no structure. SFT feeds it a curated set of structured demonstrations: instruction-response pairs, multi-turn chat conversations, tool-call traces. The set is small, typically thousands to a few hundred thousand examples. The loss is usually masked so only the response (assistant) tokens contribute. The model is being graded on what it should produce, not on what the user typed. This is critical: without masking, the model learns to generate user-like text alongside responses. The goal of SFT is not new knowledge. The base already knows facts from pretraining. SFT installs format and behaviour: when to answer, how to structure replies, how to follow the chat template, how to refuse harmful requests.

**SFT** is Supervised Fine-Tuning, the standard first step of post-training. It takes a pretrained base model and shapes it into a useful assistant by running continued next-token training on a curated set of demonstrations. **Data shape.** SFT consumes structured `(prompt, response)` pairs, typically as multi-turn chat conversations with `system`, `user`, and `assistant` roles. Common formats include the OpenAI chat-completions schema, ShareGPT, and Alpaca. Datasets range from 1k (the LIMA paper showed this is enough for 65B) to a few hundred k examples; quality matters far more than quantity once you are past a few thousand high-signal examples. **Loss.** The same next-token cross-entropy as pretraining. The novelty is **prompt loss masking**: only assistant tokens contribute to the loss. System and user tokens are conditioned on but masked out (set to the ignore index in PyTorch). The model is graded on what it should produce, not on what it observes. **Training setup.** Learning rate is much lower than pretraining (typically 1e-5 to 2e-5 for full SFT, 1e-4 for LoRA), runs are short (hours to a few days), and hardware is far smaller (single node or a few). A pretraining-scale LR torches the base model in a few hundred steps via catastrophic forgetting. **What gets installed.** Format and behaviour, not knowledge: - How to follow the chat template - When to answer vs ask clarifying questions - How to structure replies (lists, code blocks, citations) - How to invoke tools when applicable - How to refuse harmful or out of scope requests The base already has the factual knowledge from pretraining. SFT shapes how that knowledge gets delivered. The LIMA result is the classic demonstration: 1k carefully curated examples installed competent instruction-following on a 65B base, proving that SFT teaches behaviour, not facts.

TL;DR

SFT is continued next-token training on curated (prompt, response) demos, with loss masked to response tokens, to install assistant behaviour on a pretrained base.

Memory aid

Easy to grasp

Imagine a brilliant student who has read every book in the library but has never been to a job interview. They know everything but they ramble, they speak out of turn, they cite obscure sources when a one-line answer would do. SFT is a weekend with a tutor who shows the student a few hundred good interview answers. The tutor never teaches new facts; the student already knows the material. What changes is style and shape, when to be concise, when to elaborate, when to refuse, when to ask. By Monday the student answers in the right format. Same knowledge, brand new presentation. That polish is exactly what SFT installs on top of a pretrained base.

Key concepts

Supervised fine-tuning Instruction tuning Chat template Prompt loss masking

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

Supervised fine-tuning, SFT, is the gateway step between a pretrained base model and any modern alignment pipeline. It is also one of the most commonly misunderstood operations in the entire LLM stack. Beginners assume SFT teaches new facts. It does not, primarily. Beginners assume SFT runs a special loss. It does not. The loss is the same next-token cross-entropy as pretraining. What changes is everything around the loss.

This deep dive walks through what SFT actually does. We start with the mechanical definition (same loss, different data, different masking, different learning rate), explain why prompt loss masking matters, lay out the behaviour versus knowledge distinction that decides when SFT is the right tool, and survey the production recipe that has converged across the open ecosystem.

The headline is concise. SFT runs masked next-token cross-entropy on curated chat-format demonstrations at a much lower learning rate than pretraining, in order to install behaviour and format on top of a pretrained base. It excels at teaching the model how to follow the chat template, when to answer, how to structure replies, how to refuse, and how to invoke tools. It is poor at teaching genuinely new factual knowledge; that is the job of retrieval or continued pretraining.

Getting this distinction right reshapes how teams think about post-training. A team that treats SFT as a knowledge-injection tool will collect 100k facts in chat format, spend a week training, and watch the model produce mediocre answers that hallucinate facts in the same shape as the demonstrations. A team that treats SFT as behaviour installation will collect 1k high-quality format demonstrations, finish training in hours, and ship a sharply better assistant.

What SFT actually runs under the hood

The loss

SFT runs the same loss as pretraining: next-token cross-entropy on a causal-LM forward pass. For a sequence of tokens x_1, x_2, ..., x_T, the model predicts each token from the ones before it:

\mathcal{L} = -\frac{1}{|\text{response}|}\sum_{t \in \text{response}} \log P_\theta(x_t \mid x_{<t})

Notice the sum is restricted to response token positions. This is the prompt loss masking discussed below; the loss function itself is identical to pretraining.

The data

SFT data is curated (prompt, response) pairs, typically formatted as multi-turn chat conversations with system, user, and assistant roles. A single example might be a one-turn instruction-response pair (Alpaca-style) or a long multi-turn dialogue with tool calls embedded (modern agentic SFT).

Volume ranges from 1k (LIMA) to a few hundred k examples. Past a few thousand high-quality examples, more data offers diminishing returns; quality and diversity dominate.

The learning rate

Full SFT uses 1e-5 to 2e-5. LoRA SFT uses 1e-4 (most weights frozen, larger steps on the small trainable slice are safe). Both are roughly ten times smaller than pretraining LRs.

The reason is geometric. Pretraining ended in a sharp loss basin built over trillions of tokens. SFT takes small steps inside that basin. A pretraining-scale LR pushes the weights out of the basin, the small SFT dataset cannot rebuild the pretraining distribution, and the model rapidly loses its general capabilities. This is catastrophic forgetting, and using too high a fine-tuning LR is the fastest way to cause it.

The training duration

Typical SFT runs are hours to a few days on a single node or a few nodes. Compare to pretraining (weeks to months on thousands of GPUs). The 100x to 1000x cost reduction is what made SFT economically central to modern LLM development.

Prompt loss masking and why it matters

Behaviour vs knowledge, and why SFT is poor at knowledge injection

Where SFT sits in the alignment stack

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Dimension	Pretraining	SFT
Data shape	Raw text, no labels	Curated chat-format demos
Data volume	Trillions of tokens	Thousands to low millions
Loss	Next-token CE, every token	Next-token CE, assistant only
Learning rate	1e-4 to 6e-4	1e-5 to 2e-5
What changes	World knowledge	Format and behaviour

Real products, models, and research that use this idea.

Llama 4 Maverick's post-training begins with a large SFT stage on curated demonstrations before any preference optimisation.
DeepSeek V4 publishes an SFT recipe using around 2e-5 learning rate on a multi-million example chat dataset.

What an interviewer would ask next. Try answering before peeking at the approach.

QWhy does prompt loss masking matter so much in practice?

Without masking the model learns to predict user tokens too, which means it sometimes generates fake user turns mid-response or refuses to respond because it just wrote a user message. Masking aligns gradients with what you want the model to produce, not with what it observes.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Treating SFT as a way to inject new factual knowledge. SFT primarily reshapes behaviour and format; for genuinely new facts you usually need retrieval or continued pretraining.

60 second bullets to scan on the way to the call.

The definition of SFT in terms of data, loss, and goal
Why the loss is masked to assistant tokens only

Primary sources. Browse if you want the original framing.