Deep Convolutional GAN

Deep Learning untuk Gambar dengan PyTorch

Michal Oleszak

Machine Learning Engineer

Intuisi DCGAN

Di diskriminator, ganti layer linear dengan konvolusi
Di generator, gunakan konvolusi tertranspos
Melatih GAN sering tidak stabil; perlu penyesuaian tambahan

Pedoman DCGAN

Deep Convolutional GAN (DCGAN)
Pedoman DCGAN:
- Hanya gunakan konvolusi ber-stride
- Jangan gunakan layer linear atau pooling
- Gunakan normalisasi batch
- Gunakan aktivasi ReLU di generator (kecuali layer terakhir memakai tanh)
- Gunakan aktivasi Leaky ReLU di diskriminator

grafik aktivasi

Konvolusi ber-stride

Konvolusi dengan stride 1:

Animasi konvolusi tanpa stride.

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

Konvolusi dengan stride 2:

Animasi konvolusi ber-stride.

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

Blok generator konvolusional

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

Blok generator berisi:

Konvolusi tertranspos ber-stride
Normalisasi batch
Aktivasi ReLU

Generator Konvolusional Mendalam

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)

Blok diskriminator konvolusional

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

Blok diskriminator berisi:

Konvolusi ber-stride
Normalisasi batch
Aktivasi Leaky ReLU

Diskriminator Konvolusional Mendalam

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)

Ayo berlatih!

Deep Learning untuk Gambar dengan PyTorch