Time Series Data নিয়ে কাজ করার উদাহরণ

Time Series Data হল এমন ডেটা যা নির্দিষ্ট সময়ের মধ্যে সংগ্রহ করা হয়, যেখানে প্রতিটি ডেটা পয়েন্ট একটি সময় সিলেবেল দ্বারা চিহ্নিত থাকে। এটি সাধারণত আর্থিক ডেটা, আবহাওয়া, ইকোনমিক ডেটা, সেলস ডেটা ইত্যাদির জন্য ব্যবহৃত হয়।

Time Series Data নিয়ে কাজ করার জন্য, সাধারণত Data Preprocessing, Model Building, এবং Forecasting প্রক্রিয়াগুলি প্রয়োজন হয়। নিচে PyTorch দিয়ে একটি Time Series Data নিয়ে কাজ করার উদাহরণ দেওয়া হলো, যেখানে ARIMA, LSTM বা অন্য কোনো মডেল ব্যবহার করতে পারি।

এখানে, আমরা PyTorch দিয়ে একটি Time Series Forecasting মডেল তৈরি করার একটি উদাহরণ দেখাবো যেখানে আমরা LSTM (Long Short-Term Memory) ব্যবহার করব, যা Time Series Prediction এর জন্য একটি শক্তিশালী টুল।

১. ডেটা লোডিং এবং প্রিপ্রসেসিং

এখানে আমরা Pandas এবং Matplotlib ব্যবহার করব Time Series ডেটা লোড, প্রিপ্রসেস এবং ভিজ্যুয়ালাইজ করার জন্য।

pip install pandas matplotlib numpy torch scikit-learn

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from sklearn.preprocessing import MinMaxScaler

# ডেটা লোড করা (উদাহরণস্বরূপ, এক্সেল বা CSV ফাইল)
url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-passengers.csv'
df = pd.read_csv(url, header=0, index_col=0, parse_dates=True, squeeze=True)

# ডেটা প্লট করা
df.plot()
plt.title('Monthly Airline Passengers')
plt.xlabel('Date')
plt.ylabel('Passengers')
plt.show()

এই কোডের মাধ্যমে Airline Passengers Dataset ডেটা লোড এবং একটি Time Series চিত্র তৈরি করা হবে।

২. ডেটা স্কেলিং

Time Series মডেল তৈরি করার আগে, ডেটা স্কেলিং অত্যন্ত গুরুত্বপূর্ণ, বিশেষত LSTM এর জন্য। এখানে আমরা MinMaxScaler ব্যবহার করব।

# MinMaxScaler ব্যবহার করে ডেটা স্কেলিং
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(df.values.reshape(-1, 1))

# ডেটা ট্রেনিং এবং টেস্টিং সেটে ভাগ করা
train_size = int(len(scaled_data) * 0.8)
train_data, test_data = scaled_data[:train_size], scaled_data[train_size:]

# ডেটা পুনর্গঠন করা যাতে তা LSTM এর জন্য উপযুক্ত হয়
def create_dataset(data, time_step=1):
    X, Y = [], []
    for i in range(len(data) - time_step - 1):
        X.append(data[i:(i + time_step), 0])
        Y.append(data[i + time_step, 0])
    return np.array(X), np.array(Y)

time_step = 12  # একটি বছর ধরে (12 মাস)
X_train, Y_train = create_dataset(train_data, time_step)
X_test, Y_test = create_dataset(test_data, time_step)

# LSTM মডেলের ইনপুট ফরম্যাটে ডেটা রি শেপ করা
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)

এখানে, create_dataset ফাংশনটি Time Series ডেটা কে (X, Y) সেটে পরিণত করবে যেখানে X হবে পেছনের কিছু পয়েন্ট এবং Y হবে পরবর্তী পয়েন্টের মান।

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

এখন, PyTorch দিয়ে একটি LSTM মডেল তৈরি করা হবে। LSTM সাধারণত Time Series Data-এর পূর্বাভাস (forecasting) করতে ব্যবহৃত হয়।

import torch
import torch.nn as nn

# LSTM মডেল তৈরি
class LSTMModel(nn.Module):
    def __init__(self, input_size=1, hidden_layer_size=50, num_layers=1):
        super(LSTMModel, self).__init__()
        
        self.lstm = nn.LSTM(input_size, hidden_layer_size, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_layer_size, 1)
    
    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.fc(out[:, -1, :])  # আমরা শেষ লেয়ারের আউটপুট নেবো
        return out

# মডেল ইনস্ট্যান্স তৈরি
model = LSTMModel()

এখানে LSTMModel ক্লাস তৈরি করা হয়েছে, যা LSTM এবং Fully Connected (FC) Layer ব্যবহার করে।

৪. মডেল ট্রেনিং এবং টেস্টিং

এখন আমরা LSTM মডেলটি ট্রেনিং এবং টেস্টিং করতে পারি। প্রথমে Mean Squared Error (MSE) লস ফাংশন এবং Adam অপটিমাইজার ব্যবহার করা হবে।

# হার্ডওয়্যার নির্বাচন
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

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

# ট্রেনিং
epochs = 100
for epoch in range(epochs):
    model.train()
    inputs = torch.tensor(X_train, dtype=torch.float32).to(device)
    labels = torch.tensor(Y_train, dtype=torch.float32).to(device)
    
    # ফরওয়ার্ড পাস
    outputs = model(inputs)
    
    # লস ক্যালকুলেশন
    loss = criterion(outputs, labels)
    
    # ব্যাকপ্রোপাগেশন
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if epoch % 10 == 0:
        print(f'Epoch [{epoch}/{epochs}], Loss: {loss.item():.4f}')

# টেস্টিং
model.eval()
inputs = torch.tensor(X_test, dtype=torch.float32).to(device)
labels = torch.tensor(Y_test, dtype=torch.float32).to(device)

# আউটপুট প্রেডিকশন
with torch.no_grad():
    predictions = model(inputs)
    
# আউটপুটকে স্কেল করে আসল মানে ফিরিয়ে আনা
predicted = scaler.inverse_transform(predictions.cpu().numpy())
real = scaler.inverse_transform(labels.cpu().numpy().reshape(-1, 1))

# প্লট করা
plt.plot(real, label='Real Data')
plt.plot(predicted, label='Predicted Data')
plt.legend()
plt.show()

এখানে, আমরা LSTM মডেলটি ট্রেনিং এবং টেস্টিং করেছি এবং MSE লস ব্যবহার করেছি। মডেলটি টেস্ট ডেটার উপর প্রেডিকশন করেছে এবং তার পরিমাণের সঙ্গে তুলনা করা হয়েছে।

৫. ফলাফল এবং ভিজ্যুয়ালাইজেশন

আমরা real এবং predicted ডেটা প্লট করে দেখতে পারি কিভাবে মডেলটি আসল ডেটা ভবিষ্যদ্বাণী করেছে।

# প্রেডিকশন এবং আসল ডেটার তুলনা
plt.plot(real, label='Real Data')
plt.plot(predicted, label='Predicted Data')
plt.legend()
plt.title("Real vs Predicted Time Series Data")
plt.show()

এটি Real Data এবং Predicted Data এর মধ্যে তুলনা করবে, যাতে আমরা বুঝতে পারি মডেলটি কতটা সঠিকভাবে ভবিষ্যদ্বাণী করতে সক্ষম।

সারাংশ

এটি ছিল একটি Time Series Forecasting এর উদাহরণ, যেখানে আমরা PyTorch দিয়ে একটি LSTM মডেল তৈরি করেছি, এবং MNIST ডেটাসেটের উপর প্রেডিকশন করা হয়েছে। Data preprocessing, LSTM Model building, Training এবং Testing এর প্রক্রিয়া ছিল:

• ডেটা স্কেলিং
• LSTM আর্কিটেকচার তৈরি
• মডেল ট্রেনিং এবং টেস্টিং
• প্রেডিকশন এবং ফলাফল ভিজ্যুয়ালাইজেশন

এভাবে LSTM ব্যবহার করে Time Series Data-এর ভবিষ্যদ্বাণী করা যেতে পারে।