Redistributed

A pre-trained language model is a general-purpose tool. It knows a lot about everything and not enough about anything specific. Fine-tuning is the process of taking that general tool and reshaping it for a particular job — teaching it your vocabulary, your standards, your domain.

This matters for redistribution because fine-tuning is where organizations turn a shared resource into a private advantage. The base model is (sometimes) open. The fine-tuned version rarely is. Understanding how fine-tuning works reveals who gets to customize AI and who's stuck with the default.

The Mechanism: What Actually Happens

When you fine-tune a model, you resume the training process — but instead of exposing it to the entire internet, you feed it a much smaller, curated dataset specific to your task. The model's internal parameters (its weights) shift to reflect these new examples.

Think of it like an experienced professional changing industries. A skilled writer already knows grammar, structure, and argumentation. When they move from journalism to legal drafting, they don't learn language from scratch — they adjust their style, learn new conventions, and absorb domain-specific vocabulary. The foundational capabilities remain; the application changes.

Technically, the model runs through the same gradient descent process used in original training. It sees your examples, compares its outputs to what you want, computes the error, and adjusts its weights to reduce that error. The difference is scale: instead of trillions of tokens over months, you might use thousands of examples over hours.

Types of Fine-Tuning

Not all fine-tuning is created equal. The approaches vary dramatically in cost, capability, and who can realistically use them.

Full Fine-Tuning

Every parameter in the model gets updated. For a 70-billion parameter model, this means loading all 70 billion weights into GPU memory, computing gradients for each one, and storing optimizer states that can triple memory requirements. You need clusters of high-end GPUs — the same kind of hardware that trained the model in the first place.

Who can do this: Large tech companies, well-funded AI labs, a few research institutions. A full fine-tune of a 70B model can run $100,000 to $500,000+ in compute costs. This is not a weekend project.

When it makes sense: When you need to fundamentally alter the model's behavior or embed deep domain knowledge across all its capabilities.

LoRA and QLoRA (Parameter-Efficient Fine-Tuning)

This is where fine-tuning became accessible. Low-Rank Adaptation (LoRA), introduced by Hu et al. in 2021, freezes the original model weights and injects small trainable matrices into each layer. Instead of updating 70 billion parameters, you might train 10-50 million — a reduction of over 99%.

QLoRA goes further: it loads the frozen model in 4-bit quantized format, slashing memory requirements. A 65-billion parameter model that would normally need multiple A100 GPUs can be fine-tuned on a single 48GB GPU (Dettmers et al., 2023).

What this costs: $50-500 for a small model on cloud GPUs. Under $2,000 for serious work on large models. Some hobbyists do it on consumer GPUs at home.

The tradeoff: Parameter-efficient methods produce models that are slightly less capable than full fine-tunes for the same data. For most practical applications, the difference is negligible. For pushing the frontier, it matters.

Instruction Tuning

A specific application of fine-tuning where the training data consists of instruction-response pairs. "Summarize this article" followed by a good summary. "Extract the key dates from this contract" followed by correct extractions. The model learns to follow instructions in a particular format and domain.

This is what turned raw pre-trained models into the chatbots people actually use. GPT-3 could complete text; InstructGPT could answer questions (Ouyang et al., 2022). The underlying technique is fine-tuning; the innovation was in the data format.

RLHF and Preference Tuning

Reinforcement Learning from Human Feedback adds another layer: instead of showing the model correct outputs, you show it pairs of outputs and tell it which one humans preferred. The model learns to generate outputs that match human preferences — or more precisely, the preferences of whoever is doing the rating.

DPO (Direct Preference Optimization) and its variants have simplified this process, removing the need for a separate reward model. But the core dynamic remains: someone decides what "better" means, and the model absorbs that definition.

How Fine-Tuning Differs from the Alternatives

Fine-tuning sits in a specific spot on the customization spectrum. Knowing where it falls helps you decide whether it's worth the investment.

Prompting is the simplest approach. You give the model instructions and examples in the prompt itself. No training, no cost beyond API calls, no technical barrier. But you're limited by the context window, and the model's underlying behavior doesn't change. Every request starts fresh.

Retrieval-Augmented Generation (RAG) fetches relevant documents and includes them in the prompt. The model gets access to your data without retraining. This works well for factual queries against a knowledge base, but the model still processes information through its generic lens. It doesn't learn your domain's reasoning patterns.

Training from scratch builds a model from the ground up. This requires millions of dollars, months of work, and massive datasets. Almost nobody does this. Even most "AI companies" start from pre-trained models.

Fine-tuning changes the model itself. It learns patterns, styles, and domain knowledge that persist across all future interactions without needing to be re-specified in every prompt. It's more permanent than prompting, more integrated than RAG, and vastly cheaper than training from scratch.

Approach	Cost	Persistence	Depth	Technical Barrier
Prompting	Lowest	Per-session	Surface	Minimal
RAG	Low-Medium	Knowledge base	Factual	Moderate
Fine-tuning	Medium-High	Permanent	Behavioral	High
Training from scratch	Extreme	Permanent	Total	Very high

The Practical Mechanics

If you're considering fine-tuning, here's what's actually involved.

Data Requirements

You need examples of the behavior you want. The format is typically input-output pairs: a prompt and the ideal response. Quality matters far more than quantity. Research consistently shows that a few thousand high-quality examples outperform tens of thousands of mediocre ones (Zhou et al., 2023).

For instruction tuning: 1,000-10,000 examples is a common range. For domain adaptation (teaching the model a new field): 10,000-100,000 documents. For style transfer (matching a specific voice): sometimes as few as 500 examples suffice.

The data must be clean, consistent, and representative of what you actually want. Garbage in, garbage out applies with particular force here — the model will faithfully learn whatever patterns your data contains, including the mistakes.

Compute Requirements

This depends entirely on the method and model size:

LoRA on a 7B model: A single consumer GPU (RTX 3090/4090) or a few hours on cloud GPUs. Cost: $10-100.
LoRA on a 70B model: One or two A100 GPUs. Cost: $200-2,000.
Full fine-tune of a 7B model: Multiple GPUs, significant memory. Cost: $1,000-10,000.
Full fine-tune of a 70B+ model: GPU clusters. Cost: $100,000-500,000+.

Cloud providers (AWS, Google Cloud, Lambda Labs) rent A100 and H100 GPUs by the hour. Fine-tuning APIs from OpenAI, Google, and Anthropic abstract away the hardware entirely — you upload data and pay per token.

Timeline

A LoRA fine-tune on a small model can complete in under an hour. Full fine-tunes of large models take days to weeks. Data preparation — cleaning, formatting, quality control — often takes longer than the training itself.

Real-World Applications

Fine-tuning isn't theoretical. Organizations are already using it to build competitive advantages.

Medical diagnosis support. Models fine-tuned on clinical notes and diagnostic criteria outperform general models at identifying potential conditions from patient descriptions. Med-PaLM 2, fine-tuned on medical examination questions and clinical data, reached expert-level performance on medical licensing exams (Singhal et al., 2023). But the training data — years of clinical records — is owned by hospitals and health systems. The resulting model compounds existing institutional advantages.

Legal document analysis. Law firms fine-tune models on their own contract databases, case histories, and legal reasoning patterns. The fine-tuned model understands their specific clause structures, jurisdictional nuances, and drafting conventions. A general model sees a contract; the fine-tuned model sees their kind of contract.

Code generation for specific stacks. Companies fine-tune coding models on their internal codebases — their conventions, their APIs, their architectural patterns. The result is an assistant that writes code the way the team writes code, not the way Stack Overflow writes code.

Customer service automation. Fine-tuned models learn a company's specific products, policies, tone, and escalation triggers. This is where the knowledge extraction problem becomes most visible.

The Redistribution Angle

Fine-tuning is where AI customization meets AI concentration. The dynamics are worth examining plainly.

Access Is Unequal

Cloud fine-tuning APIs — OpenAI's, Google's, Amazon Bedrock — are controlled by a handful of providers. They set the prices, the model options, the data handling terms. If you fine-tune through their API, your training data passes through their systems. For regulated industries (healthcare, finance, legal), this creates compliance tensions that only well-resourced organizations can navigate.

Open-weight models (Llama, Mistral, Qwen) make fine-tuning possible without API gatekeepers. You download the weights, train on your own hardware, keep everything in-house. But "open" doesn't mean "accessible" — the distinction matters. You still need ML engineering talent, GPU infrastructure, and data pipelines. As Kate Crawford documented in Atlas of AI, the resources required for AI development — data, compute, expertise — track existing concentrations of power. Platforms like Hugging Face and tools like Ollama are lowering some technical barriers, but the underlying resource requirements remain substantial.

Data as Moat

Quality training data for fine-tuning is itself a competitive advantage. A hospital system with decades of digitized patient records can build a clinical model that no startup can replicate — not because the technique is secret, but because the data is proprietary. A legal firm's 50 years of contract negotiations represent a dataset no one can buy on the open market.

This creates a feedback loop. Organizations with data build better models, which serve clients better, which generates more data. The Matthew effect applies: to those who have data, more capability shall be given.

The Knowledge Extraction Problem

This is perhaps the most consequential redistribution dynamic around fine-tuning. When an organization fine-tunes a model on its employees' work — their writing, their code, their clinical judgments, their customer interactions — it extracts institutional knowledge into a portable, scalable form.

The knowledge that once existed only in experienced workers' heads now lives in model weights. The worker who spent fifteen years learning to draft contracts in a particular style has, through their accumulated work product, trained a model that can approximate that skill. The model doesn't need a salary, health insurance, or retirement benefits.

This isn't speculative. It's the explicit business case that companies make for fine-tuning: "capture institutional knowledge before employees leave." The phrasing sounds benign. The implication is that once the knowledge is captured, the employees become more replaceable. Workers could, in principle, negotiate for ongoing value from the knowledge they contribute — through collective bargaining, profit-sharing, or data rights. But in practice, most have no such leverage, and the extraction is already underway.

Who Benefits, Who Pays

Who benefits: Organizations with proprietary data, ML engineering teams, and the capital to invest in fine-tuning infrastructure. Cloud AI providers who charge for fine-tuning APIs. Consultancies that help companies build custom models.

Who pays: Workers whose expertise gets extracted into model weights. Smaller organizations stuck using generic models because they lack the data or talent to fine-tune. Users of AI systems that were fine-tuned to optimize for the provider's goals rather than the user's needs.

What Readers Should Know

If you're evaluating whether fine-tuning makes sense for your situation, here's the practical framework:

Try prompting first. Seriously. Modern models with well-crafted system prompts and few-shot examples handle many use cases without any training. If prompting solves 80% of your problem, the other 20% may not justify fine-tuning costs.

Try RAG before fine-tuning for knowledge tasks. If your goal is getting the model to reference specific documents or facts, RAG is cheaper, faster, and easier to update. Fine-tuning embeds knowledge into the model; RAG looks it up at query time.

Fine-tune when you need consistent behavior at scale. If you need the model to reliably adopt a specific style, follow domain-specific reasoning patterns, or handle specialized terminology across thousands of daily interactions, fine-tuning pays for itself in reduced prompt engineering and more consistent outputs.

Start with LoRA on small models. The cost of experimentation is now low enough that there's little reason to begin with full fine-tuning. Run a LoRA experiment for under $100, evaluate the results, and scale up only if the results justify it.

Understand what you're giving up. When you fine-tune through a cloud API, read the data usage terms carefully. When you fine-tune on employee work product, consider the labor implications honestly. The technical question of can we fine-tune is straightforward. The questions of should we and who bears the cost are harder.

Sources

Hu, Edward J. et al. "LoRA: Low-Rank Adaptation of Large Language Models." ICLR, 2022. arXiv
Dettmers, Tim et al. "QLoRA: Efficient Finetuning of Quantized Language Models." NeurIPS, 2023. arXiv
Ouyang, Long et al. "Training Language Models to Follow Instructions with Human Feedback." NeurIPS, 2022. arXiv
Singhal, Karan et al. "Towards Expert-Level Medical Question Answering with Large Language Models." Nature, 2023. arXiv
Zhou, Chunting et al. "LIMA: Less Is More for Alignment." NeurIPS, 2023. arXiv
Crawford, Kate. Atlas of AI: Power, Politics, and the Planetary Costs of Artificial Intelligence. Yale University Press, 2021. Publisher

General

What Fine-Tuning Really Does