Mes projets Agntbox AI utilisent maintenant PEFT pour l’harmonie multi-modèles.

Bonjour à tous, ici Nina, de retour pour explorer le monde en constante é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 s’harmonisent, surtout quand ils ne proviennent pas tous de la même entreprise. Plus précisément, j’ai lutté avec — et finalement été très impressionnée par — les récentes avancées des techniques de PEFT (Parameter-Efficient Fine-Tuning), et comment elles rendent vraiment pratique l’adaptation de modèles open source sans casser la banque ni perdre la raison.

Mon angle cette fois n’est pas juste un aperçu général du PEFT ; nous allons nous concentrer sur la manière dont cela devient le cadre pour rendre le fine-tuning accessible aux développeurs indépendants et aux équipes plus petites. Oubliez le besoin d’une ferme de serveurs pour adapter un grand modèle de langage (LLM). Nous parlons de prendre un puissant monstre 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 enseigner de nouveaux tours à un vieux chien, mais le chien est un génie et vous n’avez besoin de lui apprendre que quelques signaux 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 versions open source, pas le secret de fabrication d’OpenAI), vous aviez besoin de matériel sérieux. Nous parlons de plusieurs GPU haut de gamme, d’heures de temps d’entraînement 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 qui construit des outils pour des clients plus petits, ce genre d’engagement était généralement difficile à envisager. Je me retrouvais souvent à essayer de plier un modèle pré-entraîné à ma volonté avec des incitations élaborées ou en enchaînant plusieurs petits modèles, juste pour éviter le drain de ressources d’un véritable fine-tuning.

Je me souviens d’un projet, à la fin de 2024, où j’essayais de créer un outil de résumés personnalisé pour des documents juridiques très spécifiques d’un client. Les résumeurs standards étaient corrects, mais ils manquaient des nuances et des phrases clés cruciales pour le contexte légal. Ma première pensée était : « Super, je vais affiner un modèle T5. » Après environ une heure de configuration de l’environnement et en 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, peinait rien qu’à y penser. Je me suis finalement tournée vers une approche complexe d’ingénierie de prompt qui a fonctionné, mais qui était fragile et difficile à maintenir.

Cette expérience, et beaucoup d’autres similaires, a mis en évidence un écart énorme. Nous avions ces modèles fondamentaux incroyables, mais les rendre vraiment à nous, 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 ici que le PEFT entre en jeu et change la donne.

Qu’est-ce que le PEFT exactement et pourquoi cela devrait-il vous intéresser ?

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 ensembles de données avec beaucoup 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 n’actualisent qu’un petit sous-ensemble ou introduisent de nouveaux paramètres plus petits qui sont ensuite entraînés.

Pensez-y comme ça : vous avez un chef étoilé (le LLM pré-entraîné) qui sait presque tout cuisiner. 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 en sorte que le chef réapprenne 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 nouveau 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 une façon ciblée d’exceller dans votre demande spécifique.

Le principal avantage ici est une économie massive de ressources informatiques – à la fois de mémoire GPU et de temps d’entraînement. Cela signifie que vous pouvez affiner des modèles beaucoup plus grands sur des GPU de type grand public, ou même sur des CPU si vous êtes suffisamment patient. Cela démocratise l’accès à l’adaptation des modèles d’IA à la pointe de la technologie, et c’est un grand enjeu pour des personnes comme nous.

LoRA : Ma méthode PEFT actuelle de prédilection

Parmi les diverses techniques de PEFT, l’Adaptation à Rang Bas (LoRA) est devenue ma préférée personnelle et celle que j’ai utilisée le plus souvent. Elle est élégante dans sa simplicité et étonnamment efficace. LoRA fonctionne en injectant des matrices de décomposition à rang entraînables dans les couches de transformeur 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 gelés.

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

Un exemple concret : Fine-Tuning de Llama 2 pour les réponses du support client

Passons aux choses concrètes. 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 respectent également le ton spécifique de votre marque, utilisent un jargon particulier et suivent certaines politiques internes. Utiliser un LLM généraliste 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 de commerce électronique spécialisé dans les bijoux artisanaux. Leur voix de marque est très chaleureuse, personnelle et légèrement fantaisiste. Un modèle standard de Llama 2 7B, bien que puissant, avait souvent un ton trop générique ou formel. Le fine-tuning complet était hors de question avec mon matériel. Laissez entrer LoRA.

Mise en place de l’environnement (simplifiée)

Tout d’abord, vous installeriez généralement les bibliothèques nécessaires. Les bibliothèques Hugging Face transformers et peft sont vos meilleures amies 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, vous permettant de charger même des modèles plus grands avec moins de VRAM.

Chargement du modèle de base et du tokenizeur

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, lui permettant de tenir dans moins de VRAM, souvent avec un impact minime 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 token de remplissage par défaut

Préparation du modèle pour LoRA

Ensuite, nous utilisons la bibliothèque peft pour préparer le modèle. Nous lui indiquons quelles couches nous voulons appliquer le LoRA (typiquement les couches d’attention, les valeurs courantes étant 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 plus bas signifie moins de paramètres entraînables.
 lora_alpha=16, # Facteur de mise à l'échelle pour les poids de 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()

Quand 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 || pourcentage entraînable : 0.0599 ». C’est moins de 0.1 % du total des paramètres ! C’est ce qui le rend faisable.

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

Pour les données d’entraînement, j’ai utilisé un petit ensemble de données (environ 500 exemples) d’enquêtes clients accompagnées de 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.

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

data = [
 {"text": "### Client : Mon collier 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 organiserons une réparation ou un remplacement tout de suite. Nous voulons que vous aimiez vos bijoux !",},
 {"text": "### Client : Faites-vous des expéditions à l'international ?\n### Assistant : Oui, c'est le cas ! Nous expédions nos trésors faits main 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, # À ajuster 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 les journaux
)

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 pris environ une heure et demie. L’utilisation de la mémoire était gérable, restant bien en deçà des 24 Go de VRAM. C’était un changement radical par rapport à mes précédentes tentatives de réglage complet.

Enregistrement et Chargement de l’Adaptateur

Après l’entraînement, vous enregistrez uniquement 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 d’abord le modèle de base (quantifié ou non) puis vous chargez l’adaptateur par-dessus :

from peft import PeftModel, PeftConfig

# Charger 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,
)

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

# Maintenant vous pouvez 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 fantasque et serviable du client. Il a utilisé leurs noms de produits spécifiques de manière naturelle et a mieux compris leurs politiques internes. Ce projet, qui aurait été prohibitif ou complexe il y a un an ou deux, est devenu véritablement 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 ajouté à l’entrée, plutôt que des jetons 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 mémoire et de complexité d’implémentation. Cependant, LoRA trouve actuellement un très bon équilibre pour de nombreuses tâches de réglage commun.

Quand Envisager PEFT

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

Limitations Actuelles et Prochaines Étapes

Bien que PEFT soit un énorme pas en avant, ce n’est pas une solution miracle. La qualité de votre réglage 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 avoir besoin de considérer un réglage à plus grande échelle ou même d’entraîner un modèle à partir de zéro si les ressources le permettent.

Une autre chose que j’ai observée est que bien que PEFT rende le réglage accessible, obtenir les hyperparamètres justes (comme le r et lora_alpha de LoRA, ou le taux d’apprentissage) nécessite encore quelques expérimentations. 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, combinant potentiellement différentes techniques pour plus d’efficacité et de performance. Nous pourrions également voir plus d’outils automatisés qui aident à sélectionner la meilleure technique et les meilleurs hyperparamètres PEFT 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 excellent pour le déploiement lorsque vous souhaitez un fichier de modèle consolidé.

Pratiques à Retenir

Si vous avez été hésitant à peaufiner 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 du texte, LoRA est un excellent point de départ. C’est solide et largement pris en charge.
3. Quantifiez votre modèle de base : Pensez toujours à charger votre modèle de base en précision 4 bits ou 8 bits en utilisant bitsandbytes. Cela réduit considérablement les exigences en VRAM, rendant les modèles plus grands accessibles.
4. Préparez des données de qualité : Même avec PEFT, la qualité de vos données de réglage est primordiale. Un petit ensemble de données de haute qualité sera presque toujours meilleur qu’un grand ensemble de données bruyantes.
5. Expérimentez avec les hyperparamètres : N’ayez pas peur d’ajuster le r (rang) et le lora_alpha de LoRA, ainsi que le taux d’apprentissage et le nombre d’époques. De petits changements peuvent conduire à des améliorations notables.
6. Envisagez de fusionner des adaptateurs pour le déploiement : Si vous déployez votre modèle réglé, vérifiez si votre adaptateur PEFT peut être fusionné dans les poids du modèle de base pour créer un fichier de modèle unique et 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. Elle a fait passer le réglage de la possibilité théorique pour les amateurs à 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 personnaliser et de posséder réellement vos modèles d’IA sans avoir besoin d’un superordinateur. Essayez-le – vous pourriez être surpris de ce que vous pouvez réaliser !

🕒 Published: March 26, 2026