PyTorch দিয়ে NLP প্রজেক্ট তৈরি

Natural Language Processing (NLP) হলো মেশিন লার্নিং এবং ডিপ লার্নিংয়ের একটি গুরুত্বপূর্ণ শাখা, যা ভাষাগত তথ্যের সাথে কাজ করে, যেমন টেক্সট বা স্পিচ ডেটা। PyTorch-এ NLP প্রজেক্ট তৈরি করার জন্য সাধারণত প্রাকৃতিক ভাষা প্রক্রিয়াকরণ (NLP) টাস্ক যেমন টেক্সট ক্লাসিফিকেশন, স্প্যাম ফিল্টারিং, টেক্সট জেনারেশন, এম্বেডিং, টেক্সট ট্রান্সলেশন ইত্যাদি করা হয়।

এখানে আমরা একটি সাধারণ টেক্সট ক্লাসিফিকেশন প্রজেক্ট তৈরি করব, যেখানে একটি মডেল বিনামূল্যে টেক্সট ডেটা ব্যবহার করে দুইটি শ্রেণীতে (positive/negative) শ্রেণীবদ্ধ করবে। আমরা LSTM (Long Short-Term Memory) ব্যবহার করব যা NLP টাস্কে জনপ্রিয় মডেল।

ধাপ ১: PyTorch এবং প্রয়োজনীয় লাইব্রেরি ইনস্টলেশন

প্রথমে, PyTorch এবং প্রয়োজনীয় লাইব্রেরি ইনস্টল করতে হবে:

pip install torch torchvision torchaudio
pip install torchtext

ধাপ ২: ডেটা লোডিং এবং প্রিপ্রসেসিং

এখানে আমরা torchtext লাইব্রেরি ব্যবহার করে একটি সাধারণ টেক্সট ডেটাসেট (যেমন IMDB বা AG News) লোড করব এবং কিছু প্রিপ্রসেসিং করব।

১. ডেটা লোডিং:

import torch
from torchtext.datasets import IMDB
from torchtext.data import Field, BucketIterator

# Define Fields (data preprocessing steps)
TEXT = Field(sequential=True, tokenize='spacy', batch_first=True, include_lengths=True)
LABEL = Field(sequential=False, use_vocab=True, pad_token=None, unk_token=None)

# Load IMDB dataset
train_data, test_data = IMDB.splits(TEXT, LABEL)

২. প্রিপ্রসেসিং:

• Tokenization: আমরা spaCy tokenizer ব্যবহার করব।
• Vocabulary Creation: ডেটাসেট থেকে ভোক্যাবুলারি তৈরি করা হবে।
• Vectorization: শব্দগুলিকে ইনডেক্সে রূপান্তর করা হবে।

# Build vocabulary
TEXT.build_vocab(train_data, max_size=10000, vectors="glove.6B.100d", unk_init=torch.Tensor.normal_)
LABEL.build_vocab(train_data)

# Create iterators for batching
BATCH_SIZE = 64
train_iterator, test_iterator = BucketIterator.splits((train_data, test_data), batch_size=BATCH_SIZE, device=torch.device('cuda' if torch.cuda.is_available() else 'cpu'))

ধাপ ৩: মডেল তৈরি

এখন, আমরা একটি LSTM ভিত্তিক মডেল তৈরি করব, যা টেক্সট ক্লাসিফিকেশন করবে। আমরা Embedding Layer, LSTM Layer, এবং Fully Connected Layer ব্যবহার করব।

import torch.nn as nn

class LSTMModel(nn.Module):
    def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout):
        super(LSTMModel, self).__init__()
        self.embedding = nn.Embedding(input_dim, embedding_dim)
        self.lstm = nn.LSTM(embedding_dim, hidden_dim, num_layers=n_layers, dropout=dropout, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_dim)
        self.dropout = nn.Dropout(dropout)
        
    def forward(self, text, text_lengths):
        embedded = self.embedding(text)
        packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths.cpu(), batch_first=True, enforce_sorted=False)
        packed_output, (hidden, cell) = self.lstm(packed_embedded)
        output = self.dropout(hidden[-1])
        return self.fc(output)

# Hyperparameters
input_dim = len(TEXT.vocab)
embedding_dim = 100
hidden_dim = 256
output_dim = 1
n_layers = 2
dropout = 0.5

# Create model
model = LSTMModel(input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout)

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

এখন, আমরা মডেলটি ট্রেন করব। আমরা binary cross-entropy loss এবং Adam optimizer ব্যবহার করব।

import torch.optim as optim
import torch.nn.functional as F

# Loss function and optimizer
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()

# Move model to GPU if available
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model.to(device)
criterion.to(device)

# Training loop
def train(model, iterator, optimizer, criterion):
    model.train()
    epoch_loss = 0
    epoch_acc = 0
    
    for batch in iterator:
        text, text_lengths = batch.text
        labels = batch.label
        
        optimizer.zero_grad()
        
        # Forward pass
        predictions = model(text, text_lengths).squeeze(1)
        
        # Calculate loss and accuracy
        loss = criterion(predictions, labels.float())
        acc = binary_accuracy(predictions, labels)
        
        # Backward pass
        loss.backward()
        optimizer.step()
        
        epoch_loss += loss.item()
        epoch_acc += acc.item()
    
    return epoch_loss / len(iterator), epoch_acc / len(iterator)

def binary_accuracy(preds, y):
    rounded_preds = torch.round(torch.sigmoid(preds))
    correct = (rounded_preds == y).float()
    acc = correct.sum() / len(correct)
    return acc

# Train the model for some epochs
num_epochs = 5
for epoch in range(num_epochs):
    train_loss, train_acc = train(model, train_iterator, optimizer, criterion)
    print(f'Epoch: {epoch+1}, Train Loss: {train_loss:.3f}, Train Accuracy: {train_acc:.3f}')

ধাপ ৫: মডেল ভ্যালিডেশন

ভ্যালিডেশন ডেটা ব্যবহার করে মডেলটি পরীক্ষা করা।

def evaluate(model, iterator, criterion):
    model.eval()
    epoch_loss = 0
    epoch_acc = 0
    
    with torch.no_grad():
        for batch in iterator:
            text, text_lengths = batch.text
            labels = batch.label
            
            predictions = model(text, text_lengths).squeeze(1)
            
            loss = criterion(predictions, labels.float())
            acc = binary_accuracy(predictions, labels)
            
            epoch_loss += loss.item()
            epoch_acc += acc.item()
    
    return epoch_loss / len(iterator), epoch_acc / len(iterator)

# Evaluate the model
val_loss, val_acc = evaluate(model, test_iterator, criterion)
print(f'Validation Loss: {val_loss:.3f}, Validation Accuracy: {val_acc:.3f}')

ধাপ ৬: মডেল সংরক্ষণ এবং লোড করা

মডেলটি প্রোডাকশনে ব্যবহারের জন্য সংরক্ষণ (save) এবং পরে লোড (load) করা যাবে।

মডেল সংরক্ষণ:

torch.save(model.state_dict(), 'text_classification_model.pth')

মডেল লোড করা:

model = LSTMModel(input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout)
model.load_state_dict(torch.load('text_classification_model.pth'))
model.eval()

সারাংশ

এই প্রজেক্টে, আমরা একটি LSTM মডেল তৈরি করেছি এবং IMDB ডেটাসেট ব্যবহার করে টেক্সট ক্লাসিফিকেশন করার জন্য PyTorch এর মাধ্যমে একটি NLP প্রজেক্ট তৈরি করেছি। মডেলটি ট্রেন করার জন্য আমরা Embedding Layer, LSTM Layer, এবং Fully Connected Layer ব্যবহার করেছি। এরপর আমরা মডেলটি Flask বা FastAPI এ ডেপ্লয় করতে পারি এবং প্রোডাকশনে ব্যবহার করতে পারি।

এই প্রক্রিয়া দ্বারা, আপনি অন্য ধরনের NLP টাস্ক, যেমন স্প্যাম ফিল্টারিং, টেক্সট জেনারেশন, ভাষা অনুবাদ, এবং অন্য ক্লাসিফিকেশন টাস্কে PyTorch ব্যবহার করতে পারবেন।