Ajuster finement GPT-4 d’OpenAI : guide pas à pas

Le modèle le plus avancé d’OpenAI, le Generative Pre-trained Transformer 4 (GPT-4), lancé en mars 2023, marque une avancée majeure en intelligence artificielle et fixe un nouveau standard de performance. Disponible via ChatGPT Plus, l’API d’OpenAI et Microsoft Copilot, GPT-4 se distingue par ses capacités multimodales, notamment avec GPT-4V, qui lui permet de traiter des images en plus du texte et ouvre la voie à des applications innovantes dans de nombreux domaines.

Au cœur des progrès de GPT-4 se trouve son architecture de type transformer, largement préentraînée sur de vastes corpus issus d’Internet et de sources sous licence, puis ajustée finement grâce à une combinaison de retours humains et d’apprentissage par renforcement piloté par l’IA. Cette approche vise à mieux aligner le modèle sur des standards éthiques et des politiques conformes aux attentes humaines.

Bien que GPT-4 améliore son prédécesseur, GPT-3, il en hérite aussi certaines limites, ce qui illustre la complexité des grands modèles de langage et de l’IA générative. Certaines de ces limites peuvent être atténuées via un processus appelé fine-tuning, qui constitue le sujet de ce tutoriel. Les objectifs sont :

• Comprendre ce qu’est le fine-tuning et quand l’utiliser
• Découvrir les cas d’usage courants du fine-tuning
• Implémenter pas à pas l’API de fine-tuning d’OpenAI en Python.

À noter toutefois que le fine-tuning de GPT-4 n’est pour l’instant accessible qu’à titre expérimental : les développeurs éligibles peuvent demander l’accès via l’interface de fine-tuning. Cela dit, les techniques décrites s’appliquent à tous les modèles GPT.

Qu’est-ce que le fine-tuning ?

Le fine-tuning est un processus avancé qui adapte des modèles préentraînés (comme GPT-4) à des tâches ou des domaines spécifiques, en tirant parti de leurs connaissances fondamentales acquises lors de l’entraînement initial sur des jeux de données variés. Il consiste à ajuster les paramètres du modèle à partir de données propres à la tâche, afin d’en améliorer les performances et de le rendre plus précis et efficace sur des applications ciblées.

Un exemple parlant de l’impact du fine-tuning est l’enrichissement des réponses à des questions spécialisées. Par exemple, un modèle préentraîné peut fournir une explication simple à « Pourquoi le ciel est-il bleu ? ». Après fine-tuning, il pourra intégrer un contexte scientifique détaillé, plus adapté à des usages comme les plateformes éducatives.

Les méthodes de fine-tuning vont de l’ajustement par instructions, où l’on entraîne le modèle avec des exemples illustrant le comportement attendu, aux approches efficaces en paramètres (PEFT), qui n’actualisent qu’un sous-ensemble de paramètres afin d’économiser des ressources et d’éviter l’oubli catastrophique.

À l’inverse, la génération augmentée par récupération (RAG) propose une autre voie. RAG combine des éléments de systèmes à récupération d’information et de modèles génératifs pour améliorer la qualité des contenus en intégrant, pendant la génération, des informations récupérées depuis des sources externes.

Alors que le fine-tuning optimise un modèle existant pour des tâches précises, RAG injecte des connaissances externes pour enrichir la génération.

Le choix entre fine-tuning et RAG dépend des besoins de l’application : fraîcheur de l’information requise, ressources de calcul disponibles, et niveau de spécialisation recherché. Le fine-tuning permet d’exploiter directement la base de connaissances d’un modèle préentraîné pour une tâche donnée, tandis que RAG apporte une approche dynamique pour garantir la pertinence et l’exactitude des informations utilisées par le modèle.

Quand utiliser le fine-tuning ?

Le fine-tuning des modèles de génération de texte d’OpenAI est une méthode puissante pour les adapter à des besoins spécifiques, mais elle exige du temps et des ressources. Avant de vous lancer, essayez d’abord d’optimiser les performances via le prompt engineering, le chaînage de prompts (décomposer une tâche complexe en étapes séquentielles) et l’usage de fonctions. Cette approche est recommandée pour plusieurs raisons :

• Les modèles peuvent au départ peiner sur certaines tâches, mais des prompts bien conçus améliorent nettement les résultats, rendant souvent le fine-tuning superflu.
• Ajuster les prompts et recourir à des stratégies comme le chaînage de prompts ou le function calling offre un retour immédiat et permet d’itérer rapidement. À l’inverse, le fine-tuning implique de constituer des jeux de données et d’entraîner des modèles, ce qui prend plus de temps.
• Même si le fine-tuning devient nécessaire, le travail préparatoire en prompt engineering n’est pas perdu. Intégrer des prompts bien pensés dans le processus d’ajustement ou les combiner aux techniques de fine-tuning donne souvent les meilleurs résultats.

Cas d’usage courants du fine-tuning

Le fine-tuning est particulièrement utile dans les situations suivantes :

• Personnaliser les caractéristiques de sortie. Si vous avez besoin d’un style, d’un ton, d’un format ou d’autres attributs qualitatifs spécifiques, le fine-tuning permet de modeler les réponses en conséquence.
• Renforcer la fiabilité. Pour les applications où il est crucial que le modèle produise systématiquement le type de sortie attendu, le fine-tuning améliore la constance.
• Gérer des prompts complexes. Si le modèle suit mal des consignes élaborées, le fine-tuning l’aide à mieux les comprendre et les exécuter.
• Traiter les cas limites. Le fine-tuning peut apprendre au modèle à gérer de nombreux cas particuliers de manière spécifique et prédéfinie, ce qui accroît sa polyvalence.
• Apprendre de nouvelles compétences ou tâches. Si vous souhaitez lui enseigner une compétence ou une tâche difficile à encapsuler dans un simple prompt, le fine-tuning lui apporte les capacités nécessaires.

Guide pas à pas pour ajuster les modèles GPT d’OpenAI avec Python

En raison de la nature propriétaire des modèles d’OpenAI, vous devez utiliser leur API de fine-tuning si vous souhaitez ajuster l’un de leurs modèles. Ce processus implique de téléverser vos données sur les serveurs d’OpenAI pour entraîner le modèle.

Actuellement, seuls les modèles suivants sont pris en charge pour le fine-tuning via l’API :

• gpt-3.5-turbo-0125,
• gpt-3.5-turbo-1106,
• gpt-3.5-turbo-0613,
• babbage-002,
• davinci-002

Le fine-tuning de GPT-4 est en accès expérimental ; les développeurs éligibles peuvent demander l’accès via l’interface de fine-tuning. Quel que soit le modèle utilisé, le processus et le code de ce tutoriel ne changent pas.

6 étapes pour ajuster les modèles GPT d’OpenAI

1. Préparer les données d’entraînement

C’est l’étape la plus importante. La qualité d’un modèle ajusté dépend directement des données que vous créez pour le fine-tuning. Pour l’API OpenAI, les données doivent être au format jsonl.

Le format JSONL est un format texte où chaque ligne est un objet JSON indépendant, ce qui le rend adapté au traitement de gros volumes ligne par ligne. Il est particulièrement utile lorsque les données peuvent être segmentées en enregistrements individuels sans perdre leur structure.

Exemple :

{"prompt": "<prompt text>", "completion": "<ideal generated text>"}

{"prompt": "<prompt text>", "completion": "<ideal generated text>"}

{"prompt": "<prompt text>", "completion": "<ideal generated text>"}

Pour ce tutoriel, j’ai créé un petit jeu d’exemples (cinq au total). Il s’agit de questions sur divers sujets de machine learning, avec des réponses dans le style de Shakespeare.

Extrait d’exemples utilisés :

{"messages": [{"role": "system", "content": "You are teaching assistant for Machine Learning. You should help to user to answer on his question."}, {"role": "user", "content": "What is machine learning?"}, {"role": "assistant", "content": "'Tis but the art of teaching machines to think, to learn from data most fine, and decisions to link."}]}

{"messages": [{"role": "system", "content": "You are teaching assistant for Machine Learning. You should help to user to answer on his question."}, {"role": "user", "content": "How doth neural networks work?"}, {"role": "assistant", "content": "They're like the brains of yon digital beast, with layers many, and nodes that cease."}]}

2. Installer la bibliothèque openai et configurer un jeton d’API

La première étape pour créer une tâche de fine-tuning avec l’API OpenAI consiste à téléverser le fichier. Pour utiliser cette API, vous devez installer la bibliothèque Python openai.

!pip install openai

Connectez-vous ensuite à votre compte platform.openai.com et générez un jeton d’API :

Vous pouvez ensuite définir ce jeton comme variable d’environnement via la bibliothèque os.

import os


# Set the OPENAI_API_KEY environment variable
os.environ['OPENAI_API_KEY'] = '...'

3. Téléverser le fichier d’entraînement

Votre fichier d’entraînement doit être au format jsonl. Après téléversement, le traitement peut prendre un certain temps. La taille maximale autorisée est de 1 Go. Pour envoyer un fichier sur le serveur d’OpenAI :

from openai import OpenAI
client = OpenAI()


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

Sortie :

FileObject(id='file-rIua39sJX1O64gzxTYfpvJx7', bytes=11165, created_at=1709499930, filename='train.jsonl', object='file', purpose='fine-tune', status='processed', status_details=None)

4. Créer un modèle ajusté

Une fois le fichier correctement téléversé, créez une tâche de fine-tuning. training_file correspond à l’identifiant renvoyé lors de l’envoi du fichier à l’API OpenAI. Pour démarrer une tâche :

from openai import OpenAI
client = OpenAI()


client.fine_tuning.jobs.create(
  training_file="file-rIua39sJX1O64gzxTYfpvJx7",
  model="gpt-3.5-turbo" #change to gpt-4-0613 if you have access
)

Pour configurer des paramètres supplémentaires (fichier de validation, hyperparamètres, etc.), consultez la documentation de l’API sur le fine-tuning.

La durée d’un job de fine-tuning varie de quelques minutes à plusieurs heures, selon le modèle et la taille du jeu de données. Par exemple, avec seulement 50 exemples dans notre train.jsonl et le modèle gpt-3.5-turbo, la tâche s’est achevée en 7 minutes.

Une confirmation par e‑mail est également envoyée une fois la tâche terminée.

Au-delà de la création d’un job, vous pouvez lister les tâches en cours, consulter l’état d’une tâche spécifique ou l’annuler.

from openai import OpenAI
client = OpenAI()


# List 10 fine-tuning jobs
client.fine_tuning.jobs.list(limit=10)


# Retrieve the state of a fine-tune
client.fine_tuning.jobs.retrieve("...")


# Cancel a job
client.fine_tuning.jobs.cancel("...")


# List up to 10 events from a fine-tuning job
client.fine_tuning.jobs.list_events(fine_tuning_job_id="...", limit=10)


# Delete a fine-tuned model (must be an owner of the org the model was created in)
client.models.delete("ft:gpt-3.5-turbo:xxx:xxx")\

5. Analyser le modèle ajusté

OpenAI fournit des métriques clés d’entraînement : perte d’entraînement, précision par jeton en entraînement, perte de test et précision par jeton en test. Elles permettent de vérifier que l’apprentissage progresse comme prévu, avec une baisse de la perte et une amélioration de la précision. Vous pouvez consulter ces métriques dans un objet d’événement pendant l’exécution de la tâche.

{
    "object": "fine_tuning.job.event",
    "id": "ftjob-Na7BnF5y91wwGJ4EgxtzVyDD",
    "created_at": 1693582679,
    "level": "info",
    "message": "Step 100/100: training loss=0.00",
    "data": {
        "step": 100,
        "train_loss": 1.805623287509661e-5,
        "train_mean_token_accuracy": 1.0
    },
    "type": "metrics"
}

Vous pouvez aussi retrouver ces informations dans l’interface.

6. Utiliser le modèle ajusté

À l’issue de la tâche, les détails incluent le champ fine_tuned_model, qui fournit le nom du modèle. Vous pouvez alors appeler l’API sur ce modèle et obtenir une réponse du modèle que vous venez d’ajuster.

from openai import OpenAI
client = OpenAI()


completion = client.chat.completions.create(
  model="ft:gpt-3.5-turbo-0613:personal::8k01tfYd",
  messages=[
    {"role": "system", "content": "You are a teaching assistant for Machine Learning. You should help to user to answer on his question."},
    {"role": "user", "content": "What is a loss function?"}
  ]
)
print(completion.choices[0].message)

Sortie :

ChatCompletionMessage(content="To measure how far we falter, it guides our way, our hope's defaulter.", role='assistant', function_call=None, tool_calls=None)

Conclusion

Ce tutoriel vous a guidé dans le processus de fine-tuning d’un modèle GPT d’OpenAI, une étape avancée pour exploiter pleinement les capacités des LLM dans des domaines applicatifs spécialisés. Le fine-tuning permet d’affiner les réponses du modèle de langage, afin de mieux traiter des tâches, des styles ou des domaines spécifiques avec plus de précision et d’efficacité.

Ce tutoriel utilise l’API Python d’OpenAI pour ajuster un modèle. Si vous préférez apprendre à faire la même chose via une interface, sans écrire une ligne de code, consultez le tutoriel How to Fine Tune GPT 3.5 sur Datacamp.

Comme GPT n’est pas un modèle open source, le processus de fine-tuning est plutôt simple et se résume à des appels d’API. La démarche diffère fortement pour des modèles open source comme Llama 2, Mistral, Stable Diffusion, etc. Si vous souhaitez apprendre à ajuster différents modèles open source, consultez ces articles sur DataCamp :

• Fine-Tuning LLaMA 2: A Step-by-Step Guide to Customizing the Large Language Model
• FLAN-T5 Tutorial: Guide and Fine-Tuning
• Fine-tuning Stable Diffusion XL with DreamBooth and LoRA

Pour des ressources d’introduction au fine-tuning de LLM, consultez An Introductory Guide to Fine-Tuning LLMs sur Datacamp.