Fine-Tuning et Transfer Learning : Guide d’Entraînement de Modèle

Le fine-tuning est le processus de personnalisation de modèles pré-entraînés pour des tâches ou des domaines spécifiques. Avec les bonnes stratégies de fine-tuning, des améliorations de performance allant jusqu’à 40 % peuvent être obtenues dans les solutions d’IA d’entreprise.

Fondamentaux du Transfer Learning

Le transfer learning consiste à transférer les connaissances acquises dans une tâche vers une autre tâche.

Avantages du Transfer Learning

1. Efficacité des données : De bons résultats avec moins de données
2. Gain de temps : Beaucoup plus rapide qu’un entraînement depuis zéro
3. Réduction des coûts : Moins de ressources de calcul
4. Performance : Exploitation des connaissances pré-entraînées

Pré-entraînement vs Fine-tuning

1Pre-training:
2- Large, general dataset (TBs)
3- Learning general language/task understanding
4- Training takes months
5- Cost in millions of dollars
6
7Fine-tuning:
8- Small, domain-specific dataset (MB-GB)
9- Specific task adaptation
10- Training takes hours-days
11- Cost in thousands of dollars

Full Fine-Tuning

Mise à jour de tous les paramètres du modèle.

Avantages

• Capacité d’adaptation maximale
• Potentiel de performance le plus élevé

Inconvénients

• Besoin mémoire élevé
• Risque d’oubli catastrophique
• Copie de modèle séparée pour chaque tâche

Exigences matérielles

Parameter-Efficient Fine-Tuning (PEFT)

Fine-tuning en mettant à jour seulement une petite portion des paramètres.

Avantages du PEFT

• Efficacité mémoire : Réduction de plus de 90 %
• Vitesse : Entraînement plus rapide
• Modularité : Un seul modèle de base, plusieurs adaptateurs
• Oubli catastrophique : Risque minimisé

LoRA (Low-Rank Adaptation)

La méthode PEFT la plus populaire.

Théorie de LoRA

Mise à jour de la matrice de poids approximativement à l’aide de matrices de rang faible :

1W' = W + ΔW = W + BA
2
3Where:
4- W: Original weight matrix (d × k)
5- B: Low-rank matrix (d × r)
6- A: Low-rank matrix (r × k)
7- r: Rank (typical: 8-64)

Économie de paramètres

1Original: d × k parameters
2LoRA: r × (d + k) parameters
3
4Example (d=4096, k=4096, r=16):
5Original: 16.7M parameters
6LoRA: 131K parameters
7Savings: ~127x

Configuration LoRA

1from peft import LoraConfig, get_peft_model
2
3config = LoraConfig(
4    r=16,                      # Rank
5    lora_alpha=32,             # Scaling factor
6    target_modules=[           # Which layers to apply
7        "q_proj",
8        "k_proj", 
9        "v_proj",
10        "o_proj"
11    ],
12    lora_dropout=0.05,
13    bias="none",
14    task_type="CAUSAL_LM"
15)
16
17model = get_peft_model(base_model, config)

Hyperparamètres LoRA

Rank (r) :

• Faible (4-8) : Tâches simples, peu de données
• Moyen (16-32) : Usage général
• Élevé (64-128) : Adaptation complexe

Alpha :

• Généralement alpha = 2 × r

Target Modules :

• Couches d’attention : q_proj, k_proj, v_proj, o_proj
• Couches MLP : gate_proj, up_proj, down_proj

QLoRA (Quantized LoRA)

Combinaison de LoRA + quantification 4 bits.

Fonctionnalités de QLoRA

1. 4-bit NormalFloat (NF4) : Format de quantification personnalisé
2. Double Quantization : Quantification des constantes de quantification
3. Paged Optimizers : Gestion du dépassement de mémoire GPU

Comparaison mémoire QLoRA

Implémentation QLoRA

1from transformers import BitsAndBytesConfig
2import torch
3
4bnb_config = BitsAndBytesConfig(
5    load_in_4bit=True,
6    bnb_4bit_use_double_quant=True,
7    bnb_4bit_quant_type="nf4",
8    bnb_4bit_compute_dtype=torch.bfloat16
9)
10
11model = AutoModelForCausalLM.from_pretrained(
12    "meta-llama/Llama-2-7b-hf",
13    quantization_config=bnb_config,
14    device_map="auto"
15)
16## Autres méthodes PEFT
17
18### Prefix Tuning
19
20Ajoute des préfixes apprenables aux embeddings d’entrée :
21

Input: [PREFIX_1, PREFIX_2, ..., PREFIX_N, token_1, token_2, ...]

1
2### Prompt Tuning
3
4Apprentissage de soft prompts :
5

[SOFT_PROMPT] + "Actual input text"

1
2### Adapter Layers
3
4Ajout de petits réseaux entre les couches du transformer :
5

Attention → Adapter → LayerNorm → FFN → Adapter → LayerNorm

1
2### (IA)³ - Infused Adapter
3
4Multiplication des activations avec des vecteurs appris :
5

output = activation × learned_vector

1
2## Préparation des données
3
4### Formats de données
5
6**Instruction Format :**
7```json
8{
9  "instruction": "Summarize this text",
10  "input": "Long text...",
11  "output": "Summary..."
12}

Chat Format :

1{
2  "messages": [
3    {"role": "system", "content": "You are a helpful assistant"},
4    {"role": "user", "content": "Question..."},
5    {"role": "assistant", "content": "Answer..."}
6  ]
7}

Qualité des données

Caractéristiques de bonnes données :

• Diversité (exemples variés)
• Cohérence (format cohérent)
• Précision (étiquettes correctes)
• Quantité suffisante (généralement 1K-100K exemples)

Augmentation de données

1# Paraphrasing
2augmented_data = paraphrase(original_data)
3
4# Back-translation
5translated = translate(text, "tr")
6back_translated = translate(translated, "en")
7
8# Synonym replacement
9augmented = replace_synonyms(text)

Stratégies d’entraînement

Sélection des hyperparamètres

1training_args = TrainingArguments(
2    learning_rate=2e-4,        # Typical for LoRA
3    num_train_epochs=3,
4    per_device_train_batch_size=4,
5    gradient_accumulation_steps=4,
6    warmup_ratio=0.03,
7    lr_scheduler_type="cosine",
8    fp16=True,
9    logging_steps=10,
10    save_strategy="epoch",
11    evaluation_strategy="epoch"
12)

Taux d’apprentissage

• Full fine-tuning : 1e-5 - 5e-5
• LoRA : 1e-4 - 3e-4
• QLoRA : 2e-4 - 5e-4

Régularisation

1# Weight decay
2weight_decay=0.01
3
4# Dropout
5lora_dropout=0.05
6
7# Gradient clipping
8max_grad_norm=1.0

Évaluation et validation

Métriques

Perplexity :

PPL = exp(average cross-entropy loss)
Lower = better

BLEU/ROUGE : Qualité de génération de texte

Spécifique à la tâche : Accuracy, F1, métriques personnalisées

Détection du surapprentissage

1Train loss ↓ + Validation loss ↑ = Overfitting
2
3Solutions:
4- Early stopping
5- More dropout
6- Data augmentation
7- Fewer epochs

Déploiement

Fusion de modèles

Fusion de l’adaptateur LoRA dans le modèle de base :

merged_model = model.merge_and_unload()
merged_model.save_pretrained("merged_model")

Multi-Adapter Serving

Plusieurs adaptateurs avec un seul modèle de base :

1from peft import PeftModel
2
3base_model = AutoModelForCausalLM.from_pretrained("base")
4model_a = PeftModel.from_pretrained(base_model, "adapter_a")
5model_b = PeftModel.from_pretrained(base_model, "adapter_b")

Pipeline de fine-tuning entreprise

1┌─────────────┐     ┌─────────────┐     ┌─────────────┐
2│ Data        │────▶│ Training    │────▶│ Evaluation  │
3│ Preparation │     │ (LoRA/QLoRA)│     │ & Testing   │
4└─────────────┘     └─────────────┘     └──────┬──────┘
5                                                │
6                    ┌─────────────┐     ┌──────▼──────┐
7                    │ Production  │◀────│ Model       │
8                    │ Deployment  │     │ Registry    │
9                    └─────────────┘     └─────────────┘

Problèmes courants et solutions

1. Out of Memory

Solution : QLoRA, gradient checkpointing, réduction de la taille du batch

2. Catastrophic Forgetting

Solution : Taux d’apprentissage plus bas, replay buffer, elastic weight consolidation

3. Surapprentissage

Solution : Plus de données, régularisation, early stopping

4. Mauvaise généralisation

Solution : Augmentation de la diversité des données, diversité des instructions

Conclusion

Le fine-tuning est la méthode la plus efficace pour adapter des modèles pré-entraînés aux besoins des entreprises. Des personnalisations puissantes peuvent être réalisées même avec des ressources limitées grâce aux méthodes PEFT comme LoRA et QLoRA.

Chez Veni AI, nous fournissons des services de conseil et de mise en œuvre pour les projets de fine-tuning en entreprise. Contactez-nous pour vos besoins.