Derin Evrişimsel GAN

PyTorch ile Görüntüler için Deep Learning

Michal Oleszak

Machine Learning Engineer

Derin Evrişimsel GAN sezgisi

Ayrıştırıcıda, doğrusal katmanları evrişimlerle değiştirin
Üreteçte, transpoze evrişimler kullanabiliriz
GAN eğitimi çoğunlukla kararsızdır; ek ayarlar gerekir

DCGAN yönergeleri

Derin Evrişimsel GAN (DCGAN)
DCGAN yönergeleri:
- Yalnızca adımlı evrişimler kullanın
- Doğrusal veya havuzlama katmanı kullanmayın
- Yığın normlaştırma kullanın
- Üreteçte ReLU kullanın (son katman tanh kullanır)
- Ayrıştırıcıda Leaky ReLU kullanın

aktivasyon grafikleri

Adımlı evrişim

Adım boyutu 1 olan evrişim:

Adımsız bir evrişimin animasyonu.

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

Adım boyutu 2 olan evrişim:

Adımlı bir evrişimin animasyonu.

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

Evrişimsel üreteç bloğu

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

Üreteç bloğu şunlardan oluşur:

Adımlı transpoze evrişim
Yığın normlaştırma
ReLU aktivasyonu

Derin Evrişimsel Üreteç

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)

Evrişimsel ayrıştırıcı bloğu

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

Ayrıştırıcı bloğu şunlardan oluşur:

Adımlı evrişim
Yığın normlaştırma
Leaky ReLU aktivasyonu

Derin Evrişimsel Ayrıştırıcı

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!

PyTorch ile Görüntüler için Deep Learning