1. Introduction à l'ajustement fin

1.1. Définition et avantages de l'ajustement fin du modèle

L'ajustement fin est un concept en apprentissage profond qui désigne le processus de poursuite de l'entraînement basé sur un modèle pré-entraîné afin de l'adapter à des tâches ou des ensembles de données spécifiques. Les modèles pré-entraînés ont été entraînés sur de très grandes quantités de données et ont appris des représentations de caractéristiques riches. Grâce à l'ajustement fin, les performances du modèle pour des tâches spécifiques peuvent être encore améliorées sur cette base.

Les avantages de l'ajustement fin par rapport à l'entraînement des modèles à partir de zéro incluent principalement :

  1. Économie de temps et de ressources : Les modèles pré-entraînés éliminent le temps et les ressources informatiques nécessaires pour entraîner les modèles à partir de zéro, surtout pour les modèles volumineux et les tâches complexes.
  2. Efficacité des données : L'ajustement fin nécessite généralement moins de données annotées pour obtenir de bons résultats, notamment dans les domaines présentant des données rares.
  3. Transfert d'apprentissage : Les modèles pré-entraînés apprennent à partir de données diverses, et l'ajustement fin peut transférer ces connaissances à des tâches spécifiques, améliorant ainsi la capacité de généralisation.
  4. Amélioration des performances : L'ajustement fin permet au modèle de mieux s'adapter aux exigences spécifiques de la tâche, ce qui contribue à améliorer la qualité du modèle et à réduire les taux d'erreur.

Par exemple, en exploitant l'API d'OpenAI, les utilisateurs peuvent personnaliser le modèle GPT grâce à l'ajustement fin afin d'obtenir des résultats de meilleure qualité tout en économisant sur les coûts associés aux longs prompts et en réduisant la latence.

1.2. Cas d'application pratique

L'ajustement fin s'est avéré très efficace dans divers scénarios pratiques. Par exemple :

  • Définition de styles et de tonalités : Grâce à l'ajustement fin, les réponses des chatbots peuvent être adaptées à des styles ou des tonalités spécifiques, tels que formel, humoristique, ou en adéquation avec le langage d'un secteur particulier.
  • Amélioration de la fiabilité : Dans des applications sensibles telles que les consultations médicales ou les conseils juridiques, l'ajustement fin peut réduire les malentendus ou les réponses inexactes, améliorant ainsi la fiabilité globale.
  • Traitement de prompts complexes : Certaines tâches nécessitent le traitement d'entrées utilisateur complexes, et l'ajustement fin peut aider le modèle à mieux comprendre ces scénarios complexes et à fournir des réponses précises.
  • Amélioration des performances pour des tâches spécifiques : Pour les tâches difficiles à décrire à travers un seul prompt, telles que le transfert de style dans la génération de texte ou la génération de texte sur des sujets spécifiques, l'ajustement fin peut améliorer significativement les performances du modèle.

À travers ces cas, on constate que l'ajustement fin permet aux modèles de mieux s'adapter à des scénarios d'application spécifiques, offrant des services plus précis et personnalisés.

2. Quand utiliser l'ajustement fin

2.1. Analyse des exigences de la tâche

L'ajustement fin est une stratégie employée lorsqu'il est déterminé que les modèles généraux existants ne peuvent pas répondre à des exigences spécifiques. L'ajustement fin peut être nécessaire lorsque la tâche présente les caractéristiques suivantes :

  • Exigences particulières en termes de style, de ton, de format, ou d'autres aspects qualitatifs
  • Besoin d'améliorer la fiabilité dans la production des sorties souhaitées
  • Approches spécifiques requises pour traiter de nombreux cas détaillés
  • Compétences ou tâches difficiles à spécifier clairement dans les prompts

Les étapes pour déterminer la nécessité de l'ajustement fin incluent généralement :

  1. Tenter un "ingénierie de prompts", en ajustant la manière dont les prompts d'entrée sont présentés pour optimiser les résultats.
  2. Analyser l'efficacité des modèles existants pour déterminer la nécessité de l'ajustement fin.
  3. Si la décision d'effectuer un ajustement fin est prise, préparer les ensembles de données pertinents pour un entraînement ultérieur.

2.2. Comparaison entre l'ajustement fin et l'ingénierie de prompts

L'ajustement fin et l'ingénierie de prompts sont deux stratégies différentes pour améliorer les performances du modèle. L'ingénierie de prompts consiste à guider le modèle pour produire la réponse attendue à l'aide de prompts soigneusement conçus, sans modifier le modèle lui-même. Il s'agit souvent de la première étape pour rechercher une amélioration des performances, car elle a un cycle de rétroaction rapide et ne nécessite pas de données d'entraînement.

Cependant, dans certains cas, même avec des prompts soigneusement conçus, le modèle peut encore avoir du mal à obtenir les résultats attendus. Dans de tels scénarios, l'ajustement fin devient le choix nécessaire pour améliorer les performances du modèle. En fournissant un grand nombre d'exemples sur lesquels le modèle peut apprendre, l'ajustement fin peut obtenir de meilleurs résultats sur différentes tâches par rapport à l'ingénierie de prompts seule.

3. Modèles prenant en charge le fine-tuning

OpenAI propose une gamme de modèles prenant en charge le fine-tuning, notamment gpt-3.5-turbo-1106 (recommandé), gpt-3.5-turbo-0613, babbage-002, davinci-002, et le modèle expérimentalement accessible gpt-4-0613. Ces modèles peuvent être davantage entraînés via le fine-tuning pour s'adapter à des besoins spécifiques des utilisateurs.

Le fine-tuning s'applique non seulement aux nouveaux ensembles de données, mais les utilisateurs peuvent également poursuivre le fine-tuning sur des modèles qui ont été précédemment fine-tunés. Ceci est particulièrement utile lorsque plus de données sont obtenues et qu'il est nécessaire d'optimiser davantage le modèle sans répéter les étapes d'entraînement précédentes.

Pour la plupart des utilisateurs, gpt-3.5-turbo est le choix préféré en raison de ses résultats satisfaisants et de sa facilité d'utilisation. Compte tenu des améliorations continues et des besoins spécifiques des utilisateurs, OpenAI peut continuer à mettre à jour et à étendre la gamme de modèles prenant en charge le fine-tuning.

4. Préparation des données d'entraînement

4.1. Format du jeu de données

Pour effectuer le fine-tuning, vous devez préparer un jeu de données qui répond aux exigences de format spécifiées. Typiquement, ce jeu de données contient une série d'entrées et de leurs sorties attendues correspondantes. L'API de fine-tuning d'OpenAI prend en charge deux formats principaux de données : le modèle de dialogue et les paires de questions-réponses simples.

Le format de jeu de données du modèle de dialogue est généralement utilisé pour le modèle gpt-3.5-turbo. Chaque exemple est organisé sous la forme d'une conversation, où chaque message a un rôle, un contenu et un nom facultatif. La structure de données d'exemple est la suivante :

{
  "messages": [
    {"role": "system", "content": "Vous êtes un assistant utile."},
    {"role": "user", "content": "Quel temps fait-il aujourd'hui ?"},
    {"role": "assistant", "content": "Le temps aujourd'hui est clair et propice à la sortie."}
  ]
}

Chaque cas doit être formaté sous la forme d'un fichier au format JSON Lines (.jsonl), où chaque ligne représente un échantillon d'entraînement, par exemple :

{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "Quelle est la capitale de la France ?"}, {"role": "assistant", "content": "Paris, comme si tout le monde ne le savait pas déjà."}]}
{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "Qui a écrit 'Roméo et Juliette' ?"}, {"role": "assistant", "content": "Oh, juste un certain William Shakespeare. Tu en as déjà entendu parler ?"}]}
{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "À quelle distance se trouve la Lune de la Terre ?"}, {"role": "assistant", "content": "Environ 384 400 kilomètres. À quelques kilomètres près, comme si ça avait vraiment de l'importance."}]}

Le format de jeu de données de paires de questions-réponses simples convient aux modèles comme babbage-002 et davinci-002. Le format est plus simple, il se compose d'une paire de prompt (invite) et de completion (achèvement). Un exemple est le suivant :

{
  "prompt": "Quel temps fait-il aujourd'hui ?",
  "completion": "Le temps aujourd'hui est clair et propice à la sortie."
}

De même, chaque échantillon d'entraînement occupe une ligne, par exemple :

{"prompt": "<texte de l'invite>", "completion": "<texte généré idéal>"}
{"prompt": "<texte de l'invite>", "completion": "<texte généré idéal>"}
{"prompt": "<texte de l'invite>", "completion": "<texte généré idéal>"}

Lors de la création des données de fine-tuning, veillez à bien tenir compte de chaque instruction ou invitation fournie pour assurer la cohérence entre les exemples d'entraînement et couvrir autant que possible tous les scénarios d'utilisation attendus.

4.2. Division des données d'entraînement et de test

Après avoir créé le jeu de données de fine-tuning, il est crucial de diviser correctement le jeu de données en ensembles d'entraînement et de test. Typiquement, le jeu de données est divisé en deux parties, la majorité étant utilisée pour l'entraînement du modèle (généralement 70 % à 90 %) et la portion restante utilisée pour les tests (10 % à 30 %). Cette division permet de valider la performance du modèle sur des données non vues et d'évaluer rigoureusement ses performances.

La division du jeu de données peut être effectuée manuellement ou en écrivant du code pour la diviser, ce qui sera expliqué dans les sections suivantes sur la manière d'évaluer le modèle en utilisant les données de l'ensemble de test.

5. Création du modèle fine-tuned

5.1. Choix du bon modèle pré-entraîné

Avant de commencer le processus de fine-tuning, il est crucial de sélectionner le bon modèle pré-entraîné pour garantir le succès de la tâche. Voici quelques suggestions pour choisir le modèle pré-entraîné approprié :

  1. Type de tâche : En fonction de la nature de votre tâche, telle que la compréhension du langage, la génération ou la réponse à des questions spécifiques à un domaine, choisissez le modèle qui convient le mieux à ces tâches. Par exemple, le modèle gpt-3.5-turbo est adapté à la plupart des scénarios car il équilibre performances et facilité d'utilisation.

  2. Volume de données : Si vous disposez de relativement moins de données d'entraînement, vous pouvez préférer choisir un modèle plus petit comme babbage-002, car il nécessite moins de données pour le réglage des paramètres.

  3. Exigences de performances : Pour les scénarios nécessitant un traitement de tâches plus complexe et plus fin, envisagez de choisir le modèle plus puissant davinci-002.

  4. Considération des coûts : Différents modèles ont différentes exigences en termes de calcul et de stockage. En général, les modèles plus volumineux entraînent des coûts plus élevés. Équilibrez selon le budget et les exigences de performance.

  5. Fonctionnalités expérimentales : Le modèle gpt-4-0613 est actuellement à un stade expérimental. Si vous souhaitez tester la dernière technologie et avez une tolérance pour les interfaces expérimentales, envisagez de demander l'accès.

5.2. Processus de fine-tuning

Le processus de fine-tuning couvre plusieurs étapes telles que la préparation des données, le téléchargement des fichiers, la création de tâches d'entraînement et le suivi des progrès. Voici un décompte détaillé :

5.2.1. Préparation des données

Préparez suffisamment de données d'entraînement et de test en fonction de la tâche cible et assurez-vous que le format des données est conforme aux exigences, telles que le format JSON Lines (.jsonl). Veuillez vous référer aux chapitres précédents pour les détails du contenu.

5.2.2. Téléchargement des données

Téléchargez vos fichiers de données d'entraînement via l'API de fichiers OpenAI, en spécifiant l'objectif du fichier comme fine-tune, comme illustré ci-dessous :

   curl https://api.openai.com/v1/files \
     -H "Authorization: Bearer $OPENAI_API_KEY" \
     -F purpose="fine-tune" \
     -F file="@mydata.jsonl"

Après un téléchargement réussi, vous recevrez un ID de fichier à utiliser pour les tâches d'entraînement du modèle ultérieur.

5.2.3. Création des tâches d'entraînement

Initialisez les tâches de fine-tuning à l'aide de l'API ou des outils CLI d'OpenAI, en spécifiant les paramètres requis et le modèle. Par exemple :

   from openai import OpenAI
   client = OpenAI()

   client.fine_tuning.jobs.create(
     training_file="file-abc123", 
     model="gpt-3.5-turbo"
   )

Le paramètre training_file spécifie l'ID du fichier de données d'entraînement, et le paramètre model spécifie le modèle à utiliser pour l'entraînement.

5.2.4. Suivi des tâches d'entraînement

Ce qui suit illustre comment interroger les résultats de l'entraînement en utilisant Python :

from openai import OpenAI
client = OpenAI()

client.fine_tuning.jobs.list(limit=10)

client.fine_tuning.jobs.retrieve("ftjob-abc123")

client.fine_tuning.jobs.cancel("ftjob-abc123")

client.fine_tuning.jobs.list_events(fine_tuning_job_id="ftjob-abc123", limit=10)

client.models.delete("ft:gpt-3.5-turbo:acemeco:suffix:abc123")

6. Ajustement des paramètres pendant les processus de fine-tuning

6.1 Compréhension et ajustement des hyperparamètres

Les hyperparamètres sont des paramètres définis avant l'entraînement du modèle et ils ne peuvent généralement pas être appris à partir des données. Voici quelques hyperparamètres importants :

  • Nombre d'époques (n_epochs) : Cela détermine combien de fois votre modèle va itérer à travers l'ensemble des données. Trop d'époques peuvent entraîner un surajustement, tandis que trop peu peuvent empêcher le modèle d'apprendre suffisamment.

  • Taux d'apprentissage (learning_rate_multiplier) : Le taux d'apprentissage détermine dans quelle mesure le modèle met à jour ses poids à chaque itération. Un taux d'apprentissage trop élevé peut causer de l'instabilité dans le processus d'apprentissage, tandis qu'un taux trop faible peut ralentir le processus d'apprentissage.

  • Taille du lot (batch_size) : La taille du lot détermine combien d'instances d'entraînement sont prises en compte dans chaque mise à jour du modèle. Une taille de lot plus grande aide à stabiliser l'entraînement, mais peut augmenter la pression sur la mémoire.

L'ajustement des hyperparamètres nécessite généralement des expérimentations répétées pour trouver la combinaison optimale de paramètres.

Exemple d'initialisation d'une tâche de peaufinage avec des hyperparamètres :

from openai import OpenAI
client = OpenAI()

client.fine_tuning.jobs.create(
  training_file="file-abc123",
  model="gpt-3.5-turbo",
  hyperparameters={
    "n_epochs":2
  }
)

Le paramètre hyperparameters est utilisé pour définir les hyperparamètres.

6.2 Méthodes d'itération et d'amélioration du modèle

Après le premier réglage fin, il peut être nécessaire d'itérer pour optimiser davantage les performances du modèle. Voici quelques stratégies d'itération :

  • Augmenter les données : Si le modèle se comporte mal sur certains types d'entrées, essayez d'ajouter plus d'exemples de ces entrées.

  • Réfléchir sur la qualité des données : Vérifiez si les données d'entraînement contiennent des informations incorrectes ou ambiguës. Ces problèmes de qualité peuvent entraîner de mauvaises performances du modèle.

  • Équilibre des données : Assurez-vous que les données d'entraînement présentent une diversité et un équilibre dans les catégories et les styles.

  • Ajuster les hyperparamètres : Comme mentionné précédemment, ajuster le nombre d'époques, le taux d'apprentissage et la taille du lot peut avoir un impact significatif sur les performances du modèle.

Grâce à ces méthodes, vous pouvez optimiser progressivement votre modèle peaufiné pour obtenir les meilleures performances.

7. Évaluation et utilisation des modèles peaufinés

7.1 Évaluation des modèles peaufinés

Lorsque le peaufinage du modèle est terminé, évaluer les performances du modèle peaufiné est crucial. Voici quelques méthodes d'évaluation standard :

  1. Comparaison des échantillons : Utilisez les échantillons de test préparés pour appeler séparément le modèle de base et le modèle peaufiné, puis comparez les résultats de sortie pour évaluer l'efficacité du modèle peaufiné.

  2. Métriques statistiques : Suivez des métriques telles que la perte et l'exactitude pendant le processus de peaufinage. La perte devrait diminuer pendant l'entraînement, tandis que l'exactitude devrait augmenter.

  3. Test A/B : Concevez des expériences, divisez le trafic et exécutez à la fois le modèle de base et le modèle peaufiné simultanément pour observer les différences de performances dans un environnement réel.

  4. Avis des utilisateurs : Recueillez les avis des utilisateurs sur l'utilisation du modèle, en particulier pour les tâches de traitement du langage naturel, où la satisfaction des utilisateurs est un critère essentiel des performances du modèle.

7.2 Comment utiliser les modèles peaufinés

L'utilisation d'un modèle peaufiné est très simple. Il vous suffit de passer le nom de votre modèle peaufiné en tant que paramètre dans l'appel API. Voici un exemple de code pour utiliser un modèle peaufiné :

Exemple en Python

from openai import OpenAI

client = OpenAI(api_key='Your API Key')

response = client.chat.completions.create(
  model="Nom du modèle",
  messages=[
    {"role": "system", "content": "Vous êtes un assistant serviable."},
    {"role": "user", "content": "Bonjour !"}
  ]
)
print(response.choices[0].message)

Ici, remplacez "Nom du modèle" par le nom spécifique de votre modèle peaufiné, par exemple "ft:nom du modèle:votre organisation:votre nom de peaufinage:id".

Chapitre 7: Meilleures pratiques pour le peaufinage

Pendant le processus de peaufinage, nous pouvons suivre quelques meilleures pratiques pour améliorer davantage les performances du modèle :

  1. Qualité des données: Assurez-vous d'avoir des données d'entraînement de haute qualité et diversifiées pour éviter une mauvaise performance du modèle due à des données inexactes ou uniques.

  2. Distribution des données: Les données d'entraînement doivent couvrir tous les scénarios d'entrée possibles pour garantir les performances du modèle dans des situations réelles.

  3. Itérations progressives: Augmentez progressivement les données d'entraînement et observez les changements de performance du modèle, au lieu d'ajouter une grande quantité de données en une seule fois.

  4. Ajustement des hyperparamètres: Ajustez les hyperparamètres tels que le taux d'apprentissage, la taille du batch et le nombre d'itérations en fonction des performances du modèle.

  5. Amélioration continue: Peaufiner un modèle n'est pas un processus ponctuel. Des itérations régulières pour mettre à jour l'ensemble de données et le modèle peuvent améliorer continuellement l'efficacité du modèle.

Problèmes courants et solutions :

  • Q: Que faire si le modèle peaufiné ne produit pas les résultats attendus ?

    • A: Vérifiez attentivement et améliorez la qualité et la diversité des données d'entraînement, et ajustez la stratégie d'entraînement en fonction des résultats d'évaluation.

  • Q: Comment gérer une mauvaise performance du modèle dans des scénarios spécifiques ?

    • A: Augmentez les échantillons d'entraînement pour ce scénario afin d'améliorer la capacité de traitement du modèle dans cette situation particulière.

  • Q: Comment contrôler les coûts pendant le processus de peaufinage ?

    • A: Estimez les comptes de jetons à l'avance et évaluez les coûts des différents modèles.

En intégrant ces suggestions et outils, vous pourrez maximiser l'efficacité du peaufinage de votre modèle et vous assurer que le processus de peaufinage répond à vos attentes et besoins.