डीप कन्वोल्यूशनल GAN

PyTorch के साथ इमेज के लिए डीप लर्निंग

Michal Oleszak

Machine Learning Engineer

डीप कन्वोल्यूशनल GAN की समझ

डिस्क्रिमिनेटर में, लीनियर लेयर्स को कन्वोल्यूशंस से बदलें
जनरेटर में, ट्रांसपोज़्ड कन्वोल्यूशंस इस्तेमाल कर सकते हैं
GANs का प्रशिक्षण अक्सर अस्थिर होता है, और समायोजन चाहिए

DCGAN दिशानिर्देश

डीप कन्वोल्यूशनल GAN (DCGAN)
DCGAN दिशानिर्देश:
- केवल स्ट्राइडेड कन्वोल्यूशंस इस्तेमाल करें
- कोई लीनियर या पूलिंग लेयर न रखें
- बैच नॉर्मलाइज़ेशन इस्तेमाल करें
- जनरेटर में ReLU एक्टिवेशन रखें (आखिरी लेयर में tanh)
- डिस्क्रिमिनेटर में Leaky ReLU इस्तेमाल करें

एक्टिवेशन ग्राफ

स्ट्राइडेड कन्वोल्यूशन

स्ट्राइड 1 वाली कन्वोल्यूशन:

अनस्ट्राइडेड कन्वोल्यूशन का एनीमेशन.

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

स्ट्राइड 2 वाली कन्वोल्यूशन:

स्ट्राइडेड कन्वोल्यूशन का एनीमेशन.

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

कन्वोल्यूशनल जनरेटर ब्लॉक

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

जनरेटर ब्लॉक में शामिल हैं:

स्ट्राइडेड ट्रांसपोज़्ड कन्वोल्यूशन
बैच नॉर्मलाइज़ेशन
ReLU एक्टिवेशन

डीप कन्वोल्यूशनल जनरेटर

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)

कन्वोल्यूशनल डिस्क्रिमिनेटर ब्लॉक

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

डिस्क्रिमिनेटर ब्लॉक में शामिल हैं:

स्ट्राइडेड कन्वोल्यूशन
बैच नॉर्मलाइज़ेशन
Leaky ReLU एक्टिवेशन

डीप कन्वोल्यूशनल डिस्क्रिमिनेटर

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)

अभ्यास करते हैं!

PyTorch के साथ इमेज के लिए डीप लर्निंग