Autoencodeurs variationnels

Les autoencodeurs variationnels (VAE, pour Variational Autoencoders) sont une classe de modèles génératifs qui allient les principes des autoencodeurs classiques avec des concepts issus des méthodes bayésiennes. Contrairement aux autoencodeurs classiques qui cherchent à apprendre une représentation compacte des données d’entrée, les VAE modélisent directement la distribution de probabilité des données, permettant ainsi de générer de nouvelles données de manière plus contrôlée et réaliste. Les VAE sont devenus une approche populaire pour des tâches de génération de données, telles que la création d’images, la génération de texte, ou même la modélisation de distributions complexes.

1. Principe des Autoencodeurs Variationnels

Les autoencodeurs sont des réseaux de neurones conçus pour apprendre à encoder les données d’entrée dans un espace de dimensions plus faibles, puis à les reconstruire à partir de cette représentation compacte. Le réseau est composé de deux parties :

L’encodeur : Il prend en entrée une donnée (par exemple, une image) et la transforme en une représentation de dimension réduite, appelée code latent.
Le décodeur : Il prend cette représentation compacte (code latent) et tente de reconstruire l’entrée d’origine à partir de cette version réduite.

Les autoencodeurs variationnels diffèrent des autoencodeurs classiques en ce qu’ils ne cherchent pas seulement à encoder une entrée sous forme de code latent, mais plutôt à modéliser la distribution probabiliste de ces codes latents. Cela signifie qu’au lieu de coder directement une seule valeur pour chaque dimension du code latent, un VAE apprend à encoder une distribution (généralement une distribution normale multivariée) sur cet espace latent.

Les VAE utilisent un processus d’optimisation basé sur la méthode du maximum de vraisemblance et la distance Kullback-Leibler (KL), qui mesure la divergence entre la distribution apprise par le modèle et une distribution a priori (généralement une distribution normale). En fin de compte, le VAE est capable de générer de nouvelles données en échantillonnant dans cet espace latent et en passant ces échantillons à travers le décodeur.

2. Structure des VAE : Encodeur et Décodeur

Un VAE se compose de deux réseaux de neurones principaux :

L’encodeur : Ce réseau prend une donnée d’entrée $x$ et produit deux sorties : la moyenne ( $\mu$ ) et l’écart-type ( $\sigma$ ) de la distribution normale approximée du code latent. Cela permet de définir une distribution normale sur l’espace latent, plutôt que de représenter directement une seule valeur.
Le décodeur : Le décodeur prend un échantillon aléatoire $z$ du code latent (échantillonné selon la distribution de l’encodeur) et génère une reconstruction de la donnée d’entrée, notée $\hat{x}$ . Ce processus de génération est ce qui permet aux VAE de créer de nouvelles données après avoir appris les distributions de données d’origine.

3. Formulation du Modèle

La formation d’un VAE repose sur l’optimisation d’une fonction de coût qui combine deux termes principaux :

La reconstruction (ou perte de reconstruction) : Cela mesure la différence entre la donnée d’entrée $x$ et sa reconstruction $\hat{x}$ . Elle est généralement calculée à l’aide d’une fonction de perte comme la moyenne quadratique (MSE) ou la perte de cross-entropy pour des données binaires.
La divergence Kullback-Leibler (KL) : Ce terme mesure la différence entre la distribution latente apprise par l’encodeur et une distribution normale standard $N(0, I)$ (la distribution a priori). L’objectif est de rendre cette distribution aussi proche que possible de la normale standard, ce qui permet de générer des échantillons significatifs à partir de cet espace latent.

L’objectif d’optimisation du VAE est donc de minimiser la somme de ces deux termes, à savoir :

$\mathcal{L}(\theta, \phi, x) = \mathbb{E}_{q(z|x)}[\log p(x|z)] – D_{KL}(q(z|x) || p(z))$

Où :

$q(z|x)$ est la distribution approximée par l’encodeur,
$p(x|z)$ est la fonction de vraisemblance du décodeur,
$p(z)$ est la distribution prior de l’espace latent (généralement une normale standard).

4. Applications des VAE

Les autoencodeurs variationnels ont de nombreuses applications dans divers domaines, grâce à leur capacité à modéliser des distributions complexes et à générer des données réalistes. Quelques exemples notables incluent :

Génération d’images : Les VAE sont utilisés pour créer de nouvelles images réalistes en apprenant la distribution des images dans un espace latent. Cette capacité est utilisée dans la création d’art génératif et de modèles visuels comme la génération de visages ou de paysages.
Modélisation de données complexes : Les VAE peuvent être utilisés pour la modélisation de distributions de données dans des contextes complexes, comme la génétique ou la finance, où des distributions complexes et multidimensionnelles doivent être apprises.
Apprentissage semi-supervisé : Les VAE peuvent également être utilisés dans des scénarios d’apprentissage semi-supervisé, où l’on dispose de peu de données étiquetées. Ils permettent de générer des échantillons supplémentaires pour augmenter l’apprentissage supervisé.
Denoising (filtrage du bruit) : Les VAE peuvent être utilisés pour nettoyer des données bruyantes, comme dans le cas de la restauration d’images ou de la détection de défauts dans les données.

5. Défis et Limitations des VAE

Bien que les VAE soient puissants et polyvalents, ils présentent quelques défis et limitations :

Qualité des échantillons générés : Bien que les VAE puissent générer des échantillons réalistes, la qualité de ces échantillons peut être inférieure à celle des autres modèles génératifs comme les GANs (Generative Adversarial Networks), en particulier pour des tâches complexes comme la génération d’images de haute résolution.
Mode collapse : Le problème de l’effondrement des modes (mode collapse), où plusieurs points de l’espace latent se correspondent à une même sortie générée, peut également se manifester, réduisant ainsi la diversité des échantillons générés.
Difficile de capturer des structures complexes : Les VAE ont parfois des difficultés à capturer des structures très complexes ou non linéaires dans les données, ce qui peut limiter leur capacité à modéliser des distributions extrêmement compliquées.

6. Conclusion

Les autoencodeurs variationnels (VAE) représentent un puissant outil pour la génération de données et la modélisation probabiliste. En apprenant à capturer et à générer des distributions complexes, les VAE ouvrent des possibilités dans des domaines aussi variés que la génération d’images, l’apprentissage semi-supervisé, et la modélisation de données complexes. Malgré certaines limitations, les VAE continuent de jouer un rôle important dans l’avancement des techniques d’IA générative.

Fonctions :

Variational Autoencoders (exemple)

Importation :

from tensorflow.keras.layers import Input, Dense, Lambda
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K
from tensorflow.keras.losses import binary_crossentropy
from tensorflow.keras.optimizers import Adam
import numpy as np

Attributs :

Paramètre	Type	Valeur par défaut	Description
input_dim	int		Dimension des données d'entrée (nombre de caractéristiques).
latent_dim	int		Dimension de l'espace latent, i.e., la taille de la représentation compressée.
hidden_dim	int	128	Dimension des couches cachées dans l'encodeur et le décodeur.
activation	str	'relu'	La fonction d'activation utilisée pour les couches du modèle (par défaut ReLU).
loss_function	function	binary_crossentropy	La fonction de perte utilisée pour l'entraînement du modèle (par défaut binary_crossentropy).
optimizer	str	'adam'	L'optimiseur utilisé pour la mise à jour des poids du modèle pendant l'entraînement (par défaut Adam).

Exemple de code :

from tensorflow.keras.layers import Input, Dense, Lambda
from tensorflow.keras.models import Model
from tensorflow.keras import backend as K
from tensorflow.keras.losses import binary_crossentropy
from tensorflow.keras.optimizers import Adam
import numpy as np

# Paramètres du VAE
input_dim = 784  # Par exemple pour des images 28x28 (flattened)
latent_dim = 2   # Dimension de l'espace latent

# Définir l'encodeur
inputs = Input(shape=(input_dim,))
h = Dense(128, activation='relu')(inputs)
z_mean = Dense(latent_dim)(h)
z_log_var = Dense(latent_dim)(h)

# Échantillonnage des variables latentes
def sampling(args):
    z_mean, z_log_var = args
    batch = K.shape(z_mean)[0]
    dim = K.int_shape(z_mean)[1]
    epsilon = K.random_normal(shape=(batch, dim))
    return z_mean + K.exp(0.5 * z_log_var) * epsilon

z = Lambda(sampling, output_shape=(latent_dim,))([z_mean, z_log_var])

# Définir le décodeur
encoder = Model(inputs, [z_mean, z_log_var, z])

latent_inputs = Input(shape=(latent_dim,))
h_decoded = Dense(128, activation='relu')(latent_inputs)
x_decoded = Dense(input_dim, activation='sigmoid')(h_decoded)

# VAE modèle complet
vae = Model(inputs, x_decoded)

# Définir la fonction de perte (reconstruction + divergence KL)
xent_loss = input_dim * binary_crossentropy(inputs, x_decoded)
kl_loss = - 0.5 * K.mean(1 + z_log_var - K.square(z_mean) - K.exp(z_log_var), axis=-1)
vae_loss = K.mean(xent_loss + kl_loss)

# Compilation du modèle
vae.add_loss(vae_loss)
vae.compile(optimizer=Adam())

# Résumé du modèle
vae.summary()

Explication du code :

Paramètres :
- input_dim = 784 : La dimension d'entrée pour chaque donnée. Par exemple, pour des images de 28x28 pixels (comme dans MNIST), l'entrée serait un vecteur de taille 784 (28*28).
- latent_dim = 2 : La dimension de l'espace latent. Cela détermine la taille du "code" compressé, qui est appris par le modèle.
Encodeur :
- inputs = Input(shape=(input_dim,)) : La couche d'entrée qui accepte les données d'entrée (par exemple, des images aplaties).
- h = Dense(128, activation='relu')(inputs) : Une couche dense de 128 unités avec ReLU comme fonction d'activation.
- z_mean = Dense(latent_dim)(h) et z_log_var = Dense(latent_dim)(h) : Ces deux couches créent la moyenne et le logarithme de la variance, respectivement, qui définissent la distribution latente. Le VAE apprend à approximer une distribution normale pour les codes latents.
Échantillonnage :
- def sampling(args) : Cette fonction échantillonne les valeurs latentes en utilisant la moyenne (z_mean) et la variance log transformée (z_log_var) selon la formule de rééchantillonnage de la variabilité dans un VAE. Elle utilise K.random_normal() pour générer un bruit gaussien et en fait un échantillon de la distribution latente.
Décodeur :
- latent_inputs = Input(shape=(latent_dim,)) : La couche d'entrée pour les codes latents.
- h_decoded = Dense(128, activation='relu')(latent_inputs) : Une couche dense qui reconstruit la représentation latente.
- x_decoded = Dense(input_dim, activation='sigmoid')(h_decoded) : La sortie du décodeur, une reconstruction de l'entrée, avec une activation sigmoïde pour les valeurs comprises entre 0 et 1.
Perte du VAE :
- La fonction de perte combine deux termes :
  - Erreur de reconstruction (xent_loss) : Elle mesure la différence entre les données d'entrée et la reconstruction générée.
  - Divergence KL (kl_loss) : Elle mesure la différence entre la distribution apprise des codes latents et la distribution normale standard (prior). Ce terme régularise l'espace latent pour qu'il soit bien structuré.
Compilation et résumé :
- Le modèle est compilé avec l'optimiseur Adam et la fonction de perte vae_loss définie comme la somme de l'erreur de reconstruction et de la divergence KL.
- vae.summary() donne un résumé du modèle pour voir sa structure.

Applications des VAE :

Génération d'images : Les VAE sont largement utilisés dans des tâches de génération d'images, comme la création de nouvelles images réalistes à partir d'une distribution latente apprise.
Réduction de la dimensionnalité : Les VAE peuvent être utilisés pour la réduction de la dimensionnalité de données complexes tout en conservant la structure sous-jacente.
Imputation de données manquantes : En apprenant une distribution sur les données, les VAE peuvent être utilisés pour générer ou imputer des données manquantes.