Generator এবং Discriminator মডেল তৈরি করা

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

GAN এর মৌলিক কাঠামো:

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

এখন, আসুন Keras ব্যবহার করে একটি সাধারণ Generator এবং Discriminator মডেল তৈরি করি, যেগুলি একটি GAN (Generative Adversarial Network) তৈরি করার জন্য ব্যবহৃত হবে।

1. Generator মডেল তৈরি করা

Generator মডেলটি সাধারণত Dense লেয়ার ব্যবহার করে, এবং ইনপুট হিসেবে নইস (random noise) নেয় এবং তারপরে এটি বাস্তবসম্মত ডেটা উদাহরণ তৈরি করে।

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LeakyReLU, BatchNormalization
import numpy as np

# Generator মডেল তৈরি
def build_generator(latent_dim):
    model = Sequential()

    # প্রথম Dense লেয়ার, noise ইনপুট (latent_dim)
    model.add(Dense(256, input_dim=latent_dim))
    model.add(LeakyReLU(0.2))  # LeakyReLU অ্যাকটিভেশন
    model.add(BatchNormalization(momentum=0.8))  # BatchNormalization

    # দ্বিতীয় Dense লেয়ার
    model.add(Dense(512))
    model.add(LeakyReLU(0.2))
    model.add(BatchNormalization(momentum=0.8))

    # তৃতীয় Dense লেয়ার
    model.add(Dense(1024))
    model.add(LeakyReLU(0.2))
    model.add(BatchNormalization(momentum=0.8))

    # আউটপুট লেয়ার
    model.add(Dense(28 * 28 * 1, activation='tanh'))  # 28x28 পিক্সেল, 1 চ্যানেল ইমেজ
    model.add(Reshape((28, 28, 1)))  # আউটপুট আকার পরিবর্তন (28x28x1)

    return model

latent_dim = 100  # নইসের ডাইমেনশন
generator = build_generator(latent_dim)
generator.summary()

ব্যাখ্যা:

• Dense লেয়ার: এই লেয়ারগুলি ইনপুট (latent noise) থেকে ধীরে ধীরে উচ্চ মাত্রার ফিচার তৈরি করে।
• LeakyReLU: এটি একটি অ্যাকটিভেশন ফাংশন যা নেগেটিভ ভ্যালুগুলিকে কিছুটা প্রবাহিত করতে সহায়তা করে, যা গ্রেডিয়েন্ট ভ্যানিশিং সমস্যাকে কমিয়ে আনে।
• BatchNormalization: এটি গ্রেডিয়েন্ট প্রশিক্ষণ উন্নত করতে এবং মডেলকে দ্রুত শিখতে সাহায্য করে।
• Reshape: আউটপুটটি 28x28 পিক্সেল আকারে রূপান্তরিত করা হয় (যেমন MNIST ইমেজ সাইজ)।

2. Discriminator মডেল তৈরি করা

Discriminator মডেলটি একটি কনভোলিউশনাল নিউরাল নেটওয়ার্ক (CNN) হতে পারে, যা ইমেজের বৈশিষ্ট্য বের করে এবং যাচাই করে যে এটি আসল নাকি জেনারেটেড।

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, Flatten, Dense, LeakyReLU, Dropout

# Discriminator মডেল তৈরি
def build_discriminator(img_shape):
    model = Sequential()

    # প্রথম কনভোলিউশনাল লেয়ার
    model.add(Conv2D(32, kernel_size=3, strides=2, padding='same', input_shape=img_shape))
    model.add(LeakyReLU(0.2))

    # দ্বিতীয় কনভোলিউশনাল লেয়ার
    model.add(Conv2D(64, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(0.2))

    # তৃতীয় কনভোলিউশনাল লেয়ার
    model.add(Conv2D(128, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(0.2))

    # চতুর্থ কনভোলিউশনাল লেয়ার
    model.add(Conv2D(256, kernel_size=3, strides=2, padding='same'))
    model.add(LeakyReLU(0.2))

    # Flatten এবং Dense লেয়ার
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))  # আসল বা জেনারেটেড তা নির্ধারণ করবে

    return model

img_shape = (28, 28, 1)  # 28x28x1 ইমেজ সাইজ
discriminator = build_discriminator(img_shape)
discriminator.summary()

ব্যাখ্যা:

• Conv2D: কনভোলিউশনাল লেয়ার ব্যবহার করে ইমেজের ফিচার শিখা হচ্ছে।
• LeakyReLU: এখানে নেগেটিভ ভ্যালু কিছুটা প্রবাহিত করার জন্য ব্যবহৃত হয়েছে।
• Dense: Flatten করার পর, একটি Dense লেয়ার ব্যবহার করে মডেলটি একটি একক আউটপুট (যেমন আসল বা জেনারেটেড) প্রদান করে।
• Sigmoid: আউটপুট লেয়ারটি sigmoid অ্যাকটিভেশন ফাংশন ব্যবহার করে, যাতে আউটপুটটি 0 অথবা 1 (প্রবাবিলিটি) হয়।

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

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

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

# GAN মডেল তৈরি করা
def build_gan(generator, discriminator):
    # Discriminator কে Freeze করা (এটি ট্রেনিং হবে না)
    discriminator.trainable = False

    # Generator এর ইনপুট
    z = Input(shape=(latent_dim,))  # Latent vector input
    generated_img = generator(z)

    # Discriminator এর আউটপুট
    validity = discriminator(generated_img)

    # GAN মডেল তৈরি করা
    model = Model(z, validity)
    return model

# Generator এবং Discriminator মডেল তৈরি
gan = build_gan(generator, discriminator)

# GAN মডেল কম্পাইল
gan.compile(loss='binary_crossentropy', optimizer=Adam(learning_rate=0.0002, beta_1=0.5))

ব্যাখ্যা:

• Discriminator.trainable = False: যখন GAN প্রশিক্ষিত হবে, তখন আমরা Discriminator কে Freeze (অপফ্রি) করে দিব, যাতে শুধুমাত্র Generator প্রশিক্ষণ হয়। কারণ, GAN ট্রেনিংয়ের সময় Generator কে আপডেট করার উদ্দেশ্য থাকে।
• GAN কম্পাইল: GAN মডেলটি binary_crossentropy লস ফাংশন এবং Adam optimizer ব্যবহার করে কম্পাইল করা হয়েছে।

4. GAN প্রশিক্ষণ

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

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

# MNIST ডেটাসেট লোড করা
(X_train, _), (_, _) = mnist.load_data()
X_train = X_train / 127.5 - 1.0  # মান স্কেলিং [-1, 1] এ রূপান্তর

# 28x28x1 আকারে রূপান্তর
X_train = np.expand_dims(X_train, axis=-1)

# Batch সাইজ
batch_size = 64

# প্রশিক্ষণ লুপ
for epoch in range(10000):
    # 1. Discriminator প্রশিক্ষণ
    idx = np.random.randint(0, X_train.shape[0], batch_size)
    real_images = X_train[idx]

    noise = np.random.normal(0, 1, (batch_size, latent_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. Generator প্রশিক্ষণ
    noise = np.random.normal(0, 1, (batch_size, latent_dim))
    g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))

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

        # কিছু স্যাম্পল ইমেজ তৈরি করে দেখানো
        if epoch % 5000 == 0:
            noise = np.random.normal(0, 1, (25, latent_dim))
            generated_images = generator.predict(noise)
            generated_images = 0.5 * generated_images + 0.5  # [0, 1] এ রূপান্তর

            # ইমেজ প্রিন্ট করা
            fig, axs = plt.subplots(5, 5)
            cnt = 0
            for i in range(5):
                for j in range(5):
                    axs[i, j].imshow(generated_images[cnt, :, :, 0], cmap='gray')
                    axs[i, j].axis('off')
                    cnt += 1
            plt.show()

ব্যাখ্যা:

1. Discriminator প্রশিক্ষণ:
   • প্রথমে আসল ইমেজ এবং জেনারেটেড ইমেজ নিয়ে Discriminator কে প্রশিক্ষণ দেওয়া হয়। Discriminator আসল ইমেজের জন্য 1 এবং জেনারেটেড ইমেজের জন্য 0 আউটপুট দেয়।
2. Generator প্রশিক্ষণ:
   • এরপর Generator কে প্রশিক্ষণ দেওয়ার জন্য, আমরা GAN মডেলটি ব্যবহার করি। এখানে, Generator এর আউটপুটের জন্য Discriminator কে Freeze করা হয় এবং Generator এর আউটপুট 1 (আসল) হিসেবে ট্রেনিং করা হয়।

সারাংশ

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

এই প্রক্রিয়া হল adversarial training, যা মডেলকে আরও ভালোভাবে উন্নত করে, বিশেষ করে ইমেজ জেনারেশন, স্টাইল ট্রান্সফার, এবং অন্যান্য ক্রিয়েটিভ কাজের জন্য।