De l'architecture au modèle entraîné : comprendre le processus d'apprentissage
Vous connaissez maintenant l'architecture d'un Transformer. Mais comment passe-t-on d'un modèle avec des poids aléatoires à un modèle capable de générer du texte cohérent comme GPT-4 ou de comprendre le langage comme BERT ?
La réponse tient en un mot : l'entraînement. C'est le processus par lequel le modèle apprend à partir de millions (voire milliards) d'exemples, en ajustant ses paramètres pour minimiser ses erreurs.
Ce cycle se répète des millions de fois sur des milliards d'exemples, jusqu'à ce que le modèle converge vers une solution optimale.
La fonction de perte mesure à quel point le modèle se trompe. Pour un modèle de langage, on utilise généralement la Cross-Entropy Loss.
Contexte : "Le chat mange la"
Mot réel : "souris"
Prédictions du modèle :
Loss = -log(P(souris)) = -log(0.60) ≈ 0.51
Plus la probabilité du bon mot est élevée, plus la perte est faible. Si le modèle prédisait 100% pour "souris", la perte serait 0.
Probabilité = 90%
Loss = 0.10 (faible)
Probabilité = 10%
Loss = 2.30 (élevée)
La backpropagation (rétropropagation) est l'algorithme qui calcule comment chaque paramètre du modèle a contribué à l'erreur. C'est le cœur de l'apprentissage profond.
Le gradient est un vecteur mathématique qui indique dans quelle direction et de combien il faut modifier chaque paramètre pour réduire l'erreur (la fonction de perte).
Le learning rate contrôle l'amplitude de la mise à jour. Trop grand → instabilité ; trop petit → apprentissage lent.
Imaginez que vous êtes sur une montagne et voulez atteindre le point le plus bas (erreur minimale). Le gradient est comme une boussole qui vous indique la pente la plus raide. Vous faites un pas dans la direction opposée à la montée (descente de gradient). La taille du pas est le learning rate.
Sortie (Loss = 2.3)
Couche 12
Couche 6
Couche 1
Les gradients se propagent de la sortie vers l'entrée, indiquant à chaque couche comment ajuster ses poids.
Imaginez une chaîne de montage où le produit final est défectueux. La backpropagation remonte la chaîne pour identifier quelle étape a causé le problème et de combien il faut ajuster chaque étape pour corriger l'erreur.
Une fois les gradients calculés, l'optimiseur décide comment mettre à jour les poids. L'optimiseur le plus utilisé pour les Transformers est AdamW.
Descente de gradient simple : même learning rate pour tous les paramètres.
Rarement utilisé seulAdaptive learning rates + momentum. S'adapte automatiquement à chaque paramètre.
PopulaireAdam + weight decay découplé. Standard pour GPT, BERT, Llama, etc.
RecommandéLe weight decay interagit avec les adaptive learning rates, ce qui peut nuire à la généralisation.
Le weight decay est appliqué directement aux poids, indépendamment des gradients. Meilleure régularisation.
Hyperparamètres typiques pour AdamW :
Le learning rate (taux d'apprentissage) contrôle la taille des mises à jour. Trop grand = instabilité. Trop petit = apprentissage lent. La solution : le faire varier pendant l'entraînement.
Augmentation linéaire de 0 → learning rate max. Évite les grandes mises à jour au début.
Learning rate constant. Le modèle apprend rapidement.
Réduction progressive (cosine ou linéaire). Affine la convergence.
Sans warm-up, le modèle peut diverger dès les premières étapes. Les poids initiaux sont aléatoires et de grandes mises à jour peuvent les pousser dans des régions où les gradients explosent.
Accumuler les gradients sur plusieurs mini-batchs avant de mettre à jour les poids. Permet de simuler de gros batchs avec peu de mémoire GPU.
Limiter la norme des gradients pour éviter les explosions. Typiquement : clip à 1.0 ou 5.0.
Entraîner en précision mixte (16-bit + 32-bit) pour accélérer l'entraînement et réduire la consommation mémoire de ~50%.
2x plus rapide50% moins de VRAMEntraîner sur plusieurs GPUs/machines en parallèle. Techniques : Data Parallelism, Model Parallelism, Pipeline Parallelism.
Essentiel pour LLMsimport torch
from torch.optim import AdamW
from transformers import GPT2LMHeadModel, GPT2Tokenizer
# 1. Charger le modèle et tokenizer
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
model.train()
# 2. Configurer l'optimiseur (AdamW)
optimizer = AdamW(
model.parameters(),
lr=5e-5, # Learning rate
betas=(0.9, 0.999), # Momentum
weight_decay=0.01 # Régularisation
)
# 3. Boucle d'entraînement
for epoch in range(num_epochs): # epoch = passage complet sur le dataset
for batch in dataloader:
# Forward pass
inputs = tokenizer(batch['text'], return_tensors='pt',
padding=True, truncation=True)
outputs = model(**inputs, labels=inputs['input_ids'])
loss = outputs.loss # Cross-entropy loss
# Backward pass (backpropagation)
loss.backward()
# Gradient clipping
torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
# Mise à jour des poids
optimizer.step()
optimizer.zero_grad()
print(f"Loss: {loss.item():.4f}")
# 4. Sauvegarder le modèle
model.save_pretrained('./my_trained_model')Explorez comment les paramètres de génération (température, top-p, top-k) influencent les prédictions du prochain token. Visualisez la distribution de probabilités en temps réel.
Le modèle prédit le prochain token après ce texte
Créatif
Seuil de probabilité cumulée
Nombre de tokens candidats
🌡️ Température
Contrôle l'aléatoire. Basse (0.1-0.5) : précis et prévisible.Haute (1.0-2.0) : créatif et varié.
🎯 Top-P
Garde les tokens dont la somme des probabilités atteint P.0.9 = 90% de la masse de probabilité.
🔢 Top-K
Limite aux K tokens les plus probables.50 = choisir parmi les 50 meilleurs.
Processus de génération :
1. Logits = Model(input_text) → scores bruts
2. Scaled_logits = Logits / temperature
3. Probabilities = Softmax(Scaled_logits)
4. Filtered = Top_K(Top_P(Probabilities))
5. Next_token = Sample(Filtered)
Les modèles comme GPT-4o, Claude 3.7 et Gemini 2.0utilisent ce processus pour générer chaque token, un par un (génération autoregressive).
💡 Ces statistiques reflètent l'expérience de nos lecteurs
Comment évaluez-vous cette page ?
Continuez votre apprentissage avec ces sujets liés