Deep Convolutional GAN

Deep Learning voor afbeeldingen met PyTorch

Michal Oleszak

Machine Learning Engineer

Intuïtie achter Deep Convolutional GAN

In de discriminator vervang je lineaire lagen door convoluties
In de generator gebruik je getransponeerde convoluties
GANs trainen is vaak instabiel; meer afstemming nodig

DCGAN-richtlijnen

Deep Convolutional GAN (DCGAN)
DCGAN-richtlijnen:
- Gebruik alleen strided convoluties
- Gebruik geen lineaire of poolinglagen
- Gebruik batch-normalisatie
- Gebruik ReLU in de generator (behalve de laatste laag: tanh)
- Gebruik Leaky ReLU in de discriminator

activatiegrafieken

Gestridede convolutie

Convolutie met stride 1:

Animatie van een niet-gestridede convolutie.

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

Convolutie met stride 2:

Animatie van een gestridede convolutie.

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

Convolutioneel generatorblok

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()
    )

Generatorblok bestaat uit:

Getransponeerde convolutie met stride
Batch-normalisatie
ReLU-activatie

Diep Convolutionele Generator

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)

Convolutioneel discriminatorblok

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),
    )

Discriminatorblok bestaat uit:

Strided convolutie
Batch-normalisatie
Leaky ReLU-activatie

Diep Convolutionele Discriminator

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)

Laten we oefenen!

Deep Learning voor afbeeldingen met PyTorch