GANs को ट्रेन करना

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

Michal Oleszak

Machine Learning Engineer

Generator का उद्देश्य

GAN वर्कफ़्लो डायग्राम.

उद्देश्य: ऐसे फेक बनाना जो डिस्क्रिमिनेटर को धोखा दें
आइडिया: डिस्क्रिमिनेटर से जनरेटर के प्रदर्शन की जानकारी लें
डिस्क्रिमिनेटर द्वारा जनरेटर का आउटपुट ऐसे वर्गीकृत:
- Real (लेबल 1) - अच्छा, कम लॉस
- Fake (लेबल 0) - खराब, ज़्यादा लॉस

Generator लॉस

def gen_loss(gen, disc, num_images, z_dim):

    noise = torch.randn(num_images, z_dim)

    fake = gen(noise)

    disc_pred = disc(fake)

    criterion = nn.BCEWithLogitsLoss()

    gen_loss = criterion(
        disc_pred, torch.ones_like(disc_pred)
    )
    return gen_loss

रैंडम नॉइज़ परिभाषित करें
फेक इमेज जनरेट करें
फेक इमेज पर डिस्क्रिमिनेटर की प्रेडिक्शन लें
बाइनरी क्रॉस-एंट्रॉपी (BCE) क्राइटेरियन उपयोग करें
Generator लॉस: डिस्क्रिमिनेटर प्रेडिक्शन और ones टेन्सर के बीच BCE

Discriminator का उद्देश्य

GAN वर्कफ़्लो डायग्राम.

उद्देश्य: फेक और रियल इमेज को सही तरह वर्गीकृत करना
Generator के आउटपुट को फेक (लेबल 0) के रूप में वर्गीकृत होना चाहिए
रियल इमेज को रियल (लेबल 1) के रूप में वर्गीकृत होना चाहिए

Discriminator लॉस

def disc_loss(gen, disc, real, num_images, z_dim):

    criterion = nn.BCEWithLogitsLoss()

    noise = torch.randn(num_images, z_dim)

    fake = gen(noise)

    disc_pred_fake = disc(fake)

    fake_loss = criterion(
        disc_pred_fake,
        torch.zeros_like(disc_pred_fake)
    )

    disc_pred_real = disc(real)

    real_loss = criterion(
        disc_pred_real,
        torch.ones_like(disc_pred_real)
    )

    disc_loss = (real_loss + fake_loss) / 2
    return disc_loss

बाइनरी क्रॉस-एंट्रॉपी क्राइटेरियन परिभाषित करें
Generator के लिए इनपुट नॉइज़ जनरेट करें
फेक्स जनरेट करें
फेक इमेज के लिए डिस्क्रिमिनेटर की प्रेडिक्शन लें
फेक लॉस घटक निकालें
रियल इमेज के लिए डिस्क्रिमिनेटर की प्रेडिक्शन लें
रियल लॉस घटक निकालें
फाइनल लॉस: रियल और फेक लॉस का औसत

GAN ट्रेनिंग लूप

for epoch in range(num_epochs):
    for real in dataloader:
        cur_batch_size = len(real)


        disc_opt.zero_grad()

        disc_loss = disc_loss(
            gen, disc, real, cur_batch_size, z_dim=16)

        disc_loss.backward()
        disc_opt.step()


        gen_opt.zero_grad()

        gen_loss = gen_loss(
            gen, disc, cur_batch_size, z_dim=16)

        gen_loss.backward() 
        gen_opt.step()

epochs और रियल डेटा बैच पर लूप करें और करंट बैच साइज़ निकालें
डिस्क्रिमिनेटर ऑप्टिमाइज़र के ग्रेडिएंट रीसेट करें
डिस्क्रिमिनेटर लॉस निकालें
डिस्क्रिमिनेटर के ग्रेडिएंट निकालें और ऑप्टिमाइज़ेशन स्टेप करें
जनरेटर ऑप्टिमाइज़र के ग्रेडिएंट रीसेट करें
जनरेटर लॉस निकालें
जनरेटर के ग्रेडिएंट निकालें और ऑप्टिमाइज़ेशन स्टेप करें

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

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