GAN Tích chập Sâu

Deep Learning cho Ảnh với PyTorch

Michal Oleszak

Machine Learning Engineer

Trực giác về GAN tích chập sâu

Ở bộ phân biệt, thay tầng tuyến tính bằng tích chập
Ở bộ sinh, dùng tích chập chuyển vị
Huấn luyện GAN thường không ổn định, cần tinh chỉnh thêm

Hướng dẫn DCGAN

Deep Convolutional GAN (DCGAN)
Hướng dẫn DCGAN:
- Chỉ dùng tích chập có bước nhảy
- Không dùng tầng tuyến tính hoặc pooling
- Dùng chuẩn hóa theo lô
- Dùng ReLU trong bộ sinh (trừ tầng cuối dùng tanh)
- Dùng Leaky ReLU trong bộ phân biệt

đồ thị hàm kích hoạt

Tích chập có bước nhảy (Strided convolution)

Tích chập với bước nhảy 1:

Hoạt ảnh tích chập không bước nhảy.

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

Tích chập với bước nhảy 2:

Hoạt ảnh tích chập có bước nhảy.

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

Khối sinh tích chập

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

Khối sinh gồm:

Tích chập chuyển vị có bước nhảy
Chuẩn hóa theo lô
Kích hoạt ReLU

Bộ sinh tích chập sâu

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)

Khối phân biệt tích chập

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

Khối phân biệt gồm:

Tích chập bước nhảy (stride)
Chuẩn hóa theo lô
Kích hoạt Leaky ReLU

Bộ phân biệt tích chập sâu

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 cho Ảnh với PyTorch