Skip to main content

Documentation Index

Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt

Use this file to discover all available pages before exploring further.

Fine-tuning teaches a pre-trained language model to excel on your specific tasks. By training on a domain-focused dataset, you improve relevance, accuracy, and cost efficiency without starting from scratch.

​
Why Fine-Tune?

When a base model’s general-purpose knowledge falls short, fine-tuning bridges the gap. Key benefits include:
BenefitDescription
Enhanced PerformanceOptimize for task-specific language patterns.
Custom Use CasesTailor outputs to your industry or application.
Improved AccuracyGenerate more precise and relevant responses.
Cost EfficiencySave compute and time versus full-model training.

​
Customization for Specific Use Cases

Fine-tuning adapts models like GPT-4 to handle domain terminology and workflows. For instance:
  • A retail chatbot that understands product catalogs and return policies
  • A healthcare assistant trained on medical language and compliance
The image shows a comparison of specific use cases and benefits of customization, with examples from retail and healthcare on the left, and advantages like enhanced performance and cost efficiency on the right.

​
Accuracy vs. Precision

Balancing accuracy (closeness to the correct answer) with precision (consistency across runs) is crucial:
ScenarioAccuracyPrecisionOutcome
Consistently correct responsesHighHighReliable and repeatable output
Generally correct but varied styleHighLowGood answers, inconsistent form
Consistently wrong responsesLowHighRepeated errors
The image illustrates the concepts of accuracy and precision using three target diagrams: high accuracy and high precision, high accuracy and low precision, and low accuracy and high precision.

​
Cost Efficiency

Fine-tuning reuses existing model weights, drastically reducing training time and compute costs:
  • Leverage pre-trained parameters
  • Shorter training cycles
  • Lower resource consumption
The image lists benefits of a process, including saving time, computational resources, and costs, with additional points on enhanced performance, customization, improved accuracy, and cost efficiency.

​
How Fine-Tuning Works

The process refines a pre-trained model on your labeled dataset while preserving its broad knowledge:
  1. Prepare the dataset
  2. Upload the dataset
  3. Train the model
  4. Evaluate the model
The image explains how a pre-trained model is fine-tuned on a specialized dataset for specific use cases, allowing it to adjust weights better with new data exposure.

​
High-Level Flow

The image is a flowchart titled "How It Works," outlining three steps: Prepare (curate dataset and include inputs/outputs), Upload (load dataset into the model), and Train (use fine-tuning to train the model).

​
Example Code

Below is a step-by-step example using the OpenAI Python SDK.

​
1. Prepare the Dataset

Each line in a JSONL file should contain a prompt and completion object. 
{"prompt": "Generate a confidentiality agreement clause:", "completion": "The Parties agree to keep all information confidential..."}
{"prompt": "Create a termination clause for a contract:", "completion": "This Agreement may be terminated by either party upon written notice..."}
Ensure your JSONL file follows the JSONL specification and that prompts/completions accurately reflect your target style.

​
2. Upload the Dataset

Use the Files endpoint to register your dataset for fine-tuning. 
from openai import OpenAI

client = OpenAI()

client.files.create(
    file=open("mydata.jsonl", "rb"),
    purpose="fine-tune"
)

​
3. Fine-Tune the Model

Start a fine-tuning job by specifying the training file, base model, and hyperparameters. 
from openai import OpenAI

client = OpenAI()

client.fine_tuning.jobs.create(
    training_file="file-abc123",
    model="gpt-4o-mini-2024-07-18",
    hyperparameters={
        "n_epochs": 2
    }
)
An epoch is one pass over the entire dataset. Multiple epochs let the model gradually refine its parameters.
The image is a slide titled "Fine-Tune the Model," explaining the process of initiating fine-tuning, defining epochs, and how the model adjusts its weights.

​
4. Evaluate the Model

After fine-tuning, send test prompts to verify performance. 
from openai import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
    model="your-fine-tuned-model-id",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a haiku about recursion in programming."}
    ]
)

print(completion.choices[0].message.content)

​
Best Practices

​
Use High-Quality Data

High-quality, relevant data drives better models. Clean and validate entries before fine-tuning.
DatePriceQuantity SoldCity
2024-01-011.20150New York
2024-01-021.30200Los Angeles
The image shows a slide titled "Use High-Quality Data" with a table of avocado sales data, including dates, prices, quantities sold, and city information. It emphasizes that good data leads to good models and should be clean, relevant, and comprehensive.
Manually review samples to ensure consistency and remove noisy entries.

​
Start with a Small Dataset

Begin with a smaller dataset to gauge model behavior before scaling to larger volumes.

​
Monitor the Fine-Tuning Process

Track metrics such as loss and accuracy. If you see overfitting or stalled progress, adjust hyperparameters (e.g., learning rate, epochs).
The image shows a slide about monitoring the fine-tuning process, with points on metrics, model improvement, and hyperparameters, alongside a table of avocado sales data by date and city.

Watch Video