Ajustement supervisé des LLMs : guide Python

Dans ce guide sur la mise au point supervisée des MLD, vous apprendrez :

Qu’est-ce que le réglage fin supervisé dans le contexte des LLM ?
Quel est l’objectif de cette pratique ?
Les ressources dont vous avez besoin pour le mettre en œuvre
Le flux de travail pour le réglage fin supervisé des MLI
Défis et considérations techniques dans la mise en œuvre du SFT
Un tutoriel étape par étape pour reproduire le réglage fin supervisé sur un LLM

Plongeons dans l’aventure !

Définition du réglage fin supervisé (SFT) dans le contexte du LLM

Le réglage fin supervisé (SFT) est une forme d’apprentissage par transfert appliquée aux MFR. L’apprentissage par transfert est une méthode d’apprentissage automatique qui consiste à appliquer les connaissances acquises lors de la résolution d’un problème pour aider à résoudre un problème différent, mais connexe.

Dans le contexte du LLMS, le réglage fin supervisé implique de prendre un modèle pré-entraîné et de l’entraîner davantage. Pour ce faire, vous ajustez ses paramètres à l’aide d’un ensemble de données contenant des exemples étiquetés correspondant à une tâche spécifique.

La nature “supervisée” est un élément clé du processus, car les ingénieurs sont à l’origine de l’ensemble du processus :

Ils préparent l’ensemble de données de réglage fin avec des paires d’entrées-sorties explicites. Cet ensemble de données contient les “bonnes réponses” qui orientent l’apprentissage du modèle pour des invites spécifiques.
Ils prennent en charge l’ensemble du processus de mise au point, de l’installation au contrôle et à la validation.

Plus précisément, par rapport à RAG(Retrieval-Augmented Generation), le réglage fin modifie le modèle lui-même. La RAG ne touche pas au modèle et se contente de l’alimenter avec de nouvelles informations pertinentes. En revanche, le réglage fin implique un nouveau processus de formation.

Quel est l’objectif de la mise au point supervisée dans les LLM ?

L’objectif principal du réglage fin supervisé est d’améliorer les performances d’un LLM sur des tâches spécifiques au-delà de ses capacités générales pré-entraînées. Cela inclut :

Spécialisation des tâches: Rendez le modèle compétent pour des tâches telles que le résumé de texte, la génération de code pour une langue particulière, l’analyse des sentiments, etc.
Adaptation au domaine: Introduire dans le modèle des connaissances et une terminologie spécifiques à des domaines de niche. L’analyse de documents juridiques, la production de rapports médicaux et les prévisions financières en sont des exemples courants.
Alignement du ton: Entraînez le modèle à adopter une voix de marque cohérente, un niveau de formalité ou un personnage conversationnel spécifique requis pour des applications telles que les chatbots.

Ce dont vous avez besoin pour mettre en œuvre le réglage fin

À ce stade, vous vous demandez peut-être : pourquoi ne pas former un LLM pour qu’il le fasse dès le départ ? La raison en est simple. La formation d’un LLM implique :

Une grande quantité de données, souvent stockées dans plusieurs centres de données.
Beaucoup de matériel.
Investir beaucoup d’argent et de temps.

Pour donner une idée, pour former des modèles tels que ChatGPT, Gemini et autres, vous avez besoin de.. :

Plusieurs mois, voire plusieurs années.
Un grand nombre de GPU – chacun coûtant des milliers de dollars – répartis dans plusieurs centres de données.

Pour le réglage fin, vous n’avez besoin que de trois choses :

Un modèle pré-entraîné.
Un ordinateur.
Un petit ensemble de données étiquetées.

La raison pour laquelle le réglage fin est si pratique devrait maintenant être plus claire.

Les mécanismes qui sous-tendent le processus de réglage fin supervisé

L’exécution d’un processus de mise au point supervisé comporte plusieurs étapes techniques. Il est temps de décomposer l’ensemble du processus !

Étape 1 : Constituer un ensemble de données SFT de haute qualité

L’efficacité du processus dépend fortement de la qualité et de la pertinence de l’ensemble des données de mise au point. Il s’agit de

Recherche de données: Obtenir des données brutes pertinentes pour la tâche cible à l’aide de l’une des nombreuses techniques de recherche de données. La taille des données peut varier de quelques centaines à quelques dizaines de milliers de lignes. Cela dépend de la complexité de la tâche et du modèle pré-entraîné.
Structuration des données: Transformer les données brutes dans un format structuré adapté au processus SFT. L’un des formats typiques est celui des lignes JSON (JSONL), où chaque ligne est un objet JSON contenant des champs distincts pour les données d’entrée et les données de sortie souhaitées.
Assurance qualité: S’assurer que les données sont exactes, cohérentes, diversifiées et exemptes de biais susceptibles d’avoir un impact négatif sur le comportement du modèle.

Étape 2 : Sélection d’un modèle pré-entraîné approprié

Plusieurs modèles pré-entraînés sont disponibles. Les éléments clés à prendre en compte pour choisir le modèle le mieux adapté à votre cas sont les suivants :

La taille du modèle: Elle est désignée par le nombre de paramètres (par exemple, 7B, 13B, 70B) et est en corrélation avec la capacité du modèle à apprendre des modèles et des nuances complexes. Les modèles plus grands offrent généralement de meilleures performances, mais demandent plus de ressources matérielles pour le réglage fin.
L’architecture: L’architecture spécifique peut être adaptée à certaines tâches. Par exemple
```
:Polylang placeholder do not modify
```
Capacités de base: Évaluez les performances du modèle pré-entraîné sur des critères de référence académiques en rapport avec votre tâche cible avant de vous engager dans une mise au point. Cela permet d’obtenir une base de référence et d’indiquer l’aptitude du modèle. Par exemple
```
:Polylang placeholder do not modify
```
Licence : La licence sous laquelle un modèle est publié dicte la manière dont il peut être utilisé, modifié et distribué. Certains modèles bénéficient d’autorisations de source ouverte, d’autres non.
Ajustements existants: Parfois, il est plus efficace de partir d’un modèle déjà affiné pour une tâche connexe que de partir d’un modèle de base brut. Il s’agit d’une forme de mise au point intermédiaire.

Étape 3 : Mise en œuvre de la boucle de formation

Le cœur du processus consiste à itérer à travers l’ensemble de données étiquetées et à ajuster les poids du modèle de la manière suivante :

Passage en avant: Le modèle traite une entrée (l’invite) provenant de l’ensemble de données SFT et génère une sortie.
Calcul de la perte: Une fonction de perte compare le résultat généré par le modèle, jeton par jeton, au résultat cible fourni dans l’ensemble de données. Elle permet de quantifier l’erreur.
Passage à rebours (rétropropagation): La perte calculée est utilisée pour calculer les gradients, indiquant dans quelle mesure chaque poids du modèle a contribué à l’erreur.
Mise à jour des poids: un algorithme d’optimisation utilise les gradients et un taux d’apprentissage spécifié pour ajuster les poids du modèle. L’objectif est de minimiser les erreurs lors des itérations suivantes.
Réglage des hyperparamètres: Les paramètres contrôlant le processus d’apprentissage sont ajustés pour améliorer la performance du modèle.

Étape 4 : Évaluer les résultats

L’étape finale consiste à évaluer les performances du modèle affiné. Cela implique

Ensemble de validation: Une partie de l’ensemble de données étiquetées doit être utilisée pour suivre les progrès et éviter l’ajustement excessif.
Jeu d’essai: Vous avez besoin d’un ensemble de données contenant des données nouvelles et inédites pour le modèle, qui peut être un sous-ensemble de l’ensemble de données de réglage fin. Cette étape est exécutée pour l’évaluation finale une fois le réglage fin terminé.
Métriques: Définir des paramètres quantitatifs pertinents pour la tâche afin d’évaluer la performance.
Analyse qualitative : Examen des résultats du modèle pour évaluer la cohérence, la pertinence, le respect du style et la sécurité.

Défis et considérations techniques liés à la mise en œuvre du SFT

La mise en œuvre de SFT présente plusieurs défis techniques, comme par exemple :

Qualité et échelle des données: La principale difficulté réside dans la création ou l’obtention d’un ensemble de données étiquetées suffisamment important, de haute qualité et représentatif. Une mauvaise qualité des données se traduit directement par une mauvaise performance du modèle. L’extraction, le nettoyage, l’étiquetage, l’agrégation et le formatage des données requièrent des efforts considérables et une grande expertise dans le domaine.
Atténuation de l’oubli catastrophique: Un réglage fin intensif sur une tâche spécifique peut amener le modèle à “oublier” certaines de ses capacités générales acquises au cours de la préformation. Des stratégies telles que l’utilisation de taux d’apprentissage plus faibles, le réglage fin pour moins d’époques ou l’incorporation de données diverses peuvent contribuer à atténuer ce phénomène.
Stratégies d’optimisation des hyperparamètres: La recherche de l’ensemble optimal d’hyperparamètres est un processus empirique. Cela nécessite de multiples expériences et un suivi attentif des paramètres de validation. Les cadres automatisés de réglage des hyperparamètres peuvent aider, mais ajoutent de la complexité.

Réglage fin supervisé des LLM : Tutoriel étape par étape

Il est temps de mettre la théorie en pratique. Cette section du tutoriel vous guidera dans la mise au point d’un LLM léger afin que vous puissiez utiliser votre ordinateur sans matériel supplémentaire. L’objectif est d’affiner un LLM pour générer des descriptions de produits de commerce électronique, à partir d’une liste de caractéristiques.

Vous utiliserez DistilGPT2 en tant que LLM, qui est une version distillée de GPT-2 avec une taille et une efficacité réduites.

Affinons le modèle choisi !

Conditions préalables

Pour reproduire ce tutoriel sur le réglage fin supervisé des LLM, vous devez avoir au moins Python 3.10+ installé sur votre machine.

Vous avez également besoin d’un ensemble de données CSV pour la mise au point. Ici, nous utiliserons un ensemble de données personnalisé qui contient des données sur les produits de commerce électronique. L’ensemble de données contient les champs suivants pour chaque produit :

Catégorie: Électronique, livres, cuisine et similaires.
Nom: Le nom du produit.
Caractéristiques: Les principales caractéristiques du produit.
Couleur: la couleur du produit.
Description: Texte décrivant ce qu’est ou ce que fait le produit.

L’image ci-dessous montre un échantillon des données utilisées :

Un échantillon de l'ensemble de données utilisé pour le réglage fin

Étape 1 : Démarrer

Supposons que vous appeliez le dossier principal de votre projet fine_tuning/. À la fin de cette étape, le dossier aura la structure suivante :

fine_tuning/
    ├── data/
    |   └── data.csv
    ├── results_distilgpt2/
    ├── tuning.py
    └── venv/

Où ?

data.csv contient les données étiquetées pour affiner le LLM présenté précédemment.
results_distilgpts/ est le dossier qui contiendra les résultats. Il sera automatiquement créé au cours du processus.
tuning.py est le fichier Python qui contient toute la logique.
venv/ contient l’environnement virtuel.

Vous pouvez créer le répertoire de l ‘environnement virtuel venv/ de la manière suivante :

python -m venv venv

Pour l’activer, sous Windows, exécutez :

venv\Scripts\activate

De manière équivalente, sous macOS/Linux, exécutez :

source venv/bin/activate

Dans l’environnement virtuel activé, installez les bibliothèques nécessaires pour ce tutoriel :

pip install transformers datasets torch trl

Les bibliothèques utilisées dans ce projet sont les suivantes

transformers: la bibliothèque de Hugging Face pour les modèles d’apprentissage automatique de pointe.
jeux de données: Bibliothèque de Hugging Face pour l’accès et le traitement des ensembles de données.
torch: PyTorch, un cadre d’apprentissage machine open-source.
trl: la bibliothèque Transformer Reinforcement Learning de Hugging Face, qui comprend des outils pour SFT comme SFTTrainer.

C’est parfait ! Votre environnement Python pour la mise au point du LLM est correctement configuré.

Étape 2 : Configuration initiale, chargement des données et formatage du texte

La première étape, dans tuning.py, consiste à mettre en place l’ensemble du processus :

import os
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, pipeline
from trl import SFTTrainer

# Configure parameters
base_model_name = "distilgpt2"  # Pre-trained model to be fine-tuned
data_file_path = "data/data.csv" # Path to your CSV data file
output_model_dir = "./results_distilgpt2"  # Directory to save training results and checkpoints
final_model_path = os.path.join(output_model_dir, "final_model") # Path to save the final fine-tuned model
max_seq_length_for_tokenization = 512 # Maximum sequence length for tokenizing inputs

# Load dataset
raw_dataset = load_dataset("csv", data_files=data_file_path)

# Define a function to format entries into a prompt-completion pair
def format_dataset_entry(data_item):
    prompt_template = "Generate a product description for the following item:\nFeatures: {features_data}\n\nDescription:"
    data_item["text"] = prompt_template.format(features_data=data_item["features"]) + " " + data_item["description"]
    return data_item

# Apply the formatting function to the train split of the dataset
text_formatted_dataset = raw_dataset["train"].map(format_dataset_entry)

Cet extrait :

Définit le nom du LLM à utiliser avec base_model_name.
Définit le chemin d’accès au fichier CSV et l’ouvre à l’aide de la méthode load_dataset().
Crée un dossier qui stockera les résultats(results_distilgpt2/).
Crée la fonction format_dataset_entry() qui transforme chaque ligne du raw_dataset en format texte pour l’affiner. Elle ajoute également le contenu modifié dans la colonne “description” du CSV, en remplaçant la colonne actuelle. Cela fournira au modèle des descriptions textuelles nettoyées.
Applique la fonction format_dataset_entry() à chaque élément de l’ensemble de données fractionné d’apprentissage avec la méthode map().

C’est très bien ! Vous avez terminé la configuration initiale du processus.

Étape 3 : Tokeniser l’ensemble de données

Les modèles de langage ne comprennent pas le texte brut. Ils opèrent sur des représentations numériques appelées “tokens”. Cette étape consiste à charger le tokenizer pré-entraîné et à l’utiliser pour convertir les entrées de texte formatées en séquences d’ID de jetons :

# Load the tokenizer associated with the base model
tokenizer = AutoTokenizer.from_pretrained(base_model_name)
tokenizer.pad_token = tokenizer.eos_token # Padding token

# Define a function to tokenize the "text" field of the dataset
def tokenize_function(data_items_batch):
    return tokenizer(
        data_items_batch["text"],
        truncation=True,
        padding="max_length",
        max_length=max_seq_length_for_tokenization,
    )

# Apply the tokenization function to the formatted dataset
tokenized_dataset = text_formatted_dataset.map(
    tokenize_function,
    batched=True,
    remove_columns=text_formatted_dataset.column_names
)

Le code ci-dessus effectue les opérations suivantes :

Charge le tokenizer associé au nom du modèle de base avec la méthode AutoTokenizer.from_pretrained().
Définit un jeton de remplissage pour que toutes les séquences d’entrée aient la même longueur lorsqu’elles sont introduites dans le modèle.
Tokenise l’ensemble de données avec la fonction personnalisée tokenize_function() et applique la tokenisation à l’ensemble de données.

Merveilleux ! L’ensemble de données est symbolisé.

Étape 4 : Configurer et exécuter le processus de réglage fin

L’ensemble de données est préparé et tokenisé, vous pouvez donc maintenant passer au cœur de la tâche d’affinage :

# Load the pre-trained language model
model = AutoModelForCausalLM.from_pretrained(base_model_name)

# Define training arguments for the SFTTrainer
training_args = TrainingArguments(
    output_dir=output_model_dir,
    num_train_epochs=3,
    per_device_train_batch_size=1,
    learning_rate=2e-5,
    logging_steps=10,
    save_steps=50,
    report_to="none",
)

# Initialize the SFTTrainer
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
)

# Begin the training process
trainer.train()

# Save the fine-tuned model and tokenizer to the specified path
trainer.save_model(final_model_path)
tokenizer.save_pretrained(final_model_path)

Ce code :

Charge le modèle de base avec la méthode AutoModelForCausalLM.from_pretrained().
Définit les paramètres du processus, tels que le nombre d’époques, la taille du lot et le taux d’apprentissage, à l’aide de la méthode TrainingArguments().
Initialise et exécute SFTTrainer(), en fournissant au modèle le jeu de données et les arguments d’entraînement. Cette fonction gère la boucle de réglage fin.
Entraîne le modèle et enregistre les résultats dans le dossier prévu à cet effet.

C’est fantastique ! Vous avez entamé le processus de mise au point.

Étape 5 : Évaluer et tester le modèle affiné

Vous devez maintenant évaluer les performances et voir dans quelle mesure le modèle génère des descriptions pour des caractéristiques de produits nouvelles et inédites :

# Load the fine-tuned model and tokenizer for testing
fine_tuned_model_for_testing = AutoModelForCausalLM.from_pretrained(final_model_path)
fine_tuned_tokenizer_for_testing = AutoTokenizer.from_pretrained(final_model_path)

# Create a text-generation pipeline with the fine-tuned model
generator_fine_tuned = pipeline("text-generation", model=fine_tuned_model_for_testing, tokenizer=fine_tuned_tokenizer_for_testing)

# Define example product features for testing
test_product_features = [
    "Category: Kitchen, Name: Electric Kettle, Features: 1.7L capacity, Stainless steel, Auto shut-off, Boil-dry protection, Color: Silver",
    "Category: Office, Name: Ergonomic Office Chair, Features: Lumbar support, Adjustable height, Mesh back, Swivel, Color: Black"
]

# Define the prompt template
prompt_template_inference = "Generate a product description for the following item:\nFeatures: {features}\n\nDescription:"

# Generate descriptions for each test item
for features_item in test_product_features:
    full_prompt = prompt_template_inference.format(features=features_item)
    print(f"\nPROMPT:\n{full_prompt}")

    generated_outputs = generator_fine_tuned(
        full_prompt,
        max_new_tokens=70,
        num_return_sequences=1,
        pad_token_id=fine_tuned_tokenizer_for_testing.eos_token_id,
        eos_token_id=fine_tuned_tokenizer_for_testing.eos_token_id
    )
    print(f"GENERATED (Fine-tuned):\n{generated_outputs[0]['generated_text']}")

Cet extrait effectue les opérations suivantes :

Charge le modèle affiné et le tokenizer.
Crée un pipeline de génération de texte avec le modèle affiné en utilisant la méthode pipeline().
Définit une liste qui fournit de nouvelles descriptions de produits inédites afin d’alimenter et d’évaluer l’affinement du modèle avec test_product_features.
Génère les descriptions pour chaque élément de test dans la boucle for.
Imprime les descriptions générées par le modèle affiné.

C’est cool ! Vous avez mis en place un pipeline pour tester et évaluer les performances du modèle.

Étape n° 6 : Assembler le tout

Votre fichier tuning.py doit maintenant contenir :

import os
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, pipeline
from trl import SFTTrainer

# Configure parameters
base_model_name = "distilgpt2"  # Pre-trained model
data_file_path = "data/data.csv" # Path to data
output_model_dir = "./results_distilgpt2"  # Directory to save results and checkpoints
final_model_path = os.path.join(output_model_dir, "final_model") # Path to save the final fine-tuned model
max_seq_length_for_tokenization = 512 # Maximum length for tokenizing inputs

# Load dataset
raw_dataset = load_dataset("csv", data_files=data_file_path)

# Define a function to format entries into a prompt-completion pair
def format_dataset_entry(data_item):
    prompt_template = "Generate a product description for the following item:\nFeatures: {features_data}\n\nDescription:"
    data_item["text"] = prompt_template.format(features_data=data_item["features"]) + " " + data_item["description"]
    return data_item

# Apply the formatting function to the train split of the dataset
text_formatted_dataset = raw_dataset["train"].map(format_dataset_entry)

# Load the tokenizer associated with the base model
tokenizer = AutoTokenizer.from_pretrained(base_model_name)
tokenizer.pad_token = tokenizer.eos_token

# Define a function to tokenize the "text" field of the dataset
def tokenize_function(data_items_batch):
    return tokenizer(
        data_items_batch["text"],
        truncation=True,
        padding="max_length",
        max_length=max_seq_length_for_tokenization,
    )

# Apply the tokenization function to the formatted dataset
tokenized_dataset = text_formatted_dataset.map(
    tokenize_function,
    batched=True,
    remove_columns=text_formatted_dataset.column_names
)

# Load the pre-trained language model
model = AutoModelForCausalLM.from_pretrained(base_model_name)

# Define training arguments for the SFTTrainer
training_args = TrainingArguments(
    output_dir=output_model_dir,
    num_train_epochs=3,
    per_device_train_batch_size=1,
    learning_rate=2e-5,
    logging_steps=10,
    save_steps=50,
    report_to="none",
)

# Initialize the SFTTrainer
trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
)

# Begin the training process
trainer.train()

# Save the fine-tuned model and tokenizer to the specified path
trainer.save_model(final_model_path)
tokenizer.save_pretrained(final_model_path)

# Load the fine-tuned model and tokenizer for testing
fine_tuned_model_for_testing = AutoModelForCausalLM.from_pretrained(final_model_path)
fine_tuned_tokenizer_for_testing = AutoTokenizer.from_pretrained(final_model_path)

# Create a text-generation pipeline with the fine-tuned model
generator_fine_tuned = pipeline("text-generation", model=fine_tuned_model_for_testing, tokenizer=fine_tuned_tokenizer_for_testing)

# Define example product features for testing
test_product_features = [
    "Category: Kitchen, Name: Electric Kettle, Features: 1.7L capacity, Stainless steel, Auto shut-off, Boil-dry protection, Color: Silver",
    "Category: Office, Name: Ergonomic Office Chair, Features: Lumbar support, Adjustable height, Mesh back, Swivel, Color: Black"
]

# Define the prompt template
prompt_template_inference = "Generate a product description for the following item:\nFeatures: {features}\n\nDescription:"

# Generate descriptions for each test item
for features_item in test_product_features:
    full_prompt = prompt_template_inference.format(features=features_item)
    print(f"\nPROMPT:\n{full_prompt}")

    generated_outputs = generator_fine_tuned(
        full_prompt,
        max_new_tokens=70,
        num_return_sequences=1,
        pad_token_id=fine_tuned_tokenizer_for_testing.eos_token_id,
        eos_token_id=fine_tuned_tokenizer_for_testing.eos_token_id
    )
    print(f"GENERATED (Fine-tuned):\n{generated_outputs[0]['generated_text']}")

Exécutez votre code avec :

python tuning.py

Le résultat attendu est le suivant :

Résultat attendu avec un CSV de 300 lignes

Comme indiqué, l’invite demande au modèle de créer la description d’une bouilloire électrique, en fournissant les informations nécessaires. Le modèle crée la description, comme prévu. Si vous décomposez ce résultat, vous pouvez voir :

Nom de produit généré: il génère le nom de produit “ProChef Luxury Living Hood Series X”, qui semble plausible pour un article de cuisine, ainsi que la description.
Détail contradictoire: Il se termine par “Disponible dans une étonnante finition blanc pur”, ce qui est en contradiction avec la “Couleur : argent” fournie dans les caractéristiques de l’invite. Ainsi, si le réglage fin guide le modèle, il ne garantit pas une cohérence parfaite. Cela se produit surtout avec des modèles plus petits et une formation limitée.

Les imperfections et les contradictions sont typiques des modèles génératifs, en particulier pour les petits modèles comme distilgpt2. Elles peuvent également dépendre de la taille et de la qualité de l’ensemble de données de réglage fin, ainsi que du nombre d’époques d’apprentissage. Dans le cas présent, l’ensemble de données utilisé ne comporte que 300 lignes. Un ensemble de données plus important aurait permis d’obtenir une meilleure description de la bouilloire.

Pour illustrer la perte de qualité, voici le résultat escompté avec un fichier CSV ne comportant que 5 lignes :

Comme vous pouvez le constater, le résultat est une hallucination totale. Pour schématiser :

Nom de produit généré: ****It nomme le produit “Chaise de bureau” au lieu de “Chaise de bureau ergonomique” dans la première phrase.
Détail contradictoire: ****Dans la deuxième phrase, le nom devient “Lumbar”. Le modèle confond donc le nom avec la fonction (“soutien lombaire”).
Grammaire incohérente: les deux phrases ont une grammaire incohérente et incorrecte.
Caractéristiques manquantes: La couleur et les caractéristiques (“Soutien lombaire”, “Hauteur réglable”, “Pivot”) ne sont pas mentionnées dans la description.

Cependant, si vous deviez fournir la même invite au modèle distilgpt2 sans le processus de réglage fin, le résultat serait nettement moins bon. Cela s’explique par le fait que ce modèle n’a pas été entraîné sur des données aussi spécifiques. Par exemple, il ne pourrait pas fournir la description de la bouilloire.

Notez que, lorsque le processus est terminé, le code génère automatiquement un dossier appelé results_distilgpt2/, dans lequel sont consignés les résultats. À l’intérieur de ce dossier, vous trouverez des sous-dossiers qui rapportent les résultats enregistrés par le modèle à différentes époques :

Dossier contenant les résultats enregistrés par le modèle

C’est utile si vous souhaitez obtenir l’un de ces points de contrôle et l’utiliser comme bon vous semble.

Et voilà ! La mise au point du LLM est terminée.

Conclusion

Dans cet article, vous avez appris ce qu’est le réglage fin supervisé dans le contexte des LLM. Vous avez également suivi un processus étape par étape pour reproduire le processus de réglage fin.

Le cœur de SFT repose sur des ensembles de données de haute qualité pour affiner vos modèles. Heureusement, Bright Data vous propose de nombreux services pour l’acquisition ou la création d’ensembles de données :

Navigateur de scraping: Un navigateur compatible avec Playwright, Selenium et Puppeter, avec des capacités de déverrouillage intégrées.
Web Scraper APIs: API préconfigurées pour l’extraction de données structurées à partir de plus de 100 domaines majeurs.
Web Unlocker: Une API tout-en-un qui gère le déverrouillage des sites dotés de protections anti-bots.
SERP API: Une API spécialisée qui déverrouille les résultats des moteurs de recherche et extrait des données SERP complètes.
Modèles de base: Accédez à des ensembles de données conformes à l’échelle du web pour faciliter le pré-entraînement, l’évaluation et la mise au point.
Fournisseurs de données: Connectez-vous avec des fournisseurs de confiance pour obtenir des ensembles de données de haute qualité, prêts pour l’IA, à grande échelle.
Paquets de données: Obtenez des ensembles de données curatifs et prêts à l’emploi, structurés, enrichis et annotés.

Créez gratuitement un compte Bright Data pour tester nos services d’extraction de données et explorer notre marché de jeux de données !

Essai gratuit

S’inscrire avec Google

Aucune carte de crédit requise

Qu’est-ce que le réglage fin supervisé dans les LLM ?