Reconstruction d’images MNIST à l’aide d’un autoencodeur

Reconstruction d'images MNIST avec un autoencodeur.

Introduction

Avec tant d’informations sur Internet, les chercheurs et les scientifiques cherchent à développer des méthodes de transfert de données plus efficaces et sécurisées. Les autoencodeurs se sont révélés être des outils précieux à cette fin en raison de leur architecture simple et intuitive. Généralement, une fois que l’autoencodeur est entraîné, les poids de l’encodeur peuvent être envoyés à l’expéditeur et les poids du décodeur au destinataire. Cela permet à l’expéditeur d’envoyer des données sous une forme encodée, ce qui permet de gagner du temps et de l’argent, tandis que le destinataire peut recevoir des données compressées. Cet article explore l’application passionnante des autoencodeurs dans la reconstruction d’images MNIST, en utilisant notamment la base de données numériques MNIST et le framework PyTorch en Python.

Objectifs d’apprentissage

• Cet article se concentre sur la construction d’un autoencodeur TensorFlow capable d’encoder des images MNIST.
• Nous mettrons en œuvre des fonctions pour charger et traiter des bases de données et créer des transformations dynamiques des points de données.
• Nous générerons un autoencodeur d’architecture encodeur-décodeur utilisant des images bruitées et réelles en entrée.
• Nous explorerons l’importance des autoencodeurs dans l’apprentissage profond, leurs principes d’application et leur potentiel d’amélioration des performances des modèles.

Cet article a été publié dans le cadre du Data Science Blogathon.

L’architecture des autoencodeurs

Les autoencodeurs peuvent être divisés en trois composants principaux :

Encodeur : ce module prend les données d’entrée de l’ensemble d’entraînement-validation-test et les compresse dans une représentation encodée. En général, les données d’image codées sont plus petites que les données d’entrée.

• Une armée d’auteurs exhorte les entreprises d’IA à cesser d’entraîner leurs modèles avec leur travail
• Le Conseil de sécurité des Nations Unies se réunit en raison des risques liés à l’IA
• La sortie de ChatGPT a-t-elle affecté la production de données ouvertes ? Des chercheurs examinent comment la popularité des LLMs entraîne une diminution substantielle du contenu sur StackOverflow.

Barrière : le module de barrière maintient la représentation des connaissances compressée et en fait une partie critique du réseau. La dimension des données devient une barrière décroissante.

Décodeur : le module de décodeur est essentiel pour restaurer la représentation des données à sa forme d’origine en la “décompressant”. La sortie résultante du décodeur est ensuite comparée soit à la vérité terrain, soit aux données d’entrée initiales.

Le module de décodeur aide à “décompresser” l’affichage des données et à le reconstruire sous une forme encodée. La sortie du décodeur est ensuite comparée à la vérité terrain ou aux données d’entrée d’origine.

La relation entre l’encodeur, la barrière et le décodeur

Encodeur

L’encodeur joue un rôle important dans la compression des données d’entrée grâce au module de mise en pool et au bloc de convolution. Cette compression produit une image compacte appelée bloc.

Après un délai, le décodeur entre en jeu. Il est composé de modules de haut niveau qui renvoient des caractéristiques compressées au format d’image d’origine. Dans les autoencodeurs de base, le décodeur vise à reconstruire la sortie de manière similaire à l’entrée, indépendamment de la réduction du bruit.

Cependant, dans le cas des autoencodeurs variables, l’entrée n’est pas une reconstruction de l’entrée. Au lieu de cela, il crée une image entièrement nouvelle basée sur les données d’entrée fournies au modèle. Cette différence permet aux autoencodeurs variables d’avoir un certain contrôle sur l’image résultante et de produire des résultats différents.

Barrière

Bien que la barrière soit la partie la plus petite du système nerveux, elle est très importante. Elle agit comme un élément critique qui limite le flux de données de l’encodeur au décodeur, permettant ainsi uniquement le passage des données les plus critiques. En limitant le flux, la barrière garantit que les propriétés essentielles sont préservées et utilisées lors de la récupération.

Cela représente le type de connaissances d’entrée en concevant des obstacles pour extraire le maximum d’informations de l’image. La structure encodeur-décodeur permet l’extraction d’informations précieuses à partir des images et la création de connexions significatives entre différentes entrées dans le réseau.

Cette forme compressée de traitement empêche le système nerveux de mémoriser les entrées et de souffrir d’une surcharge d’informations. En général, plus la barrière est petite, plus le risque de surcharge est faible.

Cependant, des tampons très petits peuvent limiter la quantité de données stockées, augmentant ainsi le risque de perte de données essentielles par le biais de la couche de mise en pool de l’encodeur.

Décodeur

Un décodeur est composé d’un bloc de liaison montante et de convolution qui reconstruit les interruptions de sortie.

Une fois que l’entrée atteint le décodeur qui reçoit la représentation compressée, il devient un “décompresseur”. Le rôle du décodeur est de reconstruire l’image en fonction des propriétés cachées extraites de l’image compressée. En utilisant cette propriété cachée, le décodeur reconstruit efficacement l’image en inversant le processus de compression effectué par l’encodeur.

Comment entraîner des autoencodeurs?

Avant de configurer l’autoencodeur, il y a quatre hyperparamètres importants:

• Taille du code: La taille du code, également connue sous le nom de taille de bloc, est un hyperparamètre essentiel dans l’accordage de l’autoencodeur. Elle spécifie le niveau de compression des données. De plus, la taille du code peut agir comme un terme de régularisation.
• Plusieurs couches: Comme d’autres réseaux neuronaux, la profondeur de l’encodeur et du décodeur est un hyperparamètre vital de l’autoencodeur. Augmenter la profondeur ajoute de la complexité au modèle tandis que diminuer la profondeur augmente la vitesse de traitement.
• Nombre de points dans chaque couche: Le nombre de points dans chaque couche détermine le poids utilisé dans chaque couche. En général, le nombre de points diminue à mesure que nous passons à la couche suivante de l’autoencodeur, ce qui indique que l’entrée diminue.
• Récupération de la perte: Le choix de la fonction de perte pour entraîner l’autoencodeur dépend de l’adaptation souhaitée de l’entrée à la sortie. Lorsque vous travaillez avec des données d’image, les fonctions de perte populaires pour la reconstruction incluent la perte d’erreur quadratique moyenne (MSE) et la perte L1. L’entropie croisée binaire peut également être utilisée comme perte de reconstruction si les entrées et les sorties se situent dans la plage [0,1], par exemple, avec MNIST.

Exigences

Nous avons besoin de cette bibliothèque et de fonctions d’assistance pour créer un autoencodeur dans TensorFlow.

TensorFlow: Pour commencer, nous devons importer la bibliothèque TensorFlow et tous les composants nécessaires pour créer notre modèle, lui permettant ainsi de lire et de générer des images MNIST.

NumPy: Ensuite, nous importons numpy, une puissante bibliothèque de traitement des nombres, que nous utiliserons pour le prétraitement et la réorganisation de la base de données.

Matplotlib: Nous utiliserons la bibliothèque de planification matplotlib pour visualiser et évaluer les performances du modèle.

• La fonction data_proc(dat) prend la fonction d’assistance en tant que données et les redimensionne à la taille requise par le modèle.
• La fonction d’assistance gen_noise(dat) est conçue pour accepter un tableau en entrée, appliquer du bruit gaussien et garantir que les valeurs résultantes se situent dans la plage (0,1).
• Two Arrays est une fonction d’assistance d’affichage (dat1, dat2) qui prend un tableau d’entrée et un tableau d’images prédites et les place dans deux lignes.

Construction de l’autoencodeur

Dans la partie suivante, nous apprendrons à créer un autoencodeur simple à l’aide de TensorFlow et à l’entraîner à l’aide d’images MNIST. Tout d’abord, nous décrirons les étapes pour charger et traiter les données MNIST afin de répondre à nos besoins. Une fois que les données sont correctement formatées, nous construisons et entraînons le modèle.

L’architecture du réseau se compose de trois composants principaux: l’encodeur, la zone de compression et le décodeur. L’encodeur est responsable de la compression de l’image d’entrée tout en préservant les informations précieuses. La zone de compression détermine quelles caractéristiques sont essentielles pour passer par le décodeur. Enfin, le décodeur utilise le résultat de la zone de compression pour reconstruire l’image. Pendant ce processus de reconstruction, l’autoencodeur vise à apprendre l’emplacement caché des données.

Nous devons importer certaines bibliothèques et écrire certaines fonctions pour créer un modèle permettant de lire et de créer des images MNIST. Utilisez la bibliothèque TensorFlow pour l’importer avec d’autres composants associés. Importez également la bibliothèque de traitement numérique NumPy et la bibliothèque de tracé Matplotlib. Cette bibliothèque nous aidera à effectuer certaines opérations et à visualiser les résultats.

Importer la bibliothèque

import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

from tensorflow.keras.layers import *
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Model

De plus, nous avons besoin de la mise en œuvre de certaines fonctions auxiliaires. La fonction d’initialisation est responsable de la réception d’un tableau en entrée et de la modification de la taille à la taille requise par le modèle.

def data_proc(dat):
    larr = len(dat)
    return np.reshape(dat.astype("float32") /255.0 , (larr, 28,28,1))

Nous devons également ajouter une deuxième fonction d’assistance qui fonctionne sur le tableau. Cette fonction ajoute du bruit gaussien au tableau et garantit que la valeur résultante est comprise entre 0 et 1.

def gen_noise(dat):
    return np.clip(dat + 0.4 * np.random.normal(loc=0.0, scale=1.0, size=dat.shape), 0.0, 1.0)

Évaluer les performances du modèle

Pour évaluer les performances de notre modèle, il est important de visualiser un grand nombre d’images. À cette fin, nous pouvons utiliser une fonction d’entrée qui prend deux tableaux, un ensemble d’images projetées, et une troisième fonction qui les place dans deux lignes.

def display(dat1, dat2):
    ind = np.random.randint(len(dat1), size=10)
    im1 = dat1[ind, :]
    im2 = dat2[ind, :]
    for i, (a, b) in enumerate(zip(im1, im2)):
        plt_axis = plt.subplot(2, n, i + 1)
        plt.imshow(a.reshape(28, 28))
        plt.gray()
        plt_axis.get_xaxis().set_visible(False)
        plt_axis.get_yaxis().set_visible(False)
        
        plt_axis = plt.subplot(2, n, i + 1 + n)
        plt.imshow(b.reshape(28, 28))
        plt.gray()
        plt_axis.get_xaxis().set_visible(False)
        plt_axis.get_yaxis().set_visible(False)
    plt.show()

Préparation du jeu de données

Le jeu de données MNIST a été fourni dans TensorFlow, divisé en ensembles de formation et de test. Nous pouvons charger cette base de données directement et utiliser les fonctions de traitement par défaut définies précédemment. De plus, nous générons une version bruitée de l’image MNIST originale pour la seconde moitié des données d’entrée en utilisant la fonction gen_noise que nous avons définie précédemment. Il convient de noter que le niveau de bruit d’entrée affecte la distorsion de l’image, rendant difficile la reconstruction du modèle. Nous considérerons l’image originale et le bruit comme faisant partie du processus.

(ds_train, _), (ds_test, _) = mnist.load_data()
ds_train,ds_test = data_proc(ds_train), data_proc(ds_test)
noisy_ds_train, noisy_ds_test = gen_noise(ds_train), gen_noise(ds_test)
display(ds_train, noisy_ds_train)

Définition de l’encodeur

La partie encodeur du réseau utilise des couches de convolution et de max pooling avec une activation ReLU. L’objectif est de refroidir les données d’entrée avant de les envoyer dans le réseau. La sortie souhaitée de cette étape est une version compressée des données originales. Étant donné que l’image MNIST a une taille de 28x28x1, nous créons une entrée avec une certaine forme.

inps = Input(shape=(28, 28, 1))


x = Conv2D(32, (3, 3), activation="relu", padding="same")(inps)
x = MaxPooling2D((2, 2), padding="same")(x)
x = Conv2D(32, (3, 3), activation="relu", padding="same")(x)
x = MaxPooling2D((2, 2), padding="same")(x)

Définition du goulot d’étranglement

Contrairement à d’autres éléments, le goulot d’étranglement ne nécessite pas de programmation explicite. Comme la couche de codage MaxPooling produit une sortie finale très condensée, le décodeur est entraîné à reconstruire l’image en utilisant cette représentation compressée. L’architecture du goulot d’étranglement peut être modifiée dans une implémentation d’Autoencoder plus complexe.

Définition du décodeur

Le décodeur est constitué de convolutions transposées avec un pas de 2. La dernière couche du modèle utilise une simple convolution 2D avec la fonction d’activation sigmoïde. Le but de ce composant est de reconstruire les images à partir de la représentation compressée. La convolution transposée est utilisée pour l’upsampling, permettant des pas plus grands et réduisant le nombre d’étapes nécessaires pour l’upsampling des images.

x = Conv2DTranspose(32, (3, 3),activation="relu", padding="same", strides=2)(x)
x = Conv2DTranspose(32, (3, 3),activation="relu", padding="same", strides=2)(x)
x = Conv2D(1, (3, 3), activation="sigmoid", padding="same")(x)

Entraînement du modèle

Après avoir défini le modèle, il doit être configuré avec les optimiseurs et les fonctions de perte. Dans cet article, nous utiliserons l’optimiseur Adam et sélectionnerons la fonction de perte de la cross-entropie binaire pour l’entraînement.

conv_autoenc_model = Model(inps, x)
conv_autoenc_model.compile(optimizer="adam", loss="binary_crossentropy")
conv_autoenc_model.summary()

Sortie

Une fois que le modèle est construit, nous pouvons l’entraîner en utilisant les images MNIST modifiées créées précédemment dans l’article. Le processus d’entraînement consiste à exécuter le modèle pendant 50 époques avec une taille de lot de 128. De plus, nous fournissons des données de validation pour le modèle.

conv_autoenc_model.fit(
    x=ds_train,
    y=ds_train,
    epochs=50,
    batch_size=128,
    shuffle=True,
    validation_data=(ds_test, ds_test),
)

Reconstruction des images

Une fois que nous avons entraîné le modèle, nous pouvons générer des prédictions et reconstruire des images. Nous pouvons utiliser la fonction précédemment définie pour afficher l’image résultante.

preds = conv_autoenc_model.predict(ds_test)
display(ds_test, preds)

Conclusion

Un autoencodeur est un réseau neuronal artificiel que vous pouvez utiliser pour apprendre le codage de données non supervisé. L’objectif principal est d’obtenir une représentation de faible dimension, souvent appelée codage, pour des données de haute dimension afin de réduire la dimension. Les grilles permettent une représentation et une analyse efficaces des données pour capturer les caractéristiques ou les éléments les plus importants de l’image d’entrée.

Points clés à retenir

• Les autoencodeurs sont des techniques d’apprentissage non supervisées utilisées dans les réseaux neuronaux. Ils sont conçus pour apprendre une représentation efficace des données (codage) en entraînant le réseau à filtrer les signaux indésirables.
• Les autoencodeurs ont de nombreuses applications, notamment en imagerie, en compression d’image et, dans certains cas, même en génération d’images.
• Bien que les autoencodeurs semblent simples à première vue en raison de leur base théorique simple, il peut être difficile de leur apprendre à apprendre des représentations significatives des données d’entrée.
• Les autoencodeurs ont plusieurs applications, telles que l’analyse en composantes principales (ACP), une technique de réduction de dimensionnalité, le rendu d’images et de nombreuses autres tâches.

Questions fréquemment posées

Les médias présentés dans cet article n’appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l’auteur.

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!