PyTorch দিয়ে Time Series মডেল তৈরি

Time Series ডেটা হল এমন ডেটা যা সময়ের সাথে পরিবর্তিত হয়। মডেল তৈরি করার জন্য Time Series ডেটা সাধারণত পূর্ববর্তী মানের উপর ভিত্তি করে ভবিষ্যতের মানের পূর্বাভাস দেয়। PyTorch ব্যবহার করে Time Series মডেল তৈরি করতে আপনি সাধারণত Recurrent Neural Networks (RNNs), Long Short-Term Memory (LSTM), বা Gated Recurrent Units (GRU) ব্যবহার করতে পারেন। এই নেটওয়ার্কগুলি সময়ের সিকোয়েন্স ডেটা বুঝতে এবং ভবিষ্যদ্বাণী করতে সক্ষম।

এখানে আমরা একটি সহজ LSTM মডেল তৈরি করার উদাহরণ দেখবো, যা Time Series ডেটার জন্য ব্যবহৃত হয়।

১. ডেটা প্রস্তুতি

প্রথমে, Time Series ডেটা লোড করা এবং প্রস্তুত করা প্রয়োজন। এটি PyTorch টেনসর ফরম্যাটে রূপান্তরিত হবে, যাতে মডেলটি ডেটা নিয়ে কাজ করতে পারে। এখানে একটি সাধারণ sinusoidal ফাংশন থেকে ডেটা তৈরি করা হয়েছে:

import torch
import numpy as np
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader, Dataset

# Time Series Data তৈরি
def generate_data(seq_length=100):
    x = np.linspace(0, 2*np.pi, seq_length)
    y = np.sin(x)  # Sinusoidal data
    return x, y

# Generate data
x, y = generate_data(seq_length=200)

# Visualize the data
plt.plot(x, y)
plt.title('Sinusoidal Time Series Data')
plt.show()

# PyTorch Dataset তৈরি
class TimeSeriesDataset(Dataset):
    def __init__(self, x, y, seq_length=10):
        self.x = x
        self.y = y
        self.seq_length = seq_length

    def __len__(self):
        return len(self.x) - self.seq_length

    def __getitem__(self, idx):
        seq_x = self.x[idx:idx+self.seq_length]
        seq_y = self.y[idx+self.seq_length]  # Next value as target
        return torch.tensor(seq_x, dtype=torch.float32), torch.tensor(seq_y, dtype=torch.float32)

# DataLoader তৈরি
seq_length = 10
dataset = TimeSeriesDataset(x, y, seq_length)
dataloader = DataLoader(dataset, batch_size=16, shuffle=False)

• generate_data ফাংশনটি sinusoidal ফাংশন ব্যবহার করে Time Series ডেটা তৈরি করে।
• TimeSeriesDataset ক্লাসে ডেটা প্রস্তুতি এবং টেনসর রূপান্তরের কাজ করা হয়।

২. LSTM মডেল তৈরি করা

এখন LSTM মডেল তৈরি করা হবে, যা Time Series ডেটার উপর ভিত্তি করে ভবিষ্যদ্বাণী করবে।

import torch.nn as nn

# LSTM মডেল তৈরি
class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_size=64, num_layers=1, output_size=1):
        super(LSTMModel, self).__init__()
        
        # LSTM লেয়ার
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)
        
        # Fully connected layer
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x):
        # LSTM লেয়ারে ইনপুট পাস করা
        out, _ = self.lstm(x)
        
        # LSTM এর আউটপুট থেকে শেষ সময়ের আউটপুট নেয়া
        out = out[:, -1, :]
        
        # Fully connected layer এর মাধ্যমে আউটপুট তৈরি
        out = self.fc(out)
        return out

# মডেল তৈরি
model = LSTMModel(input_size=1, hidden_size=64, num_layers=1, output_size=1)
print(model)

এখানে:

• LSTMModel ক্লাসটি একটি LSTM মডেল তৈরি করে, যেখানে ইনপুট ডেটা একটি সিকোয়েন্স হিসেবে গ্রহণ করা হয় এবং মডেলটি সেই সিকোয়েন্সের শেষ অংশে ভবিষ্যতের মান অনুমান করে।
• LSTM লেয়ারটি batch_first=True সহ ইনিশিয়ালাইজ করা হয়েছে যাতে ইনপুট আউটপুট [batch_size, sequence_length, input_size] আকারে থাকে।
• Fully Connected Layer (FC) আউটপুট তৈরি করার জন্য ব্যবহার করা হয়।

৩. মডেল প্রশিক্ষণ (Training the Model)

এখন আমরা মডেলটি প্রশিক্ষণ দিতে পারি, যেখানে লস ফাংশন এবং অপটিমাইজার সেট করা হবে। এখানে MSELoss (Mean Squared Error Loss) ব্যবহার করা হয়েছে, যা Time Series প্রেডিকশনের জন্য সাধারণত ব্যবহৃত হয়।

import torch.optim as optim

# মডেল, লস ফাংশন এবং অপটিমাইজার
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# মডেল প্রশিক্ষণ
num_epochs = 100
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    
    for inputs, targets in dataloader:
        inputs = inputs.unsqueeze(-1)  # (batch_size, seq_length, 1) আকারে রূপান্তরিত
        targets = targets.unsqueeze(-1)
        
        # আউটপুট বের করা
        outputs = model(inputs)
        
        # লস হিসাব করা
        loss = criterion(outputs, targets)
        
        # গ্র্যাডিয়েন্ট শূন্য করা
        optimizer.zero_grad()
        
        # ব্যাকপ্রোপাগেশন
        loss.backward()
        
        # ওজন আপডেট করা
        optimizer.step()
        
        running_loss += loss.item()

    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {running_loss/len(dataloader)}')

# প্রশিক্ষণের পর মডেল সংরক্ষণ
torch.save(model.state_dict(), 'lstm_model.pth')

• MSELoss: মডেলের আউটপুট এবং টার্গেটের মধ্যে ত্রুটি পরিমাপ করে।
• Adam Optimizer: মডেলের প্যারামিটার আপডেট করার জন্য Adam অপটিমাইজার ব্যবহার করা হয়েছে।
• মডেল প্রশিক্ষণ পর, তার পারফরম্যান্স মূল্যায়ন করা হয়।

৪. মডেল ভবিষ্যদ্বাণী (Prediction)

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

# মডেল ভবিষ্যদ্বাণী
model.eval()
with torch.no_grad():
    test_input = torch.tensor(x[-seq_length:], dtype=torch.float32).unsqueeze(0).unsqueeze(-1)  # শেষ 10টি পয়েন্ট
    prediction = model(test_input)
    print(f'Predicted Value: {prediction.item()}')

এখানে:

• model.eval(): মডেলটিকে পরীক্ষার মোডে সেট করে।
• torch.no_grad(): এটি গ্র্যাডিয়েন্ট ক্যালকুলেশন বন্ধ করে দেয়, যাতে ভবিষ্যদ্বাণী করার সময় অতিরিক্ত ক্যালকুলেশন না হয়।

সারাংশ

PyTorch দিয়ে Time Series মডেল তৈরি করতে LSTM (Long Short-Term Memory) একটি শক্তিশালী পদ্ধতি। মডেলটি ডেটার পূর্ববর্তী মানের উপর ভিত্তি করে ভবিষ্যতের মান পূর্বাভাস দেয়। এই উদাহরণে:

1. Time Series ডেটা প্রস্তুতি এবং ডেটা লোডিং।
2. LSTM মডেল তৈরি এবং প্রশিক্ষণ।
3. ভবিষ্যদ্বাণী (prediction) করার জন্য মডেল ব্যবহার করা হয়েছে।

Time Series ডেটা প্রসেসিংয়ের জন্য LSTM একটি উপযুক্ত মডেল, কারণ এটি সময়ের উপর ভিত্তি করে প্যাটার্ন শিখতে সক্ষম।