Rendre les LLMs plus rapides, plus légers et accessibles
Les grands modèles de langage modernes comme GPT-4 (1.8T paramètres) ou Llama 3.1 (405B paramètres) sont incroyablement puissants, mais ils posent un problème majeur : ils sont énormes.
Un modèle de 70 milliards de paramètres en précision FP16 occupe 140 GB de mémoire. Cela nécessite des GPUs haut de gamme (A100, H100) coûtant des dizaines de milliers d'euros. L'inférence est lente et coûteuse.
La solution ? L'optimisation. Grâce à des techniques comme la quantization, LoRA et Flash Attention, on peut réduire la taille d'un modèle de 4x à 8x, accélérer l'inférence de 2x à 4x, et le faire tourner sur du matériel grand public.
Llama 2 70B en FP16 = 140 GB
Nécessite 2x A100 80GB minimum. Impossible sur GPU grand public (RTX 4090 = 24GB).
GPT-3 175B : ~5 tokens/sec
Latence élevée pour applications temps réel (chatbots, assistants vocaux).
Serveur 8x A100 : ~50k€/an
Coût par token élevé. Impossible pour startups et chercheurs individuels.
💡 L'optimisation permet de diviser ces coûts par 4 à 10x
Même modèle, même qualité (ou presque), mais accessible sur du matériel standard.
La quantization consiste à représenter les poids du modèle avec moins de bits. Au lieu de stocker chaque poids en 32 bits (FP32) ou 16 bits (FP16), on utilise 8 bits (INT8) ou même 4 bits (INT4).
| Format | Bits | Taille (70B params) | Qualité | Vitesse |
|---|---|---|---|---|
| FP32 | 32 | 280 GB | 100% | 1x |
| FP16 | 16 | 140 GB | 99.9% | 1.5x |
| INT8 | 8 | 70 GB | 98-99% | 2-3x |
| INT4 ⭐ | 4 | 35 GB | 95-97% | 3-4x |
• Taille réduite : 2x à 8x plus petit
• Inférence rapide : 2x à 4x plus rapide
• Moins de VRAM : Tourne sur GPU grand public
• Coûts réduits : Serveurs moins chers
• Perte de qualité : 1-5% de dégradation
• Complexité : Calibration nécessaire
• Support matériel : Tous les GPUs ne supportent pas INT4
• Irréversible : Difficile de revenir en arrière
Quantize un modèle déjà entraîné en INT4 avec calibration sur un petit dataset. Rapide, efficace, utilisé par TheBloke sur HuggingFace.
from auto_gptq import AutoGPTQForCausalLM
model = AutoGPTQForCausalLM.from_quantized(
"TheBloke/Llama-2-70B-GPTQ",
device="cuda:0"
)Quantization qui préserve les poids importants (ceux avec fortes activations). Meilleure qualité que GPTQ pour certains modèles.
Quantization à la volée pendant l'inférence. Utilisé par QLoRA. Facile à utiliser avec HuggingFace Transformers.
from transformers import AutoModelForCausalLM, BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_compute_dtype=torch.float16
)
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-2-70b-hf",
quantization_config=quantization_config
)LoRA (Low-Rank Adaptation) est une technique révolutionnaire pour fine-tuner des LLMs sans modifier tous les poids. Au lieu d'entraîner 70 milliards de paramètres, on ajoute de petites matrices (quelques millions de paramètres) qui s'adaptent à la tâche.
Modèle classique (fine-tuning complet)
On modifie TOUS les poids : W → W + ΔW
Paramètres entraînables : 70 000 000 000
Mémoire requise : ~280 GB
Avec LoRA
On ajoute deux petites matrices : W + A × B (où A et B sont de rang faible)
Paramètres entraînables : ~7 000 000 (10000x moins !)
Mémoire requise : ~3 GB
• Modèle de base en FP16
• Ajoute matrices LoRA (rank 8-64)
• Réduit paramètres de 10000x
• Mémoire : ~140 GB (modèle) + 3 GB (LoRA)
• Qualité : 99% du fine-tuning complet
• Modèle de base en INT4
• Ajoute matrices LoRA
• Réduit paramètres de 10000x
• Mémoire : ~35 GB (modèle) + 3 GB (LoRA)
• Qualité : 97-98% du fine-tuning complet
Fine-tune 70B sur 1x RTX 4090 !from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from transformers import BitsAndBytesConfig
# 1. Charger le modèle en 4-bit
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16
)
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-2-70b-hf",
quantization_config=bnb_config,
device_map="auto"
)
# 2. Préparer pour LoRA
model = prepare_model_for_kbit_training(model)
# 3. Configurer LoRA
lora_config = LoraConfig(
r=16, # Rank (nombre de dimensions)
lora_alpha=32, # Scaling factor
target_modules=["q_proj", "v_proj"], # Modules à adapter
lora_dropout=0.05,
bias="none"
)
model = get_peft_model(model, lora_config)
# 4. Fine-tuner normalement !
# Seulement 7M paramètres entraînables au lieu de 70B
model.print_trainable_parameters()
# Output: trainable params: 7,077,888 || all params: 70,007,077,888 || trainable%: 0.01%Flash Attention est une réimplémentation du mécanisme d'attention qui réduit drastiquement la consommation mémoire et accélère le calcul. C'est une optimisation algorithmique, pas une approximation : les résultats sont identiques à l'attention classique.
L'attention calcule une matrice de taille N × N (où N = longueur de la séquence). Pour un contexte de 4096 tokens, cela fait 16 millions de valeurs à stocker en mémoire.
Complexité mémoire
Attention classique : O(N²)
Flash Attention : O(N)
Pour N=4096 : 16M valeurs → 4K valeurs (4000x moins !)
Sans Flash Attention
• Contexte max : 2048 tokens
• VRAM : 40 GB
• Vitesse : 100 tokens/sec
Avec Flash Attention
• Contexte max : 8192 tokens
• VRAM : 24 GB
• Vitesse : 300 tokens/sec
Flash Attention utilise une technique appelée "tiling" : au lieu de calculer toute la matrice d'attention en une fois, on la découpe en petits blocs qui tiennent dans la mémoire cache rapide du GPU (SRAM).
Résultat : Même précision, mais 2-4x plus rapide et 10x moins de mémoire.
# PyTorch 2.0+ (intégré nativement)
import torch
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained(
"meta-llama/Llama-2-70b-hf",
torch_dtype=torch.float16,
device_map="auto",
attn_implementation="flash_attention_2" # ← Active Flash Attention
)
# Ou installer flash-attn séparément
# pip install flash-attn --no-build-isolationNote : Nécessite GPUs Ampere (RTX 30xx) ou plus récents. Compatible avec tous les modèles Transformers.
| Technique | Usage | Gain mémoire | Gain vitesse | Perte qualité | Difficulté |
|---|---|---|---|---|---|
| Quantization INT8 | Inférence | 2x | 2x | 1-2% | Facile |
| Quantization INT4 | Inférence | 4x | 3x | 3-5% | Moyenne |
| LoRA | Fine-tuning | 10000x params | 1x | ~1% | Facile |
| QLoRA ⭐ | Fine-tuning | 4x + 10000x | 1x | 2-3% | Facile |
| Flash Attention | Inférence + Training | 10x | 2-4x | 0% | Très facile |
Recommandation :
INT4 + Flash Attention
Combine réduction mémoire (4x) et accélération (6-8x total). Permet de servir Llama 2 70B sur une seule RTX 4090.
Recommandation :
QLoRA
Fine-tune des modèles 70B sur GPU 24-48GB. Qualité proche du fine-tuning complet pour 1% du coût.
Recommandation :
Tout combiner
INT4 + Flash Attention + vLLM (serving optimisé). Maximise throughput et minimise latence/coûts.
Votre retour est précieux pour améliorer cette page. Partagez votre expérience ci-dessous.
Comment évaluez-vous cette page ?
Continuez votre apprentissage avec ces sujets liés