OpenAI fine-tuning API in Prompt Engineering / GenAI - ML Experiment: Train & Evaluate

Experiment - OpenAI fine-tuning API

Problem:You have a base OpenAI language model that performs well on general tasks but does not specialize in your specific domain, leading to lower accuracy in domain-specific text generation.

Current Metrics:Training loss: 0.15, Validation loss: 0.30, Validation accuracy: 65%

Issue:The model overfits the training data, shown by a large gap between training and validation loss, and validation accuracy is too low for practical use.

Your Task

Reduce overfitting and improve validation accuracy to at least 80% by fine-tuning the OpenAI model using the fine-tuning API.

Use the OpenAI fine-tuning API only.

Do not change the base model architecture.

Limit training epochs to a maximum of 10.

Hint 1

Hint 2

Hint 3

Solution

Prompt Engineering / GenAI

import openai

# Prepare your fine-tuning datasets in JSONL format
# Training: fine_tune_data.jsonl, Validation: fine_tune_validation.jsonl
# Each line: {"prompt": "Your prompt text", "completion": "Your completion text"}

# Upload the training dataset
train_response = openai.File.create(
    file=open("fine_tune_data.jsonl", "rb"),
    purpose="fine-tune"
)
training_file_id = train_response.id

# Upload the validation dataset
val_response = openai.File.create(
    file=open("fine_tune_validation.jsonl", "rb"),
    purpose="fine-tune"
)
validation_file_id = val_response.id

# Create fine-tuning job
fine_tune_response = openai.FineTune.create(
    training_file=training_file_id,
    validation_file=validation_file_id,
    model="davinci",
    n_epochs=5,
    learning_rate_multiplier=0.1,
    batch_size=4,
    early_stopping=True
)

# Monitor fine-tuning job
import time
fine_tune_id = fine_tune_response.id
while True:
    status = openai.FineTune.retrieve(id=fine_tune_id)
    print(f"Status: {status.status}")
    if status.status in ["succeeded", "failed"]:
        break
    time.sleep(30)

# Use the fine-tuned model
fine_tuned_model = status.fine_tuned_model
response = openai.Completion.create(
    model=fine_tuned_model,
    prompt="Your domain-specific prompt",
    max_tokens=50
)
print(response.choices[0].text.strip())

Uploaded separate training and validation datasets for fine-tuning.

Set number of epochs to 5 to avoid overfitting.

Used a smaller learning rate multiplier (0.1) for stable training.

Enabled early stopping to halt training when validation loss stops improving.

Monitored fine-tuning job status to ensure completion.

Results Interpretation

Before fine-tuning: Training loss = 0.15, Validation loss = 0.30, Validation accuracy = 65%
After fine-tuning: Training loss = 0.18, Validation loss = 0.22, Validation accuracy = 82%

Fine-tuning with a domain-specific dataset and proper hyperparameter tuning reduces overfitting and improves validation accuracy, making the model better suited for specialized tasks.

Bonus Experiment

Try fine-tuning with different learning rate multipliers and batch sizes to see how they affect overfitting and accuracy.

💡 Hint

Lower learning rates and smaller batch sizes often help reduce overfitting but may require more epochs to converge.

Practice

1. What is the main purpose of using the OpenAI fine-tuning API?

easy

A. To customize a base AI model with your own training data

B. To create a new AI model from scratch without any data

C. To delete existing AI models permanently

D. To convert AI models into images

Solution

1. Step 1: Understand fine-tuning concept

   Fine-tuning means adjusting a pre-trained AI model using your own data to make it better for your specific task.

2. Step 2: Identify the API's role

   The OpenAI fine-tuning API helps you upload your data and create a customized version of an existing model.

3. Final Answer:

   To customize a base AI model with your own training data -> Option A

4. Quick Check:

   Fine-tuning = Customize model with your data [OK]

Hint: Fine-tuning means customizing existing models with your data [OK]

Common Mistakes:

• Thinking fine-tuning creates models from scratch
• Confusing fine-tuning with deleting models
• Assuming fine-tuning changes model type (like image conversion)

2. Which of the following is the correct way to start a fine-tuning job using the OpenAI API in Python?

easy

A. openai.createFineTune(training='file-abc123')

B. openai.FineTune.create(training_file='file-abc123')

C. openai.fine_tune.start(file='file-abc123')

D. openai.finetune.upload(file='file-abc123')

Solution

1. Step 1: Recall OpenAI fine-tuning syntax

   The official OpenAI Python client uses openai.FineTune.create() to start fine-tuning jobs.

2. Step 2: Check parameter names

   The parameter for training data file is training_file, matching openai.FineTune.create(training_file='file-abc123') exactly.

3. Final Answer:

   openai.FineTune.create(training_file='file-abc123') -> Option B

4. Quick Check:

   Correct method and parameter = openai.FineTune.create(training_file='file-abc123') [OK]

Hint: Use openai.FineTune.create with training_file parameter [OK]

Common Mistakes:

• Using incorrect method names like fine_tune.start
• Wrong parameter names like 'file' instead of 'training_file'
• Mixing upload and create methods

3. Given this Python code snippet using OpenAI API, what will be the output?

response = openai.FineTune.create(training_file='file-xyz789')
print(response['status'])

medium

A. 'pending'

B. 'completed'

C. 'error'

D. 'unknown'

Solution

1. Step 1: Understand fine-tuning job lifecycle

   When a fine-tuning job is created, its initial status is usually 'pending' as it waits to start processing.

2. Step 2: Analyze code output

   The code prints the 'status' field from the response, which will be 'pending' immediately after creation.

3. Final Answer:

   'pending' -> Option A

4. Quick Check:

   New fine-tune job status = 'pending' [OK]

Hint: New fine-tune jobs start with status 'pending' [OK]

Common Mistakes:

• Assuming status is 'completed' right after creation
• Expecting 'error' without any failure
• Confusing status with model name

4. You wrote this code to fine-tune a model but get an error:

openai.FineTune.create(training_file='file-123')

What is the most likely cause of the error?

medium

A. The API key is missing from the code

B. The method name should be 'fine_tune.create' instead

C. You must specify the model parameter in create()

D. The training file ID 'file-123' is invalid or not uploaded

Solution

1. Step 1: Check common fine-tuning errors

   Errors often happen if the training file ID is wrong or the file was not uploaded properly.

2. Step 2: Validate method and parameters

   The method name and parameters are correct; model parameter is optional for fine-tuning base models.

3. Step 3: Consider API key

   Missing API key causes authentication errors, not file ID errors.

4. Final Answer:

   The training file ID 'file-123' is invalid or not uploaded -> Option D

5. Quick Check:

   Invalid file ID causes error [OK]

Hint: Check if training file ID is correct and uploaded [OK]

Common Mistakes:

• Using wrong method name with underscores
• Forgetting to upload training file before fine-tuning
• Assuming model parameter is always required

5. You want to fine-tune a model to improve chatbot responses for customer support. Which steps should you follow using the OpenAI fine-tuning API?

hard

A. Train a model locally without using OpenAI API

B. Directly call chat completions with the base model without uploading data

C. Upload a JSONL training file, create a fine-tune job with it, then use the new model for chat

D. Upload any text file and call openai.ChatCompletion.create without fine-tuning

Solution

1. Step 1: Prepare training data

   Fine-tuning requires a JSONL file with prompt-completion pairs relevant to customer support.

2. Step 2: Use OpenAI API to create fine-tune job

   Upload the file, then call openai.FineTune.create() with the training file ID.

3. Step 3: Use the fine-tuned model

   After training completes, use the new model for chat completions to get improved responses.

4. Final Answer:

   Upload a JSONL training file, create a fine-tune job with it, then use the new model for chat -> Option C

5. Quick Check:

   Fine-tune with data, then use new model [OK]

Hint: Upload data, fine-tune, then use new model for better chat [OK]

Common Mistakes:

• Skipping data upload and fine-tuning steps
• Trying to train models locally without OpenAI API
• Using base model without fine-tuning for custom tasks