RNN/LSTM মডেল Training এবং Evaluation

Recurrent Neural Networks (RNNs) এবং Long Short-Term Memory (LSTM) মডেলগুলি সাধারণত sequence data (যেমন, টেক্সট, ভাষা, টাইম সিরিজ ডেটা) নিয়ে কাজ করে। RNN এবং LSTM মডেলগুলি বিশেষভাবে sequential data-এ পরবর্তী পদক্ষেপ বা পরবর্তী মান অনুমান করার জন্য ব্যবহৃত হয়। এখানে আমি PyTorch ব্যবহার করে RNN এবং LSTM মডেল ট্রেনিং এবং evaluation এর পুরো প্রক্রিয়া বিস্তারিতভাবে দেখাবো।

1. RNN এবং LSTM এর মৌলিক ধারণা

• RNN (Recurrent Neural Network): এটি একটি নিউরাল নেটওয়ার্ক যা সিকোয়েন্স ডেটার সাথে কাজ করে এবং পূর্ববর্তী ইনপুট এবং আউটপুটের উপর ভিত্তি করে ভবিষ্যতকে পূর্বাভাস করতে পারে। তবে, RNN এর একটি সীমাবদ্ধতা রয়েছে, যেটি হল vanishing gradient problem যখন দীর্ঘ সিকোয়েন্স নিয়ে কাজ করা হয়।
• LSTM (Long Short-Term Memory): LSTM হল RNN এর একটি উন্নত সংস্করণ যা vanishing gradient problem সমাধান করার জন্য ডিজাইন করা হয়েছে। LSTM গুলি দীর্ঘ সময়ের সিকোয়েন্স ডেটা ধারণ করতে সক্ষম।

2. RNN/LSTM মডেল তৈরি এবং প্রশিক্ষণ

এখানে, আমি PyTorch লাইব্রেরি ব্যবহার করে একটি সাধারণ LSTM মডেল তৈরি এবং প্রশিক্ষণের প্রক্রিয়া দেখাবো। এটি টেক্সট ক্লাসিফিকেশন বা টাইম সিরিজ ফোরকাস্টিং-এর জন্য ব্যবহৃত হতে পারে।

২.১. PyTorch ইনস্টলেশন:

pip install torch torchvision

২.২. ডেটাসেট তৈরি:

এখানে আমরা একটি সিম্পল সিকোয়েন্স ডেটা ব্যবহার করবো। ধরুন, আমরা টেক্সট ডেটা নিয়ে কাজ করছি।

import torch
from torch.utils.data import DataLoader, TensorDataset

# Sample sequence data
X = torch.tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], dtype=torch.float32)
y = torch.tensor([1, 0, 1, 0], dtype=torch.long)

# Create DataLoader for batch processing
train_data = TensorDataset(X, y)
train_loader = DataLoader(train_data, batch_size=2, shuffle=True)

২.৩. LSTM মডেল তৈরি:

import torch.nn as nn

class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(LSTMModel, self).__init__()
        # Define the LSTM layer
        self.lstm = nn.LSTM(input_size, hidden_size, batch_first=True)
        # Define a fully connected layer
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # Get LSTM output and hidden state
        lstm_out, (hn, cn) = self.lstm(x)
        # We take the output of the last time step
        last_time_step = lstm_out[:, -1, :]
        # Pass it through the fully connected layer
        out = self.fc(last_time_step)
        return out

# Model parameters
input_size = 1  # One feature per time step
hidden_size = 50
output_size = 2  # Binary classification (0 or 1)

# Initialize the model
model = LSTMModel(input_size, hidden_size, output_size)

২.৪. Loss Function এবং Optimizer সেট করা:

# Loss function and optimizer
criterion = nn.CrossEntropyLoss()  # For classification tasks
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

২.৫. মডেল প্রশিক্ষণ:

# Training loop
num_epochs = 100

for epoch in range(num_epochs):
    model.train()  # Set model to training mode
    running_loss = 0.0
    for inputs, labels in train_loader:
        inputs = inputs.unsqueeze(-1)  # Add an extra dimension for input_size
        optimizer.zero_grad()  # Zero the gradients

        # Forward pass
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        # Backward pass and optimization
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader)}')

২.৬. মডেল মূল্যায়ন (Evaluation):

প্রশিক্ষণ শেষে, মডেলটি পরীক্ষা করতে হবে।

# Evaluation mode
model.eval()

# Sample test data (the model would be evaluated on unseen data)
X_test = torch.tensor([[13, 14, 15]], dtype=torch.float32).unsqueeze(-1)  # Add extra dimension
y_test = torch.tensor([1])

# Make predictions
with torch.no_grad():  # No gradient calculation during evaluation
    output = model(X_test)

# Get predicted class
_, predicted_class = torch.max(output, 1)
print(f'Predicted Class: {predicted_class.item()}, Actual Class: {y_test.item()}')

3. RNN মডেল তৈরি এবং প্রশিক্ষণ:

RNN মডেল তৈরি এবং প্রশিক্ষণ প্রক্রিয়া LSTM এর মতো একই, তবে এখানে LSTM এর পরিবর্তে nn.RNN ব্যবহার করা হবে।

class RNNModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(RNNModel, self).__init__()
        # Define the RNN layer
        self.rnn = nn.RNN(input_size, hidden_size, batch_first=True)
        # Define a fully connected layer
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # Get RNN output and hidden state
        rnn_out, hn = self.rnn(x)
        # We take the output of the last time step
        last_time_step = rnn_out[:, -1, :]
        # Pass it through the fully connected layer
        out = self.fc(last_time_step)
        return out

# Initialize the RNN model
model_rnn = RNNModel(input_size, hidden_size, output_size)

এখানে RNN মডেলেও criterion এবং optimizer এর সেটিং একই থাকবে, এবং প্রশিক্ষণ এবং মূল্যায়নের ধাপও একই থাকবে, তবে এখানে LSTM এর পরিবর্তে RNN মডেল ব্যবহৃত হবে।

4. মডেল Evaluation এবং Metrics

এখন, আপনি আপনার মডেলের accuracy, precision, recall, এবং F1-Score এর মতো বিভিন্ন মেট্রিক্স বিশ্লেষণ করতে পারেন। এটি সাধারণত validation বা test ডেটাসেটের উপর মূল্যায়ন করা হয়।

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# Example: Calculate accuracy
predictions = []
true_labels = []

# Evaluation mode
model.eval()

with torch.no_grad():
    for inputs, labels in train_loader:
        inputs = inputs.unsqueeze(-1)  # Add an extra dimension for input_size
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        
        predictions.extend(predicted.numpy())
        true_labels.extend(labels.numpy())

# Calculate metrics
accuracy = accuracy_score(true_labels, predictions)
precision = precision_score(true_labels, predictions, average='binary')
recall = recall_score(true_labels, predictions, average='binary')
f1 = f1_score(true_labels, predictions, average='binary')

print(f'Accuracy: {accuracy}')
print(f'Precision: {precision}')
print(f'Recall: {recall}')
print(f'F1 Score: {f1}')

5. সারাংশ:

• RNN/LSTM মডেল সাধারণত sequence data নিয়ে কাজ করে, যেমন ভাষা, টেক্সট, বা টাইম সিরিজ ডেটা।
• LSTM হল RNN এর উন্নত সংস্করণ যা দীর্ঘ সময়কাল ধরে সিকোয়েন্স তথ্য ধারণ করতে সক্ষম।
• PyTorch ব্যবহার করে RNN/LSTM মডেল তৈরি করা, প্রশিক্ষণ দেওয়া এবং মূল্যায়ন করার প্রক্রিয়া সোজা এবং নমনীয়।
• মডেলটি ট্রেন করার পর, আপনি accuracy, precision, recall, এবং F1-score এর মাধ্যমে মডেলের কার্যকারিতা বিশ্লেষণ করতে পারবেন।