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

Generative Adversarial Networks (GANs) দিয়ে Image Generation একটি অত্যন্ত জনপ্রিয় প্রয়োগ, যেখানে GAN দুটি নিউরাল নেটওয়ার্ক—Generator এবং Discriminator—ব্যবহার করে নতুন এবং বাস্তবসম্মত চিত্র তৈরি করতে সাহায্য করে। এই প্রক্রিয়া adversarial training নামে পরিচিত, যেখানে Generator এবং Discriminator একে অপরের বিরুদ্ধে কাজ করে এবং সেরা ফলাফল তৈরি করতে শিখে।

এখানে একটি Image Generation প্রজেক্ট তৈরি করার প্রক্রিয়া ধাপে ধাপে ব্যাখ্যা করা হবে, যেখানে আমরা একটি সাধারণ GAN মডেল তৈরি করব এবং MNIST ডেটাসেট (হ্যান্ডরিটেন ডিজিট) ব্যবহার করে চিত্র তৈরি করব।

Image Generation প্রজেক্টের জন্য প্রয়োজনীয় লাইব্রেরি:

প্রথমে, TensorFlow এবং Keras লাইব্রেরি ইনস্টল করতে হবে। এখানে আমরা TensorFlow 2.x ব্যবহার করব।

pip install tensorflow

1. ডেটাসেট লোডিং (MNIST Dataset):

এটি একটি জনপ্রিয় ডেটাসেট যা 28x28 পিক্সেল আকারে হ্যান্ডরিটেন ডিজিটের ছবি ধারণ করে। আমরা এটি Keras থেকে সরাসরি লোড করতে পারি।

import tensorflow as tf
from tensorflow.keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt

# MNIST ডেটাসেট লোড করা
(x_train, _), (_, _) = mnist.load_data()

# ডেটা স্কেল করা (0-255 এর মধ্যে আসল মান 0 থেকে 1 এর মধ্যে রূপান্তর করা)
x_train = x_train / 255.0

# 28x28 পিক্সেলের জন্য রিসাইজ এবং ফ্ল্যাট করা (প্রথমে 28x28 পিক্সেল ইমেজকে 784 পিক্সেলে রূপান্তর করা)
x_train = x_train.reshape(x_train.shape[0], 28, 28, 1)

# শো করার জন্য কয়েকটি ইমেজ
plt.imshow(x_train[0].reshape(28, 28), cmap="gray")
plt.show()

2. Generator এবং Discriminator তৈরি করা:

Generator এবং Discriminator হল GAN এর দুটি প্রধান অংশ।

Generator:

Generator একটি নিউরাল নেটওয়ার্ক যা র্যান্ডম noise vector (এটি সাধারণত একটি গাউসিয়ান বা ইউনিফর্ম ডিসট্রিবিউশন থেকে নেওয়া হয়) গ্রহণ করে এবং সেটিকে একটি বাস্তব চিত্রে রূপান্তরিত করার চেষ্টা করে।

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Reshape, Flatten, BatchNormalization, LeakyReLU

def build_generator():
    model = Sequential()
    model.add(Dense(256, input_dim=100))  # Noise input vector of size 100
    model.add(LeakyReLU(alpha=0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(1024))
    model.add(LeakyReLU(alpha=0.2))
    model.add(BatchNormalization(momentum=0.8))
    model.add(Dense(28*28*1, activation='tanh'))  # 28x28 image, grayscale
    model.add(Reshape((28, 28, 1)))
    return model

Discriminator:

Discriminator হল একটি নিউরাল নেটওয়ার্ক যা চিত্রের আসলত্ব যাচাই করে। এটি real এবং fake চিত্রের মধ্যে পার্থক্য করতে শিখে।

def build_discriminator():
    model = Sequential()
    model.add(Flatten(input_shape=(28, 28, 1)))
    model.add(Dense(1024))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(512))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(256))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Dense(1, activation='sigmoid'))  # Probability of real or fake
    return model

3. GAN (Generator + Discriminator) তৈরি করা:

GAN হল Generator এবং Discriminator এর কম্বিনেশন, যেখানে আমরা Discriminator কে ফ্রিজ করি যখন আমরা Generator প্রশিক্ষণ করি।

from tensorflow.keras.models import Model
from tensorflow.keras.optimizers import Adam

def build_gan(generator, discriminator):
    discriminator.trainable = False  # Freezing discriminator during generator training
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    return model

4. মডেল কম্পাইল এবং প্রশিক্ষণ:

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

# Optimizer for both models
optimizer = Adam(learning_rate=0.0002, beta_1=0.5)

# Build models
generator = build_generator()
discriminator = build_discriminator()
gan = build_gan(generator, discriminator)

# Compile Discriminator
discriminator.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])

# Compile GAN
gan.compile(loss='binary_crossentropy', optimizer=optimizer)

5. প্রশিক্ষণের জন্য Loop তৈরি করা:

এখন আমরা GAN প্রশিক্ষণের জন্য training loop তৈরি করব। এখানে real এবং fake ইমেজ দিয়ে ডিসক্রিমিনেটরের লস এবং জেনারেটরের লস গণনা করা হবে।

import os

def train_gan(epochs, batch_size, save_interval):
    # Real label = 1, Fake label = 0
    half_batch = batch_size // 2

    for epoch in range(epochs):
        # -------------------------
        #  প্রশিক্ষণ ডিসক্রিমিনেটর
        # -------------------------
        
        # Select random half batch of real images
        idx = np.random.randint(0, x_train.shape[0], half_batch)
        real_images = x_train[idx]
        real_labels = np.ones((half_batch, 1))  # Labels for real images

        # Generate fake images
        noise = np.random.normal(0, 1, (half_batch, 100))
        fake_images = generator.predict(noise)
        fake_labels = np.zeros((half_batch, 1))  # Labels for fake images

        # Train discriminator on real and fake images
        d_loss_real = discriminator.train_on_batch(real_images, real_labels)
        d_loss_fake = discriminator.train_on_batch(fake_images, fake_labels)

        # Total discriminator loss
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

        # -------------------------
        #  প্রশিক্ষণ জেনারেটর
        # -------------------------

        noise = np.random.normal(0, 1, (batch_size, 100))
        valid_labels = np.ones((batch_size, 1))  # Labels for fake images to be labeled as real

        # Train generator
        g_loss = gan.train_on_batch(noise, valid_labels)

        # Print the progress
        print(f"{epoch} [D loss: {d_loss[0]} | D accuracy: {100*d_loss[1]}] [G loss: {g_loss}]")

        # Save generated images at intervals
        if epoch % save_interval == 0:
            save_generated_images(epoch)

# Save generated images for visualization
def save_generated_images(epoch, examples=10, dim=(1, 10), figsize=(10, 1)):
    noise = np.random.normal(0, 1, (examples, 100))
    generated_images = generator.predict(noise)
    plt.figure(figsize=figsize)
    for i in range(examples):
        plt.subplot(dim[0], dim[1], i+1)
        plt.imshow(generated_images[i, :, :, 0], cmap='gray')
        plt.axis('off')
    plt.tight_layout()
    plt.savefig(f"gan_generated_image_epoch_{epoch}.png")
    plt.close()

# Train the GAN for 10000 epochs, with a batch size of 64 and save every 1000 epochs
train_gan(epochs=10000, batch_size=64, save_interval=1000)

6. ফলাফল দেখানো:

যত বেশি আপনি প্রশিক্ষণ চালাবেন, তত ভালো মানের চিত্র তৈরি হবে। মডেলটি প্রতি ইপোচের পর নতুন চিত্র তৈরি করে এবং generated_images ফোল্ডারে সংরক্ষণ করা হবে।

সারাংশ:

এটি একটি GAN-based Image Generation প্রজেক্ট যেখানে Generator এবং Discriminator নিউরাল নেটওয়ার্কগুলোকে প্রশিক্ষণ দিয়ে নতুন এবং বাস্তবসম্মত ইমেজ তৈরি করা হয়। আমরা MNIST ডেটাসেট ব্যবহার করেছি, কিন্তু আপনি যেকোনো ডেটাসেট ব্যবহার করে এই পদ্ধত

িটি কাস্টমাইজ করতে পারেন। GANs ইমেজ, ভয়েস, ভিডিও এবং অন্যান্য ধরণের ডেটা তৈরি করতে ব্যবহার করা যেতে পারে।