<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
	<channel>
		<title>Fine Tuning From First Principles on Programmer.ie: Modern AI programming</title>
		<link>http://programmer.ie/books/fine-tuning/</link>
		<description>Recent content in Fine Tuning From First Principles on Programmer.ie: Modern AI programming</description>
		<generator>Hugo</generator>
		<language>en-US</language>
		
		
		
		
			<lastBuildDate>Fri, 20 Nov 2026 00:00:00 +0000</lastBuildDate>
		
			<atom:link href="http://programmer.ie/books/fine-tuning/index.xml" rel="self" type="application/rss+xml" />
			<item>
				<title>What Fine-Tuning Actually Changes</title>
				<link>http://programmer.ie/books/fine-tuning/01-chapter/</link>
				<pubDate>Thu, 12 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/01-chapter/</guid>
				<description>&lt;p&gt;Imagine a support team that wants a model to turn an incident report into a category, a severity and a routing decision. In this scenario, the current model often understands the report but returns an explanation where the downstream system expects a structured record. Sometimes it also chooses yesterday&amp;rsquo;s escalation route. The team proposes fine-tuning it on examples of the desired answers.&lt;/p&gt;&#xA;&lt;p&gt;There are already two different problems in that proposal. Consistently following an output convention is a behavioural requirement. Knowing today&amp;rsquo;s escalation route requires access to the current policy. Training might help the first, while a policy lookup might serve the second more reliably. Neither possibility can be established by successfully running a training script.&lt;/p&gt;</description>
			</item>
			<item>
				<title>When Fine-Tuning Beats Prompting, RAG, Tools or Distillation</title>
				<link>http://programmer.ie/books/fine-tuning/02-chapter/</link>
				<pubDate>Tue, 17 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/02-chapter/</guid>
				<description>&lt;p&gt;A model sends an incident to the wrong team. An engineer collects examples, trains an adapter and observes a lower validation loss. The next policy change arrives, and the system routes the same kind of incident incorrectly again. It is tempting to prescribe more training. The more useful question is whether the model was ever given the current routing policy.&lt;/p&gt;&#xA;&lt;p&gt;This is a hypothetical failure, but the engineering mistake is concrete: an intervention can optimise a component that does not own the missing information. A training run may execute correctly while leaving the application&amp;rsquo;s actual problem untouched. Chapter 01, &lt;strong&gt;What Fine-Tuning Actually Changes&lt;/strong&gt;, showed that an update changes a permitted numerical transformation. It did not show that changing that transformation is the right way to repair an application.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Write the Task Contract Before Training</title>
				<link>http://programmer.ie/books/fine-tuning/03-chapter/</link>
				<pubDate>Tue, 17 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/03-chapter/</guid>
				<description>&lt;p&gt;“Make the model better at routing incidents” sounds like a requirement until two engineers try to implement it. One counts valid JSON. Another counts correct categories. A third considers a response successful if it sends the incident somewhere plausible. After training, each can report an improvement while disagreeing about whether the system should be used.&lt;/p&gt;&#xA;&lt;p&gt;The problem is not initially an optimiser problem. The team has not defined the event it wants to improve. Does an abstention count as a safe outcome or an unresolved incident? Does a correct category compensate for an obsolete route? Which policy revision determines the expected action? Without answers, a measurement can change meaning while retaining the same name.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Budget the Adaptation</title>
				<link>http://programmer.ie/books/fine-tuning/04-chapter/</link>
				<pubDate>Tue, 17 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/04-chapter/</guid>
				<description>&lt;p&gt;A model&amp;rsquo;s weight file looks comfortably smaller than the GPU&amp;rsquo;s memory capacity. The proposed training run nevertheless fails before its first useful update. Nothing about this is paradoxical. The file counted one representation of the parameters; training required other state, and some of the GPU&amp;rsquo;s memory was already occupied.&lt;/p&gt;&#xA;&lt;p&gt;The opposite mistake is also possible. An engineer adds a universal number of bytes per parameter, concludes that adaptation cannot fit, and never investigates a frozen-base method that maintains training state for a much smaller parameter set. A useful budget needs the right accounting boundary, not merely a pessimistic constant.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Selecting a Starting Checkpoint</title>
				<link>http://programmer.ie/books/fine-tuning/05-chapter/</link>
				<pubDate>Tue, 17 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/05-chapter/</guid>
				<description>&lt;p&gt;Two engineers select the same model family and obtain different results before either trains anything. One starts from a base checkpoint; the other starts from an instruction-tuned checkpoint. Their tokenizers also come from different repository revisions. A framework default adds a reasoning prefix to one prompt. The experiment log calls both systems “the small Qwen model”. That name cannot explain the difference, and it cannot reproduce either experiment.&lt;/p&gt;&#xA;&lt;p&gt;Checkpoint selection begins by making the proposed system identifiable. Chapter 03 supplied the task contract; Chapter 04 supplied a conditional resource ledger. We now need the exact starting parameters, the mechanism that turns text into their inputs, and the evidence supporting their use. Choosing a plausible starting point is possible before a task benchmark exists. Establishing which starting point performs best requires that benchmark.&lt;/p&gt;</description>
			</item>
			<item>
				<title>A Baseline Can Defeat the Fine-Tune</title>
				<link>http://programmer.ie/books/fine-tuning/06-chapter/</link>
				<pubDate>Tue, 17 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/06-chapter/</guid>
				<description>&lt;p&gt;An adapted model routes most tickets correctly. Its training loss fell, its responses look polished, and the team can explain how the adapter was saved. Then someone implements a policy lookup: given a category, read the current routing table. The lookup never needs to relearn a changed team assignment. If classification was already adequate, the expensive adaptation may have solved a problem the system did not have.&lt;/p&gt;&#xA;&lt;p&gt;That outcome would be useful. The purpose of the experiment is to discover which intervention earns its complexity. A fine-tune becomes valuable when it improves a meaningful outcome over relevant alternatives while meeting quality, latency, cost and maintenance constraints. Running an optimiser successfully cannot establish any of those comparisons.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Tokens, Chat Templates and Special Tokens</title>
				<link>http://programmer.ie/books/fine-tuning/07-chapter/</link>
				<pubDate>Tue, 17 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/07-chapter/</guid>
				<description>&lt;p&gt;A training example can contain the right question and the right answer while asking the model to learn the wrong thing. The conversation looks sensible in a text editor. Its tensor of labels nevertheless tells the optimiser to reproduce the user&amp;rsquo;s instructions, ignore the assistant&amp;rsquo;s answer, or continue beyond a missing end marker. Those mistakes occur before we choose a learning rate or an adapter rank.&lt;/p&gt;&#xA;&lt;p&gt;Chapter 05, &lt;strong&gt;Selecting a Starting Checkpoint&lt;/strong&gt;, established the identities of four candidate tokenizers and their templates. We now use those verified artifacts to inspect the numerical interface itself. Our destination is a small batch whose token IDs, padding, target positions and causal alignment can all be checked by hand. We will build an educational tokenizer to expose the mechanism, then inspect the real cached tokenizers without loading a language model.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Next-Token Loss and Teacher Forcing</title>
				<link>http://programmer.ie/books/fine-tuning/08-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/08-chapter/</guid>
				<description>&lt;p&gt;A training run reports a lower loss after a change to its data loader. The model may have become better at predicting the intended answers. The loader may instead have started supervising easy prompt tokens, counted padding as an answer, or divided by a larger denominator. A scalar cannot tell us which event occurred. We need to know the probability being scored, the positions included and the reduction used.&lt;/p&gt;&#xA;&lt;p&gt;Chapter 07 constructed a batch with seven supervised targets. We will consume that same batch, without redefining its token IDs or masks, and calculate exactly what its loss means. The calculation comes before optimisation: at this stage an array of logits is enough. We do not need to train a model to verify the objective it would receive.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Backpropagation Through a Transformer</title>
				<link>http://programmer.ie/books/fine-tuning/09-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/09-chapter/</guid>
				<description>&lt;p&gt;A training script can call &lt;code&gt;backward()&lt;/code&gt; successfully while updating the wrong subset of parameters. It can also produce a zero gradient for a perfectly legitimate reason. The practical task is to distinguish a correct gradient path from a disconnected tensor, a frozen parameter, an unselected target or an unfortunate initialisation. Printing one final loss cannot make those distinctions.&lt;/p&gt;&#xA;&lt;p&gt;We will trace the batch from Chapter 07 through a small causal Transformer and back from Chapter 08&amp;rsquo;s scalar loss. Every major operation is visible. This is a randomly initialised educational model; the work checks derivatives and information flow, not the quality of a pretrained language model.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Optimisers, Learning Rates and Precision</title>
				<link>http://programmer.ie/books/fine-tuning/10-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/10-chapter/</guid>
				<description>&lt;p&gt;A gradient of $-8$ is not a new weight. It is a local sensitivity: increasing the parameter slightly should reduce the current loss. An optimiser must decide how that sensitivity changes the parameter, how previous sensitivities matter, whether to shrink the weight, and when an update should happen. Two scripts can start with the same parameters and gradients yet follow different training paths because those decisions differ.&lt;/p&gt;&#xA;&lt;p&gt;We will derive the updates separately from the Transformer, check their arithmetic against PyTorch, then apply the same rules to the model developed in Chapter 09. The reference calculations use float64 to expose numerical agreement. The shared training experiment uses FP32; a separate bounded CUDA probe investigates selected FP16 operations.&lt;/p&gt;</description>
			</item>
			<item>
				<title>The Memory and Compute Budget</title>
				<link>http://programmer.ie/books/fine-tuning/11-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/11-chapter/</guid>
				<description>&lt;p&gt;A model&amp;rsquo;s parameter arrays occupy less than a megabyte, yet a CUDA measurement reports tens of megabytes allocated. The discrepancy need not indicate a leak. A training step contains gradients, moment estimates, saved forward values and temporary workspace, and the runtime may retain storage for later reuse. To understand a measurement, we must specify both what it counts and where its interval begins.&lt;/p&gt;&#xA;&lt;p&gt;Chapter 04 estimated resource requirements before execution. Here we reuse its arithmetic where the assumptions match and compare it with actual tensors from our shared Transformer. We are measuring runtime mechanisms, not revisiting the financial case for adaptation or certifying that a future language model fits on the same GPU.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Build a Fine-Tune Without a Training Framework</title>
				<link>http://programmer.ie/books/fine-tuning/12-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/12-chapter/</guid>
				<description>&lt;p&gt;A model trained from random weights can demonstrate learning without demonstrating fine-tuning. To observe adaptation, we need an existing learned state, a subsequent change in its training objective or distribution, and a comparison with what would have happened without that change. Saving a randomly initialised model and naming the next loop a fine-tune would miss that distinction.&lt;/p&gt;&#xA;&lt;p&gt;We now assemble the components from Chapters 07–11 into two actual stages. First a small causal Transformer learns a synthetic source rule. Then we reload its saved weights and continue training on a related but conflicting rule. A source-continuation control begins from the same saved weights. The experiment is intentionally tiny enough to inspect completely; it uses no pretrained language-model weights or production incident records.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Dataset Rights, Provenance and Privacy</title>
				<link>http://programmer.ie/books/fine-tuning/13-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/13-chapter/</guid>
				<description>&lt;p&gt;A support team can export its ticket archive in seconds. That technical ability does not answer whether the archive may be used to train a model, sent to a labelling service, retained indefinitely or included in a public dataset. These are different acts, potentially involving different people, purposes and obligations. A permissive answer to one question cannot safely be copied into the other fields.&lt;/p&gt;&#xA;&lt;p&gt;The miniature experiment in &lt;strong&gt;Build a Fine-Tune Without a Training Framework&lt;/strong&gt; avoided this difficulty by constructing a few letter rules. A useful data pipeline must make the assumptions visible. Before asking whether an example improves a model, we need to establish where it came from, which use is proposed, and which evidence supports that use. An impressive loss curve cannot supply missing permission retrospectively.&lt;/p&gt;</description>
			</item>
			<item>
				<title>From Real Tasks to Labelling Schemas</title>
				<link>http://programmer.ie/books/fine-tuning/14-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/14-chapter/</guid>
				<description>&lt;p&gt;Two careful annotators read “The account is inaccessible after a suspicious login.” One chooses access because the user cannot authenticate. The other chooses security because compromise may explain the failure. Both can produce valid JSON. A training system receiving those records will see disagreement about the desired behaviour, not a malformed file that a parser can remove.&lt;/p&gt;&#xA;&lt;p&gt;The first question is what the annotation unit means. Are we assigning one category to the complete incident, marking every issue mentioned, or selecting an operational escalation? These are different tasks. A single-label dataset cannot quietly mix them and then blame the model for uncertainty.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Instruction, Completion and Conversation Datasets</title>
				<link>http://programmer.ie/books/fine-tuning/15-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/15-chapter/</guid>
				<description>&lt;p&gt;A labelled record can be perfectly valid and still be a disastrous training example. Put its answer in the user prompt and the model can learn to copy a supplied label. Omit the policy table and the model must guess which routing revision the annotator used. Duplicate a conversation turn during conversion and the intended response may appear twice. None of these failures requires invalid JSON.&lt;/p&gt;&#xA;&lt;p&gt;The previous chapter established what an answer means. We now decide which information is supplied as context, which text is the desired response, and how those pieces become an ordered sequence. Representation is part of the experimental intervention because a model learns from tokens, not from our intention that two database rows mean the same thing.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Which Tokens Receive Loss?</title>
				<link>http://programmer.ie/books/fine-tuning/16-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/16-chapter/</guid>
				<description>&lt;p&gt;An incident dataset can contain the right answers and still optimise the wrong objective. A collator might supervise the user report, omit the assistant ending, or include a tool&amp;rsquo;s observation as if it were the assistant&amp;rsquo;s desired response. The training loop will happily differentiate the resulting scalar. Nothing in backpropagation knows which behaviour the dataset author meant to teach.&lt;/p&gt;&#xA;&lt;p&gt;&lt;strong&gt;Next-Token Loss and Teacher Forcing&lt;/strong&gt; established the numerical loss. &lt;strong&gt;Instruction, Completion and Conversation Datasets&lt;/strong&gt; established the rendered sequence. The remaining bridge is a versioned decision about which positions become targets. We make that decision inspectable before performing an update.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Deduplication, Splits and Contamination</title>
				<link>http://programmer.ie/books/fine-tuning/17-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/17-chapter/</guid>
				<description>&lt;p&gt;A model answers every test incident correctly. Then we discover that each test example is a capitalised copy of an incident in training. The score was computed correctly; its interpretation was wrong. It measured recognition of previously available content while being presented as performance on unseen cases.&lt;/p&gt;&#xA;&lt;p&gt;Leakage can survive valid schemas, distinct record IDs and different file hashes. It can also occur without a single gradient update: a held-out example may enter a retrieval index, a few-shot prompt, a label lookup or repeated hyperparameter selection. Dataset separation is therefore a property of relationships and permitted uses, rather than a property of directory names.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Synthetic Data, Quality Assurance and Dataset Cards</title>
				<link>http://programmer.ie/books/fine-tuning/18-chapter/</link>
				<pubDate>Wed, 18 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/18-chapter/</guid>
				<description>&lt;p&gt;Every row in a dataset passes its schema. Its category strings are legal, its policy citations are correctly formed and its JSON is well ordered. Yet a retrieval index contains the proposed test records. The dataset must fail its release gate even though no individual row needs repair.&lt;/p&gt;&#xA;&lt;p&gt;That example separates record validity from study validity. A trustworthy data package needs evidence about origins, meanings, relationships, transformations and permitted use. It also needs a way to stop. Reaching the last chapter of data preparation cannot itself authorise a final benchmark freeze.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Set Up a Reproducible Local Training Environment</title>
				<link>http://programmer.ie/books/fine-tuning/19-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/19-chapter/</guid>
				<description>&lt;p&gt;A CUDA matrix multiplication succeeds, the GPU has several gigabytes free, and the&#xA;package installer reports no broken requirements. We still do not know whether a&#xA;particular language model can be loaded safely, whether its tokenizer matches its&#xA;embeddings, or whether adapting it is an authorised experiment. Each observation&#xA;answers a narrower question than the proposed run.&lt;/p&gt;&#xA;&lt;p&gt;Part II made a small Transformer inspectable. This chapter prepares a different&#xA;boundary: a reproducible environment in which a pinned pretrained checkpoint could&#xA;eventually be investigated. The distinction matters because a model introduces&#xA;external weights, architecture-specific kernels, tokenizer assets and additional&#xA;rights and resource requirements. A working educational loop cannot certify those&#xA;dependencies by inheritance.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Choose the Small Model and Measure Baselines</title>
				<link>http://programmer.ie/books/fine-tuning/20-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/20-chapter/</guid>
				<description>&lt;p&gt;Suppose a fine-tuned model classifies six out of ten incidents correctly. That&#xA;sounds promising until a rule reading one permitted metadata field also gets six&#xA;correct. Suppose it then classifies every family-challenge example correctly.&#xA;That sounds stronger until a word-overlap lookup using training examples does&#xA;the same.&lt;/p&gt;&#xA;&lt;p&gt;Neither comparison proves that fine-tuning is useless. They show that the score&#xA;alone does not identify what was learned or whether training was necessary.&#xA;A small local model is attractive because we can inspect it, afford controlled&#xA;experiments and preserve failures. Those advantages disappear if the task or&#xA;baseline protocol rewards a trivial alternative that we never measured.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Supervised Fine-Tuning: A Verified Adapter Path</title>
				<link>http://programmer.ie/books/fine-tuning/21-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/21-chapter/</guid>
				<description>&lt;p&gt;A training loop finishes, the loss declines and an adapter file appears. None of&#xA;those observations proves that the intended answer tokens were trained, that the&#xA;base stayed frozen, or that the adapter can be loaded onto the intended checkpoint.&#xA;The central engineering problem is to preserve those relationships through an&#xA;actual update.&lt;/p&gt;&#xA;&lt;p&gt;Supervised fine-tuning adapts a model using desired continuations. It does not&#xA;require a new language-model loss: the causal objective from Chapter 08 remains.&#xA;What changes is the data distribution, selected target positions and parameters&#xA;allowed to move. A framework can hide those choices behind defaults; it cannot&#xA;remove their consequences.&lt;/p&gt;</description>
			</item>
			<item>
				<title>LoRA From Linear Algebra</title>
				<link>http://programmer.ie/books/fine-tuning/22-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/22-chapter/</guid>
				<description>&lt;p&gt;A dense linear layer contains millions of weights, but a particular adaptation&#xA;may not need an independent change in every direction. Can we restrict the&#xA;update while preserving the original transformation?&lt;/p&gt;&#xA;&lt;p&gt;LoRA answers by learning two factors whose product forms an additive weight&#xA;update. The base matrix remains frozen. The proposal originates in&#xA;&lt;a href=&#34;https://arxiv.org/abs/2106.09685&#34;&gt;Hu and colleagues&amp;rsquo; LoRA paper&lt;/a&gt;. Here we derive&#xA;the layer and its gradients directly, then compare an executable reference with&#xA;the selected PEFT implementation.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Designing a LoRA Experiment</title>
				<link>http://programmer.ie/books/fine-tuning/23-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/23-chapter/</guid>
				<description>&lt;p&gt;One rank-two adapter finishes with a lower loss than a rank-one adapter. Should&#xA;we use rank two? The answer depends on what changed, which loss was measured,&#xA;how the runs were paired and what the experiment was designed to establish.&#xA;A single successful configuration does not answer those questions.&lt;/p&gt;&#xA;&lt;p&gt;LoRA exposes several choices: rank, scaling, target modules, dropout and the&#xA;surrounding optimiser and data protocol. Their interactions make casual&#xA;experimentation easy and interpretation difficult. A useful experiment begins&#xA;with a question small enough that its observations can distinguish plausible&#xA;answers.&lt;/p&gt;</description>
			</item>
			<item>
				<title>QLoRA: Four-Bit Base, Trainable Adapter</title>
				<link>http://programmer.ie/books/fine-tuning/24-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/24-chapter/</guid>
				<description>&lt;p&gt;An adapter has few trainable parameters, but its frozen base can still dominate&#xA;memory. If we store that base more compactly, can the adapter continue to learn?&#xA;Yes, provided the computation and gradient paths are defined correctly. Compact&#xA;storage, numerical precision and trainability are separate properties.&lt;/p&gt;&#xA;&lt;p&gt;QLoRA combines a quantised frozen pretrained base with trainable low-rank&#xA;adapters. The &lt;a href=&#34;https://arxiv.org/abs/2305.14314&#34;&gt;QLoRA paper&lt;/a&gt; describes NF4 storage,&#xA;double quantisation and memory-management choices for that approach. This chapter&#xA;separates those ideas before testing small pieces of the mechanism.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Full, Partial and Parameter-Efficient Fine-Tuning</title>
				<link>http://programmer.ie/books/fine-tuning/25-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/25-chapter/</guid>
				<description>&lt;p&gt;Every fine-tuning run answers a question before the first batch is read: which&#xA;numbers in the model are allowed to change? Updating everything is the most&#xA;general answer. Updating only the output layer, only the token embeddings, one&#xA;Transformer block or a low-rank adapter are narrower answers. Each narrower&#xA;answer saves something, constrains something and changes what a result can&#xA;mean.&lt;/p&gt;&#xA;&lt;p&gt;The usual summary is that parameter-efficient methods are cheaper and full&#xA;fine-tuning is stronger. That is too vague to act on. Cheaper in which memory&#xA;term? Stronger at equal learning rate, equal updates, or equal tuning effort?&#xA;And does a parameter marked trainable actually change during training?&lt;/p&gt;</description>
			</item>
			<item>
				<title>Beyond Conventional LoRA</title>
				<link>http://programmer.ie/books/fine-tuning/26-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/26-chapter/</guid>
				<description>&lt;p&gt;Parameter-efficient fine-tuning libraries offer a menu: LoRA, IA3, DoRA,&#xA;AdaLoRA, prompt tuning, prefix tuning and more. The menu presentation suggests&#xA;that these are interchangeable settings of one idea, to be swept like a learning&#xA;rate. They are not. Each method restricts the adaptation in a different place,&#xA;and the place determines what can be learned, what must be stored, whether the&#xA;result can be merged into the base, and how the method interacts with context&#xA;length and checkpoints.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Continued Pretraining Versus Instruction Tuning</title>
				<link>http://programmer.ie/books/fine-tuning/27-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/27-chapter/</guid>
				<description>&lt;p&gt;&amp;ldquo;We want the model to know our domain.&amp;rdquo; That sentence hides at least three&#xA;different requirements. The model might need to assign high probability to the&#xA;kind of text the domain produces: its vocabulary, its formats, its recurring&#xA;phrases. It might need to map a particular kind of request to a particular kind&#xA;of response. Or it might need to answer with facts that are true &lt;em&gt;today&lt;/em&gt;, such&#xA;as which team currently owns a service.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Hyperparameters, Overfitting and Forgetting</title>
				<link>http://programmer.ie/books/fine-tuning/28-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/28-chapter/</guid>
				<description>&lt;p&gt;A fine-tuning run reports one final number, and that number depends on a dozen&#xA;choices: the peak learning rate, how it rises and falls, how many examples&#xA;contribute to each update, how many times the data is seen, how strongly&#xA;parameters are pulled towards zero, how much dropout perturbs them, when&#xA;training stops and which checkpoint is kept. Change any of these and the final&#xA;number moves. Change several at once and it becomes impossible to say which&#xA;choice moved it.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Scaling Beyond One GPU</title>
				<link>http://programmer.ie/books/fine-tuning/29-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/29-chapter/</guid>
				<description>&lt;p&gt;There are two different reasons to train on more than one device, and they are&#xA;often confused. The first is &lt;em&gt;time&lt;/em&gt;: one device could hold the training state&#xA;but would take too long, so several devices each process part of every batch.&#xA;The second is &lt;em&gt;memory&lt;/em&gt;: one device cannot hold the training state at all, so&#xA;the state itself must be divided. Data parallelism addresses the first.&#xA;Sharding methods such as ZeRO and fully sharded data parallelism address the&#xA;second, at a price paid in communication.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Checkpoints, Reproducibility and Recovery</title>
				<link>http://programmer.ie/books/fine-tuning/30-chapter/</link>
				<pubDate>Thu, 19 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/30-chapter/</guid>
				<description>&lt;p&gt;A training run stops at update 3 of 8. The process was killed, the machine&#xA;rebooted, or the job hit its time limit. The adapter weights from update 3 are&#xA;on disk. Can the run continue as if it had never stopped?&lt;/p&gt;&#xA;&lt;p&gt;Usually the honest answer is &amp;ldquo;not from the weights alone&amp;rdquo;. The next update&#xA;depends on the optimiser&amp;rsquo;s moment estimates, the learning-rate schedule&amp;rsquo;s&#xA;position, the random numbers that will choose dropout masks, the order in which&#xA;the sampler will deliver examples and how far through that order it has got.&#xA;Lose any of these and the continued run is a &lt;em&gt;different&lt;/em&gt; run that happens to&#xA;start from the same weights.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Learning From Comparisons Rather Than Demonstrations</title>
				<link>http://programmer.ie/books/fine-tuning/31-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/31-chapter/</guid>
				<description>&lt;p&gt;Every chapter so far has trained on demonstrations. A prompt arrives with one&#xA;target, and the loss rewards the model for assigning high probability to that&#xA;target, token by token. The demonstration says &lt;em&gt;what to produce&lt;/em&gt;. It says&#xA;nothing about the many outputs it did not show, which of them would have been&#xA;nearly as good, and which would have been harmful.&lt;/p&gt;&#xA;&lt;p&gt;Part VI changes the signal. Instead of one target we record two candidates and&#xA;a judgement that one is better. That judgement carries different information&#xA;from a demonstration. It carries less, because it does not say whether the&#xA;better candidate is any good. It also carries more, because it says something&#xA;about a response the model might actually produce and that a demonstration&#xA;would never have mentioned. Comparisons of this kind became the central&#xA;training signal of preference-based fine-tuning: Christiano and colleagues&#39;&#xA;&lt;a href=&#34;https://arxiv.org/abs/1706.03741&#34;&gt;Deep reinforcement learning from human&#xA;preferences&lt;/a&gt; trained agents from human&#xA;comparisons of short behaviour segments, and Ouyang and colleagues&amp;rsquo; &lt;a href=&#34;https://arxiv.org/abs/2203.02155&#34;&gt;Training&#xA;language models to follow instructions with human&#xA;feedback&lt;/a&gt; had labellers rank a model&amp;rsquo;s&#xA;outputs after an initial round of supervised fine-tuning on demonstrations.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Direct Preference Optimization From First Principles</title>
				<link>http://programmer.ie/books/fine-tuning/32-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/32-chapter/</guid>
				<description>&lt;p&gt;Chapter 31 ended with a set of strict comparisons: for each prompt x, a&#xA;preferred response y_w and a rejected response y_l. The classical way to train&#xA;on them, which Chapter 34 builds in full, has two stages. First fit a reward&#xA;model that scores responses so that preferred ones score higher. Then use&#xA;reinforcement learning to move a policy towards responses the reward model&#xA;likes, while a penalty keeps the policy close to where it started.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Alternatives to DPO</title>
				<link>http://programmer.ie/books/fine-tuning/33-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/33-chapter/</guid>
				<description>&lt;p&gt;Chapter 32&amp;rsquo;s objective made four choices. It scored a response by its &lt;em&gt;summed&lt;/em&gt;&#xA;log probability. It measured the policy&amp;rsquo;s preference &lt;em&gt;relative to a frozen&#xA;reference&lt;/em&gt;. It linked preference to score through the Bradley–Terry logistic&#xA;function. And it consumed &lt;em&gt;pairs&lt;/em&gt;: one preferred and one rejected response for&#xA;the same prompt.&lt;/p&gt;&#xA;&lt;p&gt;Each choice can be made differently, and a family of methods has done so. This&#xA;chapter derives three of them from the choices they change:&lt;/p&gt;</description>
			</item>
			<item>
				<title>Reward Models, PPO and Classical RLHF</title>
				<link>http://programmer.ie/books/fine-tuning/34-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/34-chapter/</guid>
				<description>&lt;p&gt;The methods of Chapters 32 and 33 never write down a reward. They fold &amp;ldquo;which&#xA;response is better&amp;rdquo; directly into the policy&amp;rsquo;s own probabilities. The older&#xA;route, which made instruction-following language models practical, does the&#xA;opposite. It turns comparisons into an explicit scoring function, and then&#xA;trains a policy to pursue high scores.&lt;/p&gt;&#xA;&lt;p&gt;Ouyang and colleagues&amp;rsquo; &lt;a href=&#34;https://arxiv.org/abs/2203.02155&#34;&gt;Training language models to follow instructions with&#xA;human feedback&lt;/a&gt; describes the pipeline that&#xA;became standard: supervised fine-tuning on demonstrations written by labellers,&#xA;a reward model trained on labellers&amp;rsquo; rankings of the supervised model&amp;rsquo;s&#xA;outputs, and reinforcement learning against that reward model. The approach&#xA;builds on Christiano and colleagues&amp;rsquo; &lt;a href=&#34;https://arxiv.org/abs/1706.03741&#34;&gt;Deep reinforcement learning from human&#xA;preferences&lt;/a&gt;, which trained agents from&#xA;human comparisons of short behaviour segments rather than from a hand-written&#xA;reward function.&lt;/p&gt;</description>
			</item>
			<item>
				<title>GRPO and Verifiable-Reward Fine-Tuning</title>
				<link>http://programmer.ie/books/fine-tuning/35-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/35-chapter/</guid>
				<description>&lt;p&gt;PPO, as Chapter 34 built it, needs a value function to turn a reward into an&#xA;advantage. For a language model that value function is usually a second&#xA;network of comparable size, trained alongside the policy, consuming memory and&#xA;compute and adding its own errors. If the value estimate is poor, so is every&#xA;advantage computed from it.&lt;/p&gt;&#xA;&lt;p&gt;There is a cheaper way to ask &amp;ldquo;was this response better than expected?&amp;rdquo; Sample&#xA;several responses to the same prompt, score them all, and compare each one&#xA;with the others. A response that scored above its siblings was better than&#xA;expected &lt;em&gt;for this prompt&lt;/em&gt;; one that scored below was worse. No critic is&#xA;needed.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Safety, Refusals and Reward Hacking</title>
				<link>http://programmer.ie/books/fine-tuning/36-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/36-chapter/</guid>
				<description>&lt;p&gt;Chapter 35&amp;rsquo;s proxy rewarded a string that had nothing to do with the task, and&#xA;nobody would deploy such a reward on purpose. The proxies that cause trouble in&#xA;practice are more respectable. They reward behaviour that is easy to measure&#xA;and that looks, from a distance, like the behaviour wanted. Refusing a request&#xA;is a good example. Refusals are easy to detect, and a model that refuses more&#xA;often will rarely do something it should not. A reward for refusing therefore&#xA;looks like a reward for safety.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Evaluation That Measures the Task</title>
				<link>http://programmer.ie/books/fine-tuning/37-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/37-chapter/</guid>
				<description>&lt;p&gt;Part VI ended with a policy that earned its whole reward while serving none of&#xA;the requests it should have served. Its training loss fell and the number being&#xA;optimised rose. Nothing in either number said that the task had failed. Only an&#xA;evaluation built around the task, with every outcome counted against its own&#xA;denominator, revealed what had happened.&lt;/p&gt;&#xA;&lt;p&gt;Part VII makes that evaluation the subject. Its central question is how we know&#xA;whether an adapted system is genuinely better, how we deliver it, and how we&#xA;recover when something goes wrong. The six chapters follow one small workflow&#xA;through six stages: &lt;strong&gt;measure, compare, challenge, compose, serve and operate.&lt;/strong&gt;&#xA;This first chapter asks the most basic question of the six. What does it mean for&#xA;a model, or a system built around a model, to perform the intended task&#xA;correctly?&lt;/p&gt;</description>
			</item>
			<item>
				<title>Statistical Confidence and Ablation</title>
				<link>http://programmer.ie/books/fine-tuning/38-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/38-chapter/</guid>
				<description>&lt;p&gt;Chapter 37 ended with a difference that is arithmetically certain. On 24 test&#xA;cases, the combined system succeeded on all 24 and the base system on 8. The&#xA;difference is 16/24 and no further computation will change it.&lt;/p&gt;&#xA;&lt;p&gt;The question this chapter asks is different. &lt;strong&gt;How much confidence should we&#xA;place in an observed difference between two systems?&lt;/strong&gt; The arithmetic is exact,&#xA;but the conclusion we want to draw is usually about cases we have not seen. A&#xA;result can be computed correctly and still support no broad statistical&#xA;conclusion at all. The gap between those two things is set by the sampling&#xA;design, the dependence between cases and the number of comparisons made. It also&#xA;depends on what else changed between the two systems.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Generalisation, Shift and Adversarial Tests</title>
				<link>http://programmer.ie/books/fine-tuning/39-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/39-chapter/</guid>
				<description>&lt;p&gt;Chapters 37 and 38 measured systems on one fixed test set and then asked how&#xA;much a difference on that set could be trusted. Both chapters stayed inside a&#xA;single distribution: the same six request patterns, the same policy revision&#xA;and the same input format as the cases the systems were designed around. A&#xA;deployed system does not stay there. Requests arrive phrased differently, in&#xA;different formats, with operations nobody anticipated. The policy changes, and&#xA;some inputs are written by someone trying to make the system misbehave.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Adapter Composition and Model Merging</title>
				<link>http://programmer.ie/books/fine-tuning/40-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/40-chapter/</guid>
				<description>&lt;p&gt;The compatible system that passed every challenge in Chapter 39 was not a single&#xA;adapter. It was two adapters added to one base model. Adapter A was&#xA;constructed to refuse a certain erase, and adapter B to send uncertain or&#xA;unknown requests to review. Neither alone could do the whole task. Together they&#xA;scored 24/24.&lt;/p&gt;&#xA;&lt;p&gt;That outcome invites a general strategy: adapt separately for each capability,&#xA;then combine. It is attractive in practice. Separate adapters can be trained,&#xA;reviewed and replaced independently, and the base model is stored once. This&#xA;chapter asks &lt;strong&gt;whether two adaptations can be combined, and what compatibility&#xA;actually means&lt;/strong&gt;. The answer begins with linear algebra, because for LoRA&#xA;adapters on a linear layer the combination is exact arithmetic on weight&#xA;matrices. It ends with the limits of that arithmetic. Adding two weight deltas is&#xA;always possible. Whether the result keeps both behaviours depends on whether the&#xA;deltas interfere.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Exporting, Serving and Measuring the Result</title>
				<link>http://programmer.ie/books/fine-tuning/41-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/41-chapter/</guid>
				<description>&lt;p&gt;Chapter 40 ended with a composed weight in memory, checked against its unmerged&#xA;form. Nobody can use a tensor that lives in one Python process. To deliver it,&#xA;the model has to be &lt;strong&gt;exported&lt;/strong&gt; to an artifact, &lt;strong&gt;loaded&lt;/strong&gt; somewhere else,&#xA;&lt;strong&gt;identified&lt;/strong&gt; as the same model, placed behind an &lt;strong&gt;interface&lt;/strong&gt; with a strict&#xA;contract, and &lt;strong&gt;measured&lt;/strong&gt; as a running service. Each step can silently change&#xA;what is being served.&lt;/p&gt;&#xA;&lt;p&gt;This chapter asks &lt;strong&gt;what it takes to turn a model artifact into a reproducible&#xA;local service&lt;/strong&gt;. It follows the combined system from Chapter 37 through export,&#xA;reload and a loopback HTTP server. Every served response is compared with the&#xA;library&amp;rsquo;s output for the same request, and the cost of each path is measured. The&#xA;equivalence result is simple: all 24 HTTP responses matched the library exactly.&#xA;The measurements need more care. Each timing figure in this chapter measures a&#xA;different boundary, and comparing two of them without naming the boundaries&#xA;produces a wrong conclusion.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Operating, Auditing and Rolling Back a Fine-Tune</title>
				<link>http://programmer.ie/books/fine-tuning/42-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/42-chapter/</guid>
				<description>&lt;p&gt;Chapter 41 ended with a service that returns exactly the model it was given. The&#xA;artifact is identified, the interface is strict and the responses match the&#xA;library. Every technical precondition for a release is met. None of them answers&#xA;the question this chapter asks: &lt;strong&gt;what distinguishes a technically valid model&#xA;artifact from an authorised and safely operated release?&lt;/strong&gt;&lt;/p&gt;&#xA;&lt;p&gt;The difference is a set of states that are easy to blur together. Someone has to&#xA;decide that the evaluation was adequate, and someone, perhaps someone else, has&#xA;to authorise putting the artifact in front of users. After activation, someone&#xA;has to watch the release and notice when it goes wrong. And someone must be able&#xA;to put the previous version back, then confirm that what came back is really the&#xA;previous version and not only its name. Google&amp;rsquo;s &lt;em&gt;Site Reliability&#xA;Engineering&lt;/em&gt; treats release engineering as a discipline of its own (chapter 8).&#xA;Google&amp;rsquo;s reliability engineers state the corresponding operational rule&#xA;bluntly: there is no good rollout unless a rollback is ready for it.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Multilingual and Multi-Task Adaptation</title>
				<link>http://programmer.ie/books/fine-tuning/43-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/43-chapter/</guid>
				<description>&lt;p&gt;Part VII ended with a release that could be rolled back and an audit trail that&#xA;recorded every step. All of that machinery assumed one task, one population and&#xA;one number that said whether the candidate was better. Real adaptation rarely&#xA;looks like that. A support system answers in several languages. A single adapter&#xA;is asked to handle two policy revisions, or a classification head and a&#xA;generation head at once. The moment there is more than one slice, the summary&#xA;number stops being a single fact and becomes a choice about how to weigh one&#xA;group&amp;rsquo;s success against another&amp;rsquo;s.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Tool Use, Code, Structured Outputs and Agent Data</title>
				<link>http://programmer.ie/books/fine-tuning/44-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/44-chapter/</guid>
				<description>&lt;p&gt;The previous chapter, &amp;ldquo;Multilingual and Multi-Task Adaptation&amp;rdquo;, measured a system&#xA;that produced one structured decision per request. Many fine-tuning projects now&#xA;target something different: a model that emits a sequence of tool calls, reads&#xA;their results and finishes with an answer. Training data for such systems is&#xA;made of traces, and the most visible property of a trace is whether its calls&#xA;are well-formed JSON. That property is easy to check, easy to improve with&#xA;training and easy to report.&lt;/p&gt;</description>
			</item>
			<item>
				<title>Long Context, Multimodal Models and Mixture of Experts</title>
				<link>http://programmer.ie/books/fine-tuning/45-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/45-chapter/</guid>
				<description>&lt;p&gt;The tool trajectories in &amp;ldquo;Tool Use, Code, Structured Outputs and Agent Data&amp;rdquo;&#xA;were bounded at 8 events. Real systems keep asking for more: longer documents&#xA;in the prompt, images beside the text, and models so large that only part of&#xA;them runs for each token. Three families of model answer those demands. Long-&#xA;context models extend the sequence a transformer can attend over. Multimodal&#xA;models feed non-text inputs into a language model. Mixture-of-experts models&#xA;route each token to a subset of specialised sub-networks.&lt;/p&gt;</description>
			</item>
			<item>
				<title>FineTuneLab: Design the Usable Solution</title>
				<link>http://programmer.ie/books/fine-tuning/46-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/46-chapter/</guid>
				<description>&lt;p&gt;Forty-five chapters have built FineTuneLab one module at a time. Each chapter&#xA;called its own functions from its own experiment driver, and each experiment&#xA;lived in a namespace of its own. That is a good way to build evidence and a poor&#xA;way to use a tool. A reader who wants to try the workflow on the book&amp;rsquo;s fixtures&#xA;should not need to know which chapter&amp;rsquo;s driver to import, which seed the&#xA;experiment used or which receipt binds which artefact.&lt;/p&gt;</description>
			</item>
			<item>
				<title>FineTuneLab: Run and Compare the Training Pipeline</title>
				<link>http://programmer.ie/books/fine-tuning/47-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/47-chapter/</guid>
				<description>&lt;p&gt;The first chapter of this book, &amp;ldquo;What Fine-Tuning Actually Changes&amp;rdquo;, began with a&#xA;parameter update. The second, &amp;ldquo;When Fine-Tuning Beats Prompting, RAG, Tools or&#xA;Distillation&amp;rdquo;, asked when such an update is worth making. Forty-four chapters&#xA;later, FineTuneLab has every piece needed to answer that question with evidence&#xA;rather than habit: contracts, baselines, masked losses, adapters, checkpoints,&#xA;evaluators, statistics and a strict interface. This chapter runs them.&lt;/p&gt;&#xA;&lt;p&gt;Its central question is the book&amp;rsquo;s: &lt;strong&gt;when should a model be fine-tuned?&lt;/strong&gt; The&#xA;chapter answers it by running five branches of the pipeline, reading each&#xA;against its own baseline, and refusing to combine them into a single story. One&#xA;branch trains a real model. Its held-out loss falls under every trained&#xA;condition, its training loss falls in most of its stages, and it does not get a&#xA;single additional answer right. That result is the most&#xA;useful thing in the chapter.&lt;/p&gt;</description>
			</item>
			<item>
				<title>FineTuneLab: Release, Runbook and Decision Handbook</title>
				<link>http://programmer.ie/books/fine-tuning/48-chapter/</link>
				<pubDate>Fri, 20 Nov 2026 00:00:00 +0000</pubDate>
				<guid>http://programmer.ie/books/fine-tuning/48-chapter/</guid>
				<description>&lt;p&gt;The previous chapter, &amp;ldquo;FineTuneLab: Run and Compare the Training Pipeline&amp;rdquo;, ran&#xA;every branch of the pipeline and reached a decision on each. None of the decisions&#xA;was to release a trained model. That is not a failure of the pipeline. It is what&#xA;the evidence supported.&lt;/p&gt;&#xA;&lt;p&gt;This final chapter turns the pipeline into something a reader can operate. It&#xA;follows the journey a user takes, from installing the package to rehearsing a&#xA;rollback, with commands that were run and outputs that were observed. It then&#xA;gathers the operating knowledge into a runbook, states exactly what the release&#xA;rehearsal does and does not establish, and closes with a decision handbook for&#xA;the next dataset. The question for the chapter is practical: &lt;strong&gt;how does a reader&#xA;use FineTuneLab, and how do they decide what to do with what it tells them?&lt;/strong&gt;&lt;/p&gt;</description>
			</item>
	</channel>
</rss>
