Skip to content
Cognitecta

Training / Models & Machine Learning

Advanced · 2 days

Fine-Tuning Language Models

A two-day course for ML engineers and experienced AI developers: when to adapt a model, how to do it with parameter-efficient methods, and how to evaluate and deploy the result.

2 days · Advanced · Models & Machine Learning · ML engineers and experienced AI developers

Talk to us

Overview

Fine-tuning is often proposed when the real problem is retrieval, prompting, or data that should never enter a model. It is also under-used where a model must acquire a style, a schema, or a behaviour that prompting cannot hold. This course teaches the distinction, then the practice.

You cover dataset construction, cleaning, supervised fine-tuning, LoRA, QLoRA and other parameter-efficient methods. Training configuration, GPUs, quantisation, evaluation, overfitting, safety and deployment are treated as operational work. RAG versus fine-tuning is kept in view throughout.

The course includes a practical fine-tuning exercise. You run a parameter-efficient adaptation, evaluate it against a held-out set, and discuss whether the result is worth the operational cost compared with retrieval or a better application design.

The aim is a team that can fine-tune when it is justified, and refuse it when it is not.

Audience

ML engineers and experienced AI developers responsible for model adaptation, evaluation and deployment.

Prerequisites

Comfortable with Python, training loops at a basic level, and LLM application design. GPU access is required for the labs. The RAG course is useful context but not mandatory.

Duration

2 days

Can be focused on your organisation’s base model and data, including safety and deployment constraints.

Learning outcomes

  1. 01

    Decide when fine-tuning is appropriate compared with prompting, RAG or conventional software.

  2. 02

    Construct and clean a dataset that matches the behaviour being trained.

  3. 03

    Implement supervised fine-tuning with LoRA or QLoRA and explain the trade-offs.

  4. 04

    Configure training, quantisation and GPU use with an eye on cost and overfitting.

  5. 05

    Evaluate adapted models against held-out tasks, safety cases and the base model.

  6. 06

    Plan deployment, versioning and rollback for an adapted model.

  7. 07

    Account for operational and safety implications of changing model behaviour.

Outline

  1. 01

    Whether to fine-tune

    • What fine-tuning can change: style, format, specialised language, and some behaviours.
    • What it cannot replace: current facts, permissions, and tools.
    • RAG versus fine-tuning versus both.
    • Exercise: classify a set of requests as prompt, retrieve, fine-tune, or do not use a model.
  2. 02

    Data and methods

    • Datasets, labelling, cleaning and the damage done by noisy instruction data.
    • Supervised fine-tuning, preference methods at a practical level, and what the course will not over-claim.
    • LoRA, QLoRA and parameter-efficient fine-tuning.
    • Lab: prepare a small, honest dataset.
  3. 03

    Training and evaluation

    • Training configuration, batching, learning rates and overfitting.
    • GPUs, quantisation and what VRAM actually constrains.
    • Evaluation against the base model: task, safety, and regressions.
    • Lab: run a LoRA or QLoRA job and evaluate it.
  4. 04

    Deployment and operations

    • Serving an adapted model, versioning, and not losing the base model as a fallback.
    • Safety: new behaviours, prompt injection surface, and data that should not have been trained in.
    • Operational cost versus API models and retrieval.
    • Lab: package the adapter, record the evaluation, and write the go/no-go note.

Practical work

You prepare a dataset, run a parameter-efficient fine-tune, evaluate against a held-out set and the base model, and produce a deployment note. The exercise is sized to finish during the course; it is not an attempt to beat a frontier model.

Takeaways

  • A trained adapter and evaluation report
  • Dataset and training configuration templates
  • A RAG versus fine-tuning decision guide
  • Deployment, versioning and safety notes

Delivery

Cognitecta delivers private corporate training, on-site or as remote live training. Courses can be run as published, or adapted to your organisation’s stack, domain and experience level.

Instructor

Nicholas Johnson, AI architect and software engineer. He has a degree in Artificial Intelligence and around twenty years of professional technology training, including hundreds of courses for engineering teams and large organisations. About.

Related courses

  1. 2 days · Advanced

    Transformers from First Principles

    A two-day course for technically strong practitioners: build a usable understanding of transformer models by implementing simplified components, without unnecessary mathematical formalism.

  2. 2–3 days · Advanced

    Training Your Own Language Model

    A two-to-three-day course for advanced developers and ML engineers: build and train a small language model in order to understand the process, not to compete with frontier systems.

  3. 1 day · Intermediate

    Running LLMs Locally

    A one-day practical course on local and private inference: model formats, hardware, quantisation, engines, benchmarking and the privacy and cost reasons to run models yourself.

Talk to us