Natural Language Processing (NLP) হল একটি শাখা যা কম্পিউটার সিস্টেমকে মানুষের ভাষা (যেমন ইংরেজি, বাংলা, ইত্যাদি) বুঝতে, বিশ্লেষণ করতে এবং প্রক্রিয়া করতে সহায়তা করে। NLP-এর মাধ্যমে কম্পিউটার ভাষার বিভিন্ন দিক যেমন বাক্য গঠন (Syntax), অর্থ (Semantics), এবং ব্যবহারিক অর্থ (Pragmatics) বুঝতে পারে এবং সেই অনুযায়ী সিদ্ধান্ত নিতে পারে।
PyTorch একটি শক্তিশালী ডিপ লার্নিং ফ্রেমওয়ার্ক যা NLP প্রকল্পে ব্যবহার করা যেতে পারে। PyTorch-এ torchtext লাইব্রেরি এবং বিভিন্ন পিপলিন (pipeline) সহ NLP কাজগুলো সুশৃঙ্খলভাবে করা যায়।
এই পোস্টে, আমরা PyTorch দিয়ে একটি সাধারণ NLP প্রজেক্ট তৈরির প্রক্রিয়া ব্যাখ্যা করব।
PyTorch, বিশেষ করে torchtext লাইব্রেরি ব্যবহার করে, সহজে NLP মডেল তৈরি করা সম্ভব। PyTorch-এর গঠন এবং টেনসর ব্যবস্থাপনা NLP কাজকে সহজ করে তোলে। এর সাহায্যে আমরা বিভিন্ন NLP সমস্যার জন্য মডেল তৈরি করতে পারি, যেমন রেকারেন্ট নিউরাল নেটওয়ার্ক (RNN), লং শর্ট টার্ম মেমোরি (LSTM), বা ট্রান্সফর্মার মডেল।
এখানে আমরা একটি সাধারণ টেক্সট ক্লাসিফিকেশন মডেল তৈরি করব, যা IMDb ডেটাসেট ব্যবহার করে সিনেমার রিভিউ প্রেডিক্ট করবে (ইতিবাচক বা নেতিবাচক)।
pip install torch torchvision torchtext
import torch
from torchtext import data
from torchtext import datasets
# টেক্সট ফিল্ড তৈরি
TEXT = data.Field(sequential=True, tokenize='spacy', batch_first=True, include_lengths=True)
LABEL = data.LabelField(dtype=torch.float)
# ডেটাসেট লোড করা (IMDb)
train_data, test_data = datasets.IMDB.splits(TEXT, LABEL)
# ট্রেনিং ডেটা এবং টেস্ট ডেটা ভাগ করা
train_data, valid_data = train_data.split(random_state=torch.manual_seed(1234))
# শব্দ ভোকাবুলারি তৈরি করা
TEXT.build_vocab(train_data, max_size=25000, vectors="glove.6B.100d", unk_init=torch.Tensor.normal_)
LABEL.build_vocab(train_data)
# ডেটা লোডার তৈরি করা
batch_size = 64
train_iterator, valid_iterator, test_iterator = data.BucketIterator.splits(
(train_data, valid_data, test_data),
batch_size=batch_size,
device=torch.device("cuda" if torch.cuda.is_available() else "cpu")
)
এখন, একটি সাধারণ LSTM মডেল তৈরি করি:
import torch.nn as nn
class RNNModel(nn.Module):
def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout):
super().__init__()
self.embedding = nn.Embedding(input_dim, embedding_dim)
self.rnn = 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)
self.sigmoid = nn.Sigmoid()
def forward(self, text, text_lengths):
embedded = self.embedding(text)
packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths, batch_first=True, enforce_sorted=False)
packed_output, (hidden, cell) = self.rnn(packed_embedded)
output = self.fc(self.dropout(hidden[-1]))
return self.sigmoid(output)
# ইনপুট আউটপুট সাইজ নির্ধারণ
input_dim = len(TEXT.vocab)
embedding_dim = 100
hidden_dim = 256
output_dim = 1
n_layers = 2
dropout = 0.5
# মডেল তৈরি
model = RNNModel(input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout)
import torch.optim as optim
# অপটিমাইজার এবং লস ফাংশন
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()
# মডেল ট্রেনিং
def train_model(model, iterator, optimizer, criterion):
model.train()
epoch_loss = 0
epoch_acc = 0
for batch in iterator:
optimizer.zero_grad()
text, text_lengths = batch.text
predictions = model(text, text_lengths).squeeze(1)
loss = criterion(predictions, batch.label)
acc = binary_accuracy(predictions, batch.label)
loss.backward()
optimizer.step()
epoch_loss += loss.item()
epoch_acc += acc.item()
return epoch_loss / len(iterator), epoch_acc / len(iterator)
# Accuracy ফাংশন
def binary_accuracy(preds, y):
rounded_preds = torch.round(preds)
correct = (rounded_preds == y).float()
acc = correct.sum() / len(correct)
return acc
# মডেল টেস্টিং
def evaluate_model(model, iterator, criterion):
model.eval()
epoch_loss = 0
epoch_acc = 0
with torch.no_grad():
for batch in iterator:
text, text_lengths = batch.text
predictions = model(text, text_lengths).squeeze(1)
loss = criterion(predictions, batch.label)
acc = binary_accuracy(predictions, batch.label)
epoch_loss += loss.item()
epoch_acc += acc.item()
return epoch_loss / len(iterator), epoch_acc / len(iterator)
# ট্রেনিং এবং টেস্টিং চলবে
for epoch in range(10):
train_loss, train_acc = train_model(model, train_iterator, optimizer, criterion)
valid_loss, valid_acc = evaluate_model(model, valid_iterator, criterion)
print(f'Epoch {epoch+1}')
print(f'Training Loss: {train_loss:.3f}, Training Accuracy: {train_acc*100:.2f}%')
print(f'Validation Loss: {valid_loss:.3f}, Validation Accuracy: {valid_acc*100:.2f}%')
একবার মডেল ট্রেনিং শেষ হলে, আপনি এটিকে প্রেডিকশন করার জন্য ব্যবহার করতে পারেন। উদাহরণস্বরূপ, একটি সিনেমার রিভিউ প্রেডিক্ট করার জন্য:
def predict_sentiment(model, sentence):
model.eval()
tokenized = sentence.split()
indexed = [TEXT.vocab.stoi[t] for t in tokenized]
tensor = torch.LongTensor(indexed).unsqueeze(0)
length = torch.LongTensor([len(indexed)])
prediction = model(tensor, length)
return prediction.item()
sentence = "This movie is amazing!"
print(predict_sentiment(model, sentence)) # Sentiment prediction (0 = Negative, 1 = Positive)
PyTorch একটি শক্তিশালী টুল যা NLP প্রকল্পগুলিতে সহজে ডিপ লার্নিং মডেল তৈরি এবং ট্রেনিং করতে সহায়ক।
Natural Language Processing (NLP) হল মেশিন লার্নিং এবং আর্টিফিশিয়াল ইনটেলিজেন্সের একটি শাখা যা কম্পিউটারের মাধ্যমে মানুষের ভাষা (যেমন, ইংরেজি, বাংলা, স্প্যানিশ ইত্যাদি) বুঝতে, বিশ্লেষণ করতে, প্রক্রিয়া করতে এবং উৎপাদন করতে ব্যবহৃত হয়। NLP এর উদ্দেশ্য হলো কম্পিউটারের মাধ্যমে ভাষার সঙ্গে সম্পর্কিত কাজগুলো সহজ করা, যেমন:
NLP বিভিন্ন কাজের জন্য ভাষার গঠন ও অর্থ বুঝতে চেষ্টা করে। এটি ভাষাগত বৈশিষ্ট্য যেমন Syntax (বাক্য গঠন) এবং Semantics (অর্থ) বিশ্লেষণ করে।
PyTorch একটি পাওয়ারফুল ডিপ লার্নিং লাইব্রেরি যা NLP কাজের জন্যও ব্যাপকভাবে ব্যবহৃত হয়। PyTorch এ NLP কাজ করার জন্য মূলত TorchText লাইব্রেরি ব্যবহার করা হয়, তবে PyTorch এর অন্যান্য লাইব্রেরি এবং transformers এর মতো লাইব্রেরিও NLP টাস্কে ব্যবহৃত হয়।
এখানে একটি সাধারণ টেক্সট ক্লাসিফিকেশন মডেল তৈরি করার উদাহরণ দেওয়া হয়েছে, যেখানে আমরা PyTorch ব্যবহার করে একটি LSTM মডেল তৈরি করব এবং একটি ছোট ডেটাসেট ব্যবহার করে ট্রেন করব।
pip install torch torchtext
আমরা TorchText ব্যবহার করে ডেটাসেট লোড করব এবং প্রিপ্রসেস করব। এখানে একটি সাধারণ IMDB ডেটাসেট ব্যবহার করা হয়েছে, যা পজিটিভ এবং নেগেটিভ সিনেমা রিভিউ থেকে তৈরি।
import torch
from torchtext import data
from torchtext.datasets import IMDB
# ফিল্ডস তৈরি করা
TEXT = data.Field(sequential=True, lower=True, batch_first=True)
LABEL = data.LabelField(dtype=torch.float)
# IMDB ডেটাসেট লোড করা
train_data, test_data = IMDB.splits(TEXT, LABEL)
# শব্দ ভোকাবুলারি তৈরি করা
TEXT.build_vocab(train_data, max_size=25000, vectors="glove.6B.100d", unk_init=torch.Tensor.normal_)
LABEL.build_vocab(train_data)
# ডেটা লোডার তৈরি করা
train_iterator, test_iterator = data.BucketIterator.splits((train_data, test_data), batch_size=64, device=device)
এখন আমরা একটি সোজা LSTM মডেল তৈরি করব যা টেক্সট ক্লাসিফিকেশন করবে।
import torch.nn as nn
class LSTMModel(nn.Module):
def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout):
super().__init__()
self.embedding = nn.Embedding(input_dim, embedding_dim)
self.lstm = nn.LSTM(embedding_dim, hidden_dim, n_layers, dropout=dropout, batch_first=True)
self.fc = nn.Linear(hidden_dim, output_dim)
self.dropout = nn.Dropout(dropout)
def forward(self, text):
embedded = self.embedding(text)
lstm_out, (hidden, cell) = self.lstm(embedded)
hidden = self.dropout(hidden[-1])
out = self.fc(hidden)
return out
# মডেল ইনস্ট্যান্স তৈরি
input_dim = len(TEXT.vocab)
embedding_dim = 100
hidden_dim = 256
output_dim = 1
n_layers = 2
dropout = 0.5
model = LSTMModel(input_dim, embedding_dim, hidden_dim, output_dim, n_layers, dropout)
এখন আমরা আমাদের LSTM মডেলটি ট্রেনিং করব। এর জন্য আমরা binary cross-entropy loss এবং Adam optimizer ব্যবহার করব।
import torch.optim as optim
from torchmetrics.classification import BinaryAccuracy
# অপটিমাইজার এবং লস ফাংশন
optimizer = optim.Adam(model.parameters())
criterion = nn.BCEWithLogitsLoss()
# মডেল ট্রেনিং
def train_model(model, iterator, optimizer, criterion):
model.train()
epoch_loss = 0
epoch_acc = 0
for batch in iterator:
optimizer.zero_grad()
predictions = model(batch.text).squeeze(1)
loss = criterion(predictions, batch.label)
acc = BinaryAccuracy()(predictions, batch.label)
loss.backward()
optimizer.step()
epoch_loss += loss.item()
epoch_acc += acc.item()
return epoch_loss / len(iterator), epoch_acc / len(iterator)
# ট্রেনিং চালানো
train_loss, train_acc = train_model(model, train_iterator, optimizer, criterion)
print(f'Train Loss: {train_loss:.3f}, Train Accuracy: {train_acc*100:.2f}%')
টেস্ট ডেটা দিয়ে মডেলটির পারফরম্যান্স যাচাই করতে:
def evaluate_model(model, iterator, criterion):
model.eval()
epoch_loss = 0
epoch_acc = 0
with torch.no_grad():
for batch in iterator:
predictions = model(batch.text).squeeze(1)
loss = criterion(predictions, batch.label)
acc = BinaryAccuracy()(predictions, batch.label)
epoch_loss += loss.item()
epoch_acc += acc.item()
return epoch_loss / len(iterator), epoch_acc / len(iterator)
test_loss, test_acc = evaluate_model(model, test_iterator, criterion)
print(f'Test Loss: {test_loss:.3f}, Test Accuracy: {test_acc*100:.2f}%')
NLP (Natural Language Processing) হলো ভাষা সম্পর্কিত কাজের জন্য ব্যবহৃত মেশিন লার্নিং এবং ডিপ লার্নিং এর শাখা। PyTorch এ NLP কাজ করার জন্য বিভিন্ন প্রযুক্তি এবং মডেল (যেমন LSTM, GRU, Transformer) ব্যবহার করা হয়। এখানে আমরা LSTM ব্যবহার করে একটি টেক্সট ক্লাসিফিকেশন মডেল তৈরি করেছি যা প্রাক প্রশিক্ষিত GloVe embeddings এবং TorchText ব্যবহার করে ইম্প্লিমেন্ট করা হয়েছে। PyTorch একটি শক্তিশালী প্ল্যাটফর্ম NLP মডেল ট্রেনিং এবং ডিপ লার্নিং কাজগুলো সহজ এবং দ্রুত করতে সাহায্য করে।
Word Embeddings হলো একটি প্রক্রিয়া যার মাধ্যমে শব্দগুলোকে একটি সুনির্দিষ্ট ভেক্টরে রূপান্তরিত করা হয়, যেখানে প্রতিটি শব্দ একটি নির্দিষ্ট সংখ্যার ভেক্টর হিসেবে উপস্থাপিত হয়। Word Embeddings শব্দের মধ্যে সেমান্টিক সম্পর্ক (semantic relationships) ধরতে সাহায্য করে এবং শব্দের মধ্যে ভৌত বা অর্থগত সম্পর্ক তৈরি করে।
Word embeddings এর মাধ্যমে, একে অপরের সাথে সম্পর্কিত শব্দগুলো কাছাকাছি অবস্থানে থাকে, যা মেশিন লার্নিং বা ডিপ লার্নিং মডেলগুলিকে ভাষার অর্থ বুঝতে সাহায্য করে।
Word2Vec (Word to Vec) হলো একটি পদ্ধতি যা শব্দের জন্য dense vector representations তৈরি করতে ব্যবহৃত হয়। এটি Google দ্বারা উন্নত একটি শব্দ এম্বেডিং মডেল, যা শব্দের মধ্যে সেমান্টিক সম্পর্ক শেখার জন্য প্রশিক্ষিত হয়।
Word2Vec দুটি প্রধান আর্কিটেকচারে কাজ করে:
GloVe (Global Vectors for Word Representation) একটি আরেকটি জনপ্রিয় টেকনিক যা শব্দের জন্য এম্বেডিং তৈরি করার জন্য ব্যবহৃত হয়। এটি Stanford University দ্বারা তৈরি হয়েছে এবং Word2Vec এর তুলনায় কিছুটা ভিন্ন কৌশল ব্যবহার করে।
GloVe একটি matrix factorization টেকনিক ব্যবহার করে, যা একটি শব্দ-শব্দ সহমিলন ম্যাট্রিক্স (word co-occurrence matrix) তৈরি করে। এটি একটি globally aggregated কৌশল, যেখানে পুরো ডেটাসেটের মধ্যে শব্দের সহমিলন পরিসংখ্যান ব্যবহার করা হয়।
| বৈশিষ্ট্য | Word2Vec | GloVe |
|---|---|---|
| কৌশল | লোকাল কনটেক্সট ভিত্তিক (Local Context Based) | গ্লোবাল সহমিলন পরিসংখ্যান ভিত্তিক (Global Co-occurrence) |
| ডেটা প্রসেসিং | দ্রুত প্রশিক্ষণ এবং কম্পিউটেশনাল খরচ | বৃহত্তর ডেটাসেটের জন্য উপযুক্ত |
| প্রকৃতি | ডিপ নিউরাল নেটওয়ার্ক | ম্যাট্রিক্স ফ্যাক্টরাইজেশন |
| ব্যবহার | শব্দের সমকক্ষ (analogy), কনটেক্সট ভিত্তিক কাজ | শব্দের সম্পর্ক, উচ্চ মাত্রিক তথ্য বিশ্লেষণ |
Word2Vec এবং GloVe দুটি শব্দ এম্বেডিং কৌশল যা ভাষাগত সম্পর্ক এবং শব্দের মধ্যে সেমান্টিক সম্পর্ক শিখতে সহায়ক। Word2Vec একটি লোকাল কনটেক্সট ভিত্তিক মডেল যা শব্দের সম্পর্ক শেখে, আর GloVe গ্লোবাল কনটেক্সট এবং সহমিলন ম্যাট্রিক্সের উপর ভিত্তি করে শব্দের এম্বেডিং তৈরি করে। এই দুটি কৌশল শব্দের বুদ্ধিমত্তা বা অর্থ বুঝতে সাহায্য করে এবং ভাষার মডেল তৈরি করার ক্ষেত্রে একটি শক্তিশালী টুল হিসেবে ব্যবহৃত হয়।
Sentiment Analysis এবং Text Classification দুটি গুরুত্বপূর্ণ প্রাকৃতিক ভাষা প্রক্রিয়াকরণ (NLP) টাস্ক যা টেক্সট ডেটার সাথে কাজ করার সময় ব্যাপকভাবে ব্যবহৃত হয়। এগুলির মূল উদ্দেশ্য হল টেক্সট ডেটার মধ্যে গোপন তথ্য বিশ্লেষণ এবং শ্রেণীবদ্ধকরণ করা।
Sentiment Analysis হল একটি Text Classification টাস্ক যেখানে টেক্সটের একটি অংশের সেন্টিমেন্ট বা আবেগ চিহ্নিত করা হয়। সাধারণত এটি ইতিবাচক, নেতিবাচক, এবং নিরপেক্ষ হিসেবে শ্রেণীবদ্ধ করা হয়। এটি ব্যবসা, সোশ্যাল মিডিয়া মনিটরিং, রিভিউ বিশ্লেষণ, এবং কাস্টমার সাপোর্ট ব্যবস্থাপনায় ব্যবহৃত হয়।
এখানে PyTorch এবং HuggingFace Transformers ব্যবহার করে একটি বেসিক Sentiment Analysis মডেল তৈরির উদাহরণ দেওয়া হলো।
from transformers import pipeline
# HuggingFace থেকে Pretrained Sentiment Analysis Pipeline ব্যবহার
sentiment_analyzer = pipeline('sentiment-analysis')
# টেক্সট ইনপুট
text = "I love this movie! It's amazing."
# প্রেডিকশন
result = sentiment_analyzer(text)
print(result) # [{'label': 'POSITIVE', 'score': 0.9998}]
এটি একটি BERT ভিত্তিক মডেল ব্যবহার করে সেন্টিমেন্ট বিশ্লেষণ করে এবং প্রেডিকশন হিসেবে POSITIVE বা NEGATIVE সেন্টিমেন্ট প্রদান করে।
Text Classification হল একটি মেশিন লার্নিং টাস্ক যেখানে টেক্সট ডেটাকে বিভিন্ন ক্লাস বা ক্যাটেগরিতে শ্রেণীবদ্ধ করা হয়। এটি একটি সাধারণ NLP টাস্ক যা বিভিন্ন প্রকার ডেটাতে ব্যবহৃত হয়, যেমন স্প্যাম ডিটেকশন, টপিক মডেলিং, এমেইল ক্লাসিফিকেশন, নিউজ ক্লাসিফিকেশন ইত্যাদি।
import torch
from torch import nn
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics import accuracy_score
# উদাহরণ ডেটাসেট
texts = ["I love programming", "This movie is awesome", "I hate waiting", "Worst experience ever", "Best game ever"]
labels = [1, 1, 0, 0, 1] # 1 = Positive, 0 = Negative
# TF-IDF ভেক্টরাইজেশন
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(texts)
y = labels
# ডেটা ট্রেন এবং টেস্টে ভাগ করা
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Logistic Regression মডেল
from sklearn.linear_model import LogisticRegression
model = LogisticRegression()
model.fit(X_train, y_train)
# প্রেডিকশন এবং একিউরেসি
y_pred = model.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy * 100}%")
এখানে TF-IDF ব্যবহার করে টেক্সট ভেক্টরাইজ করা হয়েছে এবং Logistic Regression মডেল দিয়ে ক্লাসিফিকেশন করা হয়েছে।
| পার্থক্য | Sentiment Analysis | Text Classification |
|---|---|---|
| লক্ষ্য | টেক্সটের আবেগ বা সেন্টিমেন্ট চিহ্নিত করা (ইতিবাচক, নেতিবাচক) | টেক্সটকে নির্দিষ্ট শ্রেণিতে বিভক্ত করা (যেমন, স্প্যাম বা নন-স্প্যাম) |
| ক্লাস | সাধারণত দুটি (ইতিবাচক/নেতিবাচক) | একাধিক শ্রেণী হতে পারে (স্প্যাম, স্প্যাম নয়) |
| ব্যবহার | সোশ্যাল মিডিয়া মনিটরিং, রিভিউ বিশ্লেষণ, কাস্টমার ফিডব্যাক | স্প্যাম ডিটেকশন, টপিক মডেলিং, নিউজ শ্রেণীবিভাগ |
Natural Language Processing (NLP) হলো মেশিন লার্নিং এবং ডিপ লার্নিংয়ের একটি গুরুত্বপূর্ণ শাখা, যা ভাষাগত তথ্যের সাথে কাজ করে, যেমন টেক্সট বা স্পিচ ডেটা। PyTorch-এ NLP প্রজেক্ট তৈরি করার জন্য সাধারণত প্রাকৃতিক ভাষা প্রক্রিয়াকরণ (NLP) টাস্ক যেমন টেক্সট ক্লাসিফিকেশন, স্প্যাম ফিল্টারিং, টেক্সট জেনারেশন, এম্বেডিং, টেক্সট ট্রান্সলেশন ইত্যাদি করা হয়।
এখানে আমরা একটি সাধারণ টেক্সট ক্লাসিফিকেশন প্রজেক্ট তৈরি করব, যেখানে একটি মডেল বিনামূল্যে টেক্সট ডেটা ব্যবহার করে দুইটি শ্রেণীতে (positive/negative) শ্রেণীবদ্ধ করবে। আমরা LSTM (Long Short-Term Memory) ব্যবহার করব যা NLP টাস্কে জনপ্রিয় মডেল।
প্রথমে, 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)
spaCy tokenizer ব্যবহার করব।# 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 ব্যবহার করতে পারবেন।
Read more
or
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
