Introduction aux GAN

Deep Learning pour les images avec PyTorch

Michal Oleszak

Machine Learning Engineer

Réseaux antagonistes génératifs

Image de chat générée.

https://thesecatsdonotexist.com
Generative Adversarial Networks (GAN)
Générer de nouveaux échantillons à partir des données d'entraînement

Ensemble de données Pokemon Sprites

Échantillon d'images de l'ensemble Pokemon Sprites

Ensemble Pokemon Sprites de PokeAPI
Environ 1 300 sprites de créatures ressemblant à des animaux d'un jeu vidéo Pokémon
Objectif : générer de nouveaux Pokémon !

Architecture des GAN

Schéma du flux de travail d'un GAN.

Architecture des GAN

Schéma du flux de travail d'un GAN.

Architecture des GAN

Schéma du flux de travail d'un GAN.

Architecture des GAN

Schéma du flux de travail d'un GAN.

Apprentissage des GAN

Schéma du flux de travail d'un GAN.

Générateur : apprend à produire des images réalistes
Discriminateur : apprend à distinguer les fausses des vraies images
Objectifs opposés : chaque réseau s'améliore dans sa tâche
Au final, le générateur doit produire des images réalistes

Générateur de base

class Generator(nn.Module):
    def __init__(self, in_dim, out_dim):
        super(Generator, self).__init__()

        self.generator = nn.Sequential(
            gen_block(in_dim, 256),
            gen_block(256, 512),
            gen_block(512, 1024),
            nn.Linear(1024, out_dim),
            nn.Sigmoid(),
        )


    def forward(self, x):
        return self.generator(x)

Définir la classe Generator

Suite de blocs générateurs, une couche linéaire et une activation sigmoid

def gen_block(in_dim, out_dim):
  return nn.Sequential(
      nn.Linear(in_dim, out_dim),
      nn.BatchNorm1d(out_dim),
      nn.ReLU(inplace=True)
  )

Faire passer l'entrée dans toutes les couches
Entrée : bruit de taille in_dim
Sortie : image de taille out_dim

Discriminateur de base

class Discriminator(nn.Module):
    def __init__(self, im_dim):
        super(Discriminator, self).__init__()

        self.disc = nn.Sequential(
            disc_block(im_dim, 1024),
            disc_block(1024, 512),
            disc_block(512, 256),
            nn.Linear(256, 1),
        )


    def forward(self, x):
        return self.disc(x)

Définir la classe Discriminator

Suite de blocs discriminateurs et une couche linéaire

def disc_block(in_dim, out_dim):
  return nn.Sequential(
      nn.Linear(in_dim, out_dim),
      nn.LeakyReLU(0.2)
  )

Faire passer l'entrée dans toutes les couches
Entrée : image de taille in_dim
Sortie : classification de taille 1

Passons à la pratique !

Deep Learning pour les images avec PyTorch