CNN এবং RNN দিয়ে Image এবং Sequence Data মডেল তৈরি

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

এই প্রজেক্টে আমরা GAN ব্যবহার করে চিত্র (image) জেনারেশন করবো। উদাহরণস্বরূপ, আমরা একটি DCGAN (Deep Convolutional GAN) ব্যবহার করবো, যা চিত্র তৈরি করতে সহায়ক।

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

এখানে আমরা DCGAN (Deep Convolutional Generative Adversarial Network) ব্যবহার করবো। DCGAN সাধারণত Convolutional Layers ব্যবহার করে এবং চিত্র তৈরি করার জন্য খুবই জনপ্রিয়।

ধাপ ১: প্রয়োজনীয় লাইব্রেরি ইম্পোর্ট করা

প্রথমে আমরা প্রয়োজনীয় লাইব্রেরি ইম্পোর্ট করবো:

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

ধাপ ২: ডেটাসেট লোড করা

আমরা MNIST ডেটাসেট ব্যবহার করব, যা 28x28 পিক্সেলের হ্যান্ডরিটেন ডিজিট চিত্রের একটি জনপ্রিয় ডেটাসেট।

# MNIST ডেটাসেট লোড করা
(train_images, _), (_, _) = tf.keras.datasets.mnist.load_data()

# চিত্রগুলিকে  [-1, 1] পরিসরে রিস্কেল করা
train_images = train_images.reshape(train_images.shape[0], 28, 28, 1).astype("float32")
train_images = (train_images - 127.5) / 127.5

ধাপ ৩: GAN এর দুটি অংশ তৈরি করা

1. জেনারেটর (Generator): এটি একরকম র্যান্ডম নোইস ইনপুট নিয়ে নতুন চিত্র তৈরি করবে।

def build_generator():
    model = tf.keras.Sequential()

    model.add(layers.Dense(7 * 7 * 256, use_bias=False, input_shape=(100,)))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())

    model.add(layers.Reshape((7, 7, 256)))
    model.add(layers.Conv2DTranspose(128, (5, 5), strides=(1, 1), padding="same", use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())

    model.add(layers.Conv2DTranspose(64, (5, 5), strides=(2, 2), padding="same", use_bias=False))
    model.add(layers.BatchNormalization())
    model.add(layers.ReLU())

    model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding="same", use_bias=False, activation="tanh"))

    return model

2. ডিসক্রিমিনেটর (Discriminator): এটি জেনারেটরের তৈরি চিত্রগুলো যাচাই করে, তা আসল নাকি তৈরি করা।

def build_discriminator():
    model = tf.keras.Sequential()

    model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding="same", input_shape=[28, 28, 1]))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dropout(0.3))

    model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding="same"))
    model.add(layers.LeakyReLU(alpha=0.2))
    model.add(layers.Dropout(0.3))

    model.add(layers.Flatten())
    model.add(layers.Dense(1))

    return model

ধাপ ৪: GAN মডেল তৈরি করা

এখন আমরা দুটি মডেল একত্রিত করবো এবং হাবার loss (যথেষ্ট ট্রেনিং এর পরে, আমরা ডিসক্রিমিনেটরের ভুল ধারণা থেকে জেনারেটরকে শেখাবো) দিয়ে একে প্রশিক্ষিত করবো।

# জেনারেটর এবং ডিসক্রিমিনেটর তৈরি করা
generator = build_generator()
discriminator = build_discriminator()

# ডিসক্রিমিনেটরের গ্রেডিয়েন্ট আপডেটের জন্য ওয়াস প্লাস (real/fake) গ্রাউন্ড ট্রুথ লেবেল তৈরি করা
def compile_models():
    discriminator.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy', metrics=['accuracy'])
    discriminator.trainable = False
    gan = tf.keras.Sequential([generator, discriminator])
    gan.compile(optimizer=tf.keras.optimizers.Adam(1e-4), loss='binary_crossentropy')
    return gan

ধাপ ৫: প্রশিক্ষণ ফাংশন তৈরি করা

এখন আমরা জেনারেটর এবং ডিসক্রিমিনেটর প্রশিক্ষণের জন্য একটি ফাংশন তৈরি করবো। এখানে আমরা বায়াসের কারণে কোনো ভ্যালিডেশন বা টেস্ট ডেটাসেট ব্যবহার করবো না। আমরা শুধু জেনারেটর এবং ডিসক্রিমিনেটর এর মধ্যে বিরোধ সৃষ্টি করবো (adversarial training)।

def train_gan(epochs, batch_size=128):
    batch_count = train_images.shape[0] // batch_size

    for epoch in range(epochs):
        for _ in range(batch_count):
            noise = np.random.normal(0, 1, (batch_size, 100))

            # র্যান্ডম স্যাম্পল করা আসল চিত্রগুলি (real images)
            real_images = train_images[np.random.randint(0, train_images.shape[0], batch_size)]

            # জেনারেটরের মাধ্যমে নতুন (fake) চিত্র তৈরি করা
            fake_images = generator.predict(noise)

            # ডিসক্রিমিনেটরের ট্রেনিং (real vs fake)
            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)

            # GAN মডেল ট্রেনিং (generator এর ট্রেনিং)
            g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))

        # প্রতি epoch এ কিছু রেজাল্ট প্রদর্শন করা
        if epoch % 10 == 0:
            print(f"Epoch {epoch}/{epochs} - D Loss: {d_loss[0]} - G Loss: {g_loss}")

            # প্রতি epoch শেষে ছবি দেখানো
            if epoch % 100 == 0:
                plot_generated_images(epoch)

# চিত্র প্রজেকশন (Plot) ফাংশন
def plot_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], interpolation='nearest', cmap='gray')
        plt.axis('off')
    plt.tight_layout()
    plt.savefig(f'generated_image_{epoch}.png')
    plt.close()

# মডেল কম্পাইল
gan = compile_models()

# প্রশিক্ষণ শুরু
train_gan(epochs=5000, batch_size=128)

ধাপ ৬: আউটপুট

প্রশিক্ষণ চলাকালে প্রতি epoch এর শেষে আপনি একটি চিত্র দেখতে পাবেন, যা আপনার GAN মডেল দ্বারা তৈরি চিত্র। generated_image_epoch.png ফাইলে এই চিত্রগুলি সংরক্ষিত হবে।

সারাংশ:

এই প্রজেক্টে, আমরা DCGAN (Deep Convolutional GAN) ব্যবহার করে চিত্র সৃষ্টি করেছি। এখানে জেনারেটর এবং ডিসক্রিমিনেটর মডেল তৈরি করা হয়েছে, যেগুলি একে অপরের বিরুদ্ধে প্রশিক্ষিত হয়েছে, যা সঠিকভাবে চিত্র জেনারেশন করতে সাহায্য করে। GAN প্রশিক্ষণের মধ্যে ডিসক্রিমিনেটর আসল এবং তৈরি করা চিত্রগুলির মধ্যে পার্থক্য করতে শেখে এবং জেনারেটর সেই তথ্য ব্যবহার করে আরও ভাল চিত্র তৈরি করে।