Fijn-afstellen van GPT-4o Mini: een stapsgewijze gids

Voordat je begint met het fijn-afstellen van het GPT-4o Mini-model, raden we prompt engineering, prompt chaining en function calling aan om de modelantwoorden aan te passen en domeinspecifieke antwoorden te krijgen.

Fijn-afstellen is nodig wanneer je de stijl, toon of het formaat wilt bijsturen. Het wordt gebruikt om betrouwbaarheid en nauwkeurigheid te verbeteren, complexe prompts af te handelen of een nieuwe taak uit te voeren die met prompt engineering niet haalbaar was.

In deze tutorial stemmen we het GPT-4o Mini-model af om tekst te classificeren in labels "stress" en "non-stress". Vervolgens benaderen we het fijn-afgestelde model via de OpenAI API en de OpenAI playground. Tot slot evalueren we het fijn-afgestelde model door de prestaties vóór en na het afstellen te vergelijken met verschillende classificatiestatistieken.

Afbeelding door auteur

Kennismaking met GPT-4o Mini

GPT-4o Mini is het meest kostenefficiënte algemene large language model dat beschikbaar is. Het scoort 82% op de MMLU en presteert momenteel beter dan Claude 3.5 Sonnet op chatvoorkeuren in het LMSYS-leaderboard. De prijs is 15 cent per miljoen inputtokens en 60 cent per miljoen outputtokens, wat 60% goedkoper is dan GPT-3.5 Turbo.

GPT-4o mini ondersteunt momenteel tekst en afbeeldingen als input. Het model heeft een contextvenster van 128K tokens, ondersteunt tot 16K outputtokens per verzoek en heeft kennis tot oktober 2023. GPT-4o Mini kan niet-Engelse tekst aan, omdat het de GPT-4o-tokenizer gebruikt. We krijgen het beste van twee werelden tegen lage kosten.

Lees over de use case, de chat completion API en gedetailleerde benchmarks van GPT-4o Mini in onze blog, Wat is GPT-4o Mini?

De OpenAI API instellen

Ga naar de OpenAI-website en maak een account aan. Fijn-afstellen is duur, en om GPT-4o Mini via de API te gebruiken, moet je een betaalmethode aan je account koppelen. Om problemen te voorkomen, zorg je ervoor dat je minstens 10 USD tegoed op je account hebt voordat je het model probeert fijn te stellen.

Ga naar het hoofd-dashboard, klik op het tabblad “API keys” en genereer de geheime OpenAI API-sleutel.

We gebruiken DataCamps DataLab als onze code-editor. Om de omgevingsvariabele voor de OpenAI API-sleutel in te stellen, ga je naar het tabblad Environment en klik je op de optie voor omgevingsvariabelen. Voeg daarna de omgevingsvariabele voor de API-sleutel toe en activeer deze zoals hieronder weergegeven.

Installeer het OpenAI Python-pakket om toegang te krijgen tot GPT-4o Mini.

%%capture
%pip install openai
Mogelijk gemaakt door

Maak de client aan met de OpenAI API-sleutel en genereer een antwoord met de voorbeeldprompt. De chat completion-functie vereist de modelnaam en berichten in een lijst-van-dictionaries-formaat.

from IPython.display import Markdown, display
from openai import OpenAI
import os

openai_api_key = os.environ["OPENAI_API_KEY"]

client = OpenAI(api_key=openai_api_key)

response = client.chat.completions.create(
  model="gpt-4o-mini",
  messages=[
    {"role": "system", "content": "You are a great philosopher."},
    {"role": "user", "content": "What is the meaning of life?"}
  ]
)
display(Markdown(response.choices[0].message.content))Mogelijk gemaakt door

Onze OpenAI API is volledig ingesteld en we zijn klaar om de fine-tuningtaak te starten.

Nieuw bij de API van OpenAI? Volg de eenvoudige en gedetailleerde tutorial GPT-4o API Tutorial: Aan de slag met de API van OpenAI om te leren hoe je met een paar regels code toegang krijgt tot state-of-the-art modellen.

GPT-4o Mini fijn-afstellen

In deze sectie stellen we het GPT-4o Mini-model af op de Stress Detection from the Social Media Articles-dataset van Kaggle. De dataset bevat posts van Reddit en Twitter en classificeert deze in stress en non-stress labels.

De dataset maken

We laden en verwerken nu de dataset.

Laad de bovenste 200 rijen uit de dataset met Reddit-posts.
Laat alle kolommen vallen behalve 'title' en 'label'.
Map de kolom labels om 0 en 1 om te zetten naar labels "non-stress" en "stress".
Splits de dataset in trainings- en validatiesets.
Sla zowel de trainings- als de validatieset op in JSONL-indeling.

Opmerking: Zorg voor het juiste datasetformaat, met de systeemprompt, gebruikersvraag en het antwoord. Het antwoord is het label.

import pandas as pd
import json
from sklearn.model_selection import train_test_split

# Load the CSV file with the correct delimiter
file_path = 'Reddit_Title.csv'  # Change this to your local path
data = pd.read_csv(file_path, sep=';')

# Clean up and drop unnecessary columns, and select the top 200 rows
data_cleaned = data[['title', 'label']].head(200)

# Mapping the 'label' column to more human-readable text
label_mapping = {0: "non-stress", 1: "stress"}
data_cleaned['label'] = data_cleaned['label'].map(label_mapping)

# Split the data into training and validation sets (80% train, 20% validation)
train_data, validation_data = train_test_split(data_cleaned, test_size=0.2, random_state=42)

def save_to_jsonl(data, output_file_path):
    jsonl_data = []
    for index, row in data.iterrows():
        jsonl_data.append({
            "messages": [
                {"role": "system", "content": "Given a social media post, classify whether it indicates 'stress' or 'non-stress'."},
                {"role": "user", "content": row['title']},
                {"role": "assistant", "content": f"\"{row['label']}\""}
            ]
        })

    # Save to JSONL format
    with open(output_file_path, 'w') as f:
        for item in jsonl_data:
            f.write(json.dumps(item) + '\n')

# Save the training and validation sets to separate JSONL files
train_output_file_path = 'stress_detection_train.jsonl' 
validation_output_file_path = 'stress_detection_validation.jsonl'

save_to_jsonl(train_data, train_output_file_path)
save_to_jsonl(validation_data, validation_output_file_path)

print(f"Training dataset save to {train_output_file_path}")
print(f"Validation dataset save to {validation_output_file_path}")Mogelijk gemaakt door

Uitvoer:

Training dataset save to stress_detection_train.jsonl
Validation dataset save to stress_detection_validation.jsonlMogelijk gemaakt door

De dataset uploaden

We gebruiken nu de OpenAI-client om zowel de trainings- als de validatiedatasets te uploaden voor fine-tuning.

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

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

print(f"Training file Info: {train_file}")
print(f"Validation file Info: {valid_file}")Mogelijk gemaakt door

De OpenAI API valideert eerst de dataset, uploadt vervolgens de datasets en genereert metadata die we kunnen gebruiken om het model fijn te stellen.

Training file Info: FileObject(id='file-b2lo2chod6xuMhYg9JcEsnp6', bytes=48563, created_at=1727133513, filename='stress_detection_train.jsonl', object='file', purpose='fine-tune', status='processed', status_details=None)
Validation file Info: FileObject(id='file-Fae0AVSUhTGr49qhQz8d2yyp', bytes=12284, created_at=1727133514, filename='stress_detection_validation.jsonl', object='file', purpose='fine-tune', status='processed', status_details=None)Mogelijk gemaakt door

Om te controleren of de dataset succesvol naar de cloud is gepusht, ga je naar het Dashboard en klik je op het tabblad “Storage”. Daar staan twee bestanden klaar voor gebruik.

De fine-tuningtaak starten

Maak de fine-tuningtaak aan met de client-API. De fine-tuningfunctie vereist het bestands-ID van de trainingsdataset, het bestands-ID van de validatiedataset, de modelnaam en hyperparameters. We stemmen ons model af voor drie epochs. Om de modelprestaties te verbeteren, kun je altijd op de volledige dataset trainen met minstens 5 epochs.

model = client.fine_tuning.jobs.create(
  training_file=train_file.id, 
  validation_file=valid_file.id,
  model="gpt-4o-mini-2024-07-18", 
  hyperparameters={
    "n_epochs": 3,
	"batch_size": 3,
	"learning_rate_multiplier": 0.3
  }
)
job_id = model.id
status = model.status

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

Zodra we de functie uitvoeren, start de fine-tuningtaak en worden de logs weergegeven.

Fine-tuning model with jobID: ftjob-rgIMFxZSsWDqCNfOev54e4Jq.
Training Response: FineTuningJob(id='ftjob-rgIMFxZSsWDqCNfOev54e4Jq', created_at=1727135628, error=Error(code=None, message=None, param=None), fine_tuned_model=None, finished_at=None, hyperparameters=Hyperparameters(n_epochs=3, batch_size=3, learning_rate_multiplier=0.3), model='gpt-4o-mini-2024-07-18', object='fine_tuning.job', organization_id='org-jLXWbL5JssIxj9KNgoFBK7Qi', result_files=[], seed=748607710, status='validating_files', trained_tokens=None, training_file='file-b2lo2chod6xuMhYg9JcEsnp6', validation_file='file-Fae0AVSUhTGr49qhQz8d2yyp', estimated_finish=None, integrations=[], user_provided_suffix=None)
Training Status: validating_filesMogelijk gemaakt door

We kunnen de status van de fine-tuningtaak bekijken op het dashboard door op het tabblad “Fine-tuning” te klikken en vervolgens op de job-ID te klikken.

Of we kunnen de status van de fine-tuningtaak controleren met de functie jobs.retrieve.

# Retrieve the state of a fine-tune
client.fine_tuning.jobs.retrieve(job_id)Mogelijk gemaakt door

Uitvoer:

FineTuningJob(id='ftjob-rgIMFxZSsWDqCNfOev54e4Jq', created_at=1727135628, error=Error(code=None, message=None, param=None), fine_tuned_model=None, finished_at=None, hyperparameters=Hyperparameters(n_epochs=3, batch_size=3, learning_rate_multiplier=0.3), model='gpt-4o-mini-2024-07-18', object='fine_tuning.job', organization_id='org-jLXWbL5JssIxj9KNgoFBK7Qi', result_files=[], seed=748607710, status='running', trained_tokens=None, training_file='file-b2lo2chod6xuMhYg9JcEsnp6', validation_file='file-Fae0AVSUhTGr49qhQz8d2yyp', estimated_finish=1727135943, integrations=[], user_provided_suffix=None)Mogelijk gemaakt door

Als je denkt dat de loss niet daalt, kun je de taak altijd annuleren met de functie jobs.cancel.

# Cancel a job
client.fine_tuning.jobs.cancel(job_id)Mogelijk gemaakt door

Wanneer de fine-tuningtaak is voltooid, ontvang je een e-mail dat het fijn-afgestelde model klaar is voor gebruik.

Toegang krijgen tot het fijn-afgestelde model via de API

Om toegang te krijgen tot het fijn-afgestelde model, hebben we de naam van het fijn-afgestelde model nodig. Hiervoor verzamelen we informatie over alle fine-tuningtaken, kiezen we de meest recente en selecteren we vervolgens de modelnaam.

result = client.fine_tuning.jobs.list()

# Retrieve the fine tuned model
fine_tuned_model = result.data[0].fine_tuned_model
print(fine_tuned_model)Mogelijk gemaakt door

Dit is onze fijn-afgestelde modelnaam.

ft:gpt-4o-mini-2024-07-18:personal::AAnFfX5qMogelijk gemaakt door

Genereer een antwoord door de chat completion-functie te geven: een fijn-afgestelde modelnaam, berichten met een correcte systeemprompt en een voorbeeld uit de dataset.

completion = client.chat.completions.create(
  model = fine_tuned_model,
  messages=[
    {"role": "system", "content": "Given a social media post, classify whether it indicates 'stress' or 'non-stress'."},
    {"role": "user", "content": "Just went to my first homecoming, and they played a song I've always wanted to dance to at an official dance. Sorry for the terrible quality, but my happiness in this moment couldn't be exaggerated!"}
  ]
)
print(completion.choices[0].message.content)Mogelijk gemaakt door

Gelukt! Ik heb het label correct voorspeld.

"non-stress"Mogelijk gemaakt door

Als je niet tevreden bent met je model, kun je het altijd verwijderen met het volgende commando. Wij doen dat niet, omdat we eerst nog extra modelevaluaties moeten uitvoeren.

# Delete a fine-tuned model (must be an owner of the org the model was created in)
client.models.delete(fine_tuned_model)Mogelijk gemaakt door

Toegang tot het fijn-afgestelde model via Playground

Er is nóg een manier om toegang te krijgen tot het fijn-afgestelde model en het efficiënter te testen op verschillende prompts.

Ga naar het OpenAI-dashboard, klik op het tabblad "Fine-tuning", selecteer de recent uitgevoerde taak en klik daarna op de knop "Playground" rechtsonder.

Je komt terecht in de chatbotapplicatie. Daar kun je een systeemprompt opgeven en beginnen met het typen van het voorbeeld van de Reddit-post.

Je kunt zelfs dezelfde prompt draaien en vergelijken met een ander model voor een betere analyse.

Modelevaluatie

We hebben het model fijn-afgesteld en denken dat het goed genoeg is. Maar heb je overwogen of het vanaf het begin al beter was? We hebben nog geen gedetailleerde vergelijking vóór en na gedaan.

In deze sectie gebruiken we validatiedata om de labels te voorspellen met het basismodel en vergelijken we dit daarna met een fijn-afgesteld model. We vergelijken beide modellen op basis van nauwkeurigheid, classificatierapport en verwarringsmatrix.

Modelevaluatie vóór het fijn-afstellen

Maak een functie predict die de dataset en modelnaam als input krijgt om een lijst met voorspelde labels te genereren. Hij gebruikt dezelfde systeemberichten en posttitels uit de dataset.

def predict(test, model):
    y_pred = []
    categories = ["non-stress", "stress"]

    for index, row in test.iterrows():
        response = client.chat.completions.create(
            model=model,
            messages=[
                {
                    "role": "system",
                    "content": "Given a social media post, classify whether it indicates 'stress' or 'non-stress'.",
                },
                {"role": "user", "content": row["title"]},
            ],
        )

        answer = response.choices[0].message.content

        # Determine the predicted category

        for category in categories:
            if category.lower() in answer.lower():
                y_pred.append(category)
                break
        else:
            y_pred.append("none")
    return y_predMogelijk gemaakt door

Vervolgens maken we de functie evaluate, die de voorspelde en werkelijke labels gebruikt om een nauwkeurigheidsscore, classificatierapport en verwarringsmatrix te genereren.

from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import numpy as np


def evaluate(y_true, y_pred):
    labels = ["non-stress", "stress"]
    mapping = {label: idx for idx, label in enumerate(labels)}

    def map_func(x):
        return mapping.get(
            x, -1
        )  # Map to -1 if not found, but should not occur with correct data

    y_true_mapped = np.vectorize(map_func)(y_true)
    y_pred_mapped = np.vectorize(map_func)(y_pred)

    # Calculate accuracy

    accuracy = accuracy_score(y_true=y_true_mapped, y_pred=y_pred_mapped)
    print(f"Accuracy: {accuracy:.3f}")

    # Generate accuracy report

    unique_labels = set(y_true_mapped)  # Get unique labels

    for label in unique_labels:
        label_indices = [
            i for i in range(len(y_true_mapped)) if y_true_mapped[i] == label
        ]
        label_y_true = [y_true_mapped[i] for i in label_indices]
        label_y_pred = [y_pred_mapped[i] for i in label_indices]
        label_accuracy = accuracy_score(label_y_true, label_y_pred)
        print(f"Accuracy for label {labels[label]}: {label_accuracy:.3f}")
    # Generate classification report

    class_report = classification_report(
        y_true=y_true_mapped,
        y_pred=y_pred_mapped,
        target_names=labels,
        labels=list(range(len(labels))),
    )
    print("\nClassification Report:")
    print(class_report)

    # Generate confusion matrix

    conf_matrix = confusion_matrix(
        y_true=y_true_mapped, y_pred=y_pred_mapped, labels=list(range(len(labels)))
    )
    print("\nConfusion Matrix:")
    print(conf_matrix)
Mogelijk gemaakt door

Geef de functie predict de validatiedataset en de basismodelnaam. Geef vervolgens de voorspelde en werkelijke labels aan de functie evaluate en genereer een modelevaluatierapport.

y_pred = predict(validation_data, "gpt-4o-mini-2024-07-18")
y_true = validation_data["label"]
evaluate(y_true, y_pred)Mogelijk gemaakt door

Ons basismodel is behoorlijk goed in het classificeren van de tekst. We behaalden 92,5% nauwkeurigheid.

Accuracy: 0.925
Accuracy for label non-stress: 0.947
Accuracy for label stress: 0.905

Classification Report:
              precision    recall  f1-score   support

  non-stress       0.90      0.95      0.92        19
      stress       0.95      0.90      0.93        21

    accuracy                           0.93        40
   macro avg       0.93      0.93      0.92        40
weighted avg       0.93      0.93      0.93        40


Confusion Matrix:
[[18  1]
 [ 2 19]]Mogelijk gemaakt door

Modelevaluatie na het fijn-afstellen

Laten we de functie predict gebruiken met de fijn-afgestelde modelnaam om stresslabels te genereren. Vervolgens kunnen we met het voorspelde label en de werkelijke labels het gedetailleerde modelevaluatierapport genereren.

fine_tuned_model = "ft:gpt-4o-mini-2024-07-18:personal::AAnFfX5q"

y_pred = predict(validation_data,fine_tuned_model)
evaluate(y_true, y_pred)Mogelijk gemaakt door

De prestaties van ons model zijn verbeterd. We behaalden 97,5% nauwkeurigheid, wat een aanzienlijke verbetering is.

Accuracy: 0.975
Accuracy for label non-stress: 1.000
Accuracy for label stress: 0.952

Classification Report:
              precision    recall  f1-score   support

  non-stress       0.95      1.00      0.97        19
      stress       1.00      0.95      0.98        21

    accuracy                           0.97        40
   macro avg       0.97      0.98      0.97        40
weighted avg       0.98      0.97      0.98        40


Confusion Matrix:
[[19  0]
 [ 1 20]]Mogelijk gemaakt door

Fijn-afstellen op bepaalde taken kan de nauwkeurigheid flink verbeteren. Dit was slechts een voorbeeldtest, maar in echte projecten verbetert fijn-afstellen de nauwkeurigheid en prestaties van het model bij classificatietaken, styling en gestructureerde output.

Als je problemen ondervindt bij het uitvoeren van de bovenstaande code, raadpleeg dan de DataLab-werkruimte: Fijn-afstellen van GPT-4 Mini.

De volgende stap in je traject is om dit fijn-afgestelde model te gebruiken om een volwaardige AI-applicatie te bouwen. Je kunt erover leren door de code-along te volgen: Creating AI Assistants with GPT-4o.

Conclusie

In deze tutorial hebben we het GPT-4o mini-model succesvol fijn-afgesteld om tekst te classificeren in labels "stress" en "non-stress". We hebben dit fijn-afgestelde model vervolgens benaderd via de OpenAI API en de OpenAI playground, voor praktische toepassing en verdere tests.

De evaluatie van het fijn-afgestelde model leverde waardevolle inzichten op en toonde een verbetering in de classificatieprestaties over verschillende statistieken, vergeleken met het basismodel. Dit proces benadrukte de waarde van fijn-afstellen om betrouwbaardere en nauwkeurigere output te bereiken, vooral bij taken zoals tekstclassificatie.

Als je een gratis, open-sourcemodel wilt gebruiken, hebben we een uitstekende tutorial genaamd Fine-tuning Llama 3.2 en het lokaal gebruiken: een stapsgewijze gids. In deze gids laten we zien hoe je het nieuwste Llama-model fijnstemt en converteert naar het GGUF-formaat voor lokaal gebruik op je laptop.

Auteur

Abid Ali Awan

LinkedIn Twitter

Als gecertificeerd data scientist haal ik met passie het maximale uit de nieuwste technologie om innovatieve machinelearning-toepassingen te bouwen. Met een sterke achtergrond in spraakherkenning, data-analyse en -rapportage, MLOps, conversationele AI en NLP heb ik mijn vaardigheden aangescherpt in het ontwikkelen van intelligente systemen die echt impact maken. Naast mijn technische expertise ben ik ook een sterke communicator met een talent om complexe concepten terug te brengen tot heldere, beknopte taal. Daardoor ben ik uitgegroeid tot een veelgelezen blogger over data science, waar ik mijn inzichten en ervaringen deel met een groeiende community van data-professionals. Op dit moment richt ik me op contentcreatie en redactie, waarbij ik met large language models werk aan krachtige en aansprekende content die zowel bedrijven als individuen helpt het beste uit hun data te halen.

Onderwerpen

Kunstmatige intelligentie Large Language Models OpenAI

Onderwerpen

Technologieën

Fijn-afstellen van GPT-4o Mini: een stapsgewijze gids

Verken met AI

Kennismaking met GPT-4o Mini

De OpenAI API instellen

GPT-4o Mini fijn-afstellen

De dataset maken

De dataset uploaden

De fine-tuningtaak starten

Toegang krijgen tot het fijn-afgestelde model via de API

Toegang tot het fijn-afgestelde model via Playground

Modelevaluatie

Modelevaluatie vóór het fijn-afstellen

Modelevaluatie na het fijn-afstellen

Conclusie

Onderwerpen

Top DataCamp OpenAI-cursussen

Werken met de OpenAI API

Introductie tot Embeddings met de OpenAI API

AI-systemen ontwikkelen met de OpenAI API

Onderwerpen

Technologieën

Top DataCamp OpenAI-cursussen

Werken met de OpenAI API

Introductie tot Embeddings met de OpenAI API

AI-systemen ontwikkelen met de OpenAI API