Machine Learning Gluon API দিয়ে GAN তৈরি গাইড ও নোট

Generative Adversarial Network (GAN) একটি শক্তিশালী নিউরাল নেটওয়ার্ক আর্কিটেকচার যা দুটি মডেল, Generator এবং Discriminator, এর মধ্যে প্রতিদ্বন্দ্বিতা তৈরি করে। Generator নতুন ডেটা তৈরি করার চেষ্টা করে, এবং Discriminator সেই ডেটাকে আসল বা নকল হিসেবে চিহ্নিত করার চেষ্টা করে। এই প্রতিদ্বন্দ্বিতার ফলে, Generator সময়ের সাথে আরও ভাল, বাস্তবসম্মত ডেটা তৈরি করতে সক্ষম হয়।

এখানে, MXNet Gluon API ব্যবহার করে একটি সহজ GAN মডেল তৈরি করা হবে। আমরা দুটি মডেল তৈরি করব:

1. Generator: এটি যেকোনো র্যান্ডম নইস বা ইনপুট থেকে নতুন ডেটা তৈরি করবে।
2. Discriminator: এটি আসল এবং নকল ডেটা পার্থক্য করবে।

1. GAN আর্কিটেকচার

GAN-এর মধ্যে দুটি অংশ থাকে:

• Generator: এটি ইনপুট হিসেবে র্যান্ডম শোর (noise) নেয় এবং সেগুলিকে ডেটাতে রূপান্তরিত করে। এর লক্ষ্য হলো এমন ডেটা তৈরি করা যা Discriminator ভুলভাবে আসল বলে চিহ্নিত করতে পারে।
• Discriminator: এটি বাস্তব ডেটা এবং Generator এর তৈরি নকল ডেটার মধ্যে পার্থক্য শিখে। এর লক্ষ্য হলো নকল ডেটা চিহ্নিত করা।

Gluon API দিয়ে Generator এবং Discriminator তৈরি করা:

import mxnet as mx
from mxnet.gluon import nn
from mxnet import nd

# Generator তৈরি করা
class Generator(nn.Block):
    def __init__(self, **kwargs):
        super(Generator, self).__init__(**kwargs)
        self.dense1 = nn.Dense(256, activation='relu')
        self.dense2 = nn.Dense(512, activation='relu')
        self.dense3 = nn.Dense(1024, activation='relu')
        self.output = nn.Dense(28 * 28, activation='sigmoid')  # 28x28 pixel image output (MNIST)

    def forward(self, x):
        x = self.dense1(x)
        x = self.dense2(x)
        x = self.dense3(x)
        x = self.output(x)
        return x.reshape((-1, 28, 28))

# Discriminator তৈরি করা
class Discriminator(nn.Block):
    def __init__(self, **kwargs):
        super(Discriminator, self).__init__(**kwargs)
        self.dense1 = nn.Dense(1024, activation='relu')
        self.dense2 = nn.Dense(512, activation='relu')
        self.dense3 = nn.Dense(256, activation='relu')
        self.output = nn.Dense(1, activation='sigmoid')  # Binary output (real or fake)

    def forward(self, x):
        x = self.dense1(x)
        x = self.dense2(x)
        x = self.dense3(x)
        x = self.output(x)
        return x

2. মডেল ইনিশিয়ালাইজেশন এবং অপটিমাইজার

এখন আমাদের Generator এবং Discriminator মডেল তৈরি হয়ে গেছে, আসুন এগুলিকে ইনিশিয়ালাইজ করি এবং তাদের জন্য অপটিমাইজার সেট করি।

# মডেল ইনিশিয়ালাইজেশন
generator = Generator()
discriminator = Discriminator()

# মডেল ইনিশিয়ালাইজ করা
generator.initialize(ctx=mx.cpu())
discriminator.initialize(ctx=mx.cpu())

# অপটিমাইজার সেট করা
trainer_g = mx.gluon.Trainer(generator.collect_params(), 'adam', {'learning_rate': 0.0002, 'beta1': 0.5})
trainer_d = mx.gluon.Trainer(discriminator.collect_params(), 'adam', {'learning_rate': 0.0002, 'beta1': 0.5})

এখানে:

• Adam optimizer ব্যবহার করা হয়েছে।
• Learning rate এবং beta1 প্যারামিটারগুলো সাধারণভাবে GAN প্রশিক্ষণের জন্য ব্যবহার করা হয়।

3. লস ফাংশন

GAN এর দুটি মডেল আছে, তাই দুটি আলাদা লস ফাংশন ব্যবহার করা হয়:

• Discriminator Loss: এটি সত্য (real) এবং নকল (fake) ডেটার মধ্যে পার্থক্য শিখতে সাহায্য করে।
• Generator Loss: এটি Discriminator কে বিভ্রান্ত করার জন্য ডিজাইন করা হয়, যাতে Generator এমন ডেটা তৈরি করতে পারে যা Discriminator আসল বলে ভুল করে।

# লস ফাংশন
loss_fn = mx.gluon.loss.SigmoidBinaryCrossEntropyLoss()

4. প্রশিক্ষণ লুপ

এখন আমাদের তৈরি করা Generator এবং Discriminator মডেল দুটি প্রশিক্ষণ করতে হবে। প্রশিক্ষণের সময়, Discriminator বাস্তব এবং নকল ছবি পার্থক্য শিখবে, এবং Generator এমন ছবি তৈরি করবে যা Discriminator ভুলভাবে আসল বলে চিনবে।

import numpy as np

# Dummy data (fake noise for generator input)
z = nd.random.normal(0, 1, shape=(64, 100))  # 64 samples, 100 dimensions for noise vector

# Training loop
epochs = 100
for epoch in range(epochs):
    for i in range(100):  # 100 steps per epoch
        # Real data (MNIST dataset could be used here)
        real_data = nd.random.normal(0, 1, shape=(64, 28*28))  # Fake real data for illustration

        # Training the Discriminator
        with mx.autograd.record():
            real_output = discriminator(real_data)
            fake_data = generator(z)
            fake_output = discriminator(fake_data.detach())  # Detach to avoid computing gradient for generator

            # Loss for real and fake data
            loss_d_real = loss_fn(real_output, nd.ones_like(real_output))
            loss_d_fake = loss_fn(fake_output, nd.zeros_like(fake_output))
            loss_d = loss_d_real + loss_d_fake  # Total discriminator loss

        loss_d.backward()
        trainer_d.step(real_data.shape[0])

        # Training the Generator
        with mx.autograd.record():
            fake_output_gen = discriminator(fake_data)
            loss_g = loss_fn(fake_output_gen, nd.ones_like(fake_output_gen))  # Generator loss

        loss_g.backward()
        trainer_g.step(fake_data.shape[0])

    print(f"Epoch {epoch+1}, D Loss: {loss_d.mean().asscalar()}, G Loss: {loss_g.mean().asscalar()}")

5. GAN মডেলের মূল্যায়ন

প্রশিক্ষণ শেষে, Generator মডেলটি নতুন ডেটা (ইমেজ) তৈরি করবে। সাধারণত, Discriminator মডেলের পরিসংখ্যান ব্যবহার করে Generator এর পারফরম্যান্স মূল্যায়ন করা হয়। এছাড়াও, তৈরি করা ইমেজগুলি Visualize করার জন্য Matplotlib ব্যবহার করা যেতে পারে।

import matplotlib.pyplot as plt

# Generate some fake data
fake_data = generator(z)

# Plot the generated data
plt.imshow(fake_data[0].asnumpy().reshape(28, 28), cmap='gray')
plt.show()

সারাংশ

• GAN (Generative Adversarial Network) একটি শক্তিশালী আর্কিটেকচার যা দুটি মডেল (Generator এবং Discriminator) এর মধ্যে প্রতিদ্বন্দ্বিতার মাধ্যমে ডেটা তৈরি করে।
• Gluon API ব্যবহার করে আপনি সহজেই Generator এবং Discriminator তৈরি করতে পারেন, এবং Adam optimizer সহ প্রশিক্ষণ দিতে পারেন।
• GAN এর প্রশিক্ষণ প্রক্রিয়া দুইটি মডেলের জন্য আলাদা লস ফাংশন ব্যবহার করে এবং এর উদ্দেশ্য হল Generator কে এমন ডেটা তৈরি করতে শেখানো যা Discriminator আসল বলে ভুলভাবে চিনে।

এটি একটি সাধারণ GAN মডেল তৈরি করার পদ্ধতি, যা আপনি আপনার প্রোজেক্টে ব্যবহার করতে পারেন।