Custom Dataset ব্যবহার করে মডেল তৈরি এবং ট্রেনিং

PyTorch-এ Custom Dataset ব্যবহার করে মডেল তৈরি এবং ট্রেনিং করতে হলে, আমাদের torch.utils.data.Dataset ক্লাসটি ইনহেরিট করে একটি কাস্টম ডেটাসেট ক্লাস তৈরি করতে হবে। এটি আমাদের ডেটাসেটের জন্য ডেটা লোডিং এবং প্রিপ্রসেসিং কাস্টমাইজ করার সুবিধা দেয়। এরপর, DataLoader ব্যবহার করে সেই ডেটাসেটকে ব্যাচ হিসেবে লোড করা যায় এবং মডেল ট্রেনিং করা যায়। নিচে একটি পূর্ণাঙ্গ উদাহরণ দেখানো হলো।

ধাপ ১: Custom Dataset ক্লাস তৈরি করা

আমরা torch.utils.data.Dataset ক্লাস ইনহেরিট করে একটি কাস্টম ডেটাসেট তৈরি করবো, যা ইমেজ ডেটাসেট লোড করবে।

import torch
from torch.utils.data import Dataset
from torchvision import transforms
from PIL import Image
import os

class CustomImageDataset(Dataset):
    def __init__(self, image_dir, transform=None):
        self.image_dir = image_dir
        self.transform = transform
        self.image_names = os.listdir(image_dir)

    def __len__(self):
        return len(self.image_names)

    def __getitem__(self, idx):
        img_name = os.path.join(self.image_dir, self.image_names[idx])
        image = Image.open(img_name).convert('RGB')

        label = 0 if 'cat' in img_name else 1  # ফাইলের নাম দেখে লেবেল নির্ধারণ

        if self.transform:
            image = self.transform(image)

        return image, label

ব্যাখ্যা:

• __init__: ডেটাসেটের ডিরেক্টরি এবং ট্রান্সফর্ম প্যারামিটার হিসেবে নেওয়া হয়েছে।
• __len__: ডেটাসেটের সাইজ রিটার্ন করে।
• __getitem__: ইমেজ এবং লেবেল লোড করে এবং রিটার্ন করে।

ধাপ ২: ডেটা ট্রান্সফর্মেশন এবং DataLoader সেটআপ করা

from torch.utils.data import DataLoader

# ডেটা ট্রান্সফর্ম সেট করা
data_transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])

# Custom Dataset তৈরি করা
train_dataset = CustomImageDataset(image_dir='data/train', transform=data_transform)
val_dataset = CustomImageDataset(image_dir='data/val', transform=data_transform)

# DataLoader তৈরি করা
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4)

ধাপ ৩: মডেল তৈরি এবং GPU তে স্থানান্তর করা

import torch.nn as nn
import torchvision.models as models

# প্রি-ট্রেইনড মডেল লোড করা (ResNet18)
model = models.resnet18(pretrained=True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 2)  # Cat এবং Dog, দুটি ক্লাস

# মডেলকে GPU তে স্থানান্তর করা
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

ধাপ ৪: Loss Function এবং Optimizer সেট করা

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

ধাপ ৫: Training এবং Validation Loop

num_epochs = 10

for epoch in range(num_epochs):
    print(f'Epoch {epoch+1}/{num_epochs}')
    print('-' * 10)

    # Training Loop
    model.train()  # মডেলকে ট্রেনিং মোডে সেট করা
    running_loss = 0.0
    running_corrects = 0

    for inputs, labels in train_loader:
        inputs = inputs.to(device)
        labels = labels.to(device)

        optimizer.zero_grad()  # গ্রেডিয়েন্ট রিসেট করা

        # Forward Pass
        outputs = model(inputs)
        _, preds = torch.max(outputs, 1)
        loss = criterion(outputs, labels)

        # Backward Pass এবং Optimizer Step
        loss.backward()
        optimizer.step()

        running_loss += loss.item() * inputs.size(0)
        running_corrects += torch.sum(preds == labels.data)

    epoch_loss = running_loss / len(train_dataset)
    epoch_acc = running_corrects.double() / len(train_dataset)

    print(f'Training Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')

    # Validation Loop
    model.eval()  # মডেলকে ইভ্যালুয়েশন মোডে সেট করা
    val_running_loss = 0.0
    val_running_corrects = 0

    with torch.no_grad():
        for inputs, labels in val_loader:
            inputs = inputs.to(device)
            labels = labels.to(device)

            outputs = model(inputs)
            _, preds = torch.max(outputs, 1)
            loss = criterion(outputs, labels)

            val_running_loss += loss.item() * inputs.size(0)
            val_running_corrects += torch.sum(preds == labels.data)

    val_loss = val_running_loss / len(val_dataset)
    val_acc = val_running_corrects.double() / len(val_dataset)

    print(f'Validation Loss: {val_loss:.4f} Acc: {val_acc:.4f}')

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

1. Custom Dataset: CustomImageDataset ক্লাস ব্যবহার করে ট্রেনিং এবং ভ্যালিডেশন ডেটাসেট লোড করা হয়েছে।
2. DataLoader: DataLoader দিয়ে ডেটা ব্যাচ আকারে লোড করা হয়েছে।
3. Model Setup: ResNet18 প্রি-ট্রেইনড মডেল ব্যবহার করে শেষ লেয়ার পরিবর্তন করা হয়েছে।
4. Training এবং Validation Loop: প্রতিটি epoch-এ ট্রেনিং এবং ভ্যালিডেশন ডেটাসেট দিয়ে মডেল ট্রেনিং এবং মূল্যায়ন করা হয়েছে।

৬. মডেল সংরক্ষণ

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

এভাবে PyTorch-এ Custom Dataset ব্যবহার করে মডেল তৈরি এবং ট্রেনিং করা যায়। Custom Dataset ক্লাস ব্যবহার করে আমরা যে কোনো ধরনের ডেটা সহজেই লোড এবং প্রিপ্রসেস করতে পারি।