Fine Tuning OpenAI GPT-3 with Explanation and Code Implementation

 Fine-tuning is a critical process in customizing OpenAI's language models to meet specific application needs. In this guide, we'll explore fine-tuning, when to use it, how to prepare data, and the steps to create and use a fine-tuned model. Let's break down the key concepts and steps.


Fine-tuning is a method to enhance the performance of OpenAI's models beyond traditional prompts by providing higher-quality results, training on more examples, saving tokens, and reducing latency. It builds on "few-shot learning," which relies on demonstrations to teach models how to perform tasks.

Key Benefits of Fine-tuning:

  • Higher quality results than traditional prompts.
  • Ability to train on a larger volume of examples.
  • Token savings due to shorter prompts.
  • Lower latency in generating responses.

Steps in Fine-tuning

Fine-tuning involves the following main steps:

1. Prepare and Upload Training Data:

  • Create a dataset with conversational examples in the same format as the Chat completions API, with roles, content, and optional names.
  • Include examples that target specific issues you want to improve.
  • Aim for at least 10 examples, with 50-100 often yielding good results for gpt-3.5-turbo.

2. Craft Prompts:

  • Include instructions and prompts that worked well in pre-fine-tuning prompts in your training data.
  • Shortening prompts may save costs but should be done carefully.

3. Train a Fine-Tuned Model:

  • Use the OpenAI SDK to initiate a fine-tuning job, specifying the training file and the base model (e.g., gpt-3.5-turbo).

4. Analyze and Iterate:

  • Evaluate the fine-tuned model using training metrics and sample generations.
  • Make adjustments to data quality, quantity, and hyperparameters as needed.

5. Use Your Fine-Tuned Model:

  • Once the fine-tuning job is complete, you can use the fine-tuned model for inference by specifying it in your API requests.

Fine-tuning the GPT-3 model using the OpenAI API and Python. It covers various aspects of the process, including preparing the dataset, creating a fine-tuning job, checking the job status, and validating the fine-tuned model. Here's a summary of the key steps:

Create an OpenAI Developer Account: To access the OpenAI API and obtain the necessary API credentials, you need to create an account on the OpenAI official website.

Select GPT Models for Fine-Tuning: You can fine-tune models from the GPT-3 family, such as Ada, Babbage, Curie, and Davinci. Fine-tuning is not available for newer models like GPT-3.5-turbo or GPT-4.

Identify Use Cases: Fine-tuning can be beneficial for classification and conditional generation tasks. Examples include sentiment analysis, email categorization, chatbot development, and product description writing.

Prepare the Dataset: Your dataset should be in a specific JSONL (JSON Lines) format. This format includes prompts and completions, where prompts are input text, and completions are the expected model responses. You can generate training and validation datasets in this format.

Install Required Libraries: You'll need the OpenAI Python library, which can be installed using pip install openai.

Prepare Data in JSONL Format: Convert your training and validation datasets into JSONL format using a helper function.

Upload Datasets to OpenAI: Use OpenAI tools to upload your JSONL datasets to the OpenAI developer account.

Create a Fine-Tuning Job: Define hyperparameters for fine-tuning, such as the model (e.g., davinci), the number of epochs, batch size, and learning rate multiplier. Use the OpenAI API to create a fine-tuning job.

Monitor Training: You can monitor the training process by streaming events and checking the job status. This provides insights into the progress of fine-tuning.

Verify Job Status: Ensure that the fine-tuning job has finished successfully by checking its status. You can wait for it to reach a terminal status (succeeded or failed).

Retrieve the Fine-Tuned Model: Once fine-tuning is complete, you can retrieve the fine-tuned model's name, which can be used for inference.

Validate the Model: Test the fine-tuned model by providing prompts and generating model responses. Verify that it performs well for your specific use case.

This guide provides a structured approach to fine-tuning the GPT-3 model for customized tasks, enabling you to leverage the power of AI language models for your specific applications. Fine-tuning allows you to adapt the model to your domain and improve its accuracy and relevance.

Common Use Cases:

Fine-tuning is particularly useful for tasks like:

Setting style, tone, or format.

Improving reliability in producing desired outputs.

Correcting failures to follow complex prompts.

Handling specific edge cases effectively.

Teaching the model new skills or tasks that are challenging to articulate in a prompt.

When to Choose Fine-tuning:

It's essential to explore traditional methods such as prompt engineering, chaining prompts, and function calling before opting for fine-tuning. These methods often provide quicker feedback and cost savings. Fine-tuning should be considered when prompt-based strategies are insufficient.

Model Availability:

As of now, fine-tuning is available for models like gpt-3.5-turbo, babbage-002, and davinci-002. Support for fine-tuning GPT-4 is expected in the future.

Estimating Costs:

You can estimate the cost of a fine-tuning job by considering the cost per 1,000 tokens, the number of tokens in your input file, and the number of training epochs.

Data Validation:

Before fine-tuning, validate your data format using a provided Python script. This step ensures your dataset is suitable for the fine-tuning process.

Creating a Fine-Tuned Model:

Use the OpenAI SDK to create a fine-tuning job, specifying the training file and the base model. The job may take some time to complete, and you'll receive email confirmation upon completion.

Using Your Fine-Tuned Model:

After the job is finished, you can use the fine-tuned model for inference by specifying it in your API requests.

Analyzing Your Fine-Tuned Model:

Evaluate the model's performance using training metrics and compare it with the base model. Generate samples from both models for side-by-side comparison.

Iterating on Data Quality, Quantity, and Hyperparameters:

If the fine-tuned model's performance is not satisfactory, adjust the training dataset, increase or decrease the number of training examples, or fine-tune hyperparameters as needed.

In summary, fine-tuning empowers users to customize OpenAI's models for specific applications, improving performance and tailoring AI responses to their unique needs. However, it's essential to consider traditional strategies and iterate on data and model parameters for the best results.

Code Implementation for OpenAI Fine Tuning

Fine-tuning a language model like GPT-3 using the OpenAI API involves several steps, including data preparation, creating a fine-tuning job, monitoring the training process, and validating the fine-tuned model. Below is a complete Python code with explanations for each step.

Please note that you need to have your OpenAI API credentials, specifically your API key, before proceeding. Replace 'YOUR_API_KEY' with your actual API key in the code.

import openai
import json
import signal
import datetime
import time

# Set your OpenAI API key
openai.api_key = 'YOUR_API_KEY'

# Define your training and validation data in a dictionary format
training_data = [
        "prompt": "What is the capital of France?->",
        "completion": """ The capital of France is Paris.\n"""
    # Add more training data entries here

validation_data = [
        "prompt": "Which gas do plants use for photosynthesis?->",
        "completion": """ Plants use carbon dioxide for photosynthesis.\n"""
    # Add more validation data entries here

# Helper function to prepare data in JSONL format
def prepare_data(dictionary_data, final_file_name):
    with open(final_file_name, 'w') as outfile:
        for entry in dictionary_data:
            json.dump(entry, outfile)

# Prepare training and validation data in JSONL format
prepare_data(training_data, "training_data.jsonl")
prepare_data(validation_data, "validation_data.jsonl")

# Upload datasets to OpenAI
def upload_data_to_OpenAI(file_name):
    response = openai.FineTunes.create(file_name=file_name)
    return response['id']

training_file_name = "training_data.jsonl"
validation_file_name = "validation_data.jsonl"

training_file_id = upload_data_to_OpenAI(training_file_name)
validation_file_id = upload_data_to_OpenAI(validation_file_name)

print(f"Training File ID: {training_file_id}")
print(f"Validation File ID: {validation_file_id}")

# Define hyperparameters for fine-tuning
create_args = {
    "training_file": training_file_id,
    "validation_file": validation_file_id,
    "model": "davinci",
    "n_epochs": 15,
    "batch_size": 3,
    "learning_rate_multiplier": 0.3

# Create a fine-tuning job
response = openai.FineTune.create(**create_args)
job_id = response["id"]
status = response["status"]

print(f'Fine-tuning model with jobID: {job_id}.')
print(f"Training Response: {response}")
print(f"Training Status: {status}")

# Monitor the fine-tuning process
def signal_handler(sig, frame):
    status = openai.FineTune.retrieve(job_id).status
    print(f"Stream interrupted. Job is still {status}.")

print(f'Streaming events for the fine-tuning job: {job_id}')
signal.signal(signal.SIGINT, signal_handler)

events = openai.FineTune.stream_events(job_id)
    for event in events:
        print(f'{datetime.datetime.fromtimestamp(event["created_at"])} {event["message"]}')
except Exception:
    print("Stream interrupted (client disconnected).")

# Check the fine-tuning job status
status = openai.FineTune.retrieve(id=job_id)["status"]
if status not in ["succeeded", "failed"]:
    print(f'Job not in terminal status: {status}. Waiting.')
    while status not in ["succeeded", "failed"]:
        status = openai.FineTune.retrieve(id=job_id)["status"]
        print(f'Status: {status}')
    print(f'Fine-tune job {job_id} finished with status: {status}')

# Retrieve the fine-tuned model
result = openai.FineTune.list()
fine_tuned_model = result.fine_tuned_model

# Validate the fine-tuned model with prompts
new_prompt = "Which part is the smallest bone in the entire human body?"
answer = openai.Completion.create(


new_prompt = """ Which type of gas is utilized by plants during the process of photosynthesis?"""
answer = openai.Completion.create(


Previous Post Next Post