Accueil › Glossaire › Perplexité (Métrique)

Perplexité (Métrique)

La perplexité (perplexity, PPL) est une métrique qui mesure la qualité d’un modèle de langage en quantifiant son incertitude lors de la prédiction du prochain token dans une séquence : plus la perplexité est basse, meilleur est le modèle.

C’est la métrique d’évaluation historique et toujours fondamentale pour les modèles de langage, des n-grammes statistiques aux LLMs modernes. Ancrée dans la théorie de l’information de Claude Shannon, la perplexité a une interprétation intuitive : elle représente le nombre moyen de choix entre lesquels le modèle hésite à chaque position de la séquence. Un modèle avec une perplexité de 10 est en moyenne aussi incertain que s’il choisissait aléatoirement parmi 10 tokens à chaque étape. Un modèle parfait aurait une perplexité de 1 (aucune incertitude).

L’intuition : à quel point le modèle est-il « surpris » ?

Prenons un modèle de langage qui prédit le prochain mot dans la phrase « Le ciel est ___ ».

Faible perplexité : le modèle assigne une probabilité élevée à « bleu » (par exemple 80 %). Il n’est pas surpris par le mot qui apparaît réellement. C’est un signe que le modèle comprend bien les patterns du langage.

Forte perplexité : le modèle répartit sa probabilité entre de nombreux mots (« rouge », « vide », « tombé », « violet »…) sans en favoriser un. Il est « perplexe » face au choix. C’est un signe que le modèle capture mal la structure du langage, ou que le texte est intrinsèquement imprévisible.

La perplexité agrège cette notion de surprise sur l’ensemble d’une séquence ou d’un corpus. C’est une mesure globale de la qualité prédictive du modèle.

La formule mathématique

Pour une séquence de T tokens x₁, x₂, …, x_T, la perplexité d’un modèle est :

PPL(X) = exp( -(1/T) · Σₜ₌₁ᵀ log P(xₜ | x₁, ..., xₜ₋₁) )

Décomposons :

P(xₜ | x₁, …, xₜ₋₁) est la probabilité que le modèle assigne au token réel xₜ, étant donné tous les tokens précédents. C’est exactement la sortie du modèle après le softmax.

log P(…) est le logarithme de cette probabilité. Comme P est entre 0 et 1, le log est négatif. Plus le modèle est confiant dans le bon token, plus ce log est proche de 0.

-(1/T) · Σ log P(…) est la cross-entropy moyenne par token. C’est exactement la loss function utilisée pour entraîner les LLMs.

exp(…) convertit la cross-entropy en perplexité. L’exponentielle transforme le logarithme en un nombre interprétable : le nombre moyen de choix.

Base 2 ou base e ?

La formule ci-dessus utilise le logarithme naturel (base e), ce qui est le standard dans les frameworks de deep learning (PyTorch, TensorFlow). Certains papiers plus anciens ou certains domaines utilisent le log en base 2, ce qui donne la perplexité en « bits par caractère » (BPC) :

PPL₂ = 2^(H₂)    # avec H₂ = cross-entropy en base 2
PPLₑ = e^(Hₑ)    # avec Hₑ = cross-entropy en base e

Les deux sont liées par PPL₂ = PPLₑ (la valeur numérique est la même, seule la cross-entropy sous-jacente diffère). En pratique, utilisez la base naturelle (c’est ce que retourne loss.item() dans PyTorch) et appliquez math.exp() pour obtenir la perplexité.

Exemple numérique

# Séquence : "Le chat dort sur le canapé"
# Le modèle prédit les probabilités suivantes pour chaque token :

# Token          P(token | contexte)    log P
# "Le"           0.15                   -1.897
# "chat"         0.08                   -2.526
# "dort"         0.25                   -1.386
# "sur"          0.40                   -0.916
# "le"           0.50                   -0.693
# "canapé"       0.12                   -2.120

# Cross-entropy moyenne = -(1/6) · (-1.897 - 2.526 - 1.386 - 0.916 - 0.693 - 2.120)
#                       = 9.538 / 6 = 1.590

# Perplexité = exp(1.590) ≈ 4.9

# Interprétation : en moyenne, le modèle hésite entre ~5 tokens à chaque position

Pour un vocabulaire de 32 000 tokens, une perplexité de 5 est excellente : le modèle réduit ses choix de 32 000 à 5 en moyenne. Un modèle aléatoire sur ce vocabulaire aurait une perplexité de 32 000.

Comment interpréter la perplexité

Valeurs typiques

Ce que la perplexité mesure (et ne mesure pas)

Ce qu’elle mesure : la qualité de la modélisation probabiliste du langage. Un modèle avec une basse perplexité assigne des probabilités élevées aux tokens qui apparaissent réellement dans le texte. Il a bien capturé les patterns statistiques du langage.

Ce qu’elle ne mesure pas :

La créativité. Un modèle qui génère du texte répétitif et ennuyeux mais « prévisible » peut avoir une basse perplexité. Un texte créatif et original sera naturellement plus « surprenant » pour le modèle, augmentant la perplexité.

La factualité. Le modèle peut être très confiant dans des affirmations fausses. Une phrase comme « La capitale de la France est Lyon » pourrait recevoir une probabilité raisonnable si le modèle a mal appris.

La cohérence sémantique. La perplexité est calculée token par token. Elle ne capture pas si un texte de 500 mots raconte une histoire cohérente ou s’il dérive en non-sens.

L’alignement avec les préférences humaines. Un modèle bien calibré pour le next-token prediction peut produire du texte que les humains trouvent inapproprié, inutile, ou mal formaté.

Usages pratiques de la perplexité

Comparer des modèles

La perplexité est le moyen le plus rapide de comparer deux modèles de langage entraînés avec le même tokenizer sur le même corpus de test. Si le modèle A a une perplexité de 8 et le modèle B de 12, le modèle A est meilleur en modélisation du langage. C’est le « smoke test » de base de tout pipeline d’évaluation de LLM.

Suivre l’entraînement

Pendant le pré-entraînement d’un LLM, la perplexité sur un jeu de validation est monitorée en continu. Elle devrait diminuer régulièrement. Si elle stagne, l’entraînement a convergé. Si elle augmente alors que la perplexité d’entraînement continue de baisser, c’est de l’overfitting.

Évaluer le fine-tuning

Après un fine-tuning, la perplexité sur le domaine cible devrait diminuer. Si elle augmente sur le domaine général, c’est du « catastrophic forgetting » (le modèle oublie ce qu’il savait). Suivre les deux perplexités (domaine cible + domaine général) est une bonne pratique.

Détection d’anomalies

Un texte qui produit une perplexité anormalement élevée pour un modèle donné peut indiquer du texte hors distribution (langue différente, jargon technique inconnu), du texte généré par un autre modèle, ou des tentatives d’attaque adversariale (prompt injection). La perplexité est utilisée comme signal dans certains détecteurs de texte généré par IA et dans les défenses contre les attaques de jailbreak.

Calcul de la perplexité en Python

Avec PyTorch / Hugging Face

import torch
import math
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "gpt2"  # ou tout modèle causal
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name)
model.eval()

def calculate_perplexity(text):
    tokens = tokenizer(text, return_tensors="pt")
    with torch.no_grad():
        outputs = model(**tokens, labels=tokens.input_ids)
        loss = outputs.loss   # cross-entropy moyenne par token
    return math.exp(loss.item())

# Exemples
text_coherent = "Le soleil brille dans un ciel bleu sans nuages."
text_bizarre = "La chaise mange des probabilités quantiques vertes."

ppl_coherent = calculate_perplexity(text_coherent)
ppl_bizarre = calculate_perplexity(text_bizarre)

print(f"Texte cohérent : PPL = {ppl_coherent:.1f}")
print(f"Texte bizarre  : PPL = {ppl_bizarre:.1f}")
# Le texte cohérent aura une perplexité bien plus basse

Pendant l’entraînement

# Si vous entraînez avec nn.CrossEntropyLoss, la perplexité est triviale :
loss = criterion(logits.view(-1, vocab_size), labels.view(-1))
perplexity = math.exp(loss.item())

# Loggez-la à chaque epoch ou tous les N steps :
print(f"Step {step}: loss={loss:.4f}, PPL={perplexity:.1f}")

Limites et compléments

Sensibilité au tokenizer. Un modèle qui utilise un tokenizer avec un petit vocabulaire (8k tokens) découpera le texte en plus de tokens qu’un modèle avec un grand vocabulaire (128k). La perplexité sera calculée sur plus de positions, et la valeur absolue ne sera pas comparable. Pour comparer, utilisez le même tokenizer ou normalisez par le nombre de caractères (bits per character, BPC).

Sensibilité au domaine. Un LLM entraîné sur du texte web aura une basse perplexité sur du texte web et une haute perplexité sur du code, des formules mathématiques, ou du texte dans une langue peu représentée dans les données d’entraînement. La perplexité reflète autant la couverture des données d’entraînement que la qualité intrinsèque du modèle.

Ne s’applique qu’aux modèles autorégressifs. La perplexité est définie pour les modèles qui prédisent le prochain token (GPT, Claude, LLaMA). Elle n’est pas directement applicable aux modèles masqués comme BERT (qui prédisent des tokens au milieu de la séquence). Pour BERT, on utilise la pseudo-perplexité ou d’autres métriques.

Métriques complémentaires. Pour une évaluation complète d’un LLM, combinez la perplexité avec des métriques task-specific : BLEU et ROUGE pour la traduction et le résumé, F1-score pour la classification, et des évaluations humaines pour la qualité, la cohérence et la factualité.

Perplexité vs autres métriques de LLM

La perplexité est le « test rapide » idéal : calculable en secondes, interprétable, et bien corrélé avec la qualité globale du modèle. Mais pour juger de la qualité d’un LLM en production (cohérence des réponses, factualité, respect des instructions), elle ne suffit pas. Utilisez-la comme premier filtre, puis complétez avec des métriques plus spécifiques.

Brève histoire de la perplexité

La perplexité comme métrique d’évaluation des modèles de langage remonte aux travaux sur les modèles n-grammes dans les années 1970-80. Elle est devenue la métrique standard pour comparer les modèles statistiques de langage (bigrammes, trigrammes) utilisés en reconnaissance vocale et en traduction automatique. Avec l’avènement des réseaux de neurones récurrents (RNN, LSTM) puis des Transformers, la perplexité a été conservée comme métrique de base, même si l’échelle des modèles a changé de façon radicale (de quelques milliers à des milliards de paramètres). Elle reste pertinente car elle mesure une propriété fondamentale : la capacité du modèle à prédire le langage.