Accueil › Glossaire › Loss Function

Loss Function (Fonction de Perte)

Une loss function (fonction de perte, ou fonction de coût) est une fonction mathématique qui mesure l’écart entre les prédictions d’un modèle et les valeurs réelles attendues, fournissant le signal que l’optimiseur utilise pour ajuster les poids du modèle.

La loss function est le « juge » de l’entraînement : elle attribue un score d’erreur à chaque prédiction du modèle. Plus ce score est bas, mieux le modèle prédit. La descente de gradient et la rétropropagation travaillent ensemble pour minimiser cette fonction, itération après itération. Le choix de la bonne loss function est l’une des décisions les plus importantes en machine learning : une loss inadaptée peut empêcher un modèle d’apprendre correctement, même si l’architecture et les données sont parfaites.

Le rôle de la loss function dans l’entraînement

L’entraînement d’un modèle de deep learning suit un objectif simple : ajuster les poids pour que les prédictions se rapprochent le plus possible des valeurs réelles. La loss function définit ce que « se rapprocher » signifie mathématiquement.

Le cycle d’entraînement fonctionne ainsi : le modèle produit une prédiction (forward pass), la loss function mesure l’erreur, la rétropropagation calcule comment chaque poids contribue à cette erreur (gradient), et l’optimiseur (Adam, SGD) ajuste les poids pour réduire l’erreur. Sans loss function, le modèle n’a aucun signal pour s’améliorer.

Loss functions pour la régression

Les tâches de régression prédisent des valeurs continues (prix, température, durée). Les loss functions mesurent la distance entre la valeur prédite et la valeur réelle.

MSE (Mean Squared Error)

La plus utilisée en régression. Elle calcule la moyenne des carrés des écarts entre prédictions et cibles.

MSE = (1/n) · Σᵢ (yᵢ - ŷᵢ)²

Avantages : différentiable partout, pénalise fortement les grandes erreurs (grâce au carré), produit un gradient lisse qui facilite l’optimisation.

Inconvénients : très sensible aux outliers (une erreur de 10 pèse 100 fois plus qu’une erreur de 1). L’unité du MSE est le carré de l’unité de la variable cible, ce qui rend l’interprétation moins intuitive.

Quand l’utiliser : par défaut pour toute tâche de régression sans outliers significatifs. C’est la loss standard pour les autoencoders (reconstruction loss).

Page dédiée : MSE (Mean Squared Error)

MAE (Mean Absolute Error)

Calcule la moyenne des valeurs absolues des écarts.

MAE = (1/n) · Σᵢ |yᵢ - ŷᵢ|

Avantages : robuste aux outliers (une erreur de 10 pèse seulement 10 fois plus qu’une erreur de 1), interprétation directe dans l’unité de la variable cible.

Inconvénients : non différentiable en zéro (gradient indéfini quand prédiction = cible), ce qui peut poser des problèmes d’optimisation. Le gradient est constant (±1), ce qui ralentit la convergence quand l’erreur est déjà faible.

Quand l’utiliser : quand vos données contiennent des outliers significatifs et que vous ne voulez pas que quelques valeurs extrêmes dominent l’entraînement.

Huber Loss

Le meilleur des deux mondes. Huber Loss se comporte comme MSE quand l’erreur est petite et comme MAE quand l’erreur est grande, avec un seuil δ qui contrôle la transition.

Huber(y, ŷ) = {
    ½ · (y - ŷ)²                         si |y - ŷ| ≤ δ
    δ · |y - ŷ| - ½ · δ²                 si |y - ŷ| > δ
}

Avantages : différentiable partout, robuste aux outliers tout en conservant le gradient lisse de MSE pour les petites erreurs.

Inconvénients : introduit un hyperparamètre δ à régler. Avec δ trop grand, elle se comporte comme MSE. Avec δ trop petit, comme MAE.

Quand l’utiliser : régression robuste, Q-learning (apprentissage par renforcement). Valeur typique : δ = 1.0.

Loss functions pour la classification

Binary Cross-Entropy (BCE)

La loss standard pour la classification binaire (deux classes). Elle mesure l’écart entre la distribution de probabilité prédite et la distribution réelle.

BCE = -(1/n) · Σᵢ [yᵢ · log(ŷᵢ) + (1 - yᵢ) · log(1 - ŷᵢ)]

Où yᵢ ∈ {0, 1} est la classe réelle et ŷᵢ ∈ (0, 1) est la probabilité prédite par le modèle (sortie d’une sigmoïde).

Intuition : quand le modèle est confiant et correct (prédiction proche de 1 pour la classe 1), le log(ŷ) est proche de 0, donc la perte est faible. Quand le modèle est confiant et faux (prédiction proche de 1 alors que la classe est 0), le log(1-ŷ) explose vers -∞, produisant une perte très élevée. La BCE pénalise donc sévèrement les erreurs confiantes.

Quand l’utiliser : classification binaire, détection de spam, analyse de sentiment binaire, classification multi-label (chaque label est traité comme une classification binaire indépendante).

Categorical Cross-Entropy

L’extension de la BCE pour les problèmes à plus de deux classes. Le modèle produit un vecteur de probabilités via softmax, et la loss mesure l’écart avec la distribution one-hot de la classe réelle.

CCE = -Σⱼ yⱼ · log(ŷⱼ)    # somme sur les C classes

En pratique, comme y est un vecteur one-hot (une seule composante à 1, les autres à 0), cela se simplifie en :

CCE = -log(ŷ_c)    # c = indice de la vraie classe

C’est la loss utilisée pour l’entraînement des LLMs (next-token prediction) : à chaque position de la séquence, le modèle prédit une distribution de probabilité sur le vocabulaire, et la cross-entropy mesure l’écart avec le token réel.

Page dédiée : Cross-Entropy

Focal Loss

Introduite par Facebook AI (Lin et al., 2017), la Focal Loss résout le problème des classes déséquilibrées en réduisant la contribution des exemples « faciles » (bien classés) et en concentrant l’entraînement sur les exemples « difficiles ».

FL(ŷ) = -α · (1 - ŷ)ᵧ · log(ŷ)    # γ = focusing parameter (typiquement 2)

Le terme (1 – ŷ)ᵧ est le facteur de modulation : quand le modèle est confiant et correct (ŷ proche de 1), ce terme tend vers 0 et la perte est très réduite. Quand le modèle se trompe (ŷ proche de 0 pour la bonne classe), le terme est proche de 1 et la perte standard s’applique.

Quand l’utiliser : détection d’objets (où le ratio fond/objet est extrême, typiquement 1000:1), classification avec classes très déséquilibrées, segmentation médicale.

Hinge Loss

La loss des Support Vector Machines (SVM). Elle maximise la « marge » entre les classes.

Hinge = max(0, 1 - y · ŷ)    # y ∈ {-1, +1}

La hinge loss est nulle quand la prédiction est correcte avec une marge suffisante (y·ŷ ≥ 1). Elle pénalise linéairement les prédictions incorrectes ou insuffisamment confiantes.

Quand l’utiliser : principalement avec les SVM. Rarement utilisée en deep learning moderne, où la cross-entropy domine.

Loss functions spécialisées

Loss pour les LLMs (Next-Token Prediction)

Les grands modèles de langage (GPT, Claude, Gemini, LLaMA) sont entraînés avec une cross-entropy catégorielle sur la prédiction du prochain token. À chaque position t de la séquence, le modèle prédit une distribution de probabilité sur l’ensemble du vocabulaire (typiquement 32 000 à 128 000 tokens), et la loss mesure le log de la probabilité assignée au token réel.

L = -(1/T) · Σₜ log P(token_t | token_1, ..., token_{t-1})

La perplexité, qui est l’exponentielle de cette loss, est la métrique standard pour évaluer les modèles de langage. Une perplexité de 10 signifie que le modèle est en moyenne aussi incertain que s’il choisissait aléatoirement parmi 10 tokens à chaque position.

Loss pour la segmentation d’images

Dice Loss : mesure le chevauchement entre le masque prédit et le masque réel. Vaut 0 pour un chevauchement parfait, 1 pour aucun chevauchement. Très efficace pour les classes déséquilibrées en segmentation médicale.

IoU Loss (Jaccard Loss) : similaire à la Dice Loss, basée sur l’Intersection over Union. Plus stricte que la Dice Loss pour les prédictions partiellement correctes.

En pratique, les modèles de segmentation utilisent souvent une combinaison : Dice + Cross-Entropy, pour bénéficier à la fois de la stabilité de la cross-entropy et de la sensibilité au déséquilibre de la Dice Loss.

Loss pour la détection d’objets

Les modèles de détection (YOLO, Faster R-CNN) combinent plusieurs loss simultanément :

Loss de classification : cross-entropy ou focal loss pour identifier la classe de l’objet.

Loss de localisation : L1 smooth loss, GIoU loss, ou CIoU loss pour ajuster les coordonnées de la boîte englobante.

Loss d’objectness : cross-entropy binaire pour déterminer si une ancre contient un objet.

La loss totale est une somme pondérée de ces composantes, avec des coefficients de pondération qui équilibrent leur importance relative.

Loss pour les modèles génératifs

Reconstruction loss : MSE ou cross-entropy binaire pour les autoencoders (mesure la fidélité de la reconstruction).

KL Divergence : dans les Variational Autoencoders (VAE), la KL divergence force l’espace latent à suivre une distribution gaussienne, combinée à la reconstruction loss.

Adversarial loss : dans les GANs, le discriminateur et le générateur ont chacun leur propre loss, jouant un jeu minimax.

Comment choisir la bonne loss function

Implémentation pratique

PyTorch

import torch
import torch.nn as nn

# Régression : MSE
criterion = nn.MSELoss()
loss = criterion(predictions, targets)

# Classification multi-classe : Cross-Entropy
# ATTENTION : attend des LOGITS (pas de softmax avant)
criterion = nn.CrossEntropyLoss()
loss = criterion(logits, labels)   # labels = indices de classe (LongTensor)

# Classification binaire : BCE avec logits
criterion = nn.BCEWithLogitsLoss()
loss = criterion(logits, targets.float())   # targets = 0 ou 1

# Classes déséquilibrées : Cross-Entropy avec poids
weights = torch.tensor([1.0, 5.0, 2.0])   # poids par classe
criterion = nn.CrossEntropyLoss(weight=weights)

# Huber Loss (appelée SmoothL1Loss dans PyTorch)
criterion = nn.SmoothL1Loss(beta=1.0)  # beta = δ

Keras

import keras

# Régression
model.compile(optimizer='adam', loss='mse')

# Classification multi-classe (labels entiers)
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

# Classification multi-classe (labels one-hot)
model.compile(optimizer='adam', loss='categorical_crossentropy')

# Classification binaire
model.compile(optimizer='adam', loss='binary_crossentropy')

# Huber Loss
model.compile(optimizer='adam', loss=keras.losses.Huber(delta=1.0))

Créer une loss function personnalisée

Quand les loss standard ne suffisent pas, vous pouvez définir la vôtre. La seule contrainte : elle doit être différentiable (pour que la rétropropagation fonctionne).

# PyTorch : loss custom (exemple : Focal Loss)
class FocalLoss(nn.Module):
    def __init__(self, alpha=0.25, gamma=2.0):
        super().__init__()
        self.alpha = alpha
        self.gamma = gamma

    def forward(self, logits, targets):
        ce_loss = nn.functional.cross_entropy(
            logits, targets, reduction='none'
        )
        pt = torch.exp(-ce_loss)   # probabilité de la bonne classe
        focal_loss = self.alpha * (1 - pt) ** self.gamma * ce_loss
        return focal_loss.mean()

# Utilisation
criterion = FocalLoss(alpha=0.25, gamma=2.0)
loss = criterion(logits, labels)

Propriétés d’une bonne loss function

Toutes les fonctions mathématiques ne font pas de bonnes loss functions. Voici les propriétés essentielles.

Différentiabilité. La rétropropagation calcule le gradient de la loss par rapport aux poids. Si la loss n’est pas différentiable, le gradient n’existe pas et l’entraînement est impossible. C’est pourquoi l’accuracy (qui vaut 0 ou 1 pour chaque exemple) ne peut pas servir de loss : sa dérivée est nulle partout sauf aux points de discontinuité. La cross-entropy et le MSE sont différentiables partout, ce qui en fait de bons candidats.

Convexité (idéale mais rare). Une loss convexe garantit un unique minimum global, ce qui simplifie l’optimisation. MSE avec un modèle linéaire est convexe. En revanche, la loss d’un réseau de neurones profond est toujours non convexe (à cause des non-linéarités), mais cela fonctionne en pratique car les minima locaux en haute dimension ont des valeurs de perte similaires au minimum global.

Sensibilité aux erreurs du modèle. La loss doit produire un gradient informatif qui guide le modèle vers de meilleures prédictions. Une loss dont le gradient est presque nul dans certaines régions (comme MSE avec sigmoïde en classification) ralentit l’apprentissage. La cross-entropy est supérieure pour la classification précisément parce que son gradient reste fort même quand les prédictions sont saturées.

Alignement avec la métrique d’évaluation. Idéalement, minimiser la loss devrait aussi améliorer la métrique que vous utilisez pour évaluer le modèle. Si vous évaluez en F1-score, une loss qui optimise directement le rappel et la précision sera plus efficace qu’une cross-entropy standard. En pratique, un alignement parfait est rare, et la cross-entropy reste le choix le plus robuste pour la classification.

Le paysage de perte (loss landscape)

Le « paysage de perte » (loss landscape) est la surface définie par la valeur de la loss pour chaque configuration possible des poids du modèle. C’est un concept fondamental pour comprendre pourquoi certains modèles s’entraînent facilement et d’autres non.

Paysages lisses vs chaotiques. Un paysage lisse (peu de minima locaux, gradients réguliers) facilite l’optimisation. Les architectures modernes (connexions résiduelles, normalisation, attention) sont conçues pour produire des paysages plus lisses. Un paysage chaotique (nombreux minima locaux, régions plates, crevasses abruptes) rend l’entraînement instable.

Flat minima vs sharp minima. La recherche montre que les minima « plats » (entourés de régions de loss similaire) généralisent mieux que les minima « pointus » (entourés de régions de loss élevée). SGD tend à trouver des minima plus plats qu’Adam, ce qui explique en partie sa meilleure généralisation en vision. Des techniques comme SAM (Sharpness-Aware Minimization) cherchent explicitement les minima plats.

L’impact du batch size. Un petit batch size produit un gradient bruité, ce qui aide à explorer le paysage de perte et à échapper aux minima locaux pointus. Un grand batch size produit un gradient précis mais peut converger vers des minima pointus. C’est pourquoi augmenter le batch size nécessite d’ajuster le learning rate et d’ajouter un warmup.

Erreurs courantes

Appliquer softmax avant CrossEntropyLoss dans PyTorch. nn.CrossEntropyLoss applique softmax en interne. Ajouter un softmax avant revient à appliquer softmax deux fois, ce qui produit des gradients incorrects et ralentit drastiquement l’apprentissage.

Utiliser MSE pour la classification. MSE pénalise les prédictions proportionnellement au carré de l’écart. Pour la classification, la cross-entropy est supérieure car elle pénalise plus fortement les prédictions confiantes et fausses, produisant des gradients plus informatifs.

Ignorer le déséquilibre des classes. Avec un dataset 95 %/5 %, un modèle qui prédit toujours la classe majoritaire atteint 95 % d’accuracy et une cross-entropy raisonnable. Utilisez la focal loss, des poids de classe, ou un suréchantillonnage.

Ne pas vérifier la stabilité numérique. La cross-entropy implique des logarithmes. Si le modèle prédit une probabilité de 0, log(0) = -∞ et la loss explose. Les implémentations des frameworks ajoutent un epsilon de clipping, mais vérifiez que vous utilisez les loss intégrées plutôt qu’une implémentation naïve.

Confondre loss et métrique. L’accuracy n’est pas une loss function viable car elle n’est pas différentiable (elle est constante par morceaux). On entraîne avec la cross-entropy et on évalue avec l’accuracy.