RNN ব্যবহার করে Text Generation প্রজেক্ট

Text generation একটি সাধারণ প্রকল্প যেখানে Recurrent Neural Network (RNN) ব্যবহার করে ধারাবাহিক টেক্সট তৈরি করা হয়। RNN এর sequential data প্রসেস করার ক্ষমতার কারণে text generation প্রকল্পে এটি অত্যন্ত কার্যকর। এই প্রকল্পে আমরা একটি RNN মডেল ব্যবহার করে text generation করব, যেখানে মডেলটি একাধিক শব্দের মাধ্যমে নির্দিষ্ট প্যাটার্ন শিখে সেই প্যাটার্ন অনুসারে নতুন টেক্সট তৈরি করতে পারবে।

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

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

ধাপ ২: ডেটাসেট প্রস্তুত করা

প্রথমে আমরা একটি উদাহরণস্বরূপ টেক্সট তৈরি করব এবং তারপর ডেটাকে প্রসেস করব যাতে এটি RNN মডেলে ইনপুট হিসেবে ব্যবহারযোগ্য হয়। উদাহরণ হিসেবে আমরা Shakespeare এর লেখার কিছু অংশ ব্যবহার করব।

# Text ডেটাসেট (উদাহরণস্বরূপ)
text = "To be or not to be, that is the question."

# সমস্ত ইউনিক ক্যারেক্টারগুলো সংরক্ষণ করা
chars = sorted(set(text))
char_to_idx = {ch: i for i, ch in enumerate(chars)}
idx_to_char = {i: ch for i, ch in enumerate(chars)}

# Hyperparameters
seq_length = 10  # input sequence length
batch_size = 64  # training batch size
n_epochs = 100   # number of epochs
hidden_size = 128  # hidden state size of RNN
learning_rate = 0.01  # learning rate for optimizer

ধাপ ৩: ডেটাসেট তৈরি করা

প্রতিটি sequence এর জন্য input-output pair তৈরি করা হবে। উদাহরণস্বরূপ, যদি আমাদের টেক্সট "To be or not to be" হয়, তাহলে আমরা "To be or n" কে ইনপুট এবং "o be or no" কে টার্গেট হিসেবে ব্যবহার করব।

# ডেটাসেট তৈরি
input_seq = []
target_seq = []

for i in range(0, len(text) - seq_length):
    in_seq = text[i:i + seq_length]
    out_seq = text[i + 1:i + seq_length + 1]
    input_seq.append([char_to_idx[ch] for ch in in_seq])
    target_seq.append([char_to_idx[ch] for ch in out_seq])

input_seq = np.array(input_seq)
target_seq = np.array(target_seq)

ধাপ ৪: Custom Dataset এবং DataLoader তৈরি করা

class TextDataset(Dataset):
    def __init__(self, input_seq, target_seq):
        self.input_seq = torch.tensor(input_seq, dtype=torch.long)
        self.target_seq = torch.tensor(target_seq, dtype=torch.long)
    
    def __len__(self):
        return len(self.input_seq)
    
    def __getitem__(self, idx):
        return self.input_seq[idx], self.target_seq[idx]

# ডেটাসেট এবং ডেটা লোডার তৈরি
dataset = TextDataset(input_seq, target_seq)
data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

ধাপ ৫: RNN মডেল তৈরি করা

একটি RNN মডেল তৈরি করা, যা ইনপুট হিসাবে একটি character sequence নেবে এবং প্রেডিক্টেড character sequence আউটপুট দিবে।

class TextGenerationRNN(nn.Module):
    def __init__(self, vocab_size, hidden_size, output_size):
        super(TextGenerationRNN, self).__init__()
        self.hidden_size = hidden_size
        self.rnn = nn.RNN(vocab_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x, hidden):
        out, hidden = self.rnn(x, hidden)
        out = self.fc(out)
        return out, hidden
    
    def init_hidden(self, batch_size):
        return torch.zeros(1, batch_size, self.hidden_size)

# মডেল ইনিশিয়ালাইজ করা
vocab_size = len(chars)
model = TextGenerationRNN(vocab_size, hidden_size, vocab_size)

ধাপ ৬: লস ফাংশন এবং অপটিমাইজার সেট করা

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

ধাপ ৭: মডেল ট্রেনিং করা

RNN মডেলটি প্রতিটি character sequence নিয়ে ট্রেনিং করা হবে এবং লস কমানোর চেষ্টা করা হবে।

for epoch in range(n_epochs):
    hidden = model.init_hidden(batch_size)
    total_loss = 0
    
    for inputs, targets in data_loader:
        # One-hot encoding input data
        inputs = nn.functional.one_hot(inputs, num_classes=vocab_size).float()
        
        # Hidden state detach করা
        hidden = hidden.detach()
        
        # মডেল আউটপুট এবং লস ক্যালকুলেট করা
        outputs, hidden = model(inputs, hidden)
        loss = criterion(outputs.view(-1, vocab_size), targets.view(-1))
        
        # Backward এবং optimizer স্টেপ
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
    
    print(f"Epoch [{epoch+1}/{n_epochs}], Loss: {total_loss/len(data_loader):.4f}")

ধাপ ৮: Text Generation

এখন আমরা মডেলটিকে একটি seed text দিয়ে নতুন টেক্সট জেনারেট করতে বলব।

def generate_text(model, start_str, gen_length=100):
    input_seq = [char_to_idx[ch] for ch in start_str]
    input_seq = torch.tensor(input_seq, dtype=torch.long).unsqueeze(0)
    hidden = model.init_hidden(1)
    
    generated_text = start_str
    
    for _ in range(gen_length):
        inputs = nn.functional.one_hot(input_seq, num_classes=vocab_size).float()
        outputs, hidden = model(inputs, hidden)
        predicted_idx = torch.argmax(outputs[0, -1]).item()
        generated_text += idx_to_char[predicted_idx]
        
        input_seq = torch.cat((input_seq[:, 1:], torch.tensor([[predicted_idx]])), dim=1)
    
    return generated_text

# Example text generation
start_str = "To be or "
generated_text = generate_text(model, start_str)
print(generated_text)

কোডের সারাংশ:

1. Dataset Creation: টেক্সট ডেটাসেট তৈরি করা হয় character sequence অনুযায়ী, যাতে RNN মডেল টেক্সটের ধারাবাহিকতা শিখতে পারে।
2. Model Definition: একটি বেসিক RNN মডেল তৈরি করা হয়েছে, যা input text sequence থেকে আউটপুট text sequence প্রদান করে।
3. Training: মডেলটি একাধিক epoch ধরে train করা হয়।
4. Text Generation: একটি seed text দিয়ে মডেলকে নতুন টেক্সট জেনারেট করতে বলা হয়।

এই বেসিক প্রজেক্টের মাধ্যমে RNN ব্যবহার করে text generation এর প্রাথমিক ধারণা পাওয়া যায় এবং ভবিষ্যতে আরও উন্নত মডেল তৈরির ভিত্তি তৈরি হয়।