Intelligence Artificielle
Le seul guide dont vous avez besoin pour affiner Llama 3 ou tout autre modèle Open Source
Le réglage fin des grands modèles de langage (LLM) comme Llama 3 implique l'adaptation d'un modèle pré-entraîné à des tâches spécifiques à l'aide d'un jeu de données spécifique au domaine. Ce processus exploite les connaissances préexistantes du modèle, le rendant ainsi plus efficace et plus rentable qu'un apprentissage complet. Dans ce guide, nous détaillerons les étapes permettant de régler Llama 3 avec QLoRA (Quantized LoRA), une méthode optimisée en termes de paramètres qui minimise l'utilisation de la mémoire et les coûts de calcul.
Présentation du réglage fin
Le réglage fin implique plusieurs étapes clés :
- Sélection d'un modèle pré-entraîné: Choisissez un modèle de base qui correspond à l'architecture souhaitée.
- Rassembler un ensemble de données pertinent: Collectez et prétraitez un ensemble de données spécifique à votre tâche.
- Réglage fin: Adapter le modèle à l'aide de l'ensemble de données pour améliorer ses performances sur des tâches spécifiques.
- Évaluation: Évaluez le modèle affiné à l’aide de mesures qualitatives et quantitatives.
Concepts et techniques
Affiner les grands modèles de langage
Mise au point complète
Mise au point complète met à jour tous les paramètres du modèle, le rendant spécifique à la nouvelle tâche. Cette méthode nécessite des ressources de calcul importantes et est souvent peu pratique pour de très grands modèles.
Réglage fin efficace des paramètres (PEFT)
PEFT met à jour uniquement un sous-ensemble des paramètres du modèle, réduisant ainsi les besoins en mémoire et les coûts de calcul. Cette technique évite les oublis catastrophiques et maintient la connaissance générale du modèle.
Adaptation de bas rang (LoRA) et LoRA quantifiée (QLoRA)
LoRA affine uniquement quelques matrices de bas rang, tandis que QLoRA quantifie ces matrices pour réduire davantage l'empreinte mémoire.
Méthodes de réglage fin
- Mise au point complète: Cela implique d'entraîner tous les paramètres du modèle sur l'ensemble de données spécifique à la tâche. Bien que cette méthode puisse être très efficace, elle est également coûteuse en termes de calcul et nécessite une mémoire importante.
- Réglage fin efficace des paramètres (PEFT): PEFT met à jour uniquement un sous-ensemble des paramètres du modèle, ce qui le rend plus efficace en termes de mémoire. Des techniques telles que l'adaptation de bas rang (LoRA) et la LoRA quantifiée (QLoRA) entrent dans cette catégorie.
Qu’est-ce que LoRA ?
Comparaison des méthodes de réglage fin : QLORA améliore LoRA avec une quantification de précision sur 4 bits et des optimiseurs paginés pour la gestion des pics de mémoire
LoRA est une méthode de réglage fin améliorée dans laquelle, au lieu d'affiner tous les poids du modèle pré-entraîné, deux matrices plus petites qui se rapprochent de la matrice plus grande sont affinées. Ces matrices constituent l'adaptateur LoRA. Cet adaptateur affiné est ensuite chargé dans le modèle pré-entraîné et utilisé pour l'inférence.
Principaux avantages de LoRA :
- Efficacité de la mémoire: LoRA réduit l'empreinte mémoire en ajustant uniquement les petites matrices au lieu du modèle entier.
- Réutilisable: Le modèle d'origine reste inchangé et plusieurs adaptateurs LoRA peuvent être utilisés avec, facilitant la gestion de plusieurs tâches avec des besoins en mémoire inférieurs.
Qu’est-ce que la LoRA quantifiée (QLoRA) ?
QLoRA va encore plus loin en quantifiant les poids des adaptateurs LoRA avec une précision inférieure (par exemple, 4 bits au lieu de 8 bits). Cela réduit encore davantage l'utilisation de la mémoire et les besoins de stockage tout en conservant un niveau d'efficacité comparable.
Principaux avantages de QLoRA :
- Une efficacité de mémoire encore plus grande: En quantifiant les poids, QLoRA réduit considérablement les besoins en mémoire et en stockage du modèle.
- Maintient les performances: Malgré la précision réduite, QLoRA maintient des niveaux de performances proches de ceux des modèles pleine précision.
Adaptation spécifique à une tâche
Lors du réglage fin, les paramètres du modèle sont ajustés en fonction du nouvel ensemble de données, ce qui l'aide à mieux comprendre et générer du contenu pertinent pour la tâche spécifique. Ce processus conserve les connaissances linguistiques générales acquises lors de la pré-formation tout en adaptant le modèle aux nuances du domaine cible.
Mise au point dans la pratique
Ajustement complet par rapport au PEFT
- Mise au point complète: implique la formation de l'ensemble du modèle, ce qui peut être coûteux en calcul et nécessite une mémoire importante.
- PEFT (LoRA et QLoRA): affine uniquement un sous-ensemble de paramètres, réduisant ainsi les besoins en mémoire et empêchant les oublis catastrophiques, ce qui en fait une alternative plus efficace.
Étapes de mise en œuvre
- Environnement de configuration: Installez les bibliothèques nécessaires et configurez l'environnement informatique.
- Charger et prétraiter l'ensemble de données : chargez l'ensemble de données et prétraitez-le dans un format adapté au modèle.
- Charger le modèle pré-entraîné : chargez le modèle de base avec les configurations de quantification si vous utilisez QLoRA.
- tokenization: Tokenisez l'ensemble de données pour le préparer à la formation.
- Formation: Affinez le modèle à l’aide de l’ensemble de données préparé.
- Évaluation:Évaluer les performances du modèle sur des tâches spécifiques à l’aide de mesures qualitatives et quantitatives.
Guide Steo par étape pour affiner le LLM
Configuration de l'environnement
Nous utiliserons un notebook Jupyter pour ce tutoriel. Des plateformes comme Kaggle, qui offre l'utilisation gratuite du GPU, ou Google Colab sont idéales pour réaliser ces expériences.
1. Installer les bibliothèques requises
Tout d’abord, assurez-vous que les bibliothèques nécessaires sont installées :
!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score</div>
2. Importer des bibliothèques et configurer l'environnement
import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments,
pipeline, HfArgumentParser
)
from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer
from tqdm import tqdm
import gc
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login
# Disable Weights and Biases logging
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()
3. Chargez l'ensemble de données
Nous utiliserons l'ensemble de données DialogSum pour ce tutoriel :
Prétraiter l'ensemble de données conformément aux exigences du modèle, notamment en appliquant les modèles appropriés et en veillant à ce que le format des données soit adapté à un réglage précis. (Étreindre le visage)â € <â € < (DataCamp).
dataset_name = "neil-code/dialogsum-test" dataset = load_dataset(dataset_name)
Inspectez la structure de l'ensemble de données :
print(dataset['test'][0])
4. Créer une configuration BitsAndBytes
Pour charger le modèle au format 4 bits :
compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type='nf4',
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=False,
)
5. Chargez le modèle pré-entraîné
Utilisation du modèle Phi-2 de Microsoft pour ce tutoriel :
model_name = 'microsoft/phi-2'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)
6. Tokenization
Configurez le tokeniseur :
tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token
Réglage fin de Llama 3 ou d'autres modèles
Lors du réglage fin de modèles comme Llama 3 ou tout autre LLM open source de pointe, des considérations et des ajustements spécifiques sont nécessaires pour garantir des performances optimales. Voici les étapes détaillées et les informations sur la façon d'aborder cela pour différents modèles, notamment Llama 3, GPT-3 et Mistral.
5.1 Utiliser Lama 3
Sélection de modèle:
- Assurez-vous d'avoir l'identifiant de modèle correct provenant du hub de modèles Hugging Face. Par exemple, le modèle Llama 3 pourrait être identifié comme
meta-llama/Meta-Llama-3-8Bsur Visage étreignant. - Assurez-vous de demander l'accès et de vous connecter à votre compte Hugging Face si nécessaire pour des modèles comme Llama 3 (Étreindre le visage)â € <â € <
Tokenisation:
- Utilisez le tokenizer approprié pour Llama 3, en vous assurant qu'il est compatible avec le modèle et prend en charge les fonctionnalités requises telles que le remplissage et les jetons spéciaux.
Mémoire et calcul :
- La mise au point de grands modèles comme Llama 3 nécessite des ressources informatiques importantes. Assurez-vous que votre environnement, tel qu'une configuration GPU puissante, peut gérer les exigences de mémoire et de traitement. Assurez-vous que l'environnement peut gérer les besoins en mémoire, qui peuvent être atténués en utilisant des techniques telles que QLoRA pour réduire l'empreinte mémoire. (Forums câlins)
Exemple :
model_name = 'meta-llama/Meta-Llama-3-8B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)
Tokenisation:
En fonction du cas d'utilisation spécifique et des exigences du modèle, assurez-vous d'une configuration correcte du tokenizer sans paramètres redondants. Par exemple, use_fast=True est recommandé pour de meilleures performances (Étreindre le visage)â € <â € < (Poids et biais).
tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token
5.2 Utilisation d'autres modèles populaires (par exemple, GPT-3, Mistral)
Sélection de modèle:
- Pour les modèles comme GPT-3 et Mistral, assurez-vous d'utiliser le nom de modèle et l'identifiant corrects provenant du hub de modèles Hugging Face ou d'autres sources.
Tokenisation:
- Semblable à Llama 3, assurez-vous que le tokenizer est correctement configuré et compatible avec le modèle.
Mémoire et calcul :
- Chaque modèle peut avoir des besoins en mémoire différents. Ajustez la configuration de votre environnement en conséquence.
Exemple pour GPT-3 :
model_name = 'openai/gpt-3'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)
Exemple pour Mistral :
model_name = 'mistral-7B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)
Considérations sur la tokenisation : Chaque modèle peut avoir des exigences de tokenisation uniques. Assurez-vous que le tokenizer correspond au modèle et est correctement configuré.
Exemple de tokeniseur Llama 3 :
tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token
Exemple de GPT-3 et Mistral Tokenizer :
tokenizer = AutoTokenizer.from_pretrained(
model_name,
use_fast=True
)
7. Testez le modèle avec l'inférence Zero-Shot
Évaluez le modèle de base avec un exemple d'entrée :
from transformers import set_seed
set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"
# Generate output
def gen(model, prompt, max_length):
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.batch_decode(outputs, skip_special_tokens=True)
res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]
print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')
8. Prétraiter l'ensemble de données
Convertissez les paires boîte de dialogue-résumé en invites :
def create_prompt_formats(sample):
blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
instruction = "### Instruct: Summarize the below conversation."
input_context = sample['dialogue']
response = f"### Output:\n{sample['summary']}"
end = "### End"
parts = [blurb, instruction, input_context, response, end]
formatted_prompt = "\n\n".join(parts)
sample["text"] = formatted_prompt
return sample
dataset = dataset.map(create_prompt_formats)
Tokenisez l'ensemble de données formaté :
def preprocess_batch(batch, tokenizer, max_length):
return tokenizer(batch["text"], max_length=max_length, truncation=True)
max_length = 1024
train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
9. Préparer le modèle pour QLoRA
Préparez le modèle pour un réglage fin efficace des paramètres :
original_model = prepare_model_for_kbit_training(original_model)
Hyperparamètres et leur impact
Les hyperparamètres jouent un rôle crucial dans l'optimisation des performances de votre modèle. Voici quelques hyperparamètres clés à prendre en compte :
- Taux d'apprentissage: contrôle la vitesse à laquelle le modèle met à jour ses paramètres. Un taux d'apprentissage élevé peut conduire à une convergence plus rapide mais peut dépasser la solution optimale. Un faible taux d'apprentissage garantit une convergence constante mais peut nécessiter plus d'époques.
- Taille du lot: Le nombre d'échantillons traités avant que le modèle ne mette à jour ses paramètres. Des lots de plus grande taille peuvent améliorer la stabilité mais nécessitent plus de mémoire. Des lots plus petits peuvent entraîner plus de bruit dans le processus de formation.
- Étapes d'accumulation de dégradé: ce paramètre permet de simuler des lots de plus grande taille en accumulant des gradients sur plusieurs étapes avant d'effectuer une mise à jour des paramètres.
- Nombre d'époques: nombre de fois où l'ensemble de données entier est transmis à travers le modèle. Plus d'époques peuvent améliorer les performances, mais peuvent conduire à un surapprentissage si elles ne sont pas gérées correctement.
- Perte de poids: Technique de régularisation pour éviter le surajustement en pénalisant les gros poids.
- Planificateur de taux d'apprentissage: Ajuste le taux d'apprentissage pendant l'entraînement pour améliorer les performances et la convergence.
Personnalisez la configuration de la formation en ajustant les hyperparamètres tels que le taux d'apprentissage, la taille du lot et les étapes d'accumulation de gradient en fonction des exigences spécifiques du modèle et de la tâche. Par exemple, les modèles Llama 3 peuvent nécessiter des taux d'apprentissage différents par rapport aux modèles plus petits. (Poids et biais)â € <â € < (GitHub)
Exemple de configuration de formation
orpo_args = ORPOConfig( learning_rate=8e-6, lr_scheduler_type="linear",max_length=1024,max_prompt_length=512, beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2, gradient_accumulation_steps=4,optim="paged_adamw_8bit",num_train_epochs=1, evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10, report_to="wandb",output_dir="./results/",)
10. Former le modèle
Configurez le formateur et démarrez la formation :
trainer = ORPOTrainer(
model=original_model,
args=orpo_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
tokenizer=tokenizer,)
trainer.train()
trainer.save_model("fine-tuned-llama-3")
Évaluation du modèle affiné
Après la formation, évaluez les performances du modèle à l’aide de méthodes qualitatives et quantitatives.
1. Évaluation humaine
Comparez les résumés générés avec ceux rédigés par des humains pour évaluer la qualité.
2. Évaluation quantitative
Utilisez des métriques comme ROUGE pour évaluer les performances :
from rouge_score import rouge_scorer scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True) scores = scorer.score(reference_summary, generated_summary) print(scores)
Défis communs et solutions
1. Limitations de la mémoire
L'utilisation de QLoRA permet d'atténuer les problèmes de mémoire en quantifiant les poids du modèle à 4 bits. Assurez-vous de disposer de suffisamment de mémoire GPU pour gérer la taille de votre lot et la taille de votre modèle.
2. Surapprentissage
Surveillez les métriques de validation pour éviter le surajustement. Utilisez des techniques telles que l’arrêt précoce et la perte de poids.
3. Entraînement lent
Optimisez la vitesse d'entraînement en ajustant la taille du lot, le taux d'apprentissage et en utilisant l'accumulation de gradient.
4. Qualité des données
Assurez-vous que votre ensemble de données est propre et bien prétraité. Une mauvaise qualité des données peut avoir un impact significatif sur les performances du modèle.
Conclusion
Le réglage fin des LLM à l'aide de QLoRA est un moyen efficace d'adapter de grands modèles pré-entraînés à des tâches spécifiques avec des coûts de calcul réduits. En suivant ce guide, vous pouvez affiner PHI, Llama 3 ou tout autre modèle open source pour obtenir des performances élevées sur vos tâches spécifiques.
