GAN মডেল Train এবং Evaluate করা

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

GAN মডেল ট্রেন এবং ইভ্যালুয়েট করার প্রক্রিয়া কিছুটা বিশেষ এবং বেশ কিছু ধাপ থাকে, যা নিচে বিস্তারিতভাবে আলোচনা করা হবে।

GAN মডেল ট্রেনিং এবং ইভ্যালুয়েট করার ধাপ

১. জেনারেটর এবং ডিসক্রিমিনেটর তৈরি করা

GAN এর মূল দুটি অংশ হলো জেনারেটর এবং ডিসক্রিমিনেটর।

• জেনারেটর: এটি মূলত র্যান্ডম নোইস থেকে আসল ডেটার মতো নতুন ডেটা তৈরি করে।
• ডিসক্রিমিনেটর: এটি আসল এবং নকল ডেটা পার্থক্য করতে শেখে।

import tensorflow as tf
from tensorflow.keras import layers

# জেনারেটর
def build_generator(z_dim):
    model = tf.keras.Sequential()
    model.add(layers.Dense(128, activation='relu', input_dim=z_dim))
    model.add(layers.Dense(256, activation='relu'))
    model.add(layers.Dense(512, activation='relu'))
    model.add(layers.Dense(784, activation='sigmoid'))  # assuming output is 28x28 image
    model.add(layers.Reshape((28, 28, 1)))  # reshaping to image format
    return model

# ডিসক্রিমিনেটর
def build_discriminator(img_shape):
    model = tf.keras.Sequential()
    model.add(layers.Flatten(input_shape=img_shape))
    model.add(layers.Dense(512, activation='relu'))
    model.add(layers.Dense(256, activation='relu'))
    model.add(layers.Dense(1, activation='sigmoid'))  # Output a probability
    return model

# ইনপুট আকার নির্ধারণ
z_dim = 100  # Latent space dimension
img_shape = (28, 28, 1)  # Image shape (for example, 28x28 grayscale images)

# মডেল তৈরি
generator = build_generator(z_dim)
discriminator = build_discriminator(img_shape)

২. GAN মডেল তৈরি এবং কম্পাইল করা

এখন জেনারেটর এবং ডিসক্রিমিনেটর মডেলগুলি তৈরি হওয়ার পর, তাদের কম্পাইল করা হয়। ডিসক্রিমিনেটরকে সাধারণভাবে binary_crossentropy loss function দিয়ে প্রশিক্ষণ দেয়া হয়, কারণ এটি একটি ক্লাসিফিকেশন মডেল।

# ডিসক্রিমিনেটর মডেল কম্পাইল
discriminator.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# GAN মডেল তৈরি (জেনারেটর এবং ডিসক্রিমিনেটর সংযুক্ত)
discriminator.trainable = False  # জেনারেটর ট্রেনিং এর সময় ডিসক্রিমিনেটর ট্রেন হবে না
gan_input = layers.Input(shape=(z_dim,))
x = generator(gan_input)
gan_output = discriminator(x)

gan = tf.keras.Model(gan_input, gan_output)
gan.compile(loss='binary_crossentropy', optimizer='adam')

৩. মডেল ট্রেনিং

GAN মডেলটিকে ট্রেনিং করার জন্য মূলত দুটি ধাপ আছে:

1. ডিসক্রিমিনেটর ট্রেনিং:
   • আসল এবং নকল ছবি থেকে ডিসক্রিমিনেটরকে শিখতে দেয়া হয়।
2. জেনারেটর ট্রেনিং:
   • ডিসক্রিমিনেটরের বিরুদ্ধে জেনারেটরকে প্রশিক্ষণ দেয়া হয়, যাতে এটি আরও বেশি বাস্তবসম্মত ছবি তৈরি করতে পারে।

import numpy as np

# MNIST ডেটাসেট ব্যবহার করা হচ্ছে (আপনি আপনার ডেটা ব্যবহার করতে পারেন)
(x_train, _), (_, _) = tf.keras.datasets.mnist.load_data()
x_train = x_train / 127.5 - 1.0  # Normalize to [-1, 1]
x_train = np.expand_dims(x_train, axis=-1)  # add channel dimension

batch_size = 128
epochs = 10000

# ট্রেনিং শুরু
for epoch in range(epochs):
    # 1. ডিসক্রিমিনেটর ট্রেনিং
    idx = np.random.randint(0, x_train.shape[0], batch_size)
    real_images = x_train[idx]
    noise = np.random.normal(0, 1, (batch_size, z_dim))  # র্যান্ডম নোইস
    fake_images = generator.predict(noise)

    # ডিসক্রিমিনেটরকে ট্রেন করুন (আসল এবং নকল ছবি)
    d_loss_real = discriminator.train_on_batch(real_images, np.ones((batch_size, 1)))
    d_loss_fake = discriminator.train_on_batch(fake_images, np.zeros((batch_size, 1)))
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

    # 2. জেনারেটর ট্রেনিং
    noise = np.random.normal(0, 1, (batch_size, z_dim))  # র্যান্ডম নোইস
    g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))  # জেনারেটরকে ট্রেন করুন

    # প্রতি কিছু ইপোক পরে ফলাফল প্রিন্ট
    if epoch % 1000 == 0:
        print(f"{epoch} [D loss: {d_loss[0]}] [G loss: {g_loss}]")

৪. GAN মডেল ইভ্যালুয়েট করা

GAN মডেল ইভ্যালুয়েট করতে, আপনি সাধারণত ডিসক্রিমিনেটরের পারফরম্যান্স চেক করবেন, কারণ এটি মূলত আসল এবং নকল ডেটার পার্থক্য জানায়। তবে, GAN এর মুল লক্ষ্য হল জেনারেটরের পারফরম্যান্স ইভ্যালুয়েট করা, যা কতটা বাস্তবসম্মত ছবি তৈরি করতে পারে তা যাচাই করা।

GAN মডেলের জন্য সাধারণ ইভ্যালুয়েশন মেট্রিক্স:

• ফুল-নেটওয়ার্ক ইভ্যালুয়েশন: ডিসক্রিমিনেটরের পক্ষে Accuracy বা Loss দেখানো হতে পারে।
• ইমেজ ভিজুয়ালাইজেশন: প্রতি ইপোক পরে জেনারেটর থেকে তৈরি হওয়া ইমেজ দেখানো হতে পারে, যেটি মডেলটির উন্নতির প্রমাণ দেয়।

import matplotlib.pyplot as plt

# ফাংশন যা একটি ব্যাচের জেনারেটেড ছবি প্লট করবে
def plot_generated_images(epoch, generator, examples=10, dim=(1, 10), figsize=(10, 1)):
    noise = np.random.normal(0, 1, (examples, z_dim))
    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], interpolation='nearest', cmap='gray')
        plt.axis('off')
    plt.tight_layout()
    plt.savefig(f"generated_images_epoch_{epoch}.png")
    plt.close()

# প্রতি 1000 ইপোক পর ইমেজ প্লট
if epoch % 1000 == 0:
    plot_generated_images(epoch, generator)

সারাংশ

• জেনারেটর এবং ডিসক্রিমিনেটর দুইটি আলাদা মডেল তৈরি করা হয় যা একে অপরের বিরুদ্ধে প্রশিক্ষিত হয়।
• ডিসক্রিমিনেটর ট্রেনিংয়ের সময় আসল এবং নকল ডেটা পার্থক্য করার চেষ্টা করে।
• জেনারেটর ডিসক্রিমিনেটরের বিরুদ্ধে ট্রেন হয়, যাতে এটি আরও বাস্তবসম্মত ডেটা তৈরি করতে পারে।
• ট্রেনিংয়ের সময় GAN এর পারফরম্যান্স ইভ্যালুয়েট করা হয় ডিসক্রিমিনেটরের এবং জেনারেটরের মাধ্যমে।