Deep Convolutional GAN

Deep Learning pentru imagini cu PyTorch

Michal Oleszak

Machine Learning Engineer

Intuiția din spatele DCGAN

În discriminator, straturile liniare sunt înlocuite cu convoluții
În generator, se pot folosi convoluții transpuse
Antrenarea GAN-urilor este adesea instabilă; sunt necesare ajustări suplimentare

Reguli DCGAN

Deep Convolutional GAN (DCGAN)
Reguli DCGAN:
- Folosiți doar convoluții cu stride
- Evitați straturile liniare și de pooling
- Folosiți normalizarea pe loturi
- Folosiți activări ReLU în generator (ultimul strat folosește tanh)
- Folosiți activarea Leaky ReLU în discriminator

grafice de activare

Convoluție cu stride

Convoluție cu stride 1:

Animație a unei convoluții fără stride.

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

Convoluție cu stride 2:

Animație a unei convoluții cu stride.

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

Bloc convoluțional al generatorului

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

Blocul generatorului conține:

Convoluție transpusă cu stride
Normalizare pe loturi
Activare ReLU

Generator convoluțional profund

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 convoluțional al discriminatorului

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

Blocul discriminatorului conține:

Convoluție cu stride
Normalizare pe loturi
Activare Leaky ReLU

Discriminator convoluțional profund

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)

Să exersăm!

Deep Learning pentru imagini cu PyTorch