Accueil › Glossaire › MSE (Mean Squared Error)

MSE (Mean Squared Error)

Le MSE (Mean Squared Error, erreur quadratique moyenne) est une fonction de perte qui calcule la moyenne des carrés des écarts entre les prédictions d’un modèle et les valeurs réelles, pénalisant fortement les grandes erreurs.

C’est la loss function par défaut pour toute tâche de régression en machine learning et deep learning. De la régression linéaire la plus simple aux autoencoders et modèles de diffusion, le MSE est omniprésent. Sa popularité tient à ses propriétés mathématiques : il est différentiable partout, produit un gradient lisse et proportionnel à l’erreur, et correspond à l’hypothèse que les erreurs de prédiction suivent une distribution gaussienne (normale).

La formule expliquée

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

Décomposons chaque élément :

yᵢ est la valeur réelle (la cible, le « ground truth ») pour l’exemple i.

ŷᵢ est la valeur prédite par le modèle pour le même exemple.

(yᵢ – ŷᵢ) est le résidu (l’erreur) pour cet exemple. Il peut être positif ou négatif.

(yᵢ – ŷᵢ)² est le résidu au carré. Le carré a deux effets : (1) rendre l’erreur toujours positive (pas d’annulation entre erreurs positives et négatives), et (2) amplifier les grandes erreurs par rapport aux petites.

(1/n) · Σ prend la moyenne sur les n exemples du batch ou du dataset.

Exemple numérique

# 5 prédictions de prix immobilier (en milliers €)
y_reel   = [250, 300, 180, 420, 350]
y_predit = [245, 310, 190, 400, 360]

# Résidus
residus  = [5, -10, -10, 20, -10]

# Résidus au carré
carres   = [25, 100, 100, 400, 100]

# MSE = moyenne des carrés
MSE = (25 + 100 + 100 + 400 + 100) / 5 = 145.0

# RMSE = racine carrée du MSE (même unité que les données)
RMSE = √145 ≈ 12.04 (milliers €)

Le MSE est de 145 (en milliers² d’euros, une unité peu intuitive). Le RMSE de 12.04 milliers d’euros est plus facile à interpréter : en moyenne, le modèle se trompe d’environ 12 000 €. Notez comment la seule grosse erreur (20 sur la maison à 420k) contribue à elle seule 400/725 ≈ 55 % de la somme des carrés.

Le gradient du MSE

Le gradient du MSE par rapport à la prédiction ŷᵢ est :

∂MSE/∂ŷᵢ = (2/n) · (ŷᵢ - yᵢ)

Ce gradient a des propriétés idéales pour l’optimisation :

Proportionnel à l’erreur. Plus l’erreur est grande, plus le gradient est fort, et plus la correction sera importante. Les grandes erreurs reçoivent naturellement plus d’attention.

Linéaire en l’erreur. Le gradient diminue linéairement quand l’erreur se réduit, ce qui produit une convergence douce vers le minimum. Pas de « saut » brutal.

Différentiable partout. Contrairement au MAE (dont le gradient est indéfini en zéro), le MSE a un gradient bien défini en tout point, ce qui facilite l’optimisation par descente de gradient.

Le facteur 2. Le « 2 » devant le gradient vient de la dérivée de x². En pratique, il est souvent absorbé dans le learning rate et n’a pas d’impact sur l’entraînement. Certaines implémentations (comme MATLAB) utilisent le « half MSE » (½ · MSE) pour éliminer ce facteur.

Propriétés mathématiques

Lien avec l’hypothèse gaussienne

Minimiser le MSE est mathématiquement équivalent à maximiser la vraisemblance (maximum likelihood) sous l’hypothèse que les erreurs de prédiction suivent une distribution gaussienne (normale) de moyenne zéro. En d’autres termes, utiliser le MSE revient implicitement à supposer que vos données sont bruitées par un bruit gaussien. Si cette hypothèse est raisonnable (ce qui est souvent le cas pour les données physiques, financières, etc.), le MSE est le choix optimal au sens statistique.

Décomposition biais-variance

Le MSE se décompose en deux composantes fondamentales :

MSE = Biais² + Variance

Le biais mesure l’erreur systématique du modèle (est-ce qu’il est constamment trop haut ou trop bas ?). La variance mesure la sensibilité du modèle aux variations dans les données d’entraînement. Cette décomposition est au cœur du compromis biais-variance en machine learning : un modèle trop simple a un biais élevé (underfitting), un modèle trop complexe a une variance élevée (overfitting).

Convexité

Pour les modèles linéaires (régression linéaire, régression logistique), le MSE est une fonction convexe des paramètres, ce qui garantit un unique minimum global. Pour les réseaux de neurones, le MSE est non convexe (à cause des non-linéarités des couches), mais ses propriétés de gradient lisse facilitent tout de même l’optimisation.

Le problème des outliers

Le défaut principal du MSE est sa sensibilité extrême aux outliers. Le carré amplifie l’impact des grandes erreurs de façon disproportionnée.

# Avec outlier
y_reel   = [100, 102, 98, 101, 500]   # le dernier est un outlier
y_predit = [100, 100, 100, 100, 100]

# Résidus au carré : [0, 4, 4, 1, 160000]
# MSE = 160009/5 = 32001.8    ← dominé par l'outlier

# Sans outlier
y_reel   = [100, 102, 98, 101]
y_predit = [100, 100, 100, 100]
# MSE = (0 + 4 + 4 + 1)/4 = 2.25  ← raisonnable

Un seul outlier peut complètement dominer la loss et forcer le modèle à sur-ajuster cette donnée atypique au détriment de toutes les autres. C’est pourquoi le nettoyage des données est si important quand on utilise le MSE, et pourquoi des alternatives comme MAE ou Huber Loss existent.

MSE vs MAE vs Huber : guide de choix

Le verdict : commencez avec MSE. Si les outliers dégradent les performances, passez à Huber (δ = 1.0 par défaut). Réservez MAE aux cas où la robustesse aux outliers est primordiale et où vous acceptez une convergence moins précise près du minimum.

RMSE : rendre le MSE interprétable

Le RMSE (Root Mean Squared Error) est simplement la racine carrée du MSE :

RMSE = √MSE = √[(1/n) · Σ(yᵢ - ŷᵢ)²]

Son avantage principal : il est dans la même unité que la variable cible. Si vous prédisez des prix en euros, le RMSE est en euros. Le MSE serait en euros², ce qui est moins intuitif.

En pratique, on entraîne avec le MSE (car son gradient est plus simple) et on rapporte les résultats en RMSE (car il est plus interprétable). Minimiser le MSE et minimiser le RMSE sont strictement équivalents (la racine carrée est une fonction monotone croissante).

Le MSE en deep learning

Autoencoders et reconstruction

Les autoencoders sont entraînés pour reconstruire leur entrée après passage par un goulot d’étranglement. La loss de reconstruction est typiquement le MSE entre l’entrée originale et la sortie reconstruite. Plus le MSE est bas, plus la reconstruction est fidèle, ce qui signifie que le goulot d’étranglement (l’espace latent) capture bien l’information essentielle.

Modèles de diffusion

Les modèles de diffusion (Stable Diffusion, DALL-E, Midjourney) utilisent le MSE comme composante de leur loss d’entraînement. Le modèle apprend à prédire le bruit ajouté à une image, et le MSE mesure l’écart entre le bruit prédit et le bruit réel. La qualité de cette prédiction détermine directement la qualité des images générées.

Régression de boîtes englobantes

En détection d’objets, les coordonnées des boîtes englobantes (bounding boxes) sont prédites par régression. Le MSE (ou sa variante Smooth L1 / Huber) mesure l’écart entre les coordonnées prédites et les coordonnées réelles.

Pourquoi ne pas utiliser le MSE pour la classification

Le MSE peut techniquement être utilisé pour la classification, mais c’est une mauvaise idée. Le problème : combiné avec une sigmoïde ou un softmax, le gradient du MSE sature quand les prédictions sont proches de 0 ou 1. Le modèle « sait » qu’il se trompe (MSE élevé) mais le gradient est trop faible pour corriger rapidement. La cross-entropy ne souffre pas de ce problème car le logarithme annule la saturation de la sigmoïde.

Implémentation pratique

PyTorch

import torch
import torch.nn as nn

# MSE Loss standard
criterion = nn.MSELoss()           # reduction='mean' par défaut
loss = criterion(predictions, targets)

# MSE sans réduction (loss par exemple)
criterion = nn.MSELoss(reduction='none')
per_sample_loss = criterion(predictions, targets)  # vecteur de loss

# MSE avec somme au lieu de la moyenne
criterion = nn.MSELoss(reduction='sum')

# Smooth L1 / Huber (alternative robuste au MSE)
criterion = nn.SmoothL1Loss(beta=1.0)   # beta = seuil δ

# Entraînement typique
model = nn.Sequential(nn.Linear(10, 64), nn.ReLU(), nn.Linear(64, 1))
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.MSELoss()

for x_batch, y_batch in dataloader:
    predictions = model(x_batch).squeeze()
    loss = criterion(predictions, y_batch)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

Keras

import keras

# MSE via string
model.compile(optimizer='adam', loss='mse', metrics=['mae'])

# MSE via objet
model.compile(
    optimizer='adam',
    loss=keras.losses.MeanSquaredError(),
    metrics=[keras.metrics.RootMeanSquaredError()]
)

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

MSE from scratch (pour comprendre)

import numpy as np

def mse(y_true, y_pred):
    return np.mean((y_true - y_pred) ** 2)

def mse_gradient(y_true, y_pred):
    n = len(y_true)
    return (2 / n) * (y_pred - y_true)

# Exemple
y_true = np.array([3.0, 5.0, 2.0, 7.0])
y_pred = np.array([2.5, 5.5, 1.5, 8.0])

print(f"MSE: {mse(y_true, y_pred)}")        # 0.375
print(f"RMSE: {np.sqrt(mse(y_true, y_pred))}")  # 0.612
print(f"Gradient: {mse_gradient(y_true, y_pred)}")  # [-0.25, 0.25, -0.25, 0.5]

Variantes et extensions du MSE

MSLE (Mean Squared Logarithmic Error)

Le MSLE applique le logarithme aux valeurs avant de calculer le MSE :

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

L’ajout de 1 évite le log(0). Le MSLE est utile quand les cibles couvrent plusieurs ordres de grandeur (par exemple, des prix allant de 10 € à 10 000 000 €). Il pénalise les erreurs relatives plutôt qu’absolues : une erreur de 100 € sur un prix de 200 € est plus grave qu’une erreur de 100 € sur un prix de 100 000 €.

MSE pondéré

Attribue un poids différent à chaque exemple ou chaque composante de la sortie :

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

Utile quand certaines prédictions sont plus importantes que d’autres (par exemple, prédire correctement les pics de demande énergétique est plus critique que les heures creuses).

Smooth L1 Loss (Huber modifié)

La Smooth L1 Loss, utilisée dans Faster R-CNN et de nombreux modèles de détection, est une variante de la Huber Loss avec δ = 1 :

SmoothL1(x) = {
    0.5 · x²           si |x| < 1
    |x| - 0.5          si |x| ≥ 1
}

Elle combine la stabilité du MSE pour les petites erreurs et la robustesse du MAE pour les grandes erreurs. Dans PyTorch, c’est nn.SmoothL1Loss().

Bonnes pratiques avec le MSE

1. Normalisez vos cibles. Standardisez (moyenne 0, écart-type 1) ou normalisez (min-max vers [0, 1]) les valeurs cibles avant l’entraînement. Cela stabilise les gradients et évite que les valeurs de loss soient dominées par l’échelle des données.

2. Surveillez le MSE d’entraînement et de validation. Si le MSE d’entraînement diminue mais celui de validation augmente, c’est de l’overfitting. Ajoutez de la régularisation (dropout, weight decay) ou réduisez la taille du modèle.

3. Comparez à une baseline. Calculez toujours le MSE d’un modèle « naïf » (prédire la moyenne des cibles) comme référence. Si votre modèle ne fait pas significativement mieux, il y a un problème dans les données ou l’architecture.

4. Utilisez RMSE pour rapporter les résultats. Le RMSE est dans la même unité que les données, ce qui le rend interprétable par les non-spécialistes. C’est la métrique de prédilection pour les compétitions Kaggle en régression.

5. Testez Huber si la convergence est instable. Si vous observez des spikes dans la courbe de loss (la loss augmente brusquement puis redescend), des outliers perturbent probablement l’entraînement. Passer à Huber Loss (δ = 1.0) lisse le gradient pour les grandes erreurs.

Erreurs courantes

Utiliser le MSE pour la classification. La cross-entropy est toujours supérieure. Le MSE combiné avec sigmoïde/softmax produit des gradients qui saturent, ralentissant l’apprentissage.

Ignorer les outliers. Vérifiez la distribution de vos données avant de choisir le MSE. Quelques outliers peuvent dominer la loss et biaiser le modèle. Utilisez Huber si nécessaire.

Confondre MSE et RMSE. Le MSE est en unités² (difficile à interpréter). Le RMSE est dans l’unité originale. Rapportez toujours le RMSE dans vos rapports, mais entraînez avec le MSE.

Comparer le MSE entre datasets différents. Le MSE dépend de l’échelle des données. Un MSE de 100 sur des prix immobiliers (en milliers) est excellent, mais catastrophique sur des probabilités (entre 0 et 1). Normalisez les données ou utilisez le R² pour des comparaisons inter-datasets.

Oublier de normaliser les cibles. Si les valeurs cibles ont des ordres de grandeur très différents, les grosses valeurs domineront la loss. Standardisez les cibles (moyenne 0, écart-type 1) avant l’entraînement, puis dé-standardisez les prédictions.