Model Online / On-Site
Duration
Modules 5 modules

Course Objective & Scope

For developers used to calling commercial LLM APIs, fine-tuning a model on custom data often feels like an opaque, hardware-heavy black box. This foundational course demystifies the end-to-end workflow for adapting modern open-weight models on a single GPU.

Step by step, participants learn the difference between pre-training and post-training, why adapter tuning (LoRA) replaces full weight updates, how to format JSONL datasets with chat templates, how to run training with Hugging Face transformers, peft, trl and Unsloth, how to read loss curves and how to export the trained model. Every participant finishes with a working custom adapter trained on a real task.

Who Should Attend?

  • Software developers and data engineers running their first LLM fine-tuning job
  • Data scientists transitioning from classical machine learning to generative AI
  • Technical leads who want hands-on understanding of the model adaptation workflow
  • Prerequisite: basic Python proficiency; no prior deep-learning cluster experience required

Key Takeaways

  • Explain what fine-tuning changes inside an LLM and which use cases benefit from it
  • Convert raw task data into clean JSONL datasets with the proper model chat template
  • Fine-tune an open-weight model on a single GPU using Hugging Face TRL and Unsloth
  • Configure learning rate, epochs and batch size while diagnosing overfitting from loss curves
  • Merge and export the trained adapter for local or server-side inference

Curriculum

How LLM Fine-Tuning Works
  • Overview of pre-training, instruction fine-tuning and alignment stages
  • Full weight fine-tuning versus adapter-based (LoRA) fine-tuning
  • When a small specialised model outperforms a large general-purpose model
Dataset Preparation and Chat Templates
  • Conversation data formats (OpenAI messages, ShareGPT) with system, user and assistant roles
  • Tokenizers, special control tokens (<|im_start|>, EOS) and common chat-template bugs
  • Splitting data cleanly into train, validation and test sets
Your First Fine-Tuning Run: TRL and Unsloth
  • Loading open models in 4-bit or 16-bit precision with the Hugging Face ecosystem
  • Core hyperparameters: learning rate, batch size, gradient accumulation and epochs
  • Launching the training loop and monitoring GPU memory
Reading Loss Curves and Preventing Overfitting
  • Diagnosing learning progress from training and validation loss curves
  • Spotting and fixing underfitting and memorisation (overfitting)
  • Side-by-side output comparison before and after training
Saving, Merging and Serving the Custom Model
  • Saving lightweight adapter weights versus merging into the base model (merge_and_unload)
  • Exporting to GGUF/AWQ and serving locally or via Ollama and vLLM

Other Courses in This Category

  • Advanced Fine-Tuning: Continual Pre-Training, Long Context and Model Merging

    Advanced course covering continual pre-training (CPT), RoPE long-context extension, multi-turn tool-calling fine-tuning, catastrophic forgetting mitigation and model merging (SLERP, TIES, DARE) with MergeKit.

    LLM Customisation & Model Adaptation Corporate
    Live Course
    5 modules
    View
  • Supervised Fine-Tuning (SFT): Engineering and Optimisation

    Deep-dive engineering course on Supervised Fine-Tuning (SFT): completion-only loss masking, sequence packing, FlashAttention-2, NEFTune, learning rate schedules and production workflows with TRL SFTTrainer and Axolotl.

    LLM Customisation & Model Adaptation Corporate
    Live Course
    5 modules
    View
  • Parameter-Efficient Fine-Tuning (PEFT): Architectures and Multi-Adapter Serving

    Course on PEFT architectures—LoRA, DoRA, rsLoRA, VeRA, LoftQ, IA3 and Prefix Tuning—VRAM memory budgeting and serving dozens of dynamic adapters on a single base model with vLLM and SGLang.

    LLM Customisation & Model Adaptation Corporate
    Live Course
    5 modules
    View
  • Practical LLM Fine-Tuning with LoRA and QLoRA

    Hands-on training on Low-Rank Adaptation (LoRA) and 4-bit NormalFloat (NF4) QLoRA: rank/alpha tuning, target modules, double quantisation, paged optimizers and safe adapter merging.

    LLM Customisation & Model Adaptation Corporate
    Live Course
    5 modules
    View
  • Instruction Tuning: Following Complex Instructions, Schemas and Domain Constraints

    Course on designing and running instruction tuning so models reliably follow complex system prompts, strict JSON/schema constraints, corporate tone and refusal boundaries.

    LLM Customisation & Model Adaptation Corporate
    Live Course
    5 modules
    View
  • Preference Optimization: DPO, ORPO, KTO and LLM Alignment

    Advanced course on post-SFT alignment using DPO, IPO, KTO, ORPO and SimPO: building chosen/rejected preference datasets, tuning beta and KL constraints, and avoiding length bias and reward hacking.

    LLM Customisation & Model Adaptation Corporate
    Live Course
    5 modules
    View

Get in touch