How long will fine-tuning take?
Fine-tuning time comes down to how many tokens you push through and how fast the card can push them. A training step costs several times a generation step, which is where estimates usually go wrong.
The short answer
Computed from this tool’s default settings — model size and the rest as most people start. Change them below for your own case.
Roughly 186.0 hours to push 30.0M tokens through a 8B model on RTX 4090. Treat it as an order of magnitude: data loading and evaluation are not modelled.
Training Time Estimator
Wall-clock estimate from dataset size, epochs and your hardware.
Roughly 186.0 hours to push 30.0M tokens through a 8B model on RTX 4090. Treat it as an order of magnitude: data loading and evaluation are not modelled.
What each setting changes
Every input moves the result for a reason. This is what each one does and where to find the value for your own machine.
| Setting | Default | What it changes |
|---|---|---|
| Model size | 8B | 9 options, from 1B to 405B. |
| Your hardware | RTX 4090 · 24 GB | The machine the model runs on. Usable memory decides what fits and memory bandwidth decides how fast it runs, so this moves every figure below. |
| Dataset size | 10 million tokens | Your own figure in million tokens, starting from 10. Change it to match what you actually run. |
| Epochs | 3 | Anywhere from 1 to 20. |
Real answers across model size
The same calculation run at a range of settings, with everything else left at its default. These are computed by the tool itself, not written by hand.
| Model size | Estimated wall clock | Tokens processed | Training throughput | Inference speed |
|---|---|---|---|---|
| 1B | 23.3 hours | 30.0M | 358 tok/s | 1,434 tok/s |
| 3B | 2.9 days | 30.0M | 119 tok/s | 478 tok/s |
| 7B | 6.8 days | 30.0M | 51 tok/s | 205 tok/s |
| 8B | 7.8 days | 30.0M | 45 tok/s | 179 tok/s |
| 14B | 13.6 days | 30.0M | 26 tok/s | 102 tok/s |
Roughly 23.3 hours to push 30.0M tokens through a 1B model on RTX 4090. Treat it as an order of magnitude: data loading and evaluation are not modelled.
How this is calculated
No lookup tables and no invented constants. Here is the arithmetic, so you can check it against your own numbers.
Training throughput is derived from inference throughput rather than measured: a training step runs a forward and a backward pass, and the backward pass costs roughly twice the forward, so a step is about three times a forward pass. Gradient checkpointing adds another recomputed forward, so the estimate uses roughly a quarter of inference speed.
This is an order-of-magnitude figure, not a benchmark. Data loading, sequence packing and evaluation passes all add real time that this does not model.
These are well-founded engineering estimates, not benchmark results. Your quantisation, runtime and context length all move the real number, and usable memory is an assumption rather than a specification. See the full methodology for every assumption behind these figures.
Who this is for
The three situations that bring people to this calculation.
Planning a run
Know if this is an evening or a week.
Renting a GPU
Turn hours into a number before you commit.
Sizing a dataset
See what more epochs actually cost.
How to use this calculator
Four steps, no account, nothing leaves your browser.
Set model size
Start at the top of the panel. Every figure recalculates as you change it — there is no submit button, because watching the number move is the point.
Adjust the rest to match your setup
3 further settings: your hardware, dataset size, epochs. Defaults are the common case, so change only what differs for you.
Read the headline, then the table
The large figure answers the question. The table underneath shows how the answer changes across nearby settings, which is usually where the decision actually gets made.
Check it against the method
The arithmetic is written out above. If a number looks wrong for your hardware, the assumptions are the first place to look — usable memory and quantisation are the two that vary most.
How long will fine-tuning take: common questions
The questions people ask about this, answered without hedging.
How long does fine-tuning take?
A small QLoRA run on a few million tokens is typically hours on a consumer card. Tens of millions of tokens, or a larger base, moves it into days.
Why is training so much slower than inference?
A step runs a forward pass and a backward pass, and the backward costs roughly twice the forward. With gradient checkpointing a forward is recomputed as well, so a step is about four times a generation step.
How many epochs should I run?
Two to three for most instruction datasets. More tends to memorise rather than generalise, and on a small dataset the model starts overfitting quickly.
Is this estimate reliable?
It is an order of magnitude, not a benchmark. Data loading, sequence packing and evaluation passes all add time this does not model.
Related local AI tools
All 50 run on the same arithmetic, so answers across them agree.
More on fine-tuning
Will it fit
Context
Speed
Quantisation
Runtime & errors
Cost
Searches this page answers
Different ways of asking the same question, all resolved above.
Now find the models that fit
Sizing is only half the problem. Model Radar takes your hardware and shows which models actually run on it, ranked by what they are good at — the same arithmetic as this page, applied to every model worth running.