Now that we’ve settled when to fine-tune, let’s look at what it actually is. “Fine-tuning” gets thrown around as if it’s something exotic, and it really isn’t. If you’ve followed the AI Primer, you already know almost everything you need to understand it. Fine-tuning is just training, done again, on a much smaller and more focused set of examples. That’s the whole idea. Let me show you what that means and why it’s useful.
A quick refresher, then the twist
Cast your mind back to the Primer. A language model is trained by playing guess-the-next-word across an enormous amount of text, with its weights (millions or billions of little dials) being nudged over and over until it gets very good at predicting what comes next. When we call the result a “base model” or “pretrained model,” what we mean is: those weights have been settled into positions that capture an incredible amount of language, knowledge, and general skill.
Now here’s the small but crucial twist that gives you fine-tuning. Those weights aren’t frozen. They can be nudged further. If we take that already-trained model and continue training it, but this time on our own carefully-chosen examples, we can shift the weights toward the behaviour we want, without having to start from scratch.
That’s fine-tuning. Same training loop (predict, check, adjust). Same underlying mechanics we saw in the backpropagation article. Just applied after the model was already trained, on a much narrower dataset, to nudge it toward a specific goal. Figure 1 makes the picture concrete.
Figure 1: The base model is the general-purpose result of huge pretraining. Fine-tuning takes that model as its starting point and continues training on a smaller, focused dataset of examples of the behaviour you want. The weights shift, but only a little, toward the target behaviour.
The shift is real but usually modest. Fine-tuning doesn’t rebuild the model from scratch; it bends it toward your task. All the language ability, general knowledge, and reasoning that pretraining gave it stays intact. What changes is the tendency: the model becomes noticeably better at doing the specific thing you trained it toward.
What “an example” looks like in fine-tuning
The centrepiece of a fine-tuning job is your training dataset: a collection of examples that show the model, over and over, what you want it to do. In practice, each example is usually a pair: an input, and the ideal output for that input.
Say you want to fine-tune a model to write customer support replies in your company’s specific tone. Your training examples would look like this:
{"input": "My order arrived damaged.",
"output": "I'm sorry your order arrived that way. Please reply with a photo of the damage and your order number, and I'll arrange a replacement immediately."}
{"input": "How do I change my subscription plan?",
"output": "Great question. You can change your plan any time under Account > Subscription, and the new tier applies from your next billing cycle."}Each pair is one lesson. The model sees the input, produces its own attempt at the output, has that attempt compared to the ideal, and its weights are nudged (via the training loop from the Primer) to make its next attempt slightly closer to what you wanted. Do this across thousands of pairs, and the model gradually settles into your style.
The exact format varies by tool and provider (some use prompt-completion pairs, others use conversation transcripts, others use JSON), but the underlying idea is always the same: examples of what you want, in a form the model can learn from.
What happens to the weights, gently
I promised no forced maths, but the intuition here is worth a moment because it explains something important about why fine-tuning works so well from a good starting point.
Recall from the Primer that “learning” for a neural network means adjusting each weight a small amount to reduce the error (the loss) on the next example. During pretraining, the weights start random and have to travel enormous distances to become useful. That takes a huge amount of data and compute.
During fine-tuning, though, the weights are already in a very good place. All the general-purpose capability has been learned. So the training loop only has to make small adjustments to bend the model toward your task. Small adjustments, on a smaller dataset, over a smaller number of training passes. That’s why fine-tuning is cheaper and faster than pretraining. You’re not starting from scratch, you’re steering.
That said, “smaller and cheaper than pretraining” doesn’t mean “trivial.” Full fine-tuning still adjusts every weight in the model. For a modern language model with billions of parameters, that’s a lot of memory and compute to move around. This is why cleverer techniques exist that adjust only a tiny fraction of the weights while getting most of the benefit. That’s a full article coming up soon (LoRA and QLoRA), and it’s the technique that makes fine-tuning practical for most people.
The core loop, in one picture
Zoomed out, a fine-tuning job looks like Figure 2.
Figure 2: The fine-tuning loop, which is the same training loop from the Primer, run on your own examples. Feed in the input, see what the model produces, compare it to the desired output, adjust the weights a little, then move to the next example. Repeat across thousands of examples for a few passes.
That loop repeats across your whole dataset, usually a few times (each full pass is called an epoch). By the end, the model’s weights have shifted just enough that its default behaviour lines up with your examples. If you tested it on unseen inputs from the same task, it would now respond in the style, format, or approach you trained it toward.
Two things fine-tuning changes, and one it doesn’t
To sharpen the mental model, here’s what fine-tuning does and doesn’t change.
What it changes:
- Default behaviour, style, tone, format, and specialised patterns. This is what fine-tuning is really for.
- Baseline skill on a narrow task where you have lots of examples. A model fine-tuned on your specific extraction task can meaningfully outperform the general model on that task alone.
What it doesn’t change much (or shouldn’t):
- General reasoning ability and language skill. These come from pretraining and mostly stay put. If anything, aggressive fine-tuning can slightly reduce general ability (a phenomenon called “catastrophic forgetting” in the extreme), which is another reason not to overdo it.
- Facts and knowledge you should update often. As we hammered home in the last article, fine-tuning is a poor way to teach a model facts. Use RAG for that.
Keep both columns in mind. They explain why fine-tuning is so effective for the right jobs and so wasteful for the wrong ones.
The bridge to what’s next
You now know what fine-tuning actually is, mechanically. It’s continued training, on your own examples, that nudges the model’s weights toward your task. Simple in principle, and hugely useful when it fits.
But the whole thing rises or falls on one thing: the quality of your examples. A fine-tuning job with excellent, carefully-prepared data will beat a job with sloppy data every single time, no matter how sophisticated your technique. Which is why the next article, before we get into the clever training methods, is entirely about how to build a fine-tuning dataset that actually works.
Next in the series: Preparing a Fine-Tuning Dataset, the data decision that shapes the whole process.