Fine-tuning and parameter-efficient adaptation.
A model arrives knowing a lot about language in general. Adaptation teaches it one specific job. The question this page answers: how do you do that cheaply, without copying the whole model every time?
Fine-tuning teaches a general model a narrower behavior: the vocabulary of one industry, a preferred reply format, a particular way of summarizing a call. Parameter-efficient fine-tuning, or PEFT, is the set of methods that get most of that benefit while changing almost none of the model. We walk it the way the field is built: what it is, why it is hard, how the methods work, what it unlocks, and where it is heading. The papers behind each idea are linked, so you can read the source yourself.
Pre-train for general competence, adapt for the specific job.
A base model is pre-trained on broad data, then adapted to a narrower task or behavior. That distinction is the root the whole page hangs on.
Pre-training teaches a model a great deal about language in general. Adaptation teaches it your corner of the world: the terms one industry uses, the shape of a good reply, the format a particular team expects. The model has seen the world; adaptation teaches it your part of it.
Full fine-tuning is the original way to do this. You continue training and update every one of the model's weights on task data, then save a complete new copy of the model. It works well and remains the reference point for quality. The catch is that every task produces another full-size model.
From here the field splits into two clean alternatives. Change the weights cheaply is the subject of this page: freeze the base and train a tiny add-on. Do not change the weights at all is the other path: look up relevant text at answer time and put it in the prompt. That second path is retrieval-augmented generation, and it has its own page. The two combine well, and we draw the line once rather than repeat it.
Scale makes full fine-tuning expensive twice over.
A modern base model can hold billions of parameters. Updating and re-storing all of them, once per task, runs into several walls at once.
Touching every parameter is expensive.
Full fine-tuning updates all of the model's weights, which costs compute and memory for each task. The opening motivation of the LoRA paper (Hu et al., 2021) is exactly this: a model with billions of parameters has billions of parameters to copy for every downstream task.
Each finished variant is a full-size model.
Every fine-tuned copy is a complete model to store and to serve. With many tasks or many customers, both costs multiply, and a server cannot cheaply hold dozens of full models or switch between them per request.
Training memory is the practical limit.
Updating all weights also means holding optimizer state and gradients for all of them. That is what puts large-model fine-tuning out of reach on modest hardware, and it is the specific bottleneck QLoRA (Dettmers et al., 2023) targets.
Train hard on one task, lose the rest.
Push a model hard on a narrow task and it can lose general ability it had before, an effect known as catastrophic forgetting. Methods that touch fewer parameters, or freeze the base entirely, tend to preserve the original knowledge better.
One model, many distinct needs.
The same pressures show up whenever one model must serve many needs: adapting a model to a company's way of selling, keeping one client's adaptation separate from another's, or updating one domain without disturbing the rest. These are illustrations of the field's value, not claims about any product.
Freeze the base, train a small set of new parameters.
That one idea has several shapes. Each writes the model's "margin notes" in a different place, and each comes with a paper you can read.
Full fine-tuning
Training can change the complete model.
Parameter-efficient tuning
Common methods freeze the base and train small additions.
The old way copies the whole model for every task. The efficient way freezes the model and trains a sliver. Motivation per Hu et al., 2021.
1Adapter modules
Insert small new layers between the frozen ones.
The early answer. Slot small new layers in between the existing, frozen layers of the network and train only those inserts. The base weights never move, so new tasks add on without disturbing the old ones.
Houlsby et al. (2019) reported near-full-fine-tuning quality on the GLUE benchmark while training roughly 3% of the parameters per task. This is the original "freeze the base, train a small insert" result, and the foundation of the whole family.
- Frozen transformer layer
Base weights remain unchanged.
- Trainable adapter
A small inserted module learns task-specific changes.
- Frozen transformer layer
Continue through the existing network.
2Prefix and prompt tuning
Steer a frozen model with a learned preamble.
Instead of touching the weights at all, learn a small continuous vector that conditions the model's behavior. Prefix-tuning (Li and Liang, 2021) prepends a learned "prefix" to the model's internal state and reported comparable generation quality while training about 0.1% of the parameters, with an edge in low-data settings.
Prompt tuning (Lester et al., 2021) distills the same idea: learn a small set of "soft prompt" vectors by backpropagation rather than hand-writing a text prompt. Its key finding is about scale. As the base model grows to billions of parameters, this lightweight method closes the gap with full fine-tuning. The bigger the base, the less you need to change.
Task input → frozen model → outputThe learned vectors are parameters, rather than ordinary words typed into a prompt.
3Low-rank adaptation (LoRA)
Learn the change as two small matrices.
The widely used answer. Freeze the base weights and learn the update to them as the product of two small low-rank matrices, on the observation that the useful change has low intrinsic rank. Hu et al. (2021) reported up to 10000x fewer trainable parameters and a large drop in training memory.
The detail that makes it practical: no added inference latency. Once trained, the two small matrices can be merged back into the weights, so the served model runs at base speed. The artifact is a small file per task that snaps onto the shared base.
Frozen path
y_base = W × xTrainable path
y_delta = B × (A × x)y = y_base + scaled y_delta
4QLoRA
Fine-tune a large model on a single GPU.
The affordability lever on top of LoRA. Dettmers et al. (2023) combine LoRA with a 4-bit quantized frozen base, plus a weight data type tuned for normal distributions (NF4), double quantization, and paged optimizers that absorb memory spikes.
The reported result: fine-tuning a 65B-parameter model on a single 48GB GPU, while keeping the quality of 16-bit fine-tuning. Store the frozen base in fewer bits, train only a small add-on, and a very large model comes within reach of modest hardware.
Stored base
- Frozen
- Represent the base weights at low precision.
Trainable addition
- LoRA
- Optimize the small adapter parameters.
Combine quantized storage with the method’s precision and memory-management choices.
The family at a glance.
Different methods write the notes in different places. The base stays frozen in all of them.
These are small, swappable, often mergeable artifacts over one shared frozen base. That modularity is the structural point of the whole family, not any single method.
One shared model, many small specializations.
At the field level: many behaviors from one base, cheaper and faster adaptation, separate artifacts per task, easy update and rollback, and no inference penalty for some methods.
For a sales co-pilot, the bridge is at the outcome level. These methods are why one model can be taught to fit a particular industry's vocabulary or a company's preferred reply format without retraining and re-storing a whole model each time. The points below are properties of the field, offered as illustration, not as a description of how any product is built.
Many behaviors from one base.
Each task is a small add-on rather than a full copy, so one shared model can carry many specializations at once.
Cheaper, faster adaptation.
Training touches a fraction of the parameters and fits on far smaller hardware, the QLoRA result, so adapting a model is no longer a full-scale project.
Isolation by design.
Each adaptation is its own separate file, so distinct add-ons do not blend into each other or into the base. A clean illustration of why keeping one client's adaptation separate from another's is tractable in this field.
Easy update and rollback.
Swapping behavior means swapping a small artifact, not redeploying a whole model. For LoRA in particular, the learned change can be merged in so the served model runs at base speed.
This explainer covers published research. To see how AI REV Voice helps with sales conversations, explore Prism.
The direction the field is heading.
We describe the direction, not a roadmap of our own.
Many adapters over one base.
Systems that hold and route thousands of small task-specific adapters over a single base, switching per request rather than loading a separate model each time.
Lower-bit, lower-memory.
Extending the QLoRA direction so larger bases fine-tune on smaller hardware, with more memory-frugal training methods.
Behavior in the weights, facts at read time.
A lightly adapted base for behavior and format, plus retrieval for fresh facts, rather than choosing one over the other.
Adaptation past supervised tuning.
Parameter-efficient methods applied to preference and instruction tuning, not only to labeled task data.
Mixing and merging adapters.
Routing among, or merging, several small adapters to combine behaviors without retraining the base.
The papers behind this page.
- Houlsby et al. (2019). Parameter-Efficient Transfer Learning for NLP (adapters). arXiv:1902.00751.
- Li and Liang (2021). Prefix-Tuning: Optimizing Continuous Prompts for Generation. arXiv:2101.00190.
- Lester et al. (2021). The Power of Scale for Parameter-Efficient Prompt Tuning. arXiv:2104.08691.
- Hu et al. (2021). LoRA: Low-Rank Adaptation of Large Language Models. arXiv:2106.09685.
- Dettmers et al. (2023). QLoRA: Efficient Finetuning of Quantized LLMs. arXiv:2305.14314.
- Hugging Face. PEFT documentation and conceptual guides (industry context for the family overview).
Keep reading.
Sibling explainers in the Research section.
Talk. Done.
One model, taught to fit your work. You talk, and clean, complete notes are waiting. See it on a real call.
No app required. Just your phone number.