Most fine tuning tutorials have the same problem. They demonstrate on a model you cannot afford to run, on hardware you do not have, and by the time you have worked out the substitutions the tutorial no longer applies. The smol course solves this by design. It teaches fine tuning using small models, which means every exercise is runnable on a free Colab tier or a consumer GPU, and the feedback loop is minutes rather than hours.
That single decision is why I rate this above most of the alternatives. The course runs seven units. Instruction tuning covers supervised fine tuning and chat templates. Evaluation covers benchmarks and domain specific assessment.
Preference alignment covers methods like DPO. There are units on vision language models, on reinforcement learning approaches, on synthetic data generation, and a final showcase. Each unit is designed for about three to four hours across a week, which is honest pacing for people doing this alongside a job. The structure of each unit is theory, then a hands on section using TRL and Transformers, then an assignment applying it to something real.
The tooling choice matters. TRL is what people actually use to fine tune models in practice, and learning the real library rather than a teaching abstraction means what you learn transfers directly to work. There is a category of course that builds simplified versions of everything for pedagogical clarity and leaves you unable to use the actual ecosystem. This is not that.
The evaluation unit is the part I would defend most strongly against people who want to skip it. Fine tuning is easy to do and hard to know whether you have done well. Loss going down does not mean the model got better at the thing you care about, and the number of people who have shipped a fine tuned model that is worse than the base model on their actual task is large. Teaching evaluation as a first class topic, with domain specific assessment rather than just leaderboard benchmarks, is the correct pedagogical call.
Preference alignment being included is also more than most free courses manage. DPO and its relatives are how you get from a model that can follow instructions to a model that follows them the way you want, and understanding the difference between supervised fine tuning and preference optimisation is genuinely important. This section is more conceptually demanding than the earlier units and worth slowing down for. Now the honest problems.
This is a community built course hosted by Hugging Face, and the quality varies between units in a way a single author course would not. The early units are polished. The later ones, particularly the reinforcement learning material, feel less developed and read like they were written by someone with less time. That is the trade for a free course built openly, and I would rather have uneven free material than nothing, but you should know the back half is weaker than the front.
Notebook rot is the practical frustration. The underlying libraries move quickly, notebooks break, and the fixes arrive through community pull requests on a lag. You will hit an error that has nothing to do with your understanding and everything to do with a version change. My advice is to treat this as part of the course rather than a defect.
Reading a stack trace, working out which library changed, and fixing it is exactly the skill fine tuning work requires, and doing it in a low stakes setting is good practice. Prerequisites are the thing people underestimate. The course states that you need Python, PyTorch, machine learning fundamentals and familiarity with transformer architecture, and it means it. If you cannot read a PyTorch training loop and say what each line does, this will be miserable.
Hugging Face's own LLM course and the deep reinforcement learning course are reasonable places to build that first, and the smol course points at prerequisites for people who need them. The conceptual gap I would flag is that the course teaches fine tuning without spending much time on whether you should fine tune. In practice, most problems people try to solve with fine tuning are better solved with better prompting or with retrieval, and fine tuning is the right answer for a narrower set of cases than the enthusiasm suggests: teaching a specific format, adapting to a specialised domain vocabulary, distilling a larger model's behaviour into a smaller one. A course that opened with that framing would produce better engineers.
This one dives into the how without dwelling on the when. The certification is free and comes in two forms, one for completing the first unit and one for finishing everything plus a final project. I would not put much weight on the certificate itself. The final project is the useful output, because a fine tuned model with a documented evaluation is a portfolio piece that demonstrates something real.
My 4.2 is for a course that made the right architectural decision about model size, teaches the real tooling, takes evaluation seriously, and costs nothing. The unevenness and the notebook rot keep it from higher. If you already write PyTorch and want to learn fine tuning, start here.