Finetuner les modèles Baichuan avec LoRA : Guide pratique pour assistants verticaux spécialisés

Le déploiement d'assistants d'intelligence artificielle dédiés à des domaines verticaux hautement réglementés — tels que le triage médical, l'analyse contractuelle juridique, la conformité financière ou le support technique spécialisé — requiert une maîtrise approfondie du jargon professionnel, un raisonnement rigoureux et une stricte conformité aux formats attendus. Si les modèles généralistes propriétaires offrent une grande aisance linguistique, les contraintes de confidentialité des données et les coûts d'infrastructure incitent de plus en plus d'entreprises à adopter des modèles ouverts auto-hébergés. La gamme Baichuan (notamment Baichuan2-7B et Baichuan2-13B) s'impose comme l'une des fondations bilingues les plus performantes, forte d'un pré-entraînement sur 2,6 billions de tokens et d'une tokenisation particulièrement efficiente.

Néanmoins, l'ajustement complet de tous les paramètres (Full Fine-Tuning) sur des architectures de 7B ou 13B exige des grappes de calcul multi-GPU onéreuses et engendre souvent un "oubli catastrophique" (Catastrophic Forgetting) des facultés de dialogue général. L'adaptation à bas rang (LoRA, Low-Rank Adaptation) offre le compromis d'ingénierie idéal : en gelant les poids du modèle de base et en intégrant des matrices de décomposition de bas rang entraînables sur les projections clés, les ingénieurs en apprentissage automatique peuvent adapter Baichuan sur un GPU individuel à coût maîtrisé.

1. Alignement architectural : le mécanisme W_pack dans l'attention de Baichuan

Pour configurer correctement les adaptateurs LoRA, l'équipe d'ingénierie doit appréhender l'architecture Transformer interne de Baichuan et cibler les couches linéaires adéquates.

À l'inverse des architectures de type Llama classiques, qui décomposent l'attention en trois projections linéaires distinctes pour Query, Key et Value (q_proj, k_proj, v_proj), Baichuan regroupe ces opérations dans une couche unifiée : W_pack.

Par conséquent, appliquer une configuration LoRA générique conçue pour d'autres modèles ignorera complètement le mécanisme d'attention. Afin de capturer à la fois la dynamique attentionnelle et les transformations non linéaires du perceptron multicouche (MLP), les modules cibles (target_modules) de LoRA doivent inclure :

• Couches d'attention : W_pack (projection combinée Q, K, V) et o_proj (projection de sortie).
• Couches MLP : gate_proj, up_proj et down_proj.

Spécifier explicitement ces modules dans PEFT — ou employer la configuration target_modules="all-linear" — assure la capacité d'apprentissage indispensable à l'assimilation des connaissances métiers.

2. Préparation des jeux de données et tokens de rôle

La précision opérationnelle d'un assistant vertical est directement proportionnelle à la rigueur appliquée au nettoyage des données et au respect des gabarits conversationnels.

Structure des tokens réservés

Les déclinaisons conversationnelles de Baichuan2 (Chat) emploient des tokens spécifiques pour délimiter les tours de parole :

• <reserved_106> : Marque le début de l'intervention de l'utilisateur (<|User|>).
• <reserved_107> : Déclenche la génération de la réponse de l'assistant (<|Assistant|>).

Le format JSON standard s'articule sous forme de dialogues multi-tours :

[
  {
    "conversations": [
      {
        "from": "human",
        "value": "Quels sont les délais légaux et les critères de recevabilité pour déposer une demande en nullité de brevet ?"
      },
      {
        "from": "gpt",
        "value": "Conformément aux dispositions régissant la propriété industrielle, toute personne intéressée peut former une action en nullité dès publication de la délivrance du brevet. Les pièces justificatives requises comprennent..."
      }
    ]
  }
]

Règle critique : Le masquage de perte (Loss Masking)

Une erreur critique récurrente lors de l'écriture de scripts personnalisés consiste à calculer la perte d'entropie croisée sur l'ensemble de la séquence. Lors du finetuning supervisé (SFT), le calcul de perte doit être strictement restreint aux tokens générés par l'assistant.

Les ingénieurs doivent attribuer la valeur -100 (l'indice d'ignorance par défaut sous PyTorch) aux messages de l'utilisateur, aux invites système et aux séparateurs de rôle dans le vecteur d'étiquettes (labels). Sans ce masquage, le modèle mobilise ses gradients à apprendre à poser des questions au lieu de perfectionner la rigueur de ses réponses, ce qui provoque des récurrences parasites lors de l'inférence.

Bonnes pratiques de constitution du corpus

1. Cas d'usage et terminologie métier : Constituez un jeu de 5 000 à 20 000 paires instruction-réponse représentatives de diagnostics cliniques, de raisonnements juridiques ou d'audits financiers.
2. Données d'ancrage généralistes (Anti-oubli) : Intégrez 5 % à 10 % d'instructions conversationnelles générales. Cet ancrage protège le modèle contre la dégradation de sa logique discursive et de sa courtoisie de base.
3. Échantillons de refus et conformité déontologique : Introduisez des cas de refus nets lorsque l'utilisateur sollicite un diagnostic médical catégorique ou une promesse de rendement financier garantie, en renvoyant vers un praticien humain qualifié.

3. Mise en œuvre étape par étape avec Hugging Face PEFT

Voici la méthodologie complète sous PyTorch, transformers et peft pour adapter Baichuan2-7B-Base ou Baichuan2-7B-Chat.

Étape 1 : Installation des dépendances

pip install torch>=2.0.0 transformers>=4.31.0 peft>=0.5.0 accelerate bitsandbytes datasets

Étape 2 : Chargement du modèle et configuration de LoRA

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model, TaskType

model_id = "baichuan-inc/Baichuan2-7B-Base"

# Chargement du tokenizer avec trust_remote_code
tokenizer = AutoTokenizer.from_pretrained(
    model_id, 
    use_fast=False, 
    trust_remote_code=True
)

# Chargement en bfloat16 pour une excellente stabilité numérique
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

# Configuration des hyperparamètres LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                         # Dimension du rang (16 ou 32 en domaine vertical)
    lora_alpha=32,                # Facteur d'échelle (habituellement 2x le rang)
    lora_dropout=0.05,            # Prévient le surapprentissage
    target_modules=[
        "W_pack",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj"
    ],
    bias="none"
)

# Application de l'adaptateur PEFT
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# Résultat attendu : trainable params: ~20M || all params: 7B || trainable%: ~0.28%

Étape 3 : Entraînement et optimisation de la mémoire vidéo

L'activation du point de contrôle de gradient (gradient_checkpointing) permet de réduire drastiquement la mémoire VRAM sollicitée :

training_args = TrainingArguments(
    output_dir="./baichuan2-lora-vertical",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
    logging_steps=10,
    num_train_epochs=3,
    save_strategy="epoch",
    fp16=False,
    bf16=True,                    # Recommandé sur GPU Ampere et ultérieurs
    gradient_checkpointing=True,
    report_to="none"
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_domain_dataset,
    tokenizer=tokenizer
)

trainer.train()
model.save_pretrained("./baichuan2-vertical-adapter")

En cas de contrainte matérielle forte (par exemple un GPU unique de 24 Go tel qu'une RTX 3090/4090), activez QLoRA en transmettant BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.bfloat16) lors de l'appel from_pretrained.

4. Fusion des poids pour un déploiement en production à latence zéro

Monter dynamiquement des adaptateurs LoRA en environnement de production haute cadence ajoute une latence superflue et complique la supervision. Dès que les métriques de validation sont atteintes, il est recommandé de fusionner définitivement les poids LoRA avec ceux du modèle de base.

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch

base_model_path = "baichuan-inc/Baichuan2-7B-Base"
adapter_path = "./baichuan2-vertical-adapter"
output_path = "./baichuan2-7b-vertical-merged"

tokenizer = AutoTokenizer.from_pretrained(base_model_path, trust_remote_code=True)
base_model = AutoModelForCausalLM.from_pretrained(
    base_model_path,
    torch_dtype=torch.bfloat16,
    device_map="cpu",
    trust_remote_code=True
)

# Chargement et fusion définitive
model = PeftModel.from_pretrained(base_model, adapter_path)
merged_model = model.merge_and_unload()

# Sauvegarde du modèle unifié
merged_model.save_pretrained(output_path)
tokenizer.save_pretrained(output_path)

Le modèle fusionné présente une structure rigoureusement identique aux checkpoints Baichuan natifs et peut être servi via des moteurs comme vLLM ou TGI, assurant un débit maximal sans surcoût de calcul.

5. Arbitrage d'architecture : Finetuning LoRA ou Génération Augmentée par Récupération (RAG)

Dans les architectures d'entreprise, le choix entre LoRA et RAG soulève souvent des interrogations. En pratique, ces deux approches se complètent idéalement :

Recommandation industrielle : Ne traitez pas LoRA et RAG comme des alternatives exclusives. La solution la plus robuste consiste à déployer une architecture hybride : LoRA façonne Baichuan pour qu'il raisonne et communique comme un spécialiste chevronné du domaine, tandis que le pipeline RAG lui injecte les documents de référence en temps réel pour garantir une exactitude factuelle absolue.

Références

• GitHub - baichuan-inc/Baichuan2: A series of large language models developed by Baichuan Intelligent Technology · GitHub
• [2309.10305] Baichuan 2: Open Large-scale Language Models
• baichuan-inc/Baichuan2-7B-Base · Hugging Face
• baichuan-inc/Baichuan2-13B-Chat · Hugging Face
• GitHub - huggingface/peft: 🤗 PEFT: State-of-the-art Parameter-Efficient Fine-Tuning. · GitHub