উদাহরণসহ মডেল ট্রেনিং এবং ভ্যালিডেশন

মডেল ট্রেনিং এবং ভ্যালিডেশন করার জন্য PyTorch-এ আমরা কিছু নির্দিষ্ট ধাপ অনুসরণ করি। এই প্রক্রিয়ায়, আমরা একটি Neural Network মডেল তৈরি করে তা ট্রেন করি এবং ভ্যালিডেশন ডেটাসেটে পরীক্ষা করি, যাতে মডেলের পারফরমেন্স যাচাই করা যায়। নিচে উদাহরণসহ বর্ণনা করা হয়েছে।

ধাপ ১: প্যাকেজ ইমপোর্ট করা

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader, random_split

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

আমরা MNIST ডাটাসেট ব্যবহার করবো এবং ট্রেনিং এবং ভ্যালিডেশন ডেটাসেটে বিভক্ত করবো।

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

# ডেটাসেট ডাউনলোড এবং লোড করা
dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)

# ডেটাসেট স্প্লিট করা
train_size = int(0.8 * len(dataset))
val_size = len(dataset) - train_size
train_dataset, val_dataset = random_split(dataset, [train_size, val_size])

train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)

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

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 28 * 28)  # ইনপুট ফ্ল্যাট করা
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = SimpleNN()

ধাপ ৪: লস ফাংশন এবং অপ্টিমাইজার সেট করা

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

ধাপ ৫: ট্রেনিং ফাংশন তৈরি করা

def train_model(model, train_loader, criterion, optimizer):
    model.train()  # মডেলকে ট্রেনিং মোডে সেট করা
    running_loss = 0.0
    
    for images, labels in train_loader:
        # ফোরওয়ার্ড পাস
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # ব্যাকওয়ার্ড পাস এবং অপ্টিমাইজেশন
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
    
    return running_loss / len(train_loader)

ধাপ ৬: ভ্যালিডেশন ফাংশন তৈরি করা

def validate_model(model, val_loader, criterion):
    model.eval()  # মডেলকে ইভালুয়েশন মোডে সেট করা
    val_loss = 0.0
    correct = 0
    total = 0
    
    with torch.no_grad():  # গ্রেডিয়েন্ট ক্যালকুলেশন বন্ধ করা
        for images, labels in val_loader:
            outputs = model(images)
            loss = criterion(outputs, labels)
            val_loss += loss.item()
            
            # প্রেডিকশন বের করা
            _, predicted = torch.max(outputs, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    
    accuracy = 100 * correct / total
    return val_loss / len(val_loader), accuracy

ধাপ ৭: মডেল ট্রেনিং এবং ভ্যালিডেশন চালানো

num_epochs = 5

for epoch in range(num_epochs):
    train_loss = train_model(model, train_loader, criterion, optimizer)
    val_loss, val_accuracy = validate_model(model, val_loader, criterion)
    
    print(f'Epoch [{epoch+1}/{num_epochs}], Train Loss: {train_loss:.4f}, Validation Loss: {val_loss:.4f}, Validation Accuracy: {val_accuracy:.2f}%')

কোডের ব্যাখ্যা

1. ডেটা স্প্লিট করা: ডেটাসেটকে ৮০% ট্রেনিং এবং ২০% ভ্যালিডেশন ডেটাসেটে ভাগ করা হয়েছে।
2. মডেল তৈরি: একটি বেসিক Neural Network মডেল তৈরি করা হয়েছে।
3. ট্রেনিং ফাংশন: train_model ফাংশন ট্রেনিং ডেটার উপর মডেল ট্রেন করে এবং গড় ট্রেনিং লস রিটার্ন করে।
4. ভ্যালিডেশন ফাংশন: validate_model ফাংশন ভ্যালিডেশন ডেটাসেটে মডেল পরীক্ষা করে এবং লস ও এক্যুরেসি রিটার্ন করে।
5. মডেল ট্রেনিং এবং ভ্যালিডেশন: প্রতিটি এপকে ট্রেনিং এবং ভ্যালিডেশন লস ও এক্যুরেসি প্রিন্ট করা হয়েছে।

ধাপ ৮: মডেল সেভ করা

মডেল ট্রেনিং শেষে মডেল সংরক্ষণ করা যেতে পারে:

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

ধাপ ৯: মডেল লোড করা

পরবর্তীতে, মডেল লোড করতে:

model = SimpleNN()
model.load_state_dict(torch.load('simple_nn_model.pth'))
model.eval()  # ইভালুয়েশন মোডে সেট করা

এভাবে আপনি PyTorch-এ মডেল ট্রেনিং এবং ভ্যালিডেশন প্রক্রিয়া সম্পূর্ণ করতে পারেন। এই ধাপগুলো অনুসরণ করলে আপনি আপনার মডেল তৈরি করে তা সঠিকভাবে ট্রেন এবং ভ্যালিডেট করতে পারবেন।