How Many Training Examples Do You Actually Need for Fine-Tuning?

TL;DR

One of the most common questions before a fine-tuning project is how many training examples are actually needed. The answer is not a single number. It depends on your task type, how much the behavior you want differs from the base model's defaults, and the quality of your examples. This post gives real numbers by task type, explains the factors that push the requirement up or down, and covers the signals that tell you when you have enough data versus when adding more will actually help.

"How much data do I need?"

It is the most common question before a fine-tuning project starts. And the honest answer is: it depends. But "it depends" without specifics is not useful when you are trying to plan a dataset before committing weeks to collecting it.

Here are the real numbers, broken down by what actually determines them.

The Baseline Reality

Modern base models are already trained on enormous amounts of text. They understand language, follow instructions, and can perform a wide range of tasks without any fine-tuning at all.

What fine-tuning does is adjust the model's behavior in a specific direction. The further the target behavior is from the base model's defaults, the more examples you need to push it there reliably.

This is why the same answer of "it depends" is actually meaningful. A model that almost does what you want already needs far fewer examples than a model you are trying to teach a completely new pattern.

The second key insight: quality matters far more than quantity. Research consistently shows that 500 carefully curated examples outperform 5,000 noisy ones on the same task. This is not an abstract principle. It shows up in results every time.

Numbers by Task Type

These ranges are based on QLoRA or LoRA fine-tuning on a 7B model. Larger models generally need fewer examples to achieve the same behavior change because they have more capacity to generalize from limited data. Smaller models may need more.

Classification Tasks

Typical range: 200 to 2,000 examples

Classification is the most data-efficient task for fine-tuning. If your base model already understands the categories and the only thing you are teaching it is which category applies to which type of input, you can see meaningful improvement with as few as 200 to 500 high-quality examples.

Research has demonstrated improvements on medical text classification with as few as 200 to 300 training examples. For simpler classification tasks with clear category boundaries, even 100 examples can shift behavior noticeably.

The upper range applies when you have many categories, highly imbalanced classes, or categories that require subtle domain knowledge to distinguish.

Signal that you have enough: Validation accuracy plateaus across two or three training runs when you add more data. Adding 20 percent more examples does not improve your eval metrics.

Structured Data Extraction

Typical range: 300 to 1,500 examples

Extraction tasks, pulling specific fields from unstructured text and returning them in a consistent format, are moderately data-efficient. The base model knows how to read and understand text. You are teaching it the specific schema and what counts as a valid extraction.

300 to 500 well-formatted examples covering your target fields and edge cases is a reasonable starting point. You need coverage of the hard cases, the inputs where the target field is ambiguous, abbreviated, or formatted unusually. If your seed examples only cover easy cases, the model will struggle on exactly the inputs that matter most in production.

Signal that you have enough: The model handles edge cases correctly, not just the easy examples. Test on your 10 hardest inputs before declaring the dataset sufficient.

Summarization With a Specific Format

Typical range: 500 to 3,000 examples

Summarization is more variable than classification or extraction. The base model can already summarize. What you are teaching it is your specific style, length, format, and emphasis.

If you want bullet-point summaries of a specific length with specific section headers, you need enough examples to make that format feel like the default rather than something the model produces when specifically instructed. That usually takes 500 to 1,000 examples.

If you need the model to understand domain-specific content and summarize it accurately, technical or legal or medical text where the model's base understanding is limited, you need more. The model has to learn both the content and the format, and those requirements multiply.

Signal that you have enough: The model produces the right format on inputs it has never seen, not just on inputs similar to your training set.

Instruction Following and Chat

Typical range: 1,000 to 10,000 examples

Teaching a model to follow instructions in a consistent style, respond as a specific persona, or behave in a particular way across a wide range of open-ended inputs is the most data-hungry common task.

The challenge is coverage. An extraction task has a finite input space. A chat assistant does not. Users will ask things you did not anticipate. The more diverse your training data, the better the model generalizes to inputs it has not seen.

1,000 examples works if your use case is narrow. A customer support bot for a specific product with well-defined question types can work well with 1,000 examples that cover those types thoroughly.

For a general-purpose assistant with a custom persona, 5,000 to 10,000 diverse examples is a more realistic floor.

Signal that you have enough: The model stays in character on inputs that are off-topic or adversarial, not just on typical use-case inputs.

Tone and Style Adaptation

Typical range: 200 to 1,000 examples

This is the most underestimated category for data efficiency. If you want the model to consistently write in a specific voice, match a brand style, or maintain a particular register across diverse inputs, you often need less data than people expect.

The base model already knows how to write in many styles. You are teaching it which one to default to. 200 to 500 high-quality examples that consistently demonstrate the target style is often sufficient.

The catch is consistency in your training data. If your examples demonstrate the target style inconsistently, the model will learn inconsistency. Every example needs to be a clean demonstration of exactly the style you want.

Domain Adaptation

Typical range: 2,000 to 50,000+ examples

Domain adaptation is where data requirements jump significantly. If you are teaching the model to reason correctly about a domain it has limited exposure to in its pre-training, medical coding, niche legal frameworks, proprietary technical systems, the data requirements are much higher.

You are not just adjusting behavior. You are building knowledge coverage. And knowledge coverage requires breadth across the domain, not just depth on a narrow slice.

For narrow domain subsets, 2,000 to 5,000 examples focused on the specific knowledge the model needs may be sufficient. For broad domain coverage, the upper end is open.

Domain adaptation is also the case where full fine-tuning or continued pre-training becomes worth considering, because LoRA may not have enough capacity to encode significant domain knowledge shifts.

The Factors That Shift These Numbers

Base model quality: Stronger base models need fewer examples. A state-of-the-art 7B model in 2026 generalizes much better from limited data than the same parameter count from two years ago.

Task difficulty: How different is the target behavior from the base model's defaults? Small gaps need fewer examples. Large gaps need more.

Data quality: High-quality, consistent, diverse examples let you use fewer of them. Low-quality data with inconsistencies needs more volume to wash out the noise, and often cannot be fixed by volume at all.

Coverage of edge cases: A dataset that covers easy cases thoroughly but ignores hard cases will produce a model that handles easy cases well and fails on exactly the inputs that matter most. Edge case coverage matters more than total count.

The Practical Approach

Do not try to collect your full target dataset before your first training run.

Start with 20 percent of your target size. Train. Evaluate honestly. Look at where the model fails. Collect more data specifically for those failure cases. Train again.

This loop is more efficient than collecting a large dataset upfront, training once, and discovering the coverage gaps after the fact. The model tells you what it needs once you train on what you have.

A second run with targeted additions almost always outperforms a single run with a larger but less targeted dataset.