Autoencodeurs

Fonctions :

Autoencodeur Densely Connected (Fully Connected)

Un autoencodeur densément connecté (ou fully connected autoencoder) est un type de réseau de neurones utilisé pour la réduction de dimensionnalité ou la reconstruction de données. Il se compose généralement de deux parties principales : l'encodeur et le décodeur. L'encodeur compresse les données d'entrée en un vecteur de caractéristiques de taille réduite. Le décodeur tente de reconstruire les données d'entrée à partir de cette représentation comprimée. Dans le cas d'un autoencodeur densément connecté, chaque couche est entièrement connectée à la couche suivante, ce qui signifie que chaque neurone de la couche précédente est connecté à chaque neurone de la couche suivante. Cela permet à l'autoencodeur d'apprendre des représentations plus complexes et plus fines de ses entrées, ce qui est particulièrement utile pour la réduction de bruit, la génération de nouvelles données, ou la compression de données.

Importation :

from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model

Attributs :

Paramètre	Type	Valeur par défaut	Description
input_dim	int		La dimension d'entrée des données. Il s'agit du nombre de caractéristiques dans les données d'entrée.
encoding_dim	int		La dimension de l'espace latent (la taille de la couche encodée) où l'information est comprimée.
hidden_layers	list of ints		Une liste des tailles des couches cachées à utiliser entre l'encodeur et le décodeur.
activation_function	str	'relu'	La fonction d'activation utilisée dans les couches du modèle (par défaut ReLU).
optimizer	str	'adam'	L'optimiseur utilisé pour la mise à jour des poids du modèle pendant l'entraînement (par défaut Adam).
loss_function	str	'mse'	La fonction de perte utilisée pour entraîner le modèle, typiquement l'erreur quadratique moyenne (MSE) pour la reconstruction des données.

Exemple de code :

from tensorflow.keras.layers import Input, Dense
from tensorflow.keras.models import Model

# Définir la dimension d'entrée et de la couche latente
input_dim = 784  # Par exemple, pour les images 28x28 (comme MNIST)
encoding_dim = 64  # La taille de l'espace latent

# Définir l'encodeur
input_layer = Input(shape=(input_dim,))
encoded = Dense(128, activation='relu')(input_layer)
encoded = Dense(encoding_dim, activation='relu')(encoded)

# Définir le décodeur
decoded = Dense(128, activation='relu')(encoded)
decoded = Dense(input_dim, activation='sigmoid')(decoded)

# Créer le modèle d'autoencodeur
autoencoder = Model(input_layer, decoded)

# Compiler le modèle
autoencoder.compile(optimizer='adam', loss='mse')

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

Explication du code :

Définition de la dimension d'entrée et de l'espace latent :
- input_dim = 784 définit la taille des entrées, ici pour des images 28x28 pixels (donc 784 pixels). Cela pourrait être adapté en fonction des données d'entrée.
- encoding_dim = 64 définit la taille de l'espace latent, c'est-à-dire combien de dimensions le modèle utilisera pour représenter les données d'entrée sous une forme compressée.
Définition de l'encodeur :
- input_layer = Input(shape=(input_dim,)) définit le vecteur d'entrée.
- encoded = Dense(128, activation='relu')(input_layer) ajoute une couche cachée avec 128 neurones et la fonction d'activation ReLU pour capturer des caractéristiques complexes des données d'entrée.
- encoded = Dense(encoding_dim, activation='relu')(encoded) réduit ensuite la représentation à une dimension plus petite (ici, 64 dimensions).
Définition du décodeur :
- Le décodeur prend la représentation comprimée encoded et tente de reconstruire l'entrée d'origine. Chaque couche du décodeur est également une couche dense avec une activation ReLU, à l'exception de la dernière couche qui utilise une activation sigmoïde pour obtenir des valeurs entre 0 et 1, correspondant à des pixels dans l'image (si l'on travaille avec des données normalisées entre 0 et 1).
Création et compilation du modèle :
- Le modèle d'autoencodeur est créé en combinant l'encodeur et le décodeur avec Model(input_layer, decoded).
- Le modèle est ensuite compilé avec l'optimiseur Adam et la fonction de perte mse (Mean Squared Error), qui est couramment utilisée pour les problèmes de reconstruction.
Résumé du modèle :
- autoencoder.summary() fournit un résumé du modèle, indiquant le nombre de couches et de paramètres, ainsi que la forme des entrées et sorties.

Remarques supplémentaires :

Applications : Les autoencodeurs densément connectés sont utilisés pour des tâches de compression de données, débruitage d'images, ou réduction de dimensionnalité avant de passer à un modèle de classification ou de régression.
Types d'autoencodeurs : D'autres types d'autoencodeurs existent, comme les autoencodeurs convolutifs (pour les images), les autoencodeurs variationnels (VAE) pour générer de nouvelles données ou apprendre une distribution probabiliste des données d'entrée.

Autoencodeur Convolutif (Convolutional Autoencoder)

Un autoencodeur convolutif (ou Convolutional Autoencoder) est une variante d'un autoencodeur qui utilise des couches convolutionnelles dans l'encodeur et le décodeur, contrairement aux autoencodeurs traditionnels qui sont basés sur des couches entièrement connectées. L'autoencodeur convolutif est principalement utilisé pour le traitement d'images et d'autres données structurées spatialement, car il permet de capturer des motifs locaux à travers les couches de convolution, ce qui est particulièrement adapté pour les données d'images. Il se compose de deux parties principales : L'encodeur : qui utilise des couches de convolution et de sous-échantillonnage (pooling) pour réduire la taille de l'entrée et extraire des caractéristiques importantes. Le décodeur : qui utilise des couches de convolution transposée (ou de sur-échantillonnage) pour reconstruire l'entrée à partir de la représentation compressée. Les autoencodeurs convolutifs sont souvent utilisés pour des tâches telles que le débruitage d'images, la réduction de bruit et la compression d'images.

Importation :

from tensorflow.keras.layers import Input, Conv2D, Conv2DTranspose, MaxPooling2D, UpSampling2D
from tensorflow.keras.models import Model

Attributs :

Paramètre	Type	Valeur par défaut	Description
input_shape	tuple		La forme des données d'entrée, par exemple (hauteur, largeur, canaux) pour une image (par exemple, (28, 28, 1) pour une image en niveaux de gris de 28x28).
filters	list of int		Le nombre de filtres pour chaque couche de convolution. Cela détermine la profondeur de l'espace de caractéristiques extrait.
kernel_size	int ou tuple	(3, 3)	La taille des noyaux de convolution utilisés dans chaque couche. Par défaut, un noyau de taille (3, 3) est utilisé.
strides	int ou tuple	(1, 1)	Les strides (pas) des convolutions, qui déterminent combien l'activation est décalée à chaque application du filtre.
padding	str	'same'	Le type de padding utilisé, soit 'same' (padding pour que la taille de l'entrée et de la sortie soient égales) soit 'valid' (aucun padding).
activation	str	'relu'	La fonction d'activation utilisée dans les couches de convolution (par défaut ReLU).
optimizer	str	'adam'	L'optimiseur utilisé pour la mise à jour des poids du modèle pendant l'entraînement (par défaut Adam).
loss_function	str	'mse'	La fonction de perte utilisée pour entraîner le modèle, typiquement l'erreur quadratique moyenne (MSE) pour la reconstruction des images.

Exemple de code :

from tensorflow.keras.layers import Input, Conv2D, Conv2DTranspose, MaxPooling2D
from tensorflow.keras.models import Model

# Définir la forme de l'entrée (par exemple, une image de 28x28 pixels avec 1 canal)
input_shape = (28, 28, 1)

# Définir l'encodeur
input_layer = Input(shape=input_shape)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_layer)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)

# Définir le décodeur
x = Conv2DTranspose(64, (3, 3), activation='relu', padding='same')(encoded)
x = UpSampling2D((2, 2))(x)
x = Conv2DTranspose(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
decoded = Conv2DTranspose(1, (3, 3), activation='sigmoid', padding='same')(x)

# Créer le modèle d'autoencodeur
autoencoder = Model(input_layer, decoded)

# Compiler le modèle
autoencoder.compile(optimizer='adam', loss='mse')

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

Explication du code :

Définition de la forme de l'entrée :
- input_shape = (28, 28, 1) définit la forme de l'entrée pour un réseau de neurones convolutif, ici une image en niveaux de gris de 28x28 pixels avec 1 canal.
L'encodeur :
- input_layer = Input(shape=input_shape) définit l'entrée du modèle.
- x = Conv2D(32, (3, 3), activation='relu', padding='same')(input_layer) ajoute une couche de convolution avec 32 filtres de taille (3, 3), une fonction d'activation ReLU et un padding 'same' pour conserver la taille de l'image.
- x = MaxPooling2D((2, 2), padding='same')(x) applique une opération de pooling pour réduire la dimension de l'image en divisant la largeur et la hauteur par 2, tout en conservant la profondeur.
- encoded = MaxPooling2D((2, 2), padding='same')(x) effectue un second sous-échantillonnage, réduisant davantage la taille de l'image.
Le décodeur :
- x = Conv2DTranspose(64, (3, 3), activation='relu', padding='same')(encoded) applique une couche de convolution transposée (ou déconvultion) pour agrandir la représentation comprimée tout en apprenant des informations de plus en plus fines.
- x = UpSampling2D((2, 2))(x) augmente la taille de l'image en la doublant.
- decoded = Conv2DTranspose(1, (3, 3), activation='sigmoid', padding='same')(x) génère l'image reconstruite, avec une activation sigmoïde pour obtenir des valeurs dans la plage [0, 1] (typique pour des images normalisées).
Création et compilation du modèle :
- Le modèle est créé en utilisant Model(input_layer, decoded) pour combiner l'encodeur et le décodeur.
- Le modèle est compilé avec l'optimiseur Adam et une fonction de perte mse (Mean Squared Error), souvent utilisée pour la reconstruction d'images.
Résumé du modèle :
- autoencoder.summary() fournit un résumé du modèle, indiquant la structure du réseau, le nombre de paramètres et la taille des différentes couches.

Remarques supplémentaires :

Applications : Les autoencodeurs convolutifs sont utilisés pour des applications telles que la réduction de bruit sur les images, la compression d'images, le débruitage de données, et même dans des réseaux de neurones pour des tâches génératives.
Avantages des convolutions : L'utilisation de couches convolutionnelles dans l'encodeur permet de mieux capturer les motifs spatiaux des données d'entrée, ce qui est essentiel pour traiter les images de manière efficace par rapport aux réseaux entièrement connectés traditionnels.

Autoencodeur Récurrent (Recurrent Autoencoder)

Un autoencodeur récurrent est une extension des autoencodeurs traditionnels, qui utilise des réseaux de neurones récurrents (RNN) dans l'encodeur et le décodeur. Les autoencodeurs récurrents sont utilisés pour traiter des séquences de données, comme des séries temporelles, des textes, des vidéos ou tout autre type de données où l'ordre et la dépendance temporelle sont importants. La structure d'un autoencodeur récurrent comprend : L'encodeur : Un réseau récurrent (comme un LSTM ou un GRU) qui prend une séquence d'entrée et la compresse en une représentation de taille fixe (appelée "bottleneck" ou "code"). Le décodeur : Un autre réseau récurrent qui prend cette représentation compressée et tente de reconstruire la séquence d'origine. Les autoencodeurs récurrents sont particulièrement adaptés pour la réduction de la dimensionnalité de données séquentielles, le débruitage de séries temporelles, ou encore la reconstruction de séquences d'entrée complexes.

Importation :

from tensorflow.keras.layers import Input, LSTM, RepeatVector
from tensorflow.keras.models import Model

Attributs :

Paramètre	Type	Valeur par défaut	Description
input_shape	tuple		La forme des données d'entrée (par exemple, `(timesteps, features)` pour une séquence avec des valeurs temporelles et de caractéristiques.
latent_dim	int		La taille de la couche latente (code de l'autoencodeur), c'est-à-dire la dimension de l'espace compressé.
timesteps	int		Le nombre de pas temporels dans la séquence d'entrée.
features	int		Le nombre de caractéristiques ou dimensions dans chaque pas temporel.
activation	str	'relu'	La fonction d'activation utilisée dans les couches du modèle (par défaut ReLU).
optimizer	str	'adam'	L'optimiseur utilisé pour la mise à jour des poids du modèle pendant l'entraînement (par défaut Adam).
loss_function	str	'mse'	La fonction de perte utilisée pour entraîner le modèle, généralement l'erreur quadratique moyenne (MSE) pour la reconstruction des données séquentielles.

Exemple de code :

from tensorflow.keras.layers import Input, LSTM, RepeatVector
from tensorflow.keras.models import Model

# Définir les dimensions d'entrée (par exemple, 10 timesteps, 3 caractéristiques)
input_shape = (10, 3)
latent_dim = 2  # Taille de la représentation latente

# Encoder (RNN - LSTM)
input_layer = Input(shape=input_shape)
encoded = LSTM(64, activation='relu')(input_layer)  # LSTM avec 64 unités

# Représentation latente
latent_space = RepeatVector(input_shape[0])(encoded)  # Répétition pour les timesteps

# Décoder (RNN - LSTM)
decoded = LSTM(3, activation='sigmoid', return_sequences=True)(latent_space)  # Reconstruction avec 3 caractéristiques

# Créer le modèle d'autoencodeur
autoencoder = Model(input_layer, decoded)

# Compiler le modèle
autoencoder.compile(optimizer='adam', loss='mse')

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

Explication du code :

Définition de la forme de l'entrée :
- input_shape = (10, 3) définit l'entrée comme une séquence de 10 pas temporels (timesteps) et 3 caractéristiques (features) pour chaque pas temporel. Cela pourrait correspondre, par exemple, à une séquence de 10 jours de données avec 3 caractéristiques comme la température, l'humidité, et la pression.
L'encodeur (RNN - LSTM) :
- input_layer = Input(shape=input_shape) définit l'entrée du modèle.
- encoded = LSTM(64, activation='relu')(input_layer) applique un réseau LSTM avec 64 unités à l'entrée. LSTM est un type de RNN qui permet de capturer les dépendances temporelles dans les données séquentielles. Ici, nous utilisons l'activation relu pour la couche LSTM.
- latent_space = RepeatVector(input_shape[0])(encoded) prend la sortie du LSTM et la répète pour correspondre au nombre de pas temporels de la séquence d'entrée, créant ainsi une représentation latente qui sera utilisée pour la reconstruction de la séquence.
Le décodeur (RNN - LSTM) :
- decoded = LSTM(3, activation='sigmoid', return_sequences=True)(latent_space) utilise un autre LSTM pour reconstruire la séquence d'origine. Cette couche utilise 3 unités pour correspondre au nombre de caractéristiques de la séquence d'entrée et renvoie une séquence complète grâce à l'option return_sequences=True.
Création et compilation du modèle :
- Le modèle est créé en utilisant Model(input_layer, decoded) pour combiner l'encodeur et le décodeur.
- Le modèle est compilé avec l'optimiseur Adam et une fonction de perte mse (Mean Squared Error), qui est couramment utilisée pour les problèmes de reconstruction de séquences.
Résumé du modèle :
- autoencoder.summary() fournit un résumé du modèle, indiquant la structure du réseau, le nombre de paramètres et la taille des différentes couches.

Applications des autoencodeurs récurrents :

Débruitage de séries temporelles : Les autoencodeurs récurrents peuvent être utilisés pour éliminer le bruit des séries temporelles en apprenant à reconstruire des séquences propres à partir de données bruitées.
Réduction de la dimensionnalité de données séquentielles : Comme les autoencodeurs traditionnels, ils peuvent être utilisés pour compresser des séquences longues tout en conservant les informations importantes.
Prévision de séries temporelles : Les autoencodeurs récurrents peuvent également être utilisés dans des modèles de prévision en apprenant à encoder des séquences et à les reconstruire ou à générer des prédictions futures à partir de la séquence encodée.