#autoencodeur — Apprentissage profond

Autoencodeur : compresser puis reconstruire.

Ce que tu vas manipuler

Bienvenue dans #autoencodeur. À gauche, une croix dessinée sur 8×8 = 64 pixels ; au centre, un goulot de 4 neurones ; à droite, ce que le réseau reconstruit à partir de ces 4 nombres seulement. Les poids sont encore aléatoires : la sortie est une bouillie grise. Un autoencodeur apprend à compresser (encodeur : 64 → 4) puis à reconstruire (décodeur : 4 → 64) en minimisant l'écart entre l'entrée et la sortie. Pas d'étiquettes : la cible, c'est l'entrée elle-même. C'est l'idée derrière la compression apprise, le débruitage et une partie des générateurs d'images.
Lance l'apprentissage : /entrainer 20. À chaque époque, le réseau voit les 12 glyphes, mesure l'erreur de reconstruction et corrige ses poids par rétropropagation.
Encore 40 époques : /entrainer 40. L'erreur quadratique moyenne (MSE) affichée sous la grille de droite devrait fondre.
Serrons le goulot : /latent 2. Le réseau est réinitialisé avec seulement 2 neurones au centre : chaque glyphe devra tenir dans deux nombres, exactement les deux axes du plan latent.
Réentraîne ce réseau étroit : /entrainer 40. Compare ensuite l'erreur moyenne sur les 12 glyphes (panneau de droite) à celle obtenue avec 4 dimensions.
Change l'entrée : /image cercle. Les mêmes poids encodent puis décodent un tout autre dessin, sans rien réapprendre.
Abîme l'entrée : /bruit 0.3 remplace 30 % des pixels par des valeurs aléatoires. Le réseau, lui, n'a jamais vu de bruit.
Voyage dans l'espace latent : /interpoler croix cercle place 5 points intermédiaires entre les codes de la croix et du cercle, puis décode chacun d'eux.
À toi de jouer : /point 0.5 -0.5 décode un point libre du plan latent, /pixel 1 1 allume un pixel hors motif pour voir le réseau le gommer, /latent 8 puis /entrainer 30 pour un goulot large, /bruit 0.6 pour un débruitage difficile, /graine 3 pour une autre initialisation, /reinit pour repartir. Prochaine étape : le canal #transfer-learning, où un encodeur déjà entraîné sert de point de départ à une nouvelle tâche.

Commandes du canal

/latent <k=1..8> — Change la dimension du goulot et réinitialise le réseau (poids neufs, époque 0).
/entrainer <époques=5..60> — Continue l'entraînement (SGD, cible = glyphe propre ; entrée bruitée si /bruit > 0).
/image <croix|cercle|barre|trait|diagonale|carre|triangle|point|L|T|damier> — Change le glyphe d'entrée (le réseau ne change pas).
/bruit <0..1> — Corrompt l'entrée (part des pixels remplacés par une valeur aléatoire) ; la cible reste propre.
/interpoler <a> <b> — Décode 5 codes intermédiaires entre les codes latents de deux glyphes (bande du bas).
/point <z1> <z2> — Décode un point libre du plan latent (z1, z2 ; les autres dimensions valent 0).
/pixel <ligne=1..8> <colonne=1..8> — Allume ou éteint un pixel de l'entrée (ligne 1 en haut) pour tester une forme hors données.
/graine <n=1..999> — Change la graine : autre initialisation des poids et autre motif de bruit ; l'entraînement repart de zéro.
/reinit — Revient à l'état initial : croix, goulot 4, poids aléatoires, sans bruit.

Glossaire

Autoencodeur: Réseau entraîné à reproduire son entrée après l'avoir fait passer par une représentation plus petite. Pas d'étiquettes : la cible est l'entrée elle-même, c'est de l'apprentissage auto-supervisé.
Encodeur: Première moitié du réseau : elle compresse l'entrée (ici 64 pixels) en un code latent de k nombres.
Décodeur: Seconde moitié du réseau : elle reconstruit une sortie de la taille de l'entrée à partir du seul code latent. C'est aussi un petit générateur : donnez-lui un code inventé, il produit une image.
Goulot d'étranglement: Couche la plus étroite, entre encodeur et décodeur. Sa taille k fixe le taux de compression (64 → k) et force le réseau à ne garder que l'essentiel.
Espace latent: Espace à k dimensions où vivent les codes. Deux entrées semblables y ont des codes proches ; se déplacer dedans, c'est faire varier les traits que le réseau a appris à repérer.
Erreur de reconstruction: Écart entre la sortie et l'entrée, ici l'erreur quadratique moyenne (MSE) sur les 64 pixels. C'est la seule perte minimisée par l'entraînement.
Débruitage: Variante où l'on présente une entrée bruitée mais où la cible reste l'image propre : l'autoencodeur apprend à retirer le bruit, et sa représentation devient plus robuste.
Interpolation latente: Prendre des points intermédiaires entre deux codes et les décoder : on obtient des formes qui n'existent dans aucune donnée. Elle révèle si l'espace latent est continu ou plein de trous.
Autoencodeur variationnel: Autoencodeur dont le code est une distribution (moyenne et variance) plutôt qu'un point, avec une pénalité qui range les codes autour de l'origine. L'espace latent devient lisse et échantillonnable : c'est un vrai modèle génératif.
Réduction de dimension: Représenter des données à beaucoup de variables (64 pixels) par peu de nombres (k) en perdant le moins d'information possible. L'autoencodeur en est une version non linéaire ; la PCA en est la version linéaire.

Autres canaux du thème Apprentissage profond

#optimiseurs — SGD, Momentum et Adam : la course vers le minimum.
#batch-normalisation — Batch normalisation : garder les activations dans la bonne plage.
#rnn-lstm — RNN et LSTM : se souvenir d'une séquence.
#autoencodeur — Autoencodeur : compresser puis reconstruire.
#transfer-learning — Apprentissage par transfert : repartir d'un réseau déjà entraîné.
#gan — GAN : un faussaire contre un inspecteur