🤗 PEFT - Présentation détaillée de la bibliothèque de fine-tuning efficace en termes de paramètres

Aperçu du projet

PEFT (Parameter-Efficient Fine-Tuning) est une bibliothèque avancée de fine-tuning efficace en termes de paramètres développée par Hugging Face. Ce projet vise à résoudre les problèmes de coûts de calcul élevés et d'énormes besoins de stockage lors du fine-tuning de grands modèles pré-entraînés.

Adresse GitHub : https://github.com/huggingface/peft

Valeur fondamentale et avantages

1. Rentabilité

• Réduction significative des coûts de calcul : par rapport au fine-tuning complet des paramètres traditionnels, les méthodes PEFT ne nécessitent que l'entraînement d'une petite partie des paramètres du modèle.
• Réduction significative des besoins de stockage : les fichiers de checkpoint du modèle fine-tuné ne font généralement que quelques Mo, au lieu de quelques Go.
• Optimisation de l'utilisation de la mémoire : permet de traiter des modèles plus grands dans les mêmes conditions matérielles.

2. Maintien des performances

• Comparable au fine-tuning complet des paramètres : atteint des performances comparables au fine-tuning complet sur la plupart des tâches.
• Évite l'oubli catastrophique : protège les connaissances originales du modèle de base et réduit le risque de surapprentissage.

3. Flexibilité et commodité

• Adaptation multi-tâches : permet d'entraîner plusieurs adaptateurs légers pour différentes tâches.
• Intégration transparente : s'intègre parfaitement aux écosystèmes tels que Transformers, Diffusers et Accelerate.

Méthodes de fine-tuning prises en charge

Principales techniques PEFT

1. LoRA (Low-Rank Adaptation)

• La méthode de fine-tuning efficace en termes de paramètres la plus populaire.
• Réduit considérablement le nombre de paramètres entraînables grâce à la décomposition matricielle de faible rang.
• Dans les scénarios typiques, il suffit d'entraîner 0,1 % à 1 % des paramètres d'origine.

2. AdaLoRA

• Version améliorée de LoRA.
• Ajuste de manière adaptative la taille du rang, optimisant davantage l'efficacité.

3. Prefix Tuning

• Ajoute un préfixe apprenable à la séquence d'entrée.
• Convient aux tâches de génération.

4. P-Tuning v2

• Méthode d'ajustement des prompts améliorée.
• Ajoute des paramètres apprenables dans plusieurs couches.

5. IA³ (Infused Adapter by Inhibiting and Amplifying Inner Activations)

• Adapte le modèle en inhibant et en amplifiant les activations internes.

Effets de l'application pratique

Comparaison de l'utilisation de la mémoire (GPU A100 80 Go)

Modèle	Fine-tuning complet des paramètres	PEFT-LoRA	PEFT-LoRA + Déchargement CPU DeepSpeed
T0_3B (3 milliards de paramètres)	47,14 Go GPU / 2,96 Go CPU	14,4 Go GPU / 2,96 Go CPU	9,8 Go GPU / 17,8 Go CPU
mt0-xxl (120 milliards de paramètres)	Mémoire insuffisante	56 Go GPU / 3 Go CPU	22 Go GPU / 52 Go CPU
bloomz-7b1 (7 milliards de paramètres)	Mémoire insuffisante	32 Go GPU / 3,8 Go CPU	18,1 Go GPU / 35 Go CPU

Performances

Comparaison de la précision sur la tâche de classification des plaintes Twitter :

• Ligne de base humaine : 89,7 %
• Flan-T5 : 89,2 %
• LoRA-T0-3B : 86,3 %

Installation et démarrage rapide

Installation

pip install peft

Exemple d'utilisation de base

from transformers import AutoModelForSeq2SeqLM
from peft import get_peft_config, get_peft_model, LoraConfig, TaskType

# Configuration de PEFT
model_name_or_path = "bigscience/mt0-large"
peft_config = LoraConfig(
    task_type=TaskType.SEQ_2_SEQ_LM, 
    inference_mode=False, 
    r=8, 
    lora_alpha=32, 
    lora_dropout=0.1
)

# Chargement et encapsulation du modèle
model = AutoModelForSeq2SeqLM.from_pretrained(model_name_or_path)
model = get_peft_model(model, peft_config)

# Affichage des paramètres entraînables
model.print_trainable_parameters()
# Output: trainable params: 2359296 || all params: 1231940608 || trainable%: 0.19

Utilisation pour l'inférence

from peft import AutoPeftModelForCausalLM
from transformers import AutoTokenizer

# Chargement du modèle fine-tuné
model = AutoPeftModelForCausalLM.from_pretrained("ybelkada/opt-350m-lora").to("cuda")
tokenizer = AutoTokenizer.from_pretrained("facebook/opt-350m")

# Effectuer l'inférence
model.eval()
inputs = tokenizer("Votre texte d'entrée", return_tensors="pt")
outputs = model.generate(input_ids=inputs["input_ids"].to("cuda"), max_new_tokens=50)

Intégration de l'écosystème

1. Intégration de Transformers

• Prend en charge diverses architectures de modèles pré-entraînés.
• Flux de travail d'entraînement et d'inférence transparents.
• Configuration et optimisation automatiques du modèle.

2. Intégration de Diffusers

• Prend en charge le fine-tuning efficace des modèles de diffusion.
• Convient aux tâches de génération d'images, d'édition, etc.
• Réduit considérablement les besoins en mémoire d'entraînement.

3. Intégration d'Accelerate

• Prend en charge l'entraînement distribué.
• Optimisation de l'entraînement multi-GPU, TPU.
• Convivial pour le matériel grand public.

4. Intégration de TRL (Transformer Reinforcement Learning)

• Prend en charge RLHF (Reinforcement Learning from Human Feedback).
• DPO (Direct Preference Optimization).
• Entraînement d'alignement des grands modèles.

Scénarios d'application

1. Fine-tuning de grands modèles de langage

• Fine-tuning des instructions.
• Optimisation du système de dialogue.
• Adaptation à des domaines spécifiques.

2. Modèles multimodaux

• Fine-tuning des modèles vision-langage.
• Adaptation des modèles de traitement audio.

3. Modèles de diffusion

• Personnalisation de Stable Diffusion.
• Entraînement DreamBooth.
• Transfert de style.

4. Apprentissage par renforcement

• Fine-tuning du modèle de stratégie.
• Entraînement du modèle de récompense.
• Alignement des préférences humaines.

Avantages techniques et points d'innovation

1. Efficacité des paramètres

• N'entraîne que 0,1 % à 1 % des paramètres d'origine.
• Maintient plus de 95 % des performances.
• Réduit la taille des fichiers de checkpoint à 1/100 de la taille d'origine.

2. Optimisation de la mémoire

• Réduit considérablement les besoins en mémoire GPU.
• Prend en charge l'entraînement de grands modèles sur du matériel grand public.
• Le checkpoint de gradient optimise davantage la mémoire.

3. Compatibilité de la quantification

• Se combine parfaitement avec la quantification 8 bits et 4 bits.
• Prend en charge la technologie QLoRA.
• Réduit encore les exigences matérielles.

4. Conception modulaire

• Prend en charge diverses méthodes PEFT.
• Options de configuration flexibles.
• Facile à étendre avec de nouvelles méthodes.

Communauté et écosystème

Ressources officielles

• Documentation : https://huggingface.co/docs/peft
• Bibliothèque de modèles : https://huggingface.co/PEFT
• Exemples de notebooks : couvrant divers scénarios d'application.
• Tutoriels de blog : explications techniques détaillées et meilleures pratiques.

Conclusion

🤗 PEFT est une bibliothèque révolutionnaire de fine-tuning efficace en termes de paramètres qui non seulement résout le problème des coûts du fine-tuning des grands modèles, mais maintient également d'excellentes performances. Que ce soit pour les chercheurs ou les développeurs industriels, PEFT offre une solution économique et efficace pour la personnalisation des grands modèles, favorisant ainsi la démocratisation de la technologie de l'IA.