Skip to content
New this month 24 fresh C++, C#, F#, JavaScript, TypeScript and Lua courses just landed. Browse new releases Use code WELCOME10 for 10% off your first order · 14-day refund

Fine-Tuning Small Models on Your Own Data

Build a dataset, run a LoRA fine-tune, and prove it beats prompting for your narrow task.

Rated 3.0 out of 5 from 1 review 13 students

PR Created by Priya Raman

  • Last updated August 2026
  • English
  • 9h 5m of material
  • 68 lessons

What you will learn

8 concrete outcomes

Every bullet below is something you will have built, shipped or be able to explain by the time you finish the last lesson.

  • Decide honestly whether fine-tuning beats prompting or retrieval for your task
  • Build a training dataset from production examples with written guidelines
  • Measure annotation agreement so you know your labels mean something
  • Run a LoRA fine-tune on a small open model with a single GPU
  • Read loss curves and recognise overfitting from its shape
  • Compare the result against a strong prompted baseline on held-out data
  • Calculate latency and cost per thousand requests for both options
  • Serve a fine-tuned model with versioning and a rollback path

Course curriculum

7 modules · 68 lessons · 9h 5m of material

10 lessons running 1h 16m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

10 lessons running 1h 22m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

10 lessons running 1h 26m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

10 lessons running 1h 26m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

10 lessons running 1h 20m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

9 lessons running 1h 12m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

9 lessons running 1h 3m in total. Each lesson ships with the finished source files and a short written recap, so you can follow along in your own editor and skim the module again later.

Lesson-by-lesson titles, code downloads and exercises live inside the course library you get access to straight after checkout.

7 modules · 68 lessons

9h 5m total length

Requirements

Short list, and deliberately so. If you meet these you can start today.

  • Solid Python and comfort with the command line
  • Access to a GPU, either a rented cloud instance or a modern local card
  • A repetitive task with real examples you are allowed to use

About this course

Fine-tuning is both over-recommended and under-used. It is over-recommended because a better prompt or better retrieval solves most problems more cheaply. It is under-used because for a narrow, repetitive, well-defined task, a small fine-tuned model can be faster, cheaper and more consistent than any prompt against a large one. This course teaches you to tell the two situations apart, then to do the work properly.

The first module is a decision framework with a genuine escape hatch: several worked examples end with the recommendation not to fine-tune, and the reasoning is spelled out. Once you have a task that qualifies, the real work begins, and most of it is data. You will build a dataset from production examples, clean and deduplicate, and hold out a test set that never touches training.

Training itself uses parameter-efficient methods, principally LoRA, on small open models you can run on a single rented GPU or a decent local card. You will study rank, learning rate and epochs through their effect on loss curves, then overfit a model deliberately so you can recognise the shape of it.

Evaluation is where the course spends its final third. You compare the fine-tune against a strong prompted baseline on held-out data, measure latency and cost per thousand requests, then serve the model behind a stable API with versioning and a rollback path.

Frequently asked questions

Still unsure about something? Write to misteryjj100@gmail.com and a human answers, usually the same working day.

A single GPU with sixteen gigabytes of memory is enough for every exercise. Rented instance instructions and cost estimates are included for those without local hardware.

Small open-weight instruction models in the three to eight billion parameter range, chosen because they train quickly and are realistic to self-host.

Every exercise runs on infrastructure you control, and a lesson covers redaction and licensing questions before you use production data for training.

Checkout is handled on our provider's secure payment page. The moment your payment clears we email your personal access link and access code to the address you used at checkout, and the same link appears in your account library. There is nothing to install and nothing to wait for.

Email misteryjj100@gmail.com within 14 days of your purchase, quote your order number, and we refund the full amount to your original payment method. No form to fill in and no questions about how much of the course you watched.

What students say

Reviews are written by people who bought this course. We publish the critical ones too.

3.0

Rated 3.0 out of 5

Course rating · 1 review

Rating distribution

  • 5 stars 0%
  • 4 stars 0%
  • 3 stars 100%
  • 2 stars 0%
  • 1 star 0%
  • IC

    Ilaria Conti

    ML engineer

    Jul 2025
    Rated 3.0 out of 5

    Honest opening, thin on the hard parts

    Full credit for a first chapter that argues most people should not fine-tune at all, which cannot have been good for sales. Dataset construction is decent. But the LoRA walkthrough runs on a tidy dataset that never fights back, and the hyperparameter section hands you starting values without much guidance for when the loss curve does something strange, which in my experience it always does. I understand the shape of the process now. I do not feel equipped to run it against my own data.

Your instructor

PR

Priya Raman

Applied AI and machine-learning engineer

  • 236 students taught
  • 13 courses published
  • 4.3 instructor rating
  • Machine learning
  • RAG
  • Fine-tuning
  • LLM agents

Priya builds language-model features for a document-heavy SaaS product, which means she has taken retrieval and fine-tuning from a promising notebook to something on call at three in the morning. She teaches the mathematics only where it changes a decision you are about to make, and spends the rest of the time on data quality, evaluation and the cost of an agent that loops. Her courses run on a laptop and a modest API budget, so nobody has to rent a cluster to follow along. She publishes reproducible notebooks alongside every module.

$69 USD

One-time payment · lifetime access

The WisdomCharms dispatch

One useful email a week. No fluff, no spam.

New course releases, discount codes before anyone else, and a short, practical breakdown of one technique — a prompt pattern, a C++ idiom, a TypeScript trick — that you can use the same day.

  • Subscriber-only launch pricing
  • Unsubscribe in one click
  • We never sell your address

By subscribing you agree to our Privacy Policy. Questions? Write to misteryjj100@gmail.com.