What it actually takes to train your own model: the math nobody shows you

Ask anyone what it takes to train your own AI model and the answer comes in seconds: lots of GPU. It's the most repeated answer, and the most incomplete one. Compute is a credit card — today you can rent the same power a major lab used, by the hour, without asking anyone's permission. What you can't rent is a corpus you actually have the rights to use, and what you can only learn by training is what to do when, at hour 300, the model's loss spikes for no obvious reason. Compute, data and knowledge aren't three things that add up — they're three gates in a row, and reaching the third means you've already cleared the first two. Almost nobody reaches the third.

Three things called "training" that aren't the same thing

The word "training" gets used for three operations of completely different scale, and mixing them up is why the hardware question sounds simpler than it is.

Training from scratch (pretraining) means starting from random numbers and adjusting every parameter in the model, from nothing, on a massive corpus. Dolma, the open corpus used to train the Allen Institute for AI's OLMo models, runs to roughly three trillion tokens of web pages, academic papers, code and books. That's the scale of the first gate.

Fine-tuning starts from an already-trained model and keeps adjusting its parameters — usually all of them — but on a corpus thousands of times smaller and task-specific: not trillions of tokens, but thousands or millions of examples.

LoRA (Low-Rank Adaptation) doesn't even touch the original parameters: it freezes them and trains only a small set of added matrices. The original LoRA paper (Hu et al., Microsoft, 2021) puts a precise number on the difference: applied to GPT-3 175B, LoRA "reduces the number of trainable parameters by 10,000 times" and GPU memory requirements "by 3 times," with quality comparable to full fine-tuning. Three operations, three different orders of magnitude — not shades of the same thing.

The confusion isn't innocent: all three produce a file that behaves like "a model" and can be tested in a chat window, so from the outside they look interchangeable. They aren't. Asking "how much GPU does it take to train a model" without specifying which of the three operations you mean is like asking "how much fuel does a trip take" without saying whether it's crossing the street, crossing the country, or reaching orbit. The right answer depends entirely on which question is actually being asked, and almost nobody frames it correctly before going looking for the answer.

The three gates, with today's numbers

Compute. Right now, on Lambda Labs' pricing page, a single H100 GPU rents for $3.29 an hour on its own, or $3.99 per GPU in an eight-GPU node. Nobody asks for a résumé to pay for it.

To see what training from scratch actually costs, a real, documented case helps: OPT-175B, the 175-billion-parameter model Meta trained in 2021, whose technical paper details the infrastructure used — 992 A100 80GB GPUs, over roughly two months. Doing the math at today's prices — 992 GPUs × 24 hours × about 60 days ≈ 1.43 million GPU-hours, at Lambda's current eight-GPU-node rate — the total comes out around $5.7 million. That's an illustrative figure, not what Meta actually paid back in 2021 with a different hardware generation and provider, but it gives the real scale of the first gate when you clear it in full.

Data. Having tokens isn't enough — you need the right to use them. Dolma solves this by publishing its corpus under an ODC-BY license that permits reuse — the exception, not the norm, among large models, as already covered when explaining what an AI "openness" claim actually checks. Assembling a corpus of that size with clean rights — not scraped from wherever — is, for almost any entity, harder than paying for the compute.

Knowledge. This is the gate the "lots of GPU" myth never mentions, and the OPT-175B paper itself documents it with an uncomfortable level of detail: hardware failures caused "at least 35 manual restarts and the cycling of over 100 hosts over the course of 2 months," with roughly 70 additional automatic restarts. When the model's loss diverged — spiked out of control — the team fixed it by "lowering the learning rate and restarting from an earlier checkpoint," and had to make "a number of mid-flight changes" to that rate, on top of lowering gradient clipping from 1.0 to 0.3 to stabilize training. None of that is something a credit card buys: it takes someone awake at three in the morning who can recognize a divergence and decide, in minutes, which knob to turn. That's what actually separates someone training a frontier model from someone who just rented the machines.

And unlike compute, this knowledge doesn't rent out easily either. It isn't written down in a manual you can buy or a course you can finish in a weekend: it builds up by watching real training runs diverge, over and over, until you recognize the pattern before the loss spikes all the way. One lab can pay to use another's compute by the hour; it can't rent, the same way, the months of on-call watching it takes to know what to do at hour 300. That's why the third gate is the one that really filters people out — not because it's the most expensive, but because there's no way to buy it directly, only to accumulate it.

Which gate you're actually standing at

With an ordinary laptop and 200 euros, training a model from scratch isn't hard — it's impossible, and not for lack of ambition. 200 euros doesn't cover a fraction of an hour of real frontier-training compute, and no home laptop moves a trillion-token corpus. That gate is closed to almost everyone, and there's no need to dress that up.

The second gate, full fine-tuning, is already different: it needs several powerful GPUs for hours or days — something 200 euros can partly cover, with a tight margin.

The third is the one actually within reach. With 200 euros (roughly $215-220 at current exchange rates) and a single H100 at $3.29 an hour, that buys more than 65 hours of rented compute. That's plenty of time to run a LoRA fine-tune on an already-trained open model — like OpenAI's gpt-oss, with its weights published and its license clear — adapting it to a specific domain, language or style. You won't be creating new knowledge from scratch: you'll be reshaping, with a tiny fraction of the parameters, something someone else already trained with hundreds of GPUs and months of watching over it. That's real, useful work, and it's worth being precise about its limits too: a LoRA fine-tune can teach a model a new tone, a specialized vocabulary, or a narrow task it wasn't good at before, but it can't give the model knowledge that was never in its original training data, and it inherits every one of the base model's blind spots along with its strengths. It isn't the same as clearing all three gates, and the difference between the two is exactly what the question "how much GPU do you need" never lets you see.