Autoencodeurs pour l’apprentissage de représentations
Architecture encodeur-décodeur, goulot d’étranglement, perte de reconstruction, applications à la détection d’anomalies.
Autoencodeurs pour l’apprentissage de représentations est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce qu'un autoencodeur ?
Un autoencodeur apprend à compresser des données dans un petit code, puis à les reconstruire. Il comporte deux moitiés : un encodeur qui compresse et un décodeur qui reconstruit. Le goulot d'étranglement central l'oblige à apprendre ce qui est important.
import torch
import torch.nn as nnL'idée du goulot d'étranglement
La couche centrale étroite est le goulot d'étranglement, ou code latent. En faisant passer toutes les informations par quelques nombres, le réseau doit éliminer le bruit et conserver la structure essentielle des données.
Construire l'encodeur
Pour des images 28x28 (784 pixels), l'encodeur réduit progressivement l'entrée : de 784 à 256, puis à un code latent de dimension 64. Chaque couche Linear est suivie d'une non-linéarité ReLU.
encoder = nn.Sequential(
nn.Linear(784, 256),
nn.ReLU(),
nn.Linear(256, 64)
)Construction du décodeur
Le décodeur reproduit la structure de l'encodeur et reconvertit le code de 64 dimensions en 784 pixels. Un Sigmoid final ramène les sorties dans [0,1] afin de correspondre aux valeurs de pixels normalisées.
decoder = nn.Sequential(
nn.Linear(64, 256),
nn.ReLU(),
nn.Linear(256, 784),
nn.Sigmoid()
)L'autoencodeur complet
Reliez l'encodeur et le décodeur dans un seul module. Le passage forward encode puis décode, et renvoie une reconstruction de même forme que l'entrée.
class AutoEncoder(nn.Module):
def __init__(self, enc, dec):
super().__init__()
self.enc, self.dec = enc, dec
def forward(self, x):
z = self.enc(x)
return self.dec(z)Perte de reconstruction (MSE)
La cible d'entraînement est l'entrée elle-même. L'erreur quadratique moyenne mesure l'écart entre la reconstruction et le pixel d'origine, pixel par pixel. La minimiser apprend au modèle à compresser fidèlement les données.
criterion = nn.MSELoss()
x_flat = x.view(x.size(0), -1)
recon = model(x_flat)
loss = criterion(recon, x_flat)Entraînement de l'autoencodeur
L'entraînement est non supervisé : il n'utilise aucune étiquette, uniquement les entrées. La boucle suit le schéma standard zero_grad, forward, backward, step, mais la perte compare la sortie à l'entrée.
optimizer.zero_grad()
recon = model(x_flat)
loss = criterion(recon, x_flat)
loss.backward()
optimizer.step()L'espace latent
Après l'entraînement, l'encodeur associe chaque entrée à un point de l'espace latent. Les entrées similaires se retrouvent proches les unes des autres : ce code de 64 dimensions est donc une représentation compacte des données, apprise par le modèle.
z = model.enc(x_flat)
print(z.shape) # [batch, 64]Visualisation avec t-SNE
L'espace latent de 64 dimensions est difficile à visualiser. t-SNE le projette en 2D pour permettre sa représentation graphique. Les groupes visibles montrent que l'autoencodeur a regroupé les éléments similaires sans jamais voir leurs étiquettes.
from sklearn.manifold import TSNE
codes = model.enc(all_data).detach().numpy()
proj = TSNE(n_components=2).fit_transform(codes)
# scatter plot proj colored by true labelDétection des anomalies
Un autoencodeur entraîné sur des données normales les reconstruit correctement, mais a du mal avec les anomalies qu'il n'a jamais vues. Une erreur de reconstruction élevée signale une valeur aberrante : c'est un puissant détecteur d'anomalies non supervisé.
errors = ((model(data) - data) ** 2).mean(dim=1)
anomalies = errors > thresholdPourquoi apprendre des représentations ?
Le véritable atout est le code latent : un vecteur de caractéristiques appris que vous pouvez utiliser pour le regroupement, la visualisation, la détection d'anomalies ou comme entrée d'un autre modèle, le tout sans étiquettes.
Vérification rapide
Évaluez votre compréhension des autoencodeurs.
Récapitulatif : autoencodeurs
Vous avez construit un encodeur (784 vers 256 puis 64) et un décodeur qui en reproduit la structure, entraînés avec une perte de reconstruction MSE et sans étiquettes. Vous avez utilisé le code latent pour apprendre une représentation, l'avez visualisé avec t-SNE et avez détecté les anomalies grâce à une erreur de reconstruction élevée.
Questions Fréquemment Posées
La leçon « Autoencodeurs pour l’apprentissage de représentations » est-elle gratuite ?
Oui — le texte complet de « Autoencodeurs pour l’apprentissage de représentations » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Autoencodeurs pour l’apprentissage de représentations » ?
Architecture encodeur-décodeur, goulot d’étranglement, perte de reconstruction, applications à la détection d’anomalies. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn AI with Python ?
Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Autoencodeurs pour l’apprentissage de représentations » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?
Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Autoencodeurs pour l’apprentissage de représentations
- Autoencodeurs variationnels (VAE)
- GAN : générateur et discriminateur
- GAN conditionnels et transfert de style