Personnaliser un modèle de ChatGPT/OpenAI avec l'API

Les entreprises peuvent non seulement installer un chatbot fonctionnant sur l'API d'OpenAI, mais en plus, personnaliser le modèle pour que le chatbot réponde comme leurs experts internes l'auraient fait (ou presque).

Les clients de l'API d'OpenAI ont la possibilité moyennant finance de créer un modèle personnalisé sur base du LLM d'OpenAI.

Pour cela, il faut

1. Créer le modèle grâce à des données (texte) composées d'exemples de ce que l'on souhaite apprendre à OpenAI et laisser le temps au modèle de s'entrainer sur base de ces données (c'est payant et le prix varie suivant la quantité de données transmises)

2. Tester l'efficacité du nouveau modèle

3. Sélectionner le nouveau modèle lors de chaque requête, puisque le modèle apparait parmi les modèles disponibles à côté des modèles standard et accepter de payer un peu plus cher (environ 50% plus cher par requête que pour les modèles de base).

Comment personnaliser les modèles GPT avec l'API d'OpenAI

Introduction: le fine tuning

La fine tuning, l'opération qui permet de personnaliser un modèle standard, offre les avantages suivants

• des résultats de meilleure qualité que la conception rapide
• la possibilité de s'entraîner sur un plus grand nombre d'exemples que ne peut en contenir une prompt
• Économie de tokens/jetons grâce à des prompts plus courtes (pas par rapport à l'envoi d'un prompt standard, mais par rapport à un prompt dans lequel on donne des exemples de bonnes réponses et qui consomme donc, plus de tokens).
• des demandes de latence plus faibles.

GPT-3 et GPT-4 ont été pré-entraîné sur une grande quantité de textes provenant de l'internet ouvert. Lorsqu'il reçoit une prompt/ un prompt avec seulement quelques exemples, il peut souvent comprendre la tâche que vous essayez d'accomplir et générer une réponse plausible. C'est ce que l'on appelle "l'apprentissage en quelques coups".

Le fine tuning dépasse en performance l'apprentissage à quelques coups en s'entraînant sur beaucoup plus d'exemples que n'en contient le prompt, ce qui permet d'obtenir de meilleurs résultats pour un grand nombre de tâches. Une fois qu'un modèle a été affiné, il n'est plus nécessaire de fournir des exemples dans le prompt. Cela permet d'économiser des coûts et de réduire la latence des requêtes.

Le fine tuning implique les étapes suivantes :

• Préparer et télécharger les données d'entraînement
• Entraîner un nouveau modèle affiné
• Utiliser votre modèle affiné

La page tarifs d'OpenAI indique les tarifs en vigueur d'utilisation d'un modèle affiné (personnalisé)  et de la phrase d'entraînement de ce modèle.

Quels modèles peuvent être affinés ?

La fine tuning n'est actuellement disponible que pour les modèles de base suivants :

• davinci
• curie
• babbage
• ada

Il s'agit des modèles originaux qui n'ont pas d'instruction après la formation (comme le texte-davinci-003 par exemple, que vous ne pouvez pas fine tuné, puisqu'il s'agit d'un modèle déjà fine-tuné.).

En revanche, vous pouvez également continuer à affiner un modèle que vous avez déjà fine-tuné en y ajoutant des données supplémentaires sans avoir à repartir de zéro.

Installation de la brique de fine tuning

Nous recommandons d'utiliser notre interface de ligne de commande (CLI) OpenAI. Pour l'installer, exécutezpip install --upgrade openai

(Les instructions suivantes fonctionnent à partir de la version 0.9.4). De plus, l'interface CLI OpenAI nécessite python 3).

Définissez la variable d'environnement OPENAI_API_KEY en ajoutant la ligne suivante à votre script d'initialisation du shell (par exemple .bashrc, zshrc, etc.) ou en l'exécutant dans la ligne de commande avant la commande de fine tuning :

export OPENAI_API_KEY="<OPENAI_API_KEY>"

Préparer les données d'entraînement (pour le fine tuning)

Les données d'entraînement vous permettent d'apprendre à GPT-3 ce que vous voulez qu'il dise.

Vos données doivent être un document JSONL, où chaque ligne est une paire prompt-complétion correspondant à un exemple de formation. Vous pouvez utiliser notre outil de préparation des données CLI pour convertir facilement vos données dans ce format de fichier.1 {"prompt" : "<texte du prompt>", "completion" : "<Texte ideal>"} 2 {"prompt" : "<texte du prompt>", "completion" : "<Texte ideal>"} 3 {"prompt" : "<texte du prompt>", "completion" : "<Texte ideal >"} 4 ...

La conception des prompts-complétions pour le fine tuning est différente de celle des prompts-complétions destinés à les modèles de base d'OpenAI (Davinci, Curie, Babbage, Ada) lorsque vous intégrez quelques exemples dans le prompt lui-même pour orienter de façon ponctuelle, la production du texte.. En particulier, alors que ces prompts-complétions pour les modèles de base consistent souvent en plusieurs exemples ("apprentissage en quelques coups"), dans le fine tuning, chaque exemple d'entraînement consiste généralement en un seul exemple d'entrée et sa sortie associée, sans qu'il soit nécessaire de l'accompagner d'un prompt décrivant le texte à produire. Autrement dit, pour le fine tuning, vous devez simplement fournir un prompt dans une colonne et la réponse dans une deuxième colonne. Mais lorsque vous utilisez les modèles de bases, vous intégrer les exemples dans votre prompt.

Pour obtenir des conseils plus détaillés sur la manière de préparer les données d'entrainement pour chaque type de tâche, veuillez consulter les meilleures pratiques recomamndées par OpenAI concernant la préparation de votre jeu de données.

Plus vous fournissez d'exemples d'entraînement, mieux c'est. OpenAI recommande de fournir au moins deux cents exemples. Mais, en moyenne, OpenAI dit avoir constaté que chaque doublement de la taille du jeu de données entraîne une augmentation linéaire de la qualité du modèle.

Outil de préparation des données CLI

OpenAI a créé un outil qui valide, donne des suggestions et reformate vos données :openai tools fine_tunes.prepare_data -f <LOCAL_FILE>

Cet outil accepte différents formats, à la seule condition qu'ils contiennent des colonnes prompt et complétion. Vous pouvez passer un fichier CSV, TSV, XLSX, JSON ou JSONL, et il enregistrera la sortie dans un fichier JSONL prêt à être affiné, après vous avoir guidé tout au long du processus de suggestions de modifications.

Créer un modèle affiné

Ce qui suit suppose que vous ayez déjà préparé des données d'entraînement en suivant les instructions ci-dessus.

Lancez votre travail de fine tuning en utilisant le CLI d'OpenAI :openai api fine_tunes.create -t <TRAIN_FILE_ID_OR_PATH> -m <BASE_MODEL>

Où BASE_MODEL est le nom du modèle de base à partir duquel vous commencez (ada, babbage, curie ou davinci).

Vous pouvez personnaliser le nom de votre modèle en utilisant le paramètre suffixe.

L'exécution de la commande ci-dessus a plusieurs effets :

• Téléchargement du fichier à l'aide de l'API files (ou utilisation d'un fichier déjà téléchargé)
• Création d'une tâche de fine tuning
• Transmission des événements jusqu'à ce que la tâche soit terminée (cela prend souvent quelques minutes, mais peut prendre des heures s'il y a de nombreuses tâches dans la file d'attente ou si votre jeu de données est volumineux). Cela permet de suivre l'avancement du travail d'entraînement

Chaque tâche de fine tuning démarre à partir d'un modèle de base, qui est par défaut curie si vous n'indiquez aucun modèle lorsque vous lancez le fine tuning. Le choix du modèle influe à la fois sur les performances du modèle et sur le coût d'exécution du modèle affiné. Votre modèle peut être l'un des modèles suivants : ada, babbage, curie ou davinci. Consultez la page tarif  d'OpenAI pour plus de détails sur les tarifs du fine tuning.

Une fois que vous avez lancé une travail de fine tuning, celui-ci peut prendre un certain temps avant d'être terminé. Il se peut que votre travail soit mis en file d'attente derrière d'autres travaux sur la plateforme OpenAI, et que l'entraînement de votre modèle prenne entre quelques minutes et quelques heures. Si le flux d'événements est interrompu pour une raison quelconque, vous pouvez le reprendre en exécutant la commande suivante

openai api fine_tunes.follow -i <Votre_ID_JOB_FINE_TUNE>

Lorsque le job est terminé, il doit afficher le nom du modèle fine-tune.

Outre la création d'une tâche de mise au point, vous pouvez également lister les tâches existantes, récupérer l'état d'une tâche ou annuler une tâche.# Liste de tous les fine-tunes créés openai api fine_tunes.list # Récupérer l'état d'un fine-tune. L'objet résultant comprend # l'état de la tâche (qui peut être en attente, en cours d'exécution, réussie ou échouée) # et d'autres informations openai api fine_tunes.get -i <YOUR_FINE_TUNE_JOB_ID> # Annuler un travail openai api fine_tunes.cancel -i <YOUR_FINE_TUNE_JOB_ID>

Utiliser un modèle finement réglé

Lorsqu'une opération d'entraînement a réussi et est arrivé à son terme, le champ fine_tuned_model est rempli avec le nom du modèle. Vous pouvez maintenant spécifier ce modèle en tant que paramètre de l'API de completion et lui adresser des requêtes à l'aide du playground.

Après l'complétion de ce travail d'entraînement, il peut s'écouler plusieurs minutes avant que votre modèle ne soit prêt à traiter les requêtes. Si les demandes de complétion adressées à votre modèle n'aboutissent pas, c'est probablement parce que votre modèle est encore en cours de chargement. Dans ce cas, réessayez quelques minutes plus tard.

Vous pouvez commencer à lancer des requêtes en passant le nom du modèle comme paramètre de modèle d'une requête de complétion :

OpenAI CLI :openai api completions.create -m <FINE_TUNED_MODEL> -p <YOUR_PROMPT>

cURL :

curl https://api.openai.com/v1/completions \N -H "Authorization" -H "Authorization" -H "Authorization" -H "Authorization -H "Authorization : Bearer $OPENAI_API_KEY" \N- H "Content-Type : application/json" \N- H -H "Content-Type : application/json" \N- -d '{"prompt" : {"prompt" : {"prompt" : \N-) -d '{"prompt" : YOUR_PROMPT, "model" : FINE_TUNED_MODEL}'

Python :

import openai openai.Completion.create( model=FINE_TUNED_MODEL, prompt=Votre_PROMPT)

Node.js :

const response = await openai.createCompletion({ modèle : FINE_TUNED_MODEL prompt : YOUR_PROMPT, }) ;

Vous pouvez continuer à utiliser tous les autres paramètres de complétion comme la température, la pénalité de fréquence, la pénalité de présence, etc, sur ces requêtes de modèles affinés.

Supprimer un modèle affiné

Pour supprimer un modèle fine-tuned, vous devez être désigné comme "propriétaire" au sein de votre organisation.

CLI OpenAI :openai api models.delete -i <FINE_TUNED_MODEL>

cURL :

curl -X "DELETE" https://api.openai.com/v1/models/<FINE_TUNED_MODEL> \N -H "Authorization :". -H "Authorization : Bearer $OPENAI_API_KEY"

Python :

import openai openai.Model.delete(FINE_TUNED_MODEL)

Préparation de votre jeu de données

Le fine tuning est une technique puissante pour créer un nouveau modèle spécifique à votre cas d'utilisation. Avant d'affiner votre modèle, nous vous recommandons vivement de lire les meilleures pratiques et les directives spécifiques à votre cas d'utilisation ci-dessous.

Formatage des données

Pour affiner un modèle, vous aurez besoin d'un ensemble d'exemples d'entraînement composés chacun d'une entrée unique ("prompt") et de sa sortie associée ("complétion"). Il s'agit d'une différence notable par rapport à l'utilisation de les modèles de base d'OpenAI, où vous pouvez saisir des instructions détaillées ou plusieurs exemples dans une seule prompt.

Chaque prompt doit se terminer par un séparateur fixe qui indique au modèle la fin du prompt et le début de la complétion. Un séparateur simple qui fonctionne généralement bien est \n\n###\n\n. Le séparateur ne doit pas apparaître ailleurs dans le prompt.

Chaque complétion doit commencer par un espace blanc en raison de notre tokenisation, qui tokenise la plupart des mots précédés d'un espace blanc.

Chaque complétion doit se terminer par une séquence d'arrêt fixe pour informer le modèle de la fin de la complétion. Une séquence d'arrêt peut être \n, ###, ou tout autre token qui n'apparaît dans aucune complétion.

Pour l'inférence, vous devez formater vos prompts de la même manière que vous l'avez fait lors de la création de l'ensemble de données d'apprentissage, en incluant le même séparateur. Spécifiez également la même séquence d'arrêt pour tronquer correctement la complétion.

Meilleures pratiques générales

La fine tuning est plus efficace avec davantage d'exemples de haute qualité. Pour affiner un modèle plus performant que l'utilisation d'un prompt-complétion de haute qualité avec les modèles de base d'OpenAI vous devez fournir au moins quelques centaines d'exemples de haute qualité, idéalement vérifiés par des experts humains. À partir de là, les performances tendent à augmenter de façon linéaire à chaque fois que le nombre d'exemples est doublé. L'augmentation du nombre d'exemples est généralement le moyen le plus efficace et le plus fiable d'améliorer les performances.

Les classificateurs sont les modèles les plus faciles à utiliser. Pour les problèmes de classification, nous suggérons d'utiliser Ada, dont les performances ne sont généralement que très légèrement inférieures à celles de modèles plus performants une fois qu'ils ont été affinés, tout en étant nettement plus rapides et moins coûteux.

Si vous procédez à un fine tuning sur un jeu de données préexistant plutôt que de rédiger des prompts-complétions à partir de zéro, assurez-vous de vérifier manuellement vos données pour détecter tout contenu offensant ou inexact, si possible, ou examinez autant d'échantillons aléatoires que possible de le jeu de données s'il est volumineux.

Meilleures pratiques spécifiques

Le fine tuning peut résoudre une grande variété de problèmes, et la meilleure façon de l'utiliser peut dépendre de votre cas d'utilisation spécifique. Nous avons énuméré ci-dessous les cas d'utilisation les plus courants du fine tuning et les lignes directrices correspondantes.

Classification

• Le modèle fait-il des affirmations fausses ?
• Analyse des sentiments
• Catégorisation pour le triage des emails

Génération conditionnelle

• Rédiger une publicité attrayante sur la base d'un article de Wikipédia
• Extraction d'entités
• Chatbot de support client
• Description d'un produit à partir d'une liste de propriétés techniques

Classification

Dans les problèmes de classification, chaque entrée de le prompt doit être classée dans l'une des classes prédéfinies. Pour ce type de problèmatique, nous recommandons

D'utiliser un séparateur à la fin de le prompt, par exemple \n\n##\n\n. N'oubliez pas d'ajouter ce séparateur lorsque vous ferez des requêtes à votre modèle.

De choisir des classes qui correspondent à un seul jeton. Au moment de l'inférence, spécifiez max_tokens=1 puisque vous n'avez besoin que du premier jeton pour la classification.

S'assurez que le prompt + la complétion ne dépasse pas 2048 tokens, y compris le séparateur.

Visez au moins ~100 exemples par classe

Pour obtenir les probabilités logarithmiques par classe, vous pouvez spécifier logprobs=5 (pour 5 classes) lors de l'utilisation de votre modèle.

Veillez à ce que l'jeu de données utilisé pour le fine tuning soit très similaire, en termes de structure et de type de tâche, à celui pour lequel le modèle sera utilisé.

Étude de cas : Le modèle fait-il de fausses déclarations ?

Supposons que vous souhaitiez vous assurer que le texte des annonces publicitaires sur votre site web mentionne le bon produit et la bonne entreprise. En d'autres termes, vous voulez vous assurer que le modèle n'invente rien. Vous souhaitez peut-être utiliser un classificateur affiné qui filtre les annonces incorrectes.

Le jeu de données pourrait ressembler à ce qui suit :

{"prompt" : "Entreprise : BHFF insurance\nProduit : assurance tous risques\nAd:Un guichet unique pour tous vos besoins en matière d'assurance!\nSupported :", "completion" : "yes"}

{"prompt" : "Entreprise : Spécialistes de l'aménagement des combles \nProduit : -\nAd:Des dents droites en quelques semaines!\nSupported :", "completion" :" no"}

Dans l'exemple ci-dessus, nous avons utilisé une entrée structurée contenant le nom de la société, le produit et l'annonce associée. Comme séparateur, nous avons utilisé "\nSupported :" qui sépare clairement le prompt de l'complétion. Avec un nombre suffisant d'exemples, le séparateur ne fait pas une grande différence (généralement moins de 0,4 %) tant qu'il n'apparaît pas dans le prompt ou la complétion.

Pour ce cas d'utilisation, nous avons affiné un modèle ada car il sera plus rapide et moins cher, et les performances seront comparables à celles de modèles plus grands car il s'agit d'une tâche de classification.

Nous pouvons maintenant interroger notre modèle en effectuant une demande de complétion.curl https://api.openai.com/v1/completions \N -H "Content-Type : application/json" \N -H "Content-Type : application/json" \N -H "Authorisation : \N" \N -H "Authorisation : \N" \N -H "Authorization : Bearer $OPENAI_API_KEY" \N- H -d '{ "prompt" : "Société : Reliable accountants Ltd\nProduit : Aide à la fiscalité des particuliers. Publicité : Meilleurs conseils en ville !", "max_tokens" : 1, "model" : "YOUR_FINE_TUNED_MODEL_NAME" }'

qui renverra soit oui, soit non.

Étude de cas : Analyse des sentiments

Supposons que vous souhaitiez déterminer le fait qu'un tweet soit positif ou négatif. Le jeu de données pourrait ressembler à ce qui suit :

{"prompt" : "Ravi du nouvel iPhone ! ->", "completion" : "positive"}

{"prompt" : "@lakers disappoint for a third straight night https://t.co/38EFe43 ->", "completion" : "negative"}

Une fois le modèle affiné, vous pouvez récupérer les probabilités logarithmiques pour le premier jeton de complétion en paramétrant logprobs=2 sur la requête de complétion. Plus la probabilité de la classe positive est élevée, plus le sentiment relatif est élevé.

Nous pouvons maintenant interroger notre modèle en effectuant une demande de complétion.curl https://api.openai.com/v1/completions \N -H "Content-Type : application/json" \N -H "Content-Type : application/json" \N -H "Authorisation : \N" \N -H "Authorisation : \N" \N -H "Authorization : Bearer $OPENAI_API_KEY" \N- H -d '{ "prompt" : "https://t.co/f93xEd2 Excité de partager mon dernier article de blog ! ->", "max_tokens" : 1, "model" : "YOUR_FINE_TUNED_MODEL_NAME" }'

Ce qui renverra :

{ "id" : "cmpl-COMPLETION_ID", "objet" : "text_completion", "created" : 1589"created" : 1589498378, "modèle" : "YOUR_FINE_TUNED_MODEL_NAME", "choices" : [ffset" : [ 19 ], "token_logprobs" : [ -0.03597255 ], "tokens" : [ "positif" ], "top_logprobs" : [ { "négatif" : -4.9785037, " positive" : -0.03597255 } ] }, "text" : " positif ", "index" : 0, "finish_reason" : "longueur" } ] }

Étude de cas : Catégorisation pour le triage des courriels

Supposons que vous souhaitiez classer les courriers électroniques entrants da}

Étude de cas : Catégorisation pour le triage des courriels

Supposons que vous souhaitiez classer les courriers électroniques entrants dans l'une des nombreuses catégories prédéfinies. Pour la classification dans un grand nombre de catégories, nous vous recommandons de convertir ces catégories en nombres, ce qui fonctionnera bien jusqu'à ~500 catégories. Nous avons observé que l'ajout d'un espace avant le numéro améliore parfois légèrement les performances, en raison de la tokenisation. Vous pouvez structurer vos données d'entraînement comme suit :

{"prompt" : "Subject : <email_subject>\nFrom:<customer_name>\nDate:<date>\nContent:<email_body>\n\n###\n", "completion" :" <numerical_category>"}

Par exemple :

{"prompt" : "Subject : Update my address\NFrom:Joe Doe\NCOPY00\NDate:2021-06-03\NContent:Hi,\NJe voudrais mettre à jour mon adresse de facturation pour qu'elle corresponde à mon adresse de livraison.\NPlease let me know once done.\NThanks,\NJoe\n\n##\n\n", "completion" : "4"}

Dans l'exemple ci-dessus, nous avons utilisé un email entrant plafonné à 2043 tokens en entrée. (Cela permet un séparateur de 4 tokens et une complétion d'un token, pour un total de 2048). Comme séparateur, nous avons utilisé \n\n##\n\n et nous avons supprimé toute occurrence de ### dans l'email.

Génération conditionnelle

La génération conditionnelle est un problème où le contenu doit être généré en fonction d'une certaine entrée. Cela inclut la paraphrase, le résumé, l'extraction d'entités, la rédaction de descriptions de produits à partir de spécifications, les chatbots et bien d'autres. Pour ce type de problème, nous recommandons

• Utiliser un séparateur à la fin de le prompt, par exemple \n\n##\n\n. N'oubliez pas d'ajouter ce séparateur lorsque vous adressez des promptss à votre modèle.
• Utilisez un symbole de fin à la fin de la complétion, par exemple END
• N'oubliez pas d'ajouter le jeton de fin en tant que séquence d'arrêt pendant l'inférence, par exemple stop=[" END "].
• Visez au moins ~500 exemples
• Veillez à ce que le prompt + la complétion ne dépassent pas 2048 tokens, y compris le séparateur.
• S'assurer que les exemples sont de haute qualité et suivent le même format souhaité
• S'assurer que le jeu de données utilisé pour le fine tuning soit très similaire en structure et en type de tâche à ce pour quoi le modèle sera utilisé.

L'utilisation d'un Lower Learning Rate et de seulement 1 à 2 epochs tend à donner de meilleurs résultats pour ces cas d'utilisation.

Étude de cas : Rédiger une publicité attrayante à partir d'un article de Wikipédia

Il s'agit d'un cas d'utilisation génératif. Vous devez donc vous assurer que les exemples que vous fournissez sont de la plus haute qualité, car le modèle affiné essaiera d'imiter le style (et les erreurs) des exemples donnés. Un bon point de départ se situe autour de 500 exemples. Un échantillon de données pourrait ressembler à ceci :

{"prompt" : "<nom du produit>\n<description Wikipédia>\n\n##\n\n", "completion" : "<annonce engageante> END"}

Par exemple :

{"prompt" : "Samsung Galaxy FeelLe Samsung Galaxy Feel est un smartphone Android développé par Samsung Electronics exclusivement pour le marché japonais. Le téléphone est sorti en juin 2017 et a été vendu par NTT Docomo. Il fonctionne sous Android 7.0 (Nougat), a un écran de 4,7 pouces et une batterie de 3000 mAh.\NSoftware\NLe Samsung Galaxy Feel fonctionne sous Android 7.0 (Nougat), mais peut être mis à jour ultérieurement vers Android 8.0 (Oreo).\NHardware\NLe Samsung Galaxy Feel a un écran Super AMOLED HD de 4,7 pouces, une caméra dorsale de 16 MP et une caméra frontale de 5 MP. Il dispose d'une batterie de 3000 mAh, d'un processeur ARM Cortex-A53 octa-core cadencé à 1,6 GHz et d'un GPU ARM Mali-T830 MP1 cadencé à 700 MHz. Il est doté d'un espace de stockage interne de 32 Go, extensible à 256 Go via une carte microSD. Outre ses spécifications logicielles et matérielles, Samsung a également introduit un trou unique dans la coque du téléphone pour répondre au penchant des Japonais pour la personnalisation de leurs téléphones portables. La batterie du Galaxy Feel a également été présentée comme un argument de vente majeur, le marché privilégiant les appareils dotés d'une plus grande autonomie. L'appareil est également étanche et prend en charge les émissions numériques 1seg à l'aide d'une antenne vendue séparément.", "completion" : "Vous êtes à la recherche d'un smartphone qui peut tout faire ? Ne cherchez pas plus loin que le Samsung Galaxy Feel ! Avec un design fin et élégant, notre dernier smartphone offre des capacités d'image et de vidéo de haute qualité, ainsi qu'une autonomie de batterie primée. END"}

Ici, nous avons utilisé un séparateur de plusieurs lignes, car les articles de Wikipédia contiennent plusieurs paragraphes et titres. Nous avons également utilisé un simple jeton de fin, pour que le modèle sache quand la complétion doit se terminer.

Étude de cas : Extraction d'entités

Cette tâche est similaire à une tâche de transformation linguistique. Pour améliorer les performances, il est préférable de trier les différentes entités extraites par ordre alphabétique ou dans le même ordre que celui dans lequel elles apparaissent dans le texte original. Cela aidera le modèle à garder une trace de toutes les entités qui doivent être générées dans l'ordre. Le jeu de données pourrait ressembler à ce qui suit :

{"prompt" : "<n'importe quel texte, par exemple un article de presse>\n\n##\n\n", "completion" : "<liste d'entités, séparées par une nouvelle ligne> END"}

Par exemple :

{"prompt" : "Le Portugal sera retiré de la liste verte des pays du Royaume-Uni à partir de mardi, en raison de l'augmentation du nombre de cas de coronavirus et de l'inquiétude suscitée par une mutation au Népal de la variante dite "indienne". Il rejoindra la liste orange, ce qui signifie que les vacanciers ne doivent pas s'y rendre et que les personnes qui reviennent doivent s'isoler pendant 10 jours...", "completion" :" Portugal\nUK\nMutation népalaise\nVariante indienne END"}

Il est préférable d'utiliser un séparateur multiligne, car le texte contiendra probablement plusieurs lignes. Idéalement, les types de prompts d'entrée (articles de presse, pages Wikipédia, tweets, documents juridiques) devraient être très diversifiés et refléter les textes susceptibles d'être rencontrés lors de l'extraction d'entités.

Étude de cas : Chatbot d'assistance à la clientèle

Un chatbot contient normalement un contexte pertinent pour la conversation (détails de la commande), un résumé de la conversation jusqu'à présent ainsi que les messages les plus récents. Dans ce cas d'utilisation, la même conversation passée peut générer plusieurs lignes dans le jeu de données, chaque fois avec un contexte légèrement différent, pour chaque génération d'agent en tant que complétion. Ce cas d'utilisation nécessitera quelques milliers d'exemples, car il traitera probablement différents types de demandes et de problèmes de clients. Pour garantir la qualité des performances, nous recommandons de vérifier les échantillons de conversation afin de s'assurer de la qualité des messages de l'agent. Le résumé peut être généré à l'aide d'un modèle de transformation de texte distinct. Le jeu de données pourrait ressembler à ce qui suit :

{"prompt" : "Résumé : <Résumé du début de l'échange>\n\nInformations spécifiques:<Par exemple, les détails de la commande formulés en language naturel>\n\n###\nClient: <message1>\nAgent : <response1>\nClient : <message2>\nAgent :", "completion" :" <response2>\n"}

{"prompt" : "Résumé : <Résumé du début de l'échange>\NInformations spécifiques:<Par exemple, les détails de la commande formulés en language naturel>\n\n###\nClient : <message1>\nAgent : <response1>\nClient : <message2>\nAgent : <response2>\nClient : <message3>\nAgent :", "completion" :" <response3>\n"}

Ici, nous avons délibérément séparé différents types d'informations d'entrée, mais nous avons maintenu le dialogue avec l'agent client dans le même format entre une prompt et un complétion. Toutes les complétions ne doivent concerner que l'agent (puisque c'est ce rôle qui devra être simulé dans la complétion, et nous pouvons utiliser \n comme séquence d'arrêt lors de l'inférence.

Étude de cas : Description d'un produit à partir d'une liste de propriétés techniques

Ici, il est important de convertir les données d'entrée en langage naturel, ce qui permettra probablement d'obtenir de meilleures performances. Par exemple, le format suivant :

{"prompt" : "Article=sacamain, Couleur=vert_armee, prix=$99, taille=S->", "completion" :" Cet élégant petit sac à main vert ajoutera une touche unique à votre look, sans vous coûter une fortune."}.

Ne fonctionnera pas aussi bien que :

{"prompt" : "L'article est un sac à main. La couleur est le vert armée. Le prix est moyen. Size is small.->", "completion" :" Cet élégant petit sac à main vert ajoutera une touche unique à votre look, sans vous coûter une fortune."}

Pour une performance élevée, assurez-vous que les complétions sont basées sur la description fournie. Si un contenu externe est souvent consulté, l'ajout automatisé d'un tel contenu améliorerait les performances. Si la description est basée sur des images, il peut être utile d'utiliser un algorithme pour extraire une description textuelle de l'image. Si les complétions ne comportent qu'une seule phrase, nous pouvons utiliser "." comme séquence d'arrêt lors de l'inférence.

Utilisation avancée

Personnaliser le nom de votre modèle

Vous pouvez ajouter un suffixe de 40 caractères maximum à votre nom de modèle affiné en utilisant le paramètre suffixe.

CLI OpenAI :openai api fine_tunes.create -t test.jsonl -m ada --suffix "nom de modèle personnalisé"

Le nom résultant serait :

ada:ft-your-org:custom-model-name-2022-02-15-04-21-04

Analyse de votre modèle affiné

OpenAI génère un fichier de résultats après chaque opération de fine-tuning. L'identifiant du fichier de résultats sera indiqué lorsque vous récupérez un modèle fine tuning, ainsi que lorsque vous analyserez les événements d'un fine tuning. Vous pouvez télécharger ces fichiers :

OpenAI CLI :openai api fine_tunes.results -i <YOUR_FINE_TUNE_JOB_ID>

CURL :

curl https://api.openai.com/v1/files/$RESULTS_FILE_ID/contenu \N- "Authorization :" -H "Authorization :" -H "Authorization :". -H "Authorization : Bearer $OPENAI_API_KEY" > results.csv

Le fichier _results.csv contient une ligne pour chaque étape d'entraînement (une étape correspondant à un pas en avant ou en arrière sur un jeu de données). Outre le numéro de l'étape, chaque ligne contient les champs suivants correspondant à cette étape :

• elapsed_tokens : le nombre de tokens que le modèle a vu jusqu'à présent (y compris les répétitions)
• elapsed_examples : le nombre d'exemples que le modèle a vus jusqu'à présent (y compris les répétitions), un exemple étant un élément de votre lot. Par exemple, si batch_size = 4, chaque étape augmentera elapsed_examples de 4.
• training_loss : perte sur le lot d'apprentissage
• training_sequence_accuracy : le pourcentage de complétions dans le jeu d'entraînement pour lesquelles les tokens prédits par le modèle correspondent exactement aux vrais tokens de complétion. Par exemple, avec une taille de lot de 3, si vos données contiennent les complétions [[1, 2], [0, 5], [4, 2]] et que le modèle a prédit [[1, 1], [0, 5], [4, 2]], cette précision sera de 2/3 = 0,67.
• training_token_accuracy : le pourcentage de tokens dans le lot de formation qui ont été correctement prédits par le modèle. Par exemple, avec une taille de lot de 3, si vos données contiennent les compléments [[1, 2], [0, 5], [4, 2]] et que le modèle a prédit [[1, 1], [0, 5], [4, 2]], cette précision sera de 5/6 = 0,83.

Métriques propresà la classification

OpenAI offre également la possibilité de générer des métriques supplémentaires spécifiques à la classification dans le fichier de résultats, telles que la précision et le score F1 pondéré. Ces mesures sont calculées périodiquement par rapport à l'ensemble de validation complet et à la fin de la fine tuning. Vous les verrez sous forme de colonnes supplémentaires dans votre fichier de résultats.

Pour activer cette fonction, définissez le paramètre --compute_classification_metrics. En outre, vous devez fournir un fichier de validation et définir le paramètre classification_n_classes, pour la classification multiclasse, ou classification_positive_class, pour la classification binaire.

CLI OpenAI :# Pour la classification multiclasse openai api fine_tunes.create \N- -t <TRAIN_FILEID_OR_PATH> \N- -t -t <TRAIN_FILE_ID_OR_PATH> \N- -v <VALIDATION_FILE_OR_PATH> \N- -v -v <VALIDATION_FILE_OR_PATH> \N- m <MODEL> \N- m -m <MODÈLE> \N --compute_classification_metrics \N- --classification_n_classes \N --classification_n_classes <N_C--classification_n_classes <N_CLASSES>

# Pour la classification binaire

openai api fine_tunes.create \N- -t <TRAIN_FILE> -t -t <TRAIN_FILE_ID_OR_PATH> \N--v -v <VALIDATION_FILE_OR_PATH> \N- m <MODEL> \N- m -m <MODÈLE> \N --compute_classification_metrics \N- --classification_n_classes \N --classification_n_classes 2 \N- --classification_positive_métriques \N --classification_positive_class &l--classification_positive_class <POSITIVE_CLASS_FROM_DATASET> (classe positive)

Les mesures suivantes seront affichées dans votre fichier de résultats si vous avez défini

--compute_classification_metrics :

Pour la classification multiclasse

• classification/accuracy : précisio
• classification/weighted_f1_score : score F-1 pondéré

Pour la classification binaire

Les mesures suivantes sont basées sur un seuil de classification de 0,5 (c'est-à-dire que lorsque la probabilité est > 0,5, un exemple est classé comme appartenant à la classe positive).

• classification/exactitude
• classification/précision
• classification/rappel
• classification/f{beta}
• classification/auroc - AUROC
• classification/auprc - AUPRC

Notez que ces évaluations supposent que vous utilisez des étiquettes textuelles pour les classes qui se réduisent à un seul jeton, comme décrit ci-dessus. Si ces conditions ne sont pas remplies, les chiffres que vous obtiendrez seront probablement erronés.

Validation

Vous pouvez réserver certaines de vos données à la validation. Un fichier de validation a exactement le même format qu'un fichier de train, et vos données de train et de validation doivent s'exclure mutuellement.

Si vous incluez un fichier de validation lors de la création de votre tâche de fine tuning, le fichier de résultats généré inclura des évaluations sur la performance du modèle réglé par rapport à vos données de validation à intervalles périodiques au cours de la formation.

CLI OpenAI

openai api fine_tunes.create -t <TRAIN_FILE_ID_OR_PATH> \N- -v <VALIDATION_FILE_PATH>. -v <VALIDATION_FILE_ID_OR_PATH> \N- -m <MODEL> -t <TRAIN_FILE_ID_OR_PATH> -t -m <MODÈLE>

Si vous avez fourni un fichier de validation, nous calculons périodiquement des mesures sur des lots de données de validation pendant la durée de l'entraînement. Vous verrez les mesures supplémentaires suivantes dans votre fichier de résultats :

• validation_loss : perte sur le lot de validation
• validation_sequence_accuracy : le pourcentage decomplétions dans le lot de validation pour lequel les tokens prédits par le modèle correspondent exactement aux vrais tokens d'complétion. Par exemple, avec une taille de lot de 3, si vos données contiennent l'complétion [[1, 2], [0, 5], [4, 2]] et que le modèle a prédit [[1, 1], [0, 5], [4, 2]], cette précision sera de 2/3 = 0,67.
• validation_token_accuracy : le pourcentage de tokens dans le lot de validation qui ont été correctement prédits par le modèle. Par exemple, avec une taille de lot de 3, si vos données contiennent l'intégralité des mots-clés de la liste de validation, vous obtiendrez une précision de 0,67 = 0,67.

Hyperparamètres

Nous avons choisi des hyperparamètres par défaut qui fonctionnent bien dans de nombreux cas d'utilisation. Le seul paramètre requis est le fichier d'entraînement.

Cela dit, l'ajustement des hyperparamètres utilisés pour le fine tuning peut souvent conduire à un modèle qui produit des résultats de meilleure qualité. En particulier, vous pouvez configurer les éléments suivants :

model : Le nom du modèle de base à affiner. Vous pouvez sélectionner l'un des modèles suivants : "ada", "babbage", "curie" ou "davinci". Pour en savoir plus sur ces modèles, consultez la documentation.

n_epochs est - 4 par défaut : nombre d'époques pour lesquelles le modèle doit être entraîné. Une époque correspond à un cycle complet de l'jeu de données d'apprentissage.

batch_size est - par défaut ~0.2% du nombre d'exemples dans l'ensemble d'apprentissage, plafonné à 256. La taille du lot est le nombre d'exemples d'entraînement utilisés pour entraîner une seule passe avant et arrière. En général, nous avons constaté que les lots de plus grande taille ont tendance à mieux fonctionner pour les grands ensembles de données.

learning_rate_multiplier est de  - 0,05, 0,1 ou 0,2 par défaut, en fonction de la taille finale du lot. Le taux d'apprentissage de fine tuning est le taux d'apprentissage original utilisé pour le pré-entraînement multiplié par ce multiplicateur. Nous recommandons d'expérimenter avec des valeurs comprises entre 0,02 et 0,2 pour obtenir les meilleurs résultats. De manière empirique, nous avons constaté que les taux d'apprentissage plus élevés donnent souvent de meilleurs résultats avec des lots de taille plus importante.

compute_classification_metrics - la valeur par défaut est False. Si True, pour le fine tuning des tâches de classification, calcule les métriques spécifiques à la classification (précision, score F-1, etc.) sur l'ensemble de validation à la fin de chaque époque.

Pour configurer ces hyperparamètres supplémentaires, passez-les via une ligne de commande dans le CLI d'OpenAI, par exemple :

openai api fine_tunes.create \N- -t file-JD89ePi5KMsB3Tayeli5ovov

-t file-JD89ePi5KMsB3Tayeli5ovfW \N -m ada \N -m ada \N

-m ada \N- -n_epochs 1

--n_epochs 1

Poursuivre la fine tuning à partir d'un modèle mis au point

Si vous avez déjà affiné un modèle pour les tâches que votre modèle doit accomplir et que vous disposez, de nouvelles données d'entraînement que vous souhaitez intégrer, vous pouvez poursuivre l'affinage à partir du modèle déjà affiné. Cela permet de créer un modèle qui a appris à partir de toutes les données d'entraînement sans avoir à recommencer l'entraînement depuis le début (cela va plus vite et coûte moins cher).

Pour ce faire, indiquez le nom du modèle affiné lors de la création d'une nouvelle tâche de fine tuning(par exemple -m curie:ft-<org>-<date>). Les autres paramètres d'apprentissage n'ont pas besoin d'être modifiés, mais si vos nouvelles données d'apprentissage sont beaucoup plus petites que vos données d'apprentissage précédentes, il peut être utile de réduire le multiplicateur de taux d'apprentissage d'un facteur de 2 à 4.

Pondérations et biais

Vous pouvez synchroniser vos modèles fine tunés avec Weights & Biases pour suivre les expériences, les modèles et les jeux de données.

Pour commencer, vous aurez besoin d'un compte Weights & Biases et d'un plan OpenAI payant. Pour vous assurer que vous utilisez la dernière version d'openai et de wandb, exécutez :

pip install --upgrade openai wandb

Pour synchroniser vos réglages avec Weights & Biases, lancez : pip install --upgrade openai wandb

openai wandb sync