GAN convolutionnel profond

Deep Learning pour les images avec PyTorch

Michal Oleszak

Machine Learning Engineer

Intuition des GAN convolutionnels profonds

Dans le discriminateur, remplacer les couches linéaires par des convolutions
Dans le générateur, utiliser des convolutions transposées
L'entraînement des GAN est souvent instable ; prévoir d'autres réglages

Recommandations DCGAN

Deep Convolutional GAN (DCGAN)
Recommandations DCGAN :
- Utiliser seulement des convolutions à pas (strided)
- N'utiliser aucune couche linéaire ni de regroupement (pooling)
- Utiliser la normalisation par lots
- Utiliser des activations ReLU dans le générateur (sauf la dernière couche : tanh)
- Utiliser une activation Leaky ReLU dans le discriminateur

graphiques d'activation

Convolution à pas (strided)

Convolution avec un pas de 1 :

Animation d'une convolution sans pas.

nn.Conv2d(..., stride=1)

Convolution avec un pas de 2 :

Animation d'une convolution à pas.

nn.Conv2d(..., stride=2)

Bloc de générateur convolutionnel

def dc_gen_block(
    in_dim, out_dim, kernel_size, stride
):

    return nn.Sequential(
        nn.ConvTranspose2d(
            in_dim,
            out_dim, 
            kernel_size,
            stride=stride,
        ),

        nn.BatchNorm2d(out_dim),

        nn.ReLU()
    )

Le bloc du générateur comprend :

Convolution transposée à pas
Normalisation par lots
Activation ReLU

Générateur convolutionnel profond

class DCGenerator(nn.Module):
    def __init__(self, in_dim, kernel_size=4, stride=2):
        super(Generator, self).__init__()
        self.in_dim = in_dim

        self.gen = nn.Sequential(
            dc_gen_block(in_dim, 1024, kernel_size, stride),
            dc_gen_block(1024, 512, kernel_size, stride),
            dc_gen_block(512, 256, kernel_size, stride),

            nn.ConvTranspose2d(256, 3, kernel_size, stride=stride),

            nn.Tanh()
        )


    def forward(self, x):
        x = x.view(len(x), self.in_dim, 1, 1)
        return self.gen(x)

Bloc de discriminateur convolutionnel

def dc_disc_block(
    in_dim, out_dim, kernel_size, stride
):

    return nn.Sequential(
        nn.Conv2d(
            in_dim,
            out_dim,
            kernel_size,
            stride=stride,
        ),

        nn.BatchNorm2d(out_dim),

        nn.LeakyReLU(0.2),
    )

Le bloc du discriminateur comprend :

Convolution à pas
Normalisation par lots
Activation Leaky ReLU

Discriminateur convolutionnel profond

class Discriminator(nn.Module):
    def __init__(self, kernel_size=4, stride=2):
        super(Discriminator, self).__init__()

        self.disc = nn.Sequential(
            dc_disc_block(3, 512, kernel_size, stride),
            dc_disc_block(512, 1024, kernel_size, stride),
            nn.Conv2d(1024, 1, kernel_size, stride=stride),
        )


    def forward(self, x):
        x = self.disc(x)
        return x.view(len(x), -1)

Passons à la pratique !

Deep Learning pour les images avec PyTorch