Mes projets Agntbox AI utilisent désormais PEFT pour l’harmonie multi-modèles

Salut tout le monde, ici Nina, de retour pour explorer le monde en perpétuelle évolution des outils d’IA pour agntbox.com. Aujourd’hui, je veux parler de quelque chose qui fait beaucoup de bruit dans mes propres projets ces derniers temps : faire en sorte que les modèles d’IA fonctionnent bien ensemble, surtout lorsqu’ils ne viennent pas tous de la même entreprise. Plus précisément, je me suis battue avec — et finalement assez impressionnée par — les avancées récentes dans les techniques PEFT (Parameter-Efficient Fine-Tuning), et comment elles rendent vraiment pratique l’adaptation de modèles open-source sans se ruiner ou se perdre la raison.

Mon angle aujourd’hui n’est pas juste un aperçu général du PEFT ; nous allons nous concentrer sur comment il devient le cadre pour rendre le fine-tuning accessible aux développeurs indépendants et aux petites équipes. Oubliez le besoin d’une ferme de serveurs pour adapter un modèle de langage large (LLM). Nous parlons de prendre un puissant behemoth pré-entraîné et de le pousser doucement à exécuter des tâches spécifiques avec une fraction de la puissance de calcul à laquelle vous vous attendriez. C’est comme apprendre à un vieux chien de nouveaux tours, mais le chien est un génie et vous n’avez besoin de lui apprendre que quelques signaux de main clés.

L’Éléphant dans la pièce : Pourquoi le fine-tuning était un cauchemar

Soyons réalistes. Il y a quelques années, si vous vouliez affiner un modèle comme BERT ou GPT-2 (les open-source, pas la sauce secrète d’OpenAI), vous aviez besoin d’un matériel sérieux. Nous parlons de multiples GPU haut de gamme, d’heures de temps de formation et d’une facture d’électricité salée. En tant que blogueuse et développeuse qui travaille souvent sur des projets de preuve de concept ou construit des outils pour des clients plus petits, ce type d’engagement était généralement inacceptable. Je me retrouvais souvent à essayer de plier un modèle pré-entraîné à ma volonté avec des indications élaborées ou en reliant plusieurs petits modèles ensemble, juste pour éviter l’épuisement des ressources du vrai fine-tuning.

Je me souviens d’un projet, à la fin de 2024, où j’essayais de construire un outil de synthèse personnalisé pour des documents juridiques très spécifiques d’un client. Les synthétiseurs standards étaient corrects, mais ils manquaient les nuances et les phrases clés cruciales pour le contexte légal. Ma pensée initiale était : “Super, je vais affiner un modèle T5.” Après environ une heure à configurer l’environnement et réalisant le volume de paramètres que j’allais essayer de mettre à jour, mon enthousiasme s’est rapidement évaporé. Mon unique RTX 3090, bien que puissant pour les jeux, était déjà à bout de souffle rien qu’en y pensant. J’ai fini par recourir à une approche complexe d’ingénierie de prompt qui fonctionnait, mais était fragile et difficile à maintenir.

Cette expérience, et beaucoup d’autres comme elle, ont mis en évidence un énorme fossé. Nous avions ces modèles fondamentaux incroyables, mais les rendre véritablement notres, les adapter à nos données et tâches uniques, semblait être un luxe réservé aux laboratoires de recherche bien financés ou aux grandes entreprises technologiques. C’est là que le PEFT intervient et change la donne.

Qu’est-ce que PEFT et pourquoi devriez-vous vous en soucier ?

Le PEFT, ou Parameter-Efficient Fine-Tuning, n’est pas une technique unique mais un ensemble de méthodes conçues pour adapter de grands modèles pré-entraînés à de nouvelles tâches ou jeux de données avec significativement moins de paramètres entraînables que le fine-tuning complet. Au lieu de mettre à jour chaque poids dans un modèle qui pourrait avoir des milliards de paramètres, les méthodes PEFT ne mettent à jour qu’un petit sous-ensemble ou introduisent de nouveaux paramètres plus petits qui sont ensuite entraînés.

Pensez-y ainsi : vous avez un chef cuisinier (le LLM pré-entraîné) qui sait cuisiner presque n’importe quoi. Vous voulez qu’il se spécialise dans la cuisson d’un type de pain très particulier. Un fine-tuning complet serait comme faire réapprendre au chef toutes les techniques de cuisine, toutes les recettes, depuis le début, juste pour perfectionner ce pain. Le PEFT, en revanche, c’est comme donner au chef un petit livre de recettes spécifiquement pour ce pain, ou un accessoire spécial pour son four. Il garde tout son savoir-faire existant, mais maintenant il a un moyen ciblé d’exceller à votre demande spécifique.

Le principal avantage ici est des économies massives en ressources de calcul – tant en mémoire GPU qu’en temps de formation. Cela signifie que vous pouvez affiner des modèles beaucoup plus grands sur des GPU de consommation, ou même sur des CPU si vous êtes suffisamment patient. Cela démocratise l’accès à l’adaptation de modèles d’IA de pointe, et c’est un gros plus pour des gens comme nous.

LoRA : Ma méthode PEFT actuelle préférée

Parmi les différentes techniques PEFT, l’Adaptation à Bas Rang (LoRA) est devenue ma préférée personnelle et celle que j’utilise le plus souvent. Elle est élégante dans sa simplicité et étonnamment efficace. LoRA fonctionne en injectant des matrices de décomposition de rang entraînables dans les couches de transformateur du modèle pré-entraîné. Pendant le fine-tuning, seules ces matrices injectées sont mises à jour, tandis que les poids du modèle pré-entraîné d’origine restent figés.

Cela signifie que vous n’entraînez pas des milliards de paramètres ; vous pourriez n’entraîner que quelques millions, voire juste des centaines de milliers. Les fichiers “adaptateurs” LoRA résultants sont minuscules, souvent juste quelques mégaoctets, comparés aux gigaoctets du modèle d’origine. Vous pouvez ensuite charger cet adaptateur par-dessus le modèle de base pour obtenir votre version spécialisée. C’est également incroyablement efficace pour le stockage et le déploiement.

Un exemple concret : Affiner Llama 2 pour des réponses de support client

Allons au concret. Imaginez un scénario où vous construisez un assistant IA pour le support client. Vous voulez qu’il génère des réponses qui non seulement répondent aux questions mais adhèrent également au ton spécifique de votre marque, utilisent un jargon particulier et respectent certaines politiques internes. Utiliser un LLM polyvalent pourrait vous amener à 80%, mais ces 20% restants sont cruciaux pour une expérience polie et conforme à la marque.

J’ai récemment travaillé sur un projet similaire pour un petit client e-commerce spécialisé dans les bijoux faits main. Leur voix de marque est très chaleureuse, personnelle et légèrement fantaisiste. Un modèle standard Llama 2 7B, bien que puissant, semblait souvent trop générique ou formel. Le fine-tuning complet était hors de question avec mon matériel. Voici donc LoRA.

Configurer l’environnement (simplifié)

Tout d’abord, vous devez généralement installer les bibliothèques nécessaires. Les bibliothèques Hugging Face transformers et peft sont vos meilleurs amis ici.

pip install transformers peft accelerate bitsandbytes

• transformers : Pour accéder au modèle de base Llama 2.
• peft : Pour l’implémentation de LoRA.
• accelerate : Aide avec l’entraînement distribué et l’optimisation de la mémoire.
• bitsandbytes : Pour la quantification 4 bits, permettant de charger des modèles encore plus grands avec moins de VRAM.

Charger le modèle de base et le tokenizer

Nous allons charger une version quantifiée de Llama 2 7B pour économiser de la mémoire. La quantification réduit la précision des poids du modèle, permettant de l’adapter à moins de VRAM, souvent avec un impact minimal sur les performances.

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

model_id = "meta-llama/Llama-2-7b-hf" # Ou toute autre variante de Llama 2 à laquelle vous avez accès

# Configuration pour la quantification 4 bits
bnb_config = BitsAndBytesConfig(
 load_in_4bit=True,
 bnb_4bit_quant_type="nf4",
 bnb_4bit_compute_dtype=torch.bfloat16,
 bnb_4bit_use_double_quant=True,
)

model = AutoModelForCausalLM.from_pretrained(
 model_id,
 quantization_config=bnb_config,
 device_map="auto",
 torch_dtype=torch.bfloat16,
)
model.config.use_cache = False # Important pour l'entraînement

tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token # Llama 2 n'a pas de jeton de remplissage par défaut

Préparer le modèle pour LoRA

Ensuite, nous utilisons la bibliothèque peft pour préparer le modèle. Nous lui disons quelles couches nous voulons appliquer LoRA (typiquement les couches d’attention, les valeurs communes sont q_proj et v_proj), le rang (r), et la valeur alpha (lora_alpha).

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# Préparer le modèle pour l'entraînement k-bit (important pour les modèles quantifiés)
model = prepare_model_for_kbit_training(model)

# Configuration LoRA
lora_config = LoraConfig(
 r=8, # Rang des matrices de mise à jour. Un rang inférieur signifie moins de paramètres entraînables.
 lora_alpha=16, # Facteur d'échelle pour les poids LoRA.
 target_modules=["q_proj", "v_proj"], # Appliquer LoRA à ces couches d'attention.
 lora_dropout=0.05, # Probabilité de dropout pour les couches LoRA.
 bias="none", # Nous n'affinons généralement pas les poids de biais avec LoRA.
 task_type="CAUSAL_LM", # Spécifier le type de tâche.
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

Lorsque j’ai exécuté cela sur ma machine, la sortie de print_trainable_parameters() a été une révélation. Au lieu de milliards, je voyais quelque chose comme “params entraînables : 4,194,304 || tous les params : 7,000,000,000 || % entraînable : 0.0599”. C’est moins de 0,1 % du total des paramètres ! C’est ce qui rend cela faisable.

Données d’entraînement et configuration de l’entraîneur

Pour les données d’entraînement, j’ai utilisé un petit jeu de données (environ 500 exemples) de demandes de clients associées à des réponses idéales, conformes à la marque, que mon client avait soigneusement sélectionnées au fil du temps. Chaque exemple était formaté comme une paire instruction-réponse.

# Ensemble de données fictif pour illustration
from datasets import Dataset

data = [
 {"text": "### Client : Mon collier s'est cassé, que dois-je faire ?\n### Assistant : Oh non ! Je suis vraiment désolé d'apprendre que votre collier est cassé. Veuillez envoyer une photo à [email protected] et nous allons organiser une réparation ou un remplacement tout de suite. Nous voulons que vous aimiez vos bijoux !",},
 {"text": "### Client : Expédiez-vous à l'international ?\n### Assistant : Oui, nous le faisons ! Nous expédions nos trésors artisanaux partout dans le monde. Vous pouvez trouver plus de détails sur notre page d'expédition, ou n'hésitez pas à demander si vous avez un pays spécifique en tête.",},
 # ... plus d'exemples
]

dataset = Dataset.from_list(data)

def tokenize_function(examples):
 return tokenizer(examples["text"], truncation=True, max_length=512)

tokenized_dataset = dataset.map(tokenize_function, batched=True)

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
 output_dir="./results",
 num_train_epochs=3,
 per_device_train_batch_size=2, # Ajustez en fonction de votre VRAM
 gradient_accumulation_steps=4, # Simuler une taille de lot plus grande
 optim="paged_adamw_8bit", # Optimiseur économe en mémoire
 save_steps=100,
 logging_steps=10,
 learning_rate=2e-4,
 fp16=True,
 tf32=True,
 max_grad_norm=0.3,
 warmup_ratio=0.03,
 lr_scheduler_type="constant",
 report_to="none", # Ou "wandb" pour le logging
)

trainer = Trainer(
 model=model,
 train_dataset=tokenized_dataset,
 args=training_args,
 data_collator=None, # Le collecteur de données par défaut fonctionne bien ici
)

trainer.train()

Avec cette configuration, l’entraînement pendant 3 époques sur ma 3090 a duré environ une heure et demie. L’utilisation de la mémoire était gérable, restant bien dans les 24 Go de VRAM. C’était une différence de jour et de nuit par rapport à mes précédentes tentatives de fine-tuning complet.

Enregistrement et Chargement de l’Adaptateur

Après l’entraînement, vous ne sauvegardez que les poids de l’adaptateur LoRA, pas l’ensemble du modèle.

model.save_pretrained("./llama2_customer_support_lora_adapter")
tokenizer.save_pretrained("./llama2_customer_support_lora_adapter")

Pour l’utiliser, vous chargez le modèle de base (quantifié ou non) et ensuite vous chargez l’adaptateur par-dessus :

from peft import PeftModel, PeftConfig

# Chargez d'abord le modèle de base
base_model = AutoModelForCausalLM.from_pretrained(
 model_id,
 quantization_config=bnb_config, # Ou sans quantification si vous avez la VRAM
 device_map="auto",
 torch_dtype=torch.bfloat16,
)

# Chargez l'adaptateur PEFT
peft_model_id = "./llama2_customer_support_lora_adapter"
model = PeftModel.from_pretrained(base_model, peft_model_id)
model = model.eval() # Passez en mode évaluation

# Vous pouvez maintenant utiliser le modèle pour l'inférence
inputs = tokenizer("### Client : Combien de temps prend généralement l'expédition ?\n### Assistant :", return_tensors="pt").to("cuda")
with torch.no_grad():
 outputs = model.generate(**inputs, max_new_tokens=100)
 print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Les résultats étaient vraiment impressionnants. Le modèle a commencé à générer des réponses qui correspondaient parfaitement au ton fantaisiste et utile du client. Il a utilisé leurs noms de produits spécifiques naturellement et a compris leurs politiques internes beaucoup mieux. Ce projet, qui aurait été prohibitivement coûteux ou complexe il y a un ou deux ans, est devenu réellement réalisable avec PEFT.

Au-delà de LoRA : Autres Techniques et Considérations PEFT

Bien que LoRA soit fantastique, ce n’est pas le seul acteur dans l’espace PEFT. D’autres techniques incluent :

• Prefix Tuning : Ajoute un petit préfixe entraînable à l’entrée de chaque couche de transformateur.
• P-tuning / Prompt Tuning : Optimise un “soft prompt” continu qui est préfixé à l’entrée, plutôt que des tokens discrets.
• Adapter Tuning : Insère de petits modules “adaptateurs” entraînables entre les couches du modèle pré-entraîné.

Chacune a ses propres compromis en termes de performance, d’utilisation de la mémoire et de complexité d’implémentation. Cependant, LoRA propose actuellement un très bon équilibre pour de nombreuses tâches de fine-tuning courantes.

Quand Considérer PEFT

• Vous avez une mémoire GPU limitée (par exemple, des GPU grand public comme RTX 3080/3090/4090).
• Vous souhaitez adapter un grand modèle de base à un domaine ou une tâche spécifique sans débourser une fortune.
• Vous devez itérer rapidement sur différents ensembles de données de fine-tuning ou approches.
• Vous voulez distribuer efficacement vos modèles fine-tunés (les adaptateurs LoRA sont petits !).

Limitations Actuelles et Qu’est-ce Qui Suit

Bien que PEFT soit un grand pas en avant, ce n’est pas une solution miracle. La qualité de votre fine-tuning dépend toujours fortement de la qualité et de la quantité de vos données d’entraînement. Pour des tâches extrêmement complexes ou nouvelles, un petit adaptateur peut ne pas suffire, et vous pourriez toujours devoir envisager un fine-tuning à plus grande échelle ou même entraîner un modèle depuis le début si les ressources le permettent.

Une autre chose que j’ai observée est que, bien que PEFT rende le fine-tuning accessible, obtenir les hyperparamètres juste comme il faut (comme r et lora_alpha de LoRA, ou le taux d’apprentissage) nécessite encore un peu d’expérimentation. Ce n’est pas toujours un processus “à régler et oublier”.

En regardant vers l’avenir, je m’attends à voir émerger des méthodes PEFT encore plus sophistiquées, potentiellement en combinant différentes techniques pour une efficacité et des performances encore meilleures. Nous pourrions également voir plus d’outils automatisés qui aident à sélectionner la meilleure technique PEFT et les hyperparamètres pour une tâche et un ensemble de données donnés. La possibilité de “fusionner” les adaptateurs LoRA dans les poids du modèle de base devient également de plus en plus courante, ce qui est génial pour le déploiement lorsque vous souhaitez un seul fichier modèle consolidé.

Conseils Pratiques

Si vous avez été hésitant à fine-tuner de grands modèles de langage en raison de contraintes de ressources, voici ce que vous devriez faire :

1. Explorez Hugging Face PEFT : explorez la documentation de la bibliothèque Hugging Face PEFT. Elle est incroyablement bien documentée et fournit des exemples pour divers modèles et techniques.
2. Commencez par LoRA : Pour la plupart des tâches basées sur le texte, LoRA est un excellent point de départ. C’est solide et largement supporté.
3. Quantifiez Votre Modèle de Base : Considérez toujours de charger votre modèle de base en précision 4 bits ou 8 bits en utilisant bitsandbytes. Cela réduit considérablement les besoins en VRAM, rendant des modèles plus grands accessibles.
4. Préparez des Données de Qualité : Même avec PEFT, la qualité de vos données de fine-tuning est primordiale. Un petit ensemble de données de haute qualité surpassera presque toujours un grand ensemble bruyant.
5. Expérimentez avec les Hyperparamètres : N’hésitez pas à ajuster r (rang) et lora_alpha de LoRA, ainsi que le taux d’apprentissage et le nombre d’époques. De petits changements peuvent entraîner des améliorations notables.
6. Envisagez de Fusionner des Adaptateurs pour le Déploiement : Si vous déployez votre modèle fine-tuné, vérifiez si votre adaptateur PEFT peut être fusionné dans les poids du modèle de base pour créer un seul fichier modèle déployable. Cela simplifie l’inférence.

PEFT a véritablement changé mon approche de la création d’applications alimentées par l’IA. Cela a fait passer le fine-tuning d’une possibilité théorique pour les passionnés à un outil pratique et quotidien. Si vous êtes un développeur indépendant, une startup, ou même simplement quelqu’un avec un projet passion, PEFT est le cadre qui vous permettra de vraiment personnaliser et posséder vos modèles d’IA sans avoir besoin d’un superordinateur. Essayez-le – vous pourriez être surpris par ce que vous pouvez accomplir !

🕒 Published: March 26, 2026