GAN দিয়ে Image Generation প্রজেক্ট

Generative Adversarial Networks (GANs) হল একটি শক্তিশালী মডেল যা একে অপরের বিরুদ্ধে কাজ করে দুইটি নিউরাল নেটওয়ার্ক নিয়ে গঠিত: জেনারেটর এবং ডিসক্রিমিনেটর। GANs প্রধানত নতুন এবং বাস্তবসম্মত ডেটা তৈরি করতে ব্যবহৃত হয়, যেমন চিত্র, শব্দ বা ভিডিও।

এখানে আমরা PyTorch দিয়ে একটি সহজ GAN মডেল তৈরি করব যা MNIST (হ্যান্ডরাইটেন ডিজিট) ডেটাসেট থেকে চিত্র তৈরি করবে।

১. GAN এর মৌলিক ধারণা

1. জেনারেটর (Generator): এটি নতুন এবং বাস্তবসম্মত ডেটা তৈরি করতে শেখে। জেনারেটর হল একটি নিউরাল নেটওয়ার্ক যা কোনও র্যান্ডম নইস থেকে একটি চিত্র তৈরি করার চেষ্টা করে।
2. ডিসক্রিমিনেটর (Discriminator): এটি যাচাই করে চিত্রটি আসল (এমনকি একটি ডেটাসেট থেকে এসেছে) নাকি জেনারেটর দ্বারা তৈরি হয়েছে।

এরা একে অপরকে উন্নত করতে সহায়ক হয়:

• জেনারেটর উন্নত হয় যখন এটি ডিসক্রিমিনেটর কে ভুল প্রমাণিত করতে পারে।
• ডিসক্রিমিনেটর উন্নত হয় যখন এটি সঠিকভাবে ফেক এবং রিয়েল চিত্র আলাদা করতে পারে।

এটি একটি অ্যাডভারসেরিয়াল (বিরোধী) পরিবেশ, যার মধ্যে দুটি নেটওয়ার্ক একে অপরের সাথে প্রতিদ্বন্দ্বিতা করে।

২. GAN মডেল তৈরি করা

এই উদাহরণে, আমরা PyTorch ব্যবহার করব, এবং MNIST ডেটাসেট থেকে হাতের লেখা সংখ্যা তৈরির জন্য GAN মডেলটি তৈরি করব।

প্রয়োজনীয় লাইব্রেরি ইনস্টলেশন

pip install torch torchvision matplotlib

সোর্স কোড:

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import matplotlib.pyplot as plt

# জেনারেটর মডেল
class Generator(nn.Module):
    def __init__(self):
        super(Generator, self).__init__()
        self.fc1 = nn.Linear(100, 256)
        self.fc2 = nn.Linear(256, 512)
        self.fc3 = nn.Linear(512, 1024)
        self.fc4 = nn.Linear(1024, 28*28)  # MNIST Image Size 28x28
        self.relu = nn.ReLU()
        self.tanh = nn.Tanh()

    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.relu(self.fc3(x))
        x = self.tanh(self.fc4(x))
        return x.view(-1, 1, 28, 28)  # 28x28 Image

# ডিসক্রিমিনেটর মডেল
class Discriminator(nn.Module):
    def __init__(self):
        super(Discriminator, self).__init__()
        self.fc1 = nn.Linear(28*28, 1024)
        self.fc2 = nn.Linear(1024, 512)
        self.fc3 = nn.Linear(512, 256)
        self.fc4 = nn.Linear(256, 1)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = x.view(-1, 28*28)  # Flatten Image
        x = self.relu(self.fc1(x))
        x = self.relu(self.fc2(x))
        x = self.relu(self.fc3(x))
        x = self.sigmoid(self.fc4(x))
        return x

# ডিসক্রিমিনেটর এবং জেনারেটর ইনস্ট্যান্স তৈরি
generator = Generator()
discriminator = Discriminator()

# GPU ব্যবহার করার জন্য
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
generator.to(device)
discriminator.to(device)

# লস ফাংশন এবং অপটিমাইজার
criterion = nn.BCELoss()  # Binary Cross-Entropy Loss
lr = 0.0002
optimizer_g = optim.Adam(generator.parameters(), lr=lr, betas=(0.5, 0.999))
optimizer_d = optim.Adam(discriminator.parameters(), lr=lr, betas=(0.5, 0.999))

# ডেটাসেট লোড
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
mnist = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
data_loader = DataLoader(mnist, batch_size=64, shuffle=True)

# ট্রেনিং ফাংশন
def train(num_epochs=10):
    for epoch in range(num_epochs):
        for real_images, _ in data_loader:
            real_images = real_images.to(device)
            batch_size = real_images.size(0)
            labels_real = torch.ones(batch_size, 1).to(device)
            labels_fake = torch.zeros(batch_size, 1).to(device)

            # ---- ডিসক্রিমিনেটর ট্রেনিং ----
            optimizer_d.zero_grad()

            # রিয়েল ইমেজের জন্য লস
            output_real = discriminator(real_images)
            loss_real = criterion(output_real, labels_real)

            # ফেক ইমেজ (জেনারেটর থেকে) এর জন্য লস
            noise = torch.randn(batch_size, 100).to(device)
            fake_images = generator(noise)
            output_fake = discriminator(fake_images.detach())
            loss_fake = criterion(output_fake, labels_fake)

            # মোট ডিসক্রিমিনেটর লস
            loss_d = loss_real + loss_fake
            loss_d.backward()
            optimizer_d.step()

            # ---- জেনারেটর ট্রেনিং ----
            optimizer_g.zero_grad()

            # ডিসক্রিমিনেটরের ভুল প্রতিক্রিয়া ব্যবহার করে জেনারেটর ট্রেনিং
            output_fake = discriminator(fake_images)
            loss_g = criterion(output_fake, labels_real)
            loss_g.backward()
            optimizer_g.step()

        print(f"Epoch [{epoch+1}/{num_epochs}], Loss D: {loss_d.item()}, Loss G: {loss_g.item()}")

        # কিছু উদাহরণ ছবি প্রদর্শন
        if (epoch + 1) % 5 == 0:
            with torch.no_grad():
                fake_images = generator(torch.randn(16, 100).to(device))
                fake_images = fake_images.cpu().numpy()
                plt.figure(figsize=(4, 4))
                for i in range(16):
                    plt.subplot(4, 4, i+1)
                    plt.imshow(fake_images[i].reshape(28, 28), cmap='gray')
                    plt.axis('off')
                plt.show()

# মডেল ট্রেনিং শুরু
train(20)

৩. প্রকল্পের ব্যাখ্যা

• জেনারেটর (Generator): Generator ক্লাসটি 100 ডাইমেনশনাল র্যান্ডম নইস ইনপুট নেয় এবং একাধিক লিনিয়ার ট্রান্সফরমেশন দিয়ে একটি 28x28 চিত্র আউটপুট তৈরি করে।
• ডিসক্রিমিনেটর (Discriminator): Discriminator ক্লাসটি ইনপুট হিসেবে 28x28 চিত্র নেয় এবং এটি মূল্যায়ন করে যে চিত্রটি আসল নাকি তৈরি করা হয়েছে।
• লস ফাংশন: Binary Cross-Entropy ব্যবহার করা হয় যাতে রিয়েল এবং ফেক চিত্রের মধ্যে পার্থক্য করা যায়।
• অপটিমাইজার: Adam Optimizer ব্যবহার করা হয় যা মডেলের ওজন আপডেট করতে সহায়ক।
• ট্রেনিং: train() ফাংশনটি 20 ইপোক্সে মডেল ট্রেনিং করে এবং প্রতি 5 ইপোক্স পর একটি নতুন ইমেজ তৈরি করে।

৪. ফলাফল

ট্রেনিংয়ের পর, GAN মডেলটি র্যান্ডম নইস থেকে বাস্তবসম্মত চিত্র তৈরি করতে সক্ষম হবে। আপনি প্রতি 5 ইপোক্স পর মডেলটি কিছু উদাহরণ চিত্র দেখাতে পাবেন, যা জেনারেটরের তৈরি করা চিত্র।

৫. সারাংশ

এই প্রজেক্টে, আমরা একটি সাধারণ Generative Adversarial Network (GAN) তৈরি করেছি যা MNIST ডেটাসেট ব্যবহার করে চিত্র তৈরি করতে পারে। GAN মডেলটি একটি জেনারেটর এবং ডিসক্রিমিনেটর নিয়ে গঠিত, যা একে অপরের সাথে প্রতিদ্বন্দ্বিতা করে, এবং শেষে বাস্তবসম্মত চিত্র তৈরি করতে সক্ষম হয়।