GAN এবং RNN দিয়ে প্রজেক্ট তৈরি

এখানে আমরা Generative Adversarial Network (GAN) এবং Recurrent Neural Network (RNN) ব্যবহার করে দুটি আলাদা প্রজেক্ট তৈরি করার প্রক্রিয়া দেখাবো। GAN সাধারণত ডেটা জেনারেশন বা নতুন ডেটা তৈরি করার জন্য ব্যবহৃত হয়, যখন RNN টাইম সিরিজ ডেটা বা সিকোয়েন্সিয়াল ডেটা প্রক্রিয়াকরণ এবং পূর্বানুমান করার জন্য ব্যবহৃত হয়।

১. GAN (Generative Adversarial Network) দিয়ে প্রজেক্ট তৈরি

Generative Adversarial Networks (GANs) হল দুটি নিউরাল নেটওয়ার্কের সংমিশ্রণ — Generator এবং Discriminator। Generator নতুন ডেটা তৈরি করে এবং Discriminator সেই ডেটা যাচাই করে যে এটি আসল না মিথ্যা। এই দুইটি নেটওয়ার্ক একে অপরের বিরুদ্ধে প্রশিক্ষিত হয়, যার ফলে realistic data generation সম্ভব হয়।

1.1 GAN দিয়ে MNIST Dataset থেকে Handwritten Digits Generation

এখানে আমরা MNIST ডেটাসেট থেকে হাতের লেখা ডিজিটের ছবি তৈরি করার জন্য একটি GAN প্রজেক্ট তৈরি করব।

কোড উদাহরণ:

import mxnet as mx
from mxnet.gluon import nn, rnn
from mxnet import nd
import numpy as np
import matplotlib.pyplot as plt

# Generator নেটওয়ার্ক তৈরি
class Generator(nn.Block):
    def __init__(self, **kwargs):
        super(Generator, self).__init__(**kwargs)
        self.dense1 = nn.Dense(128, activation='relu')
        self.dense2 = nn.Dense(256, activation='relu')
        self.dense3 = nn.Dense(512, activation='relu')
        self.dense4 = nn.Dense(784, activation='sigmoid')  # MNIST image size (28x28)

    def forward(self, x):
        x = self.dense1(x)
        x = self.dense2(x)
        x = self.dense3(x)
        x = self.dense4(x)
        return x.reshape((-1, 28, 28))  # reshape to image size (28x28)

# Discriminator নেটওয়ার্ক তৈরি
class Discriminator(nn.Block):
    def __init__(self, **kwargs):
        super(Discriminator, self).__init__(**kwargs)
        self.dense1 = nn.Dense(512, activation='relu')
        self.dense2 = nn.Dense(256, activation='relu')
        self.dense3 = nn.Dense(128, activation='relu')
        self.dense4 = nn.Dense(1, activation='sigmoid')  # Output layer

    def forward(self, x):
        x = self.dense1(x)
        x = self.dense2(x)
        x = self.dense3(x)
        x = self.dense4(x)
        return x

# GAN মডেল তৈরি
class GAN(nn.Block):
    def __init__(self, generator, discriminator, **kwargs):
        super(GAN, self).__init__(**kwargs)
        self.generator = generator
        self.discriminator = discriminator

    def forward(self, z):
        fake_images = self.generator(z)
        validity = self.discriminator(fake_images)
        return validity

# মডেল ইনিশিয়ালাইজ
generator = Generator()
discriminator = Discriminator()
gan = GAN(generator, discriminator)

gan.initialize(mx.init.Xavier(), ctx=mx.cpu())

1.2 GAN মডেল প্রশিক্ষণ:

এখন আমাদের একটি Loss function এবং Optimizer ব্যবহার করতে হবে, যেমন Binary Cross-Entropy Loss এবং Adam Optimizer।

from mxnet.gluon import Trainer
from mxnet.gluon.loss import SigmoidBinaryCrossEntropyLoss

# Optimizer and Loss Function
optimizer = Trainer(gan.collect_params(), 'adam', {'learning_rate': 0.0002, 'beta1': 0.5})
loss_fn = SigmoidBinaryCrossEntropyLoss()

# Training loop
epochs = 10000
batch_size = 64

for epoch in range(epochs):
    z = nd.random.normal(0, 1, shape=(batch_size, 100), ctx=mx.cpu())  # Noise for Generator
    fake_images = generator(z)
    
    # Train Discriminator
    real_images = # Load real MNIST images here
    real_labels = nd.ones((batch_size, 1), ctx=mx.cpu())  # Real labels
    fake_labels = nd.zeros((batch_size, 1), ctx=mx.cpu())  # Fake labels

    # Discriminator loss
    real_loss = loss_fn(discriminator(real_images), real_labels)
    fake_loss = loss_fn(discriminator(fake_images), fake_labels)
    d_loss = real_loss + fake_loss

    # Backpropagation
    d_loss.backward()
    optimizer.step(batch_size)

    # Train Generator
    z = nd.random.normal(0, 1, shape=(batch_size, 100), ctx=mx.cpu())  # Noise
    fake_images = generator(z)
    g_loss = loss_fn(discriminator(fake_images), real_labels)  # Want Generator to fool Discriminator

    g_loss.backward()
    optimizer.step(batch_size)

    if epoch % 1000 == 0:
        print(f"Epoch {epoch}, D Loss: {d_loss.mean().asscalar()}, G Loss: {g_loss.mean().asscalar()}")

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

২. RNN (Recurrent Neural Network) দিয়ে প্রজেক্ট তৈরি

RNN টাইম সিরিজ বা সিকোয়েন্সিয়াল ডেটার জন্য ব্যবহৃত হয়, যেখানে পূর্ববর্তী ইনপুট ভবিষ্যত প্রেডিকশন প্রভাবিত করে। Time Series Forecasting বা Text Generation এর মতো কাজের জন্য RNN ব্যবহৃত হয়।

2.1 RNN দিয়ে Text Generation (Character Level)

এখানে, আমরা একটি RNN মডেল ব্যবহার করে text generation প্রজেক্ট তৈরি করবো, যেখানে মডেলটি একাধিক চরিত্র (character) সিকোয়েন্সের উপর প্রশিক্ষণ নিয়ে নতুন টেক্সট তৈরি করবে।

কোড উদাহরণ:

from mxnet.gluon import nn, rnn
from mxnet import nd
import numpy as np

# RNN মডেল তৈরি
class CharRNN(nn.Block):
    def __init__(self, vocab_size, embed_size, hidden_size, num_layers, **kwargs):
        super(CharRNN, self).__init__(**kwargs)
        self.embedding = nn.Embedding(vocab_size, embed_size)
        self.rnn = rnn.LSTM(hidden_size, num_layers, batch_first=True)
        self.output = nn.Dense(vocab_size)

    def forward(self, x, state=None):
        x = self.embedding(x)
        x, state = self.rnn(x, state)
        output = self.output(x)
        return output, state

# মডেল ইনিশিয়ালাইজ
vocab_size = 50  # Character set size (for example)
embed_size = 128
hidden_size = 256
num_layers = 2

model = CharRNN(vocab_size, embed_size, hidden_size, num_layers)
model.initialize(mx.init.Xavier(), ctx=mx.cpu())

2.2 মডেল প্রশিক্ষণ এবং টেক্সট জেনারেশন

# Sample text data (for example, character level text)
text_data = "Hello, this is an RNN example for text generation!"

# Preprocess text data to numeric indices
char_to_idx = {ch: idx for idx, ch in enumerate(sorted(set(text_data)))}
idx_to_char = {idx: ch for ch, idx in char_to_idx.items()}

# Convert text to indices
text_indices = [char_to_idx[ch] for ch in text_data]
X = nd.array(text_indices[:-1], ctx=mx.cpu()).reshape((-1, 1))
Y = nd.array(text_indices[1:], ctx=mx.cpu()).reshape((-1, 1))

# Train the RNN model
epochs = 10
batch_size = 1

trainer = gluon.Trainer(model.collect_params(), 'adam')
loss_fn = nn.SoftmaxCrossEntropyLoss()

for epoch in range(epochs):
    with mx.autograd.record():
        output, _ = model(X)
        loss = loss_fn(output, Y)
    loss.backward()
    trainer.step(batch_size)

    print(f"Epoch {epoch}, Loss: {loss.mean().asscalar()}")

2.3 Text Generation

একবার প্রশিক্ষণ শেষে, মডেলটি ব্যবহার করে নতুন টেক্সট তৈরি করা যাবে।

def generate_text(model, start_string, num_generate=100):
    input_eval = [char_to_idx[ch] for ch in start_string]
    input_eval = nd.array(input_eval, ctx=mx.cpu()).reshape((-1, 1))

    generated_text = start_string

    for _ in range(num_generate):
        prediction, _ = model(input_eval)
        predicted_char = idx_to_char[np.argmax(prediction.asnumpy(), axis=-1)[0]]
        generated_text += predicted_char

        input_eval = nd.array([char_to_idx[predicted_char]], ctx=mx.cpu()).reshape((-1, 1))

    return generated_text

# টেক্সট তৈরি
generated_text = generate_text(model, "Hello", 200)
print(generated_text)

এখানে, Character Level RNN মডেলটি প্রশিক্ষণ পায় এবং এটি একটি শুরু স্ট্রিং থেকে নতুন টেক্সট তৈরি করতে সক্ষম হয়।

সারাংশ:

• GAN (Generative Adversarial Network) নতুন ডেটা তৈরি করার জন্য ব্যবহৃত হয়, যেমন নতুন ছবি বা সাউন্ড জেনারেশন। এটি Generator এবং Discriminator নামক দুটি মডেলের সমন্বয়ে কাজ করে।
• RNN (Recurrent Neural Network) টাইম সিরিজ বা সিকোয়েন্সিয়াল ডেটা প্রক্রিয়াকরণে ব্যবহৃত হয়, যেমন Text Generation বা Time Series Forecasting। এটি hidden state এর মাধ্যমে পূর্ববর্তী ইনপুট থেকে ভবিষ্যত তথ্য শিখে নেয়।

এটি GAN এবং RNN এর প্রজেক্ট তৈরি করার একটি সহজ ধারণা দিয়েছে, যার মাধ্যমে আপনি ডেটা জেনারেশন এবং টাইম সিরিজ বা সিকোয়েন্সিয়াল ডেটা বিশ্লেষণ করতে পারবেন।