Course: Course 3 — LLM Fine-Tuning Masterclass
Module: FT08 — LoRA & QLoRA
Duration: ~45 minutes (spoken at ~140 wpm)
Format: Verbatim transcript with [SLIDE N] cues. Read aloud or use as speaker notes.
[SLIDE 1 — Title]
Welcome to module FT zero-eight, LoRA and QLoRA. This is the first module of Pillar Two, PEFT — Parameter-Efficient Fine-Tuning. And it is the module where you do your first real fine-tune. Everything before this was preparation: the steering stack, the VRAM math, the data formats, the tokenizers. Now we build the adapter — the lightweight, swappable steer that sits on top of a frozen base — and you will train one yourself by the end.
The FT zero-zero thesis was that fine-tuning steers behavior; it does not teach knowledge. This module is where that thesis becomes operational. If fine-tuning were injecting knowledge, you would need to update large fractions of the weights — high rank, or full fine-tuning. But steering is a low-rank operation. A tiny adapter — often under one percent of the parameters — is enough. That adapter is LoRA. QLoRA is the trick that makes the base itself cheap, so the whole thing fits on a consumer GPU.
[SLIDE 2 — The LoRA mechanism: W = W0 + BA]
The one equation. LoRA — Low-Rank Adaptation, Hu et al twenty twenty-one — rewrites a frozen weight update as the sum of two small matrices. W equals W-zero plus B times A. W-zero is the pretrained weight, frozen, no gradient flows into it. A is a small trainable matrix, initialized random. B is a small trainable matrix, initialized to zero. Their product, B times A, is the low-rank update we add to the frozen base.
The detail that matters most: B starts at zero. So at step zero, B times A is zero. The adapter contributes nothing. The model behaves exactly like the base. This makes LoRA a residual steer — it begins as the identity and learns a perturbation on top. You cannot accidentally make the model worse than the base in the first few steps. Full fine-tuning has no such guarantee.
The dimensional collapse: a full weight update for a forty-ninety-six by forty-ninety-six layer lives in sixteen-point-seven-million numbers. The LoRA update at rank eight lives in sixty-five thousand — a two-hundred-fifty-six-times reduction. Multiply that across every layer and you get adapters under one percent of the model. The forward pass is base output plus adapter output. The backward pass updates only A and B. The base never moves.
[SLIDE 3 — Why this works: the intrinsic dimension]
LoRA is not a hack. It rests on the intrinsic dimension hypothesis — Aghajanyan et al, twenty twenty, arXiv two-zero-zero-seven-point-zero-seven-seven-eight-four. Aghajanyan showed that the useful changes during fine-tuning live in a low-rank subspace of the full parameter space. You can fine-tune RoBERTa to within ninety percent of full-FT performance by training only half a percent of its parameters, because the effective dimension of the optimization is tiny.
This is the same fact the FT zero-zero thesis rests on. Fine-tuning steers behavior; it does not teach knowledge. If you were injecting knowledge, you would need high rank. But you are redirecting probability mass the base already has, and that redirection is low-rank. Steering is low-rank; that is why a one-percent adapter can match full fine-tuning on steering tasks. The twenty twenty-four Shuttleworth finding — that LoRA and full FT produce structurally different weight matrices — is exactly what you would expect. LoRA finds a low-rank steering solution; full FT finds a different, higher-rank solution. They reach similar behavior through different geometry. They are not approximations of each other.
[SLIDE 4 — The LoRA config: four knobs]
Every LoRA adapter is specified by four parameters. Get them right and it works. Get them wrong and you underfit, overfit, or pay full-FT memory for LoRA quality.
Knob one: rank, r. The number of directions of change the adapter can express. Eight is the historical default, still fine for narrow tasks. Sixteen to thirty-two is the modern default for most SFT. Sixty-four and above is for complex multi-task steering — watch VRAM and overfitting. The rule: start at sixteen, escalate only with evidence.
Knob two: alpha, the scaling. The adapter contribution is scaled by alpha-over-r before being added to the base. The convention — a strong one — is alpha approximately two times r. R-equals-eight gets alpha sixteen; r-equals-sixteen gets alpha thirty-two. This keeps the adapter's effective magnitude stable across rank, so you do not retune the learning rate. Too-low alpha: the base dominates, the steer is inaudible. Too-high alpha: the adapter overpowers the base, catastrophic forgetting.
Knob three — the biggest quality lever — target modules. The original twenty twenty-one LoRA paper targeted attention only, typically q-proj and v-proj. Cheap, weaker. The modern twenty twenty-four-plus default is ALL attention plus ALL MLP projections — q, k, v, o-proj, plus gate, up, down-proj. Seven modules. Stronger, more reliable. The reason: behavior steering does not live only in attention. The MLP layers store and transform features; steering a persona or a format touches the feed-forward pathway too. Empirically, all-linear at moderate rank beats attention-only at high rank for similar param counts. Use all-linear unless you have a specific reason.
Knob four: dropout. Regularization on the adapter. Zero-point-zero-five for SFT. Higher for smaller datasets and higher ranks. The safe default.
[SLIDE 5 — The PEFT config, made concrete]
Here is a complete, production-quality LoRA config. LoraConfig: r equals sixteen, lora-alpha equals thirty-two, target-modules is the list of seven — q, k, v, o, gate, up, down — lora-dropout zero-point-zero-five, bias none, task-type causal-LM. That is the starting point. Memorize it.
[SLIDE 6 — QLoRA: three innovations]
LoRA made adapters cheap. QLoRA — Dettmers et al, twenty twenty-three, arXiv two-three-zero-five-point-one-four-three-one-four — made the BASE cheap, by freezing it at four-bit. The problem QLoRA solves: plain LoRA keeps the base at sixteen-bit, so a seven-B model is fourteen gigabytes of weights alone before any training overhead. That fits an A-hundred but not a consumer twenty-four-gigabyte card. QLoRA freezes the base at four-bit — three-point-five gigs — and trains LoRA adapters on top in sixteen-bit. Three innovations make this work without quality loss.
Innovation one: NF4, NormalFloat four-bit. Standard four-bit quantization divides the value range into sixteen equal bins. But neural-network weights are not uniform — they are approximately Gaussian, bell-shaped, most near zero, few in the tails. NF4 chooses its sixteen quantile bins to match the normal distribution: more bins near zero where weights cluster, fewer in the tails. This is information-theoretically optimal for normally-distributed weights. Four-bit storage with quality closer to what you would expect from six or eight-bit uniform.
Innovation two: double quantization. When you quantize a tensor to four-bit, you store scaling constants — one per block of about sixty-four weights — in thirty-two-bit float, to dequantize on the fly. For a seven-B model those constants add up to roughly zero-point-three-seven bits per parameter of overhead. Double quantization quantizes the constants themselves to eight-bit. Saves about zero-point-three gigs. Small, but on a twenty-four-gig card fighting for every gig, it is the difference between fitting and OOMing. No quality cost, always on.
Innovation three: paged optimizers. The sneakiest killer in fine-tuning is not steady-state memory. It is the spike. When the optimizer checkpoints its state to CPU, there is a momentary memory spike that can exceed steady-state by several gigs. On a card sized to steady-state, this spike triggers OOM and kills the job partway through. QLoRA uses NVIDIA Unified Memory to page optimizer states to CPU automatically when these spikes occur. Paged out under pressure, paged back in when needed. This is why QLoRA runs reliably on a card that barely fits.
All three are necessary. Drop any one and the method degrades. They compose: NF4 shrinks the base, double quant trims the overhead, paged optimizers absorb the spikes. Together they put seven-B fine-tuning on a fifteen-hundred-dollar card.
[SLIDE 7 — The VRAM math, made concrete]
This is FT zero-one applied to QLoRA. For a seven-B QLoRA at four-K context: the four-bit base is about three-point-five gigs. The double-quantized constants are about zero-point-one-six gigs. The LoRA adapter at r-equals-sixteen, all-linear, is about zero-point-four gigs. Activations at four-K context, batch one, gradient checkpointing, FlashAttention, are about four to seven gigs. CUDA context and fragmentation, one to two gigs. Total: about ten to fourteen gigs. That is why a seven-B QLoRA fits on a twenty-four-gig RTX forty-ninety. Compare to the same seven-B at LoRA-sixteen-bit — eighteen to thirty gigs, needs an A-hundred — or full fine-tuning, one-hundred to one-sixty gigs, needs multi-A-hundred. The spread between QLoRA and full FT is roughly ten-times. Almost no steering task justifies paying it.
[SLIDE 8 — The full QLoRA workflow]
Five steps. This is the loop you will run for nearly every steering task for the rest of the course.
One: load the base in four-bit. BitsAndBytesConfig, load-in-four-bit true, quant-type NF4, double-quant true, compute-dtype b-float-sixteen. Two: prepare the model for k-bit training — the step everyone forgets. It enables gradient checkpointing and prepares the frozen base for adapter attachment. Do not skip it. Three: attach the adapters. Get-peft-model, model, lora-config. Print trainable parameters — you should see under one percent. Four: train the adapters only. The optimizer touches only A and B; the four-bit base never moves. Standard SFTTrainer from TRL, or a manual loop. Five: merge or save. The choice matters.
[SLIDE 9 — Merge vs keep the adapter]
You have a trained adapter. Now a deployment choice.
Merge into the base: call merge-and-unload. This computes W-zero equals W-zero plus alpha-over-r times B-A for every adapter, producing a single self-contained model with no adapter runtime overhead. Best for deployment — one artifact, fast inference, can be re-quantized to GGUF or AWQ. The adapter is baked in. One caveat: on a four-bit base, the merge dequantizes, so the merged model is larger than the four-bit base you trained on. For production you re-quantize afterward. Merge, then re-quantize. That is the standard Layer Two to Layer Four path.
Keep the adapter separate: save just the adapter weights — adapter-model safetensors, often under a hundred megabytes. At inference, load the base plus PeftModel dot from-pretrained. Best for hot-swapping — one base, many adapters. A JSON adapter, a pirate-speak adapter, a persona adapter. Swap at runtime like loading a config file. The default for experimentation and multi-tenant serving.
The default for production deployment is merge. The default for experimentation and multi-tenant serving is keep separate. Module FT nine covers advanced merging; FT nineteen covers re-quantizing.
[SLIDE 10 — Attention-only vs all-linear]
A closer look at the biggest quality lever. Two teams, same trainable-param count. Team A uses r-equals-sixteen, all-linear — seven modules. Team B uses r-equals-fifty-six, attention-only — two modules. Both report similar loss. Team A's model generalizes better on unseen prompts. Why?
Because capacity distribution matters more than total param count. All-linear distributes capacity across attention AND the MLP feature pathway, where behavior steering actually lives. Attention-only concentrates capacity in attention alone, missing the MLP features. Team B compensates with higher rank but still misses the MLP modules — worse generalization at the same param budget. This is the empirical basis for the all-linear modern default. Attention-only is the cheap-and-weak setting from twenty twenty-one, not the modern one. Use all-linear.
[SLIDE 11 — Anti-patterns]
The anti-patterns to avoid.
Attention-only targeting on a modern model. Using q and v-proj because the twenty twenty-one paper did. Leaves quality on the table. Use all-linear.
Too-low rank — underfit. R-equals-two or four on a task that needs expressivity. The adapter cannot represent the change; loss plateaus high; the style never quite lands. Fix: raise r to sixteen.
Too-high rank — overfit and memory. R-equals-one-twenty-eight to be safe. You overfit the small dataset and approach full-FT memory for LoRA's structural limitations. The Shuttleworth finding says LoRA and full FT find different solutions — so paying full-FT cost for LoRA geometry is the worst of both. Start at sixteen.
Alpha poorly tuned. Alpha divorced from rank — the adapter speaks too quietly, or too loudly. Keep alpha approximately two times r.
Forgetting prepare-model-for-k-bit-training. One line, easy to forget, always include it.
And the worst framing: treating QLoRA as inferior by default. For steering tasks, QLoRA is not the compromise — it is the correct tool. Full FT is the exception, justified by specific evidence, not the starting point.
[SLIDE 12 — The lab]
The lab is called First Fine-Tune. You will QLoRA-fine-tune a one-point-five-B base — Qwen two-point-five one-point-five-B Instruct is the default, MiniCPM or Llama three-point-two one-B as fallbacks — on five hundred style-steering examples. We steer it to be a terse, contrarian pirate. A pure steering task: the base already knows pirate vocabulary; we make it reliable and in-format.
The full loop, in under thirty minutes on a consumer GPU or a free Colab T-four. Load the base in four-bit, prepare it, attach the LoRA adapter, train three epochs, merge, run inference. The moment of truth: ask the merged model a question the training set never contained, and watch it reply in pirate. Then load the un-steered base with the same prompt and watch it be polite and helpful. The difference between those two outputs is your adapter. That gap is what zero-point-six percent of the parameters bought you.
The stretch goals: a rank sweep to find your knee, attention-only versus all-linear to feel the quality lever, an alpha mismatch to see the convention's reason, an Apple Silicon fallback for those without CUDA, and exporting the merged model to GGUF — the full Layer Two to Layer Four path.
[SLIDE 13 — What you can now do]
You can now state the LoRA mechanism — W equals W-zero plus B-A — and connect it to the intrinsic dimension hypothesis and the FT zero-zero thesis. You can configure a LoRA adapter from its four knobs — rank, alpha, target modules, dropout — using the modern all-linear default. You can name QLoRA's three innovations — NF4, double quantization, paged optimizers — and say why each is necessary. You can derive why seven-B QLoRA fits a twenty-four-gig card from the FT zero-one VRAM math. And you can execute the full workflow — load four-bit, prepare, attach, train, merge or save — and choose between merge and hot-swap.
Pillar Two continues with FT nine — DoRA, rsLoRA, and modern PEFT — which closes more of the gap between LoRA and full fine-tuning. Then FT ten, the full-FT-versus-PEFT decision, and FT eleven, the training loop. You have built the steering wheel and verified the tokens; now you have built the steer itself. Let's make it better.
End of module FT zero-eight. Duration: approximately forty-five minutes at one-hundred-forty words per minute.
# Teaching Script — Module FT08: LoRA & QLoRA **Course**: Course 3 — LLM Fine-Tuning Masterclass **Module**: FT08 — LoRA & QLoRA **Duration**: ~45 minutes (spoken at ~140 wpm) **Format**: Verbatim transcript with `[SLIDE N]` cues. Read aloud or use as speaker notes. --- [SLIDE 1 — Title] Welcome to module FT zero-eight, LoRA and QLoRA. This is the first module of Pillar Two, PEFT — Parameter-Efficient Fine-Tuning. And it is the module where you do your first real fine-tune. Everything before this was preparation: the steering stack, the VRAM math, the data formats, the tokenizers. Now we build the adapter — the lightweight, swappable steer that sits on top of a frozen base — and you will train one yourself by the end. The FT zero-zero thesis was that fine-tuning steers behavior; it does not teach knowledge. This module is where that thesis becomes operational. If fine-tuning were injecting knowledge, you would need to update large fractions of the weights — high rank, or full fine-tuning. But steering is a low-rank operation. A tiny adapter — often under one percent of the parameters — is enough. That adapter is LoRA. QLoRA is the trick that makes the base itself cheap, so the whole thing fits on a consumer GPU. [SLIDE 2 — The LoRA mechanism: W = W0 + BA] The one equation. LoRA — Low-Rank Adaptation, Hu et al twenty twenty-one — rewrites a frozen weight update as the sum of two small matrices. W equals W-zero plus B times A. W-zero is the pretrained weight, frozen, no gradient flows into it. A is a small trainable matrix, initialized random. B is a small trainable matrix, initialized to zero. Their product, B times A, is the low-rank update we add to the frozen base. The detail that matters most: B starts at zero. So at step zero, B times A is zero. The adapter contributes nothing. The model behaves exactly like the base. This makes LoRA a residual steer — it begins as the identity and learns a perturbation on top. You cannot accidentally make the model worse than the base in the first few steps. Full fine-tuning has no such guarantee. The dimensional collapse: a full weight update for a forty-ninety-six by forty-ninety-six layer lives in sixteen-point-seven-million numbers. The LoRA update at rank eight lives in sixty-five thousand — a two-hundred-fifty-six-times reduction. Multiply that across every layer and you get adapters under one percent of the model. The forward pass is base output plus adapter output. The backward pass updates only A and B. The base never moves. [SLIDE 3 — Why this works: the intrinsic dimension] LoRA is not a hack. It rests on the intrinsic dimension hypothesis — Aghajanyan et al, twenty twenty, arXiv two-zero-zero-seven-point-zero-seven-seven-eight-four. Aghajanyan showed that the useful changes during fine-tuning live in a low-rank subspace of the full parameter space. You can fine-tune RoBERTa to within ninety percent of full-FT performance by training only half a percent of its parameters, because the effective dimension of the optimization is tiny. This is the same fact the FT zero-zero thesis rests on. Fine-tuning steers behavior; it does not teach knowledge. If you were injecting knowledge, you would need high rank. But you are redirecting probability mass the base already has, and that redirection is low-rank. Steering is low-rank; that is why a one-percent adapter can match full fine-tuning on steering tasks. The twenty twenty-four Shuttleworth finding — that LoRA and full FT produce structurally different weight matrices — is exactly what you would expect. LoRA finds a low-rank steering solution; full FT finds a different, higher-rank solution. They reach similar behavior through different geometry. They are not approximations of each other. [SLIDE 4 — The LoRA config: four knobs] Every LoRA adapter is specified by four parameters. Get them right and it works. Get them wrong and you underfit, overfit, or pay full-FT memory for LoRA quality. Knob one: rank, r. The number of directions of change the adapter can express. Eight is the historical default, still fine for narrow tasks. Sixteen to thirty-two is the modern default for most SFT. Sixty-four and above is for complex multi-task steering — watch VRAM and overfitting. The rule: start at sixteen, escalate only with evidence. Knob two: alpha, the scaling. The adapter contribution is scaled by alpha-over-r before being added to the base. The convention — a strong one — is alpha approximately two times r. R-equals-eight gets alpha sixteen; r-equals-sixteen gets alpha thirty-two. This keeps the adapter's effective magnitude stable across rank, so you do not retune the learning rate. Too-low alpha: the base dominates, the steer is inaudible. Too-high alpha: the adapter overpowers the base, catastrophic forgetting. Knob three — the biggest quality lever — target modules. The original twenty twenty-one LoRA paper targeted attention only, typically q-proj and v-proj. Cheap, weaker. The modern twenty twenty-four-plus default is ALL attention plus ALL MLP projections — q, k, v, o-proj, plus gate, up, down-proj. Seven modules. Stronger, more reliable. The reason: behavior steering does not live only in attention. The MLP layers store and transform features; steering a persona or a format touches the feed-forward pathway too. Empirically, all-linear at moderate rank beats attention-only at high rank for similar param counts. Use all-linear unless you have a specific reason. Knob four: dropout. Regularization on the adapter. Zero-point-zero-five for SFT. Higher for smaller datasets and higher ranks. The safe default. [SLIDE 5 — The PEFT config, made concrete] Here is a complete, production-quality LoRA config. LoraConfig: r equals sixteen, lora-alpha equals thirty-two, target-modules is the list of seven — q, k, v, o, gate, up, down — lora-dropout zero-point-zero-five, bias none, task-type causal-LM. That is the starting point. Memorize it. [SLIDE 6 — QLoRA: three innovations] LoRA made adapters cheap. QLoRA — Dettmers et al, twenty twenty-three, arXiv two-three-zero-five-point-one-four-three-one-four — made the BASE cheap, by freezing it at four-bit. The problem QLoRA solves: plain LoRA keeps the base at sixteen-bit, so a seven-B model is fourteen gigabytes of weights alone before any training overhead. That fits an A-hundred but not a consumer twenty-four-gigabyte card. QLoRA freezes the base at four-bit — three-point-five gigs — and trains LoRA adapters on top in sixteen-bit. Three innovations make this work without quality loss. Innovation one: NF4, NormalFloat four-bit. Standard four-bit quantization divides the value range into sixteen equal bins. But neural-network weights are not uniform — they are approximately Gaussian, bell-shaped, most near zero, few in the tails. NF4 chooses its sixteen quantile bins to match the normal distribution: more bins near zero where weights cluster, fewer in the tails. This is information-theoretically optimal for normally-distributed weights. Four-bit storage with quality closer to what you would expect from six or eight-bit uniform. Innovation two: double quantization. When you quantize a tensor to four-bit, you store scaling constants — one per block of about sixty-four weights — in thirty-two-bit float, to dequantize on the fly. For a seven-B model those constants add up to roughly zero-point-three-seven bits per parameter of overhead. Double quantization quantizes the constants themselves to eight-bit. Saves about zero-point-three gigs. Small, but on a twenty-four-gig card fighting for every gig, it is the difference between fitting and OOMing. No quality cost, always on. Innovation three: paged optimizers. The sneakiest killer in fine-tuning is not steady-state memory. It is the spike. When the optimizer checkpoints its state to CPU, there is a momentary memory spike that can exceed steady-state by several gigs. On a card sized to steady-state, this spike triggers OOM and kills the job partway through. QLoRA uses NVIDIA Unified Memory to page optimizer states to CPU automatically when these spikes occur. Paged out under pressure, paged back in when needed. This is why QLoRA runs reliably on a card that barely fits. All three are necessary. Drop any one and the method degrades. They compose: NF4 shrinks the base, double quant trims the overhead, paged optimizers absorb the spikes. Together they put seven-B fine-tuning on a fifteen-hundred-dollar card. [SLIDE 7 — The VRAM math, made concrete] This is FT zero-one applied to QLoRA. For a seven-B QLoRA at four-K context: the four-bit base is about three-point-five gigs. The double-quantized constants are about zero-point-one-six gigs. The LoRA adapter at r-equals-sixteen, all-linear, is about zero-point-four gigs. Activations at four-K context, batch one, gradient checkpointing, FlashAttention, are about four to seven gigs. CUDA context and fragmentation, one to two gigs. Total: about ten to fourteen gigs. That is why a seven-B QLoRA fits on a twenty-four-gig RTX forty-ninety. Compare to the same seven-B at LoRA-sixteen-bit — eighteen to thirty gigs, needs an A-hundred — or full fine-tuning, one-hundred to one-sixty gigs, needs multi-A-hundred. The spread between QLoRA and full FT is roughly ten-times. Almost no steering task justifies paying it. [SLIDE 8 — The full QLoRA workflow] Five steps. This is the loop you will run for nearly every steering task for the rest of the course. One: load the base in four-bit. BitsAndBytesConfig, load-in-four-bit true, quant-type NF4, double-quant true, compute-dtype b-float-sixteen. Two: prepare the model for k-bit training — the step everyone forgets. It enables gradient checkpointing and prepares the frozen base for adapter attachment. Do not skip it. Three: attach the adapters. Get-peft-model, model, lora-config. Print trainable parameters — you should see under one percent. Four: train the adapters only. The optimizer touches only A and B; the four-bit base never moves. Standard SFTTrainer from TRL, or a manual loop. Five: merge or save. The choice matters. [SLIDE 9 — Merge vs keep the adapter] You have a trained adapter. Now a deployment choice. Merge into the base: call merge-and-unload. This computes W-zero equals W-zero plus alpha-over-r times B-A for every adapter, producing a single self-contained model with no adapter runtime overhead. Best for deployment — one artifact, fast inference, can be re-quantized to GGUF or AWQ. The adapter is baked in. One caveat: on a four-bit base, the merge dequantizes, so the merged model is larger than the four-bit base you trained on. For production you re-quantize afterward. Merge, then re-quantize. That is the standard Layer Two to Layer Four path. Keep the adapter separate: save just the adapter weights — adapter-model safetensors, often under a hundred megabytes. At inference, load the base plus PeftModel dot from-pretrained. Best for hot-swapping — one base, many adapters. A JSON adapter, a pirate-speak adapter, a persona adapter. Swap at runtime like loading a config file. The default for experimentation and multi-tenant serving. The default for production deployment is merge. The default for experimentation and multi-tenant serving is keep separate. Module FT nine covers advanced merging; FT nineteen covers re-quantizing. [SLIDE 10 — Attention-only vs all-linear] A closer look at the biggest quality lever. Two teams, same trainable-param count. Team A uses r-equals-sixteen, all-linear — seven modules. Team B uses r-equals-fifty-six, attention-only — two modules. Both report similar loss. Team A's model generalizes better on unseen prompts. Why? Because capacity distribution matters more than total param count. All-linear distributes capacity across attention AND the MLP feature pathway, where behavior steering actually lives. Attention-only concentrates capacity in attention alone, missing the MLP features. Team B compensates with higher rank but still misses the MLP modules — worse generalization at the same param budget. This is the empirical basis for the all-linear modern default. Attention-only is the cheap-and-weak setting from twenty twenty-one, not the modern one. Use all-linear. [SLIDE 11 — Anti-patterns] The anti-patterns to avoid. Attention-only targeting on a modern model. Using q and v-proj because the twenty twenty-one paper did. Leaves quality on the table. Use all-linear. Too-low rank — underfit. R-equals-two or four on a task that needs expressivity. The adapter cannot represent the change; loss plateaus high; the style never quite lands. Fix: raise r to sixteen. Too-high rank — overfit and memory. R-equals-one-twenty-eight to be safe. You overfit the small dataset and approach full-FT memory for LoRA's structural limitations. The Shuttleworth finding says LoRA and full FT find different solutions — so paying full-FT cost for LoRA geometry is the worst of both. Start at sixteen. Alpha poorly tuned. Alpha divorced from rank — the adapter speaks too quietly, or too loudly. Keep alpha approximately two times r. Forgetting prepare-model-for-k-bit-training. One line, easy to forget, always include it. And the worst framing: treating QLoRA as inferior by default. For steering tasks, QLoRA is not the compromise — it is the correct tool. Full FT is the exception, justified by specific evidence, not the starting point. [SLIDE 12 — The lab] The lab is called First Fine-Tune. You will QLoRA-fine-tune a one-point-five-B base — Qwen two-point-five one-point-five-B Instruct is the default, MiniCPM or Llama three-point-two one-B as fallbacks — on five hundred style-steering examples. We steer it to be a terse, contrarian pirate. A pure steering task: the base already knows pirate vocabulary; we make it reliable and in-format. The full loop, in under thirty minutes on a consumer GPU or a free Colab T-four. Load the base in four-bit, prepare it, attach the LoRA adapter, train three epochs, merge, run inference. The moment of truth: ask the merged model a question the training set never contained, and watch it reply in pirate. Then load the un-steered base with the same prompt and watch it be polite and helpful. The difference between those two outputs is your adapter. That gap is what zero-point-six percent of the parameters bought you. The stretch goals: a rank sweep to find your knee, attention-only versus all-linear to feel the quality lever, an alpha mismatch to see the convention's reason, an Apple Silicon fallback for those without CUDA, and exporting the merged model to GGUF — the full Layer Two to Layer Four path. [SLIDE 13 — What you can now do] You can now state the LoRA mechanism — W equals W-zero plus B-A — and connect it to the intrinsic dimension hypothesis and the FT zero-zero thesis. You can configure a LoRA adapter from its four knobs — rank, alpha, target modules, dropout — using the modern all-linear default. You can name QLoRA's three innovations — NF4, double quantization, paged optimizers — and say why each is necessary. You can derive why seven-B QLoRA fits a twenty-four-gig card from the FT zero-one VRAM math. And you can execute the full workflow — load four-bit, prepare, attach, train, merge or save — and choose between merge and hot-swap. Pillar Two continues with FT nine — DoRA, rsLoRA, and modern PEFT — which closes more of the gap between LoRA and full fine-tuning. Then FT ten, the full-FT-versus-PEFT decision, and FT eleven, the training loop. You have built the steering wheel and verified the tokens; now you have built the steer itself. Let's make it better. --- *End of module FT zero-eight. Duration: approximately forty-five minutes at one-hundred-forty words per minute.*