Maîtrisez le Deep Learning : Créez un Autoencodeur Convolutionnel Performant

Vous souhaitez explorer le monde fascinant du deep learning et des réseaux de neurones convolutionnels ? Cet article vous guide pas à pas dans la création d'un autoencodeur convolutionnel performant, en mettant l'accent sur son fonctionnement et ses applications. Découvrez comment utiliser cet outil puissant pour l'extraction de caractéristiques et la reconstruction d'images!

Pourquoi Utiliser les Autoencodeurs Convolutionnels ?

Les réseaux convolutionnels (Convnets) excellent dans l'extraction de caractéristiques à partir d'images. Mais saviez-vous qu'ils peuvent aussi reconstruire ces images à partir de leurs caractéristiques ? Les autoencodeurs convolutionnels exploitent cette capacité pour diverses applications. Ils permettent de passer d'une représentation matricielle d'une image à un vecteur, puis inversement.

Architecte VGG16

Extraction de Caractéristiques : Le Secret des Convnets

Les couches de convolution dans un Convnet sont conçues pour extraire des caractéristiques clés des images. Prenons l'exemple du VGG-16. La partie du réseau entre la couche d'entrée et l'étape où les cartes de caractéristiques 7 x 7 x 512 sont aplaties sert d'extracteur de caractéristiques. Un autoencodeur convolutionnel tire parti de cela. Il prend une image et la réduit à un vecteur de caractéristiques, puis tente de recréer l'image à partir de ce vecteur.

Comprendre la Structure d'un Autoencodeur

Un autoencodeur est composé de trois éléments essentiels, l'encodeur, le bottleneck (ou goulot d'étranglement), et le décodeur.

Schéma d'un autoencodeur

Encodeur: C'est le Convnet qui extrait les caractéristiques les plus importantes de l'image.
Bottleneck (Goulot d'étranglement): Cette couche compresse le vecteur de caractéristiques, forçant le décodeur à apprendre des mappings complexes.
Décodeur: Ce second Convnet tente de reconstruire l'image originale à partir du vecteur compressé.

Entraînement Pratique : Créez Votre Autoencodeur en PyTorch

Passons à la pratique ! Nous allons entraîner un autoencodeur convolutionnel en PyTorch. Voici les premières étapes :

Importez les librairies nécessaires :

 import torch
 import torch.nn as nn
 import torch.nn.functional as F
 import torchvision
 import torchvision.transforms as transforms
 import torchvision.datasets as Datasets
 from torch.utils.data import Dataset, DataLoader
 import numpy as np
 import matplotlib.pyplot as plt
 import cv2
 from tqdm.notebook import tqdm
 from tqdm import tqdm as tqdm_regular
 import seaborn as sns
 from torchvision.utils import make_grid
 import random

 # Configuration du GPU
 if torch.cuda.is_available():
  device = torch.device('cuda:0')
  print('Utilisation du GPU')
 else:
  device = torch.device('cpu')
  print('Utilisation du CPU')

Préparez les données: Nous utiliserons le dataset CIFAR-10 pour notre démo.

 # Chargement des données d'entraînement
 training_set = Datasets.CIFAR10(root='./', download=True,
  transform=transforms.ToTensor())

 # Chargement des données de validation
 validation_set = Datasets.CIFAR10(root='./', download=True, train=False,
  transform=transforms.ToTensor())

Extrayez les images:

 def extract_each_class(dataset):
  """
  Cette fonction recherche et retourne
  une image par classe
  """
  images = []
  ITERATE = True
  i = 0
  j = 0

  while ITERATE:
   for label in tqdm_regular(dataset.targets):
    if label==j:
     images.append(dataset.data[i])
     print(f'classe {j} trouvée')
     i+=1
     j+=1
     if j==10:
      ITERATE = False
     else:
      i+=1

  return images


 # Extraction des images d'entraînement
 training_images = [x for x in training_set.data]

 # Extraction des images de validation
 validation_images = [x for x in validation_set.data]

 # Extraction des images de test pour la visualisation
 test_images = extract_each_class(validation_set)

Créez une classe Dataset PyTorch personnalisée:

 # Définition de la classe Dataset
 class CustomCIFAR10(Dataset):
  def __init__(self, data, transforms=None):
   self.data = data
   self.transforms = transforms

  def __len__(self):
   return len(self.data)

  def __getitem__(self, idx):
   image = self.data[idx]

   if self.transforms!=None:
    image = self.transforms(image)
   return image


 # Création des datasets PyTorch
 training_data = CustomCIFAR10(training_images, transforms=transforms.Compose([transforms.ToTensor(),
   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]))
 validation_data = CustomCIFAR10(validation_images, transforms=transforms.Compose([transforms.ToTensor(),
   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]))
 test_data = CustomCIFAR10(test_images, transforms=transforms.Compose([transforms.ToTensor(),
   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]))

Définir l'Architecture de l'Autoencodeur Convolutionnel

Nous allons maintenant définir l'architecture de notre autoencodeur personnalisé. L'encodeur prendra des images 32 x 32 avec 3 canaux et produira 64 cartes de caractéristiques 8 x 8. Ces cartes seront aplaties en un vecteur de 4096 éléments, puis compressées en 200 éléments dans le bottleneck. Le décodeur effectuera l'opération inverse pour reconstruire l'image.

Description de l'autoencodeur

Implémentons cette architecture en code:

 # Définition de l'encodeur
 class Encoder(nn.Module):
  def __init__(self, in_channels=3, out_channels=16, latent_dim=200, act_fn=nn.ReLU()):
   super().__init__()

   self.net = nn.Sequential(
    nn.Conv2d(in_channels, out_channels, 3, padding=1), # (32, 32)
    act_fn,
    nn.Conv2d(out_channels, out_channels, 3, padding=1),
    act_fn,
    nn.Conv2d(out_channels, 2*out_channels, 3, padding=1, stride=2), # (16, 16)
    act_fn,
    nn.Conv2d(2*out_channels, 2*out_channels, 3, padding=1),
    act_fn,
    nn.Conv2d(2*out_channels, 4*out_channels, 3, padding=1, stride=2), # (8, 8)
    act_fn,
    nn.Conv2d(4*out_channels, 4*out_channels, 3, padding=1),
    act_fn,
    nn.Flatten(),
    nn.Linear(4*out_channels*8*8, latent_dim),
    act_fn
   )

  def forward(self, x):
   x = x.view(-1, 3, 32, 32)
   output = self.net(x)
   return output


 # Définition du décodeur
 class Decoder(nn.Module):
  def __init__(self, in_channels=3, out_channels=16, latent_dim=200, act_fn=nn.ReLU()):
   super().__init__()

   self.out_channels = out_channels

   self.linear = nn.Sequential(
    nn.Linear(latent_dim, 4*out_channels*8*8),
    act_fn
   )

   self.conv = nn.Sequential(
    nn.ConvTranspose2d(4*out_channels, 4*out_channels, 3, padding=1), # (8, 8)
    act_fn,
    nn.ConvTranspose2d(4*out_channels, 2*out_channels, 3, padding=1,
     stride=2, output_padding=1), # (16, 16)
    act_fn,
    nn.ConvTranspose2d(2*out_channels, 2*out_channels, 3, padding=1),
    act_fn,
    nn.ConvTranspose2d(2*out_channels, out_channels, 3, padding=1,
     stride=2, output_padding=1), # (32, 32)
    act_fn,
    nn.ConvTranspose2d(out_channels, out_channels, 3, padding=1),
    act_fn,
    nn.ConvTranspose2d(out_channels, in_channels, 3, padding=1)
   )

  def forward(self, x):
   output = self.linear(x)
   output = output.view(-1, 4*self.out_channels, 8, 8)
   output = self.conv(output)
   return output


 # Définition de l'autoencodeur
 class Autoencoder(nn.Module):
  def __init__(self, encoder, decoder):
   super().__init__()
   self.encoder = encoder
   self.encoder.to(device)

   self.decoder = decoder
   self.decoder.to(device)

  def forward(self, x):
   encoded = self.encoder(x)
   decoded = self.decoder(encoded)
   return decoded

Entraînement et Visualisation des Résultats

Pour simplifier l'entraînement et la validation, nous allons définir une classe spécifique. Cela nous permettra de visualiser les résultats de la reconstruction d'image à chaque époque.

 class ConvolutionalAutoencoder():
  def __init__(self, autoencoder):
   self.network = autoencoder
   self.optimizer = torch.optim.Adam(self.network.parameters(), lr=1e-3)

  def train(self, loss_function, epochs, batch_size,
    training_set, validation_set, test_set):

   # Création du log
   log_dict = {
    'training_loss_per_batch': [],
    'validation_loss_per_batch': [],
    'visualizations': []
   }

   # Fonction d'initialisation des poids
   def init_weights(module):
    if isinstance(module, nn.Conv2d):
     torch.nn.init.xavier_uniform_(module.weight)
     module.bias.data.fill_(0.01)
    elif isinstance(module, nn.Linear):
     torch.nn.init.xavier_uniform_(module.weight)
     module.bias.data.fill_(0.01)

   # Initialisation des poids du réseau
   self.network.apply(init_weights)

   # Création des dataloaders
   train_loader = DataLoader(training_set, batch_size)
   val_loader = DataLoader(validation_set, batch_size)
   test_loader = DataLoader(test_set, 10)

   # Configuration du Convnet en mode entraînement
   self.network.train()
   self.network.to(device)

   for epoch in range(epochs):
    print(f'Epoch {epoch+1}/{epochs}')
    train_losses = []

    #------------
    # ENTRAÎNEMENT
    #------------
    print('entraînement...')
    for images in tqdm(train_loader):
     # Remise des gradients à zéro
     self.optimizer.zero_grad()
     # Envoi des images au GPU
     images = images.to(device)
     # Reconstruction des images
     output = self.network(images)
     # Calcul de la loss
     loss = loss_function(output, images.view(-1, 3, 32, 32))
     # Calcul des gradients
     loss.backward()
     # Optimisation des poids
     self.optimizer.step()

     #--------------
     # LOGGING
     #--------------
     log_dict['training_loss_per_batch'].append(loss.item())

    #--------------
    # VALIDATION
    #--------------
    print('validation...')
    for val_images in tqdm(val_loader):
     with torch.no_grad():
      # Envoi des images de validation au GPU
      val_images = val_images.to(device)
      # Reconstruction des images
      output = self.network(val_images)
      # Calcul de la loss de validation
      val_loss = loss_function(output, val_images.view(-1, 3, 32, 32))

     #--------------
     # LOGGING
     #--------------
     log_dict['validation_loss_per_batch'].append(val_loss.item())


    #--------------
    # VISUALISATION
    #--------------
    print(f'training_loss: {round(loss.item(), 4)} validation_loss: {round(val_loss.item(), 4)}')

    for test_images in test_loader:
     # Envoi des images de test au GPU
     test_images = test_images.to(device)
     with torch.no_grad():
      # Reconstruction des images de test
      reconstructed_imgs = self.network(test_images)
      # Renvoi des images reconstruites et originales au CPU pour la visualisation
      reconstructed_imgs = reconstructed_imgs.cpu()
      test_images = test_images.cpu()

     # Visualisation
     imgs = torch.stack([test_images.view(-1, 3, 32, 32), reconstructed_imgs],
       dim=1).flatten(0,1)
     grid = make_grid(imgs, nrow=10, normalize=True, padding=1)
     grid = grid.permute(1, 2, 0)
     plt.figure(dpi=170)
     plt.title('Original/Reconstructed')
     plt.imshow(grid)
     log_dict['visualizations'].append(grid)
     plt.axis('off')
     plt.show()

   return log_dict

  def autoencode(self, x):
   return self.network(x)

  def encode(self, x):
   encoder = self.network.encoder
   return encoder(x)

  def decode(self, x):
   decoder = self.network.decoder
   return decoder(x)

Enfin, initialisons et entraînons notre modèle autoencodeur :

 # Entraînement du modèle
 model = ConvolutionalAutoencoder(Autoencoder(Encoder(), Decoder()))

 log_dict = model.train(nn.MSELoss(), epochs=10, batch_size=64,
  training_set=training_data, validation_set=validation_data,
  test_set=test_data)

Optimisation du Bottleneck pour une Meilleure Généralisation

La taille du bottleneck est cruciale. Un bottleneck trop petit peut entraîner une perte d'informations importante, tandis qu'un bottleneck trop grand peut empêcher le décodeur d'apprendre des représentations efficaces. Il faut trouver un équilibre pour une bonne généralisation.

Comparaison des latents

En résumé, la création d'un autoencodeur convolutionnel performant demande un équilibre entre architecture, données et entraînement. En comprenant chaque composant et en expérimentant, vous serez en mesure de créer des modèles puissants pour l'extraction de caractéristiques, la réduction de dimension et la génération d'images.