Autoencoder

Un autoencodeur est un réseau neuronal entraîné à reproduire sa propre entrée. Un encodeur mappe l'entrée vers un code compact, souvent appelé représentation latente ; un décodeur mappe le code vers une reconstruction, et l'entraînement minimise la différence entre l'entrée et la reconstruction. Comme la cible est l'entrée elle-même, les autoencodeurs apprennent à partir de données non annotées, une forme d'apprentissage non supervisé aujourd'hui généralement classée comme apprentissage auto-supervisé. Ce qui rend le réseau utile, c'est une contrainte qui l'empêche de simplement recopier l'entrée, par exemple un goulot d'étranglement étroit, l'ajout de bruit, des entrées masquées ou une pénalité de parcimonie ; cette contrainte le force à apprendre la structure qui rend les données compressibles. Les autoencodeurs servent à la réduction de dimensionnalité, à la détection d'anomalies, au débruitage, au préentraînement et comme étape de compression des générateurs d'images modernes.

Fonctionnement des autoencodeurs#

L'encodeur f mappe une entrée x vers un code z = f(x), le décodeur g produit une reconstruction x̂ = g(z), et l'entraînement minimise une perte de reconstruction, comme l'erreur quadratique moyenne entre x et x̂, par rétropropagation. Dans un autoencodeur sous-complet, z a beaucoup moins de dimensions que x ; le code est donc un résumé de l'espace latent qui ne conserve que ce dont le décodeur a besoin. Un autoencodeur linéaire entraîné avec l'erreur quadratique apprend le même sous-espace que l'analyse en composantes principales (PCA), résultat démontré par Pierre Baldi et Kurt Hornik en 1989, tandis que les fonctions d'activation non linéaires permettent aux autoencodeurs plus profonds de saisir des structures courbes que la PCA ne peut pas représenter. Dans un article publié dans Science en 2006, Geoffrey Hinton et Ruslan Salakhutdinov ont montré que les autoencodeurs profonds produisaient, pour les images et les documents, des codes de faible dimension bien meilleurs que la PCA.

Les variantes qui ne dépendent pas d'un goulot d'étranglement étroit corrompent plutôt l'entrée et évaluent quand même la reconstruction par rapport à l'original intact :

Types d'autoencodeurs#

• Débruitage : Ajoute du bruit à l'entrée et entraîne le réseau à retrouver l'original propre, comme Pascal Vincent et ses collègues l'ont décrit en 2008. Les caractéristiques apprises résistent aux corruptions, et le modèle entraîné peut nettoyer des images ou des signaux bruités.
• Parcimonieux : Utilise plus d'unités de code que d'entrées, mais pénalise le nombre d'unités actives simultanément. Les autoencodeurs parcimonieux entraînés sur les activations internes des grands modèles de langage (LLM) les décomposent en nombreuses caractéristiques, chacune tendant à correspondre à un concept interprétable.
• Variationnel (VAE) : L'encodeur produit une distribution de probabilité sur les codes, et une pénalité de divergence KL la maintient proche d'une distribution normale standard, de sorte que le décodage d'un code échantillonné aléatoirement génère de nouvelles données. Diederik Kingma et Max Welling ont présenté le VAE en 2013.
• Quantifié vectoriellement (VQ-VAE) : Chaque vecteur de code est ramené à l'entrée la plus proche d'un dictionnaire de codes appris par quantification vectorielle, ce qui convertit les images ou l'audio en jetons discrets qu'un modèle autorégressif peut générer.
• Masqué : Masque la majeure partie de l'entrée et reconstruit les parties manquantes. Les autoencodeurs masqués (MAE) masquent 75 % des patches d'une image, et l'encodeur entraîné de cette façon devient un puissant backbone pour d'autres tâches de vision. Le Segment Anything Model (SAM) de Meta, disponible dans le package Ultralytics, construit son encodeur d'image à partir d'un Vision Transformer préentraîné avec MAE, tandis que SAM 2 utilise un encodeur Hiera préentraîné avec MAE ; les caractéristiques à l'origine de chaque masque interactif ont donc d'abord été apprises en complétant des patches masqués.

Détection d'anomalies par erreur de reconstruction#

Un autoencodeur entraîné uniquement sur des données normales reconstruit bien les entrées normales et mal les entrées inconnues ; l'erreur de reconstruction sert donc de score d'anomalie pour les défauts de fabrication, les transactions frauduleuses ou les machines défaillantes, sans qu'il soit nécessaire de disposer d'anomalies étiquetées. L'extrait PyTorch ci-dessous entraîne un petit autoencodeur sur les chiffres manuscrits inclus dans scikit-learn, en excluant tous les 7, puis compare son erreur sur les chiffres mis de côté à celle obtenue sur les 7 :

import torch
from sklearn.datasets import load_digits
from torch import nn

# 8x8 handwritten digits scaled to [0, 1]; every 7 is held out as the unseen anomaly
digits = load_digits()
x = torch.tensor(digits.data / 16, dtype=torch.float32)
normal, sevens = x[digits.target != 7], x[digits.target == 7]
train, test = normal[:1200], normal[1200:]

# Encoder: 64 pixels to an 8-number code; decoder: code back to 64 pixels
torch.manual_seed(0)
encoder = nn.Sequential(nn.Linear(64, 32), nn.ReLU(), nn.Linear(32, 8))
decoder = nn.Sequential(nn.Linear(8, 32), nn.ReLU(), nn.Linear(32, 64), nn.Sigmoid())
model = nn.Sequential(encoder, decoder)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)
for step in range(1000):
    optimizer.zero_grad()
    nn.functional.mse_loss(model(train), train).backward()  # reconstruction error
    optimizer.step()

with torch.no_grad():
    for name, data in [("Held-out digits", test), ("Unseen 7s", sevens)]:
        print(f"{name}: reconstruction error {nn.functional.mse_loss(model(data), data):.4f}")

Il affiche une erreur de reconstruction de 0.0163 pour les chiffres mis de côté et de 0.0547 pour les 7, soit une moyenne 3,4 fois supérieure ; un seuil appliqué à l'erreur de chaque image transforme cet écart en indicateur d'anomalie. Un autoencodeur peut aussi trop bien généraliser et reconstruire fidèlement certaines anomalies ; les systèmes pratiques règlent donc la taille du goulot d'étranglement et le seuil à partir de données de validation qui incluent des anomalies connues.

Autoencodeurs et concepts associés#

• Réseaux antagonistes génératifs (GANs) : Le générateur d'un GAN transforme du bruit aléatoire en données et apprend à partir d'un discriminateur, sans encodeur ni cible de reconstruction. Les VAE génèrent également des données ; leur objectif fondé sur la vraisemblance rend l'entraînement plus stable, mais tend à produire des images plus floues.
• U-Net : Reprend la structure encodeur-décodeur, mais transforme l'entrée en une cible différente, comme un masque de segmentation, et fait passer des connexions de saut autour du goulot d'étranglement ; dans un autoencodeur, celles-ci permettraient au réseau de copier son entrée.
• Apprentissage contrastif : Apprend des représentations en comparant les échantillons entre eux ; ses caractéristiques capturent donc ce qui distingue les images et ignorent les détails au niveau des pixels qu'une perte de reconstruction doit préserver.
• Plongements : Le code produit par un encodeur est une forme de plongement, et les autoencodeurs sont l'une des différentes méthodes permettant de les apprendre.

Autoencodeurs pour la génération d'images#

Les modèles de diffusion latente, comme Stable Diffusion, exécutent leur processus de diffusion dans l'espace latent d'un autoencodeur et décodent le résultat en pixels à la fin. Stable Diffusion 1.x utilise un autoencodeur régularisé par KL qui compresse une image RGB de 512×512 en un latent de 64×64×4, soit 48 fois moins de valeurs à traiter à chaque étape de débruitage par le modèle de diffusion.