Fine-Tuning Explained for Noobs (How Pretrained Models Learn New Skills)

# Inroduction

 
This article is part of my noob series where we write about the questions people Google most but may not understand well because of complex math and everything. So, if you are here, you might have heard fine-tuning somewhere in the context of large language models (LLMs) especially. This concept already existed in traditional machine learning for years, but it gained popularity after LLMs because now suddenly everyone has access to these huge, general pretrained models that you can adapt based on your tasks, your own needs, and in your own tone. This act of adapting is basically called fine-tuning, and it is now one of the most common things people do with LLMs. But you cannot understand it until you understand the step that comes before it, and that is “pretraining.” Fine-tuning is literally “tuning” something that already exists, and that “something” is a pretrained model. So, let’s try to break down these concepts so that in the future, if someone asks you about it, you know it.

# What Is Pretraining?

 
If you start with a freshly created model that has millions or billions of parameters assigned random numbers, and you try to teach it a very specific task directly — let’s say how to classify movies into different categories — it has to learn the entire English language from scratch at the same time, which is impossible, especially from the limited dataset you might have. It is just like teaching a toddler biology before they can understand the language or basic science concepts first.

Pretraining solves this problem by learning the hard and general stuff once from a massive amount of data. The compute and data requirements are quite high at this stage. But once you train it, you will have a model that already understands language. During this stage, you teach it a very simple skill: predicting the next word. You show the model a piece of text with the next word hidden, and it has to guess what comes next. Good guesses get a small loss, bad guesses get a big one, and the model adjusts.

For example, in the above diagram, if we give the sentence “The cat sat on the ____”, the model learns that “mat” is far more likely than “car”. Repeating this training across billions of sentences, books, and articles makes the model a very good next-word predictor and forces it to absorb grammar, facts, reasoning patterns, and more. After pretraining, you have a model that already understands language. Every task you build later gets to stand on top of that foundation instead of starting from zero. That is also why these are often called foundation models.

You almost never pretrain anything yourself. You download the finished result — a pretrained model like Llama, Mistral, or Qwen — and start from there. This brings us to our actual topic of fine-tuning.

# What Is Fine-Tuning?

 
A lot of beginners think that once a model has been trained, the weights are frozen forever. In reality, having a pretrained model means the weights have been set to “good values” that encode intelligence and perform well at general tasks. Once you have this model, you can adapt that intelligence for your specific needs using task-specific data — and this is called “fine-tuning.” The data requirements at this stage are also much lower than pretraining, since you only need examples for the task you are interested in.

It is very similar to how different chefs are trained at the same culinary school, and then when they join a restaurant, they learn restaurant-specific skills. Since we are not building something from scratch here, it is less expensive — similar to the idea that training a completely new person for a restaurant requires far more effort than training someone who has already attended culinary school. The diagram below sums up the difference between pretraining and fine-tuning.

# How Is Fine-Tuning Done?

 
We discussed next-token prediction and the process of pretraining. Now, let’s take a look at the fine-tuning loop.

You show the model an example of task-specific data — let’s say a movie — ask it to categorize the movie and make a guess, then compare its answer to the ideal one, nudge the weights a bit, and repeat the process until it gets better at the downstream task. There are also two major things done differently in fine-tuning compared to pretraining:

1. Data → Small, high-quality, task-specific data instead of the entire internet.
2. Learning Rate → A small learning rate and few passes, because we want the model to adapt without overwriting its general skills.

# Two Common Types of Fine-Tuning

 
Though you will find different definitions across the internet, based on the number of model parameters you want to tune or adapt, fine-tuning broadly falls into two categories:

1. Full Fine-Tuning: In this setting, every parameter in your model is free to change. You run the loop above and all of the billions of numbers shift a little toward your task. The main problem with this approach is memory — you need enough to hold and update the entire model, which for a large LLM means serious hardware. There is also more risk of catastrophic forgetting, which simply means the model becomes good at the specific task but loses its general abilities on everything else.
2. Parameter-Efficient Fine-Tuning (PEFT): Instead of updating every weight in the network, PEFT techniques freeze the base model — every original number stays locked — and introduce a small set of brand-new, trainable numbers, training only those. There are different techniques to achieve this, such as LoRA, QLoRA, and prompt tuning, but the details of those are beyond the scope of this article. PEFT requires less memory and training time, with a lower risk of forgetting already-learned knowledge. For most LLM fine-tuning, this is the default choice.

# Is Fine-Tuning Always the Answer?

 
Fine-tuning is excellent at teaching models a new skill, style, behavior, or task, but it is not the only tool — and often not the first one you should reach for. A better prompt can sometimes solve your problem without any training at all. Similarly, when it makes more sense to look up information either online or in a database at query time, retrieval-augmented generation (RAG) is a better fit, especially when facts are large in volume or change often. These approaches are not rivals; in practice, most systems use them together. Worth keeping in mind before you commit to a full fine-tuning run.

# Extra Resources

 
If you want to practice fine-tuning specifically with LoRA, here are some recommended resources:

• Hugging Face PEFT: The standard open-source library for LoRA, QLoRA, prompt tuning, and more. Start with the docs and the repo.
• Hugging Face TRL: Pairs with PEFT and gives you a ready-made SFTTrainer for the supervised fine-tuning loop.
• Unsloth: The most beginner-friendly path to LoRA/QLoRA, with free Colab and Kaggle notebooks, ~2× faster training, and much lower VRAM.
• Axolotl: Once you are comfortable, a popular config-driven (YAML) tool for running fine-tuning pipelines without writing much code.
• The original LoRA paper: “LoRA: Low-Rank Adaptation of Large Language Models.”
• The QLoRA paper: “QLoRA: Efficient Finetuning of LLMs.”

For a good first project, grab a small instruct model (something like an 8B Llama, Qwen, or Gemma), open an Unsloth QLoRA notebook, fine-tune it on a few hundred clean examples of your task, and watch the training loss drop. Once you have done it once, every term in this article will feel much more concrete.
 
 

Kanwal Mehreen is a machine learning engineer and a technical writer with a profound passion for data science and the intersection of AI with medicine. She co-authored the ebook “Maximizing Productivity with ChatGPT”. As a Google Generation Scholar 2022 for APAC, she champions diversity and academic excellence. She’s also recognized as a Teradata Diversity in Tech Scholar, Mitacs Globalink Research Scholar, and Harvard WeCode Scholar. Kanwal is an ardent advocate for change, having founded FEMCodes to empower women in STEM fields.