Transfer Learning ব্যবহার করে Custom মডেল তৈরি করা

Transfer Learning ব্যবহার করে Custom মডেল তৈরি করার প্রক্রিয়া অনেক সহজ এবং কার্যকর, কারণ এটি মডেলের দক্ষতা বাড়াতে এবং কম ডেটা বা কম computational resources থাকা সত্ত্বেও ভাল ফলাফল পেতে সহায়ক। Transfer Learning এর মাধ্যমে আমরা একটি pre-trained মডেল ব্যবহার করে, নতুন ডেটাসেট বা সমস্যা অনুযায়ী মডেলটিকে fine-tune করব।

এই প্রজেক্টে, আমরা PyTorch ব্যবহার করে Image Classification এর জন্য একটি Custom মডেল তৈরি করব, যা ResNet মডেলের pre-trained ওয়েট ব্যবহার করে fine-tune করা হবে।

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

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

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

আমরা ইমেজ ডেটাসেট নিয়ে কাজ করব, যেখানে আমাদের একটি Custom ডেটাসেট আছে। এটি train এবং val নামে দুটি ফোল্ডারে ভাগ করা হয়েছে, যেখানে train ফোল্ডারে ট্রেনিং ডেটা এবং val ফোল্ডারে ভ্যালিডেশন ডেটা সংরক্ষিত।

# ট্রান্সফর্মেশন ডিফাইন করা
data_transforms = {
    'train': transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'val': transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

# ডেটাসেট লোড করা
data_dir = 'data'
image_datasets = {x: datasets.ImageFolder(root=f"{data_dir}/{x}", transform=data_transforms[x])
                  for x in ['train', 'val']}

# ডেটা লোডার তৈরি করা
dataloaders = {x: DataLoader(image_datasets[x], batch_size=32, shuffle=True, num_workers=4)
               for x in ['train', 'val']}

# ডেটাসেটের সাইজ
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes

ধাপ ৩: Pre-trained Model লোড করা

আমরা PyTorch এর ResNet মডেল ব্যবহার করব, যা ImageNet ডেটাসেটে প্রি-ট্রেন করা।

# Pre-trained ResNet18 মডেল লোড করা
model = models.resnet18(pretrained=True)

# শেষের Fully Connected লেয়ার পরিবর্তন করা
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, len(class_names))

ধাপ ৪: মডেলের কিছু লেয়ার Freeze করা (Optional)

আমরা মডেলের কিছু লেয়ার freeze করে রাখতে পারি, যাতে training এর সময় সেই লেয়ারগুলো পরিবর্তিত না হয়। এটি training কে আরও দ্রুত করে তোলে।

# মডেলের সমস্ত লেয়ার freeze করা
for param in model.parameters():
    param.requires_grad = False

# শুধু নতুন Fully Connected লেয়ারটি trainable রাখা
for param in model.fc.parameters():
    param.requires_grad = True

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

# Loss function এবং optimizer ডিফাইন করা
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)

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

মডেল ট্রেন এবং ভ্যালিডেশন করার জন্য একটি ফাংশন তৈরি করা হয়, যা আমাদের মডেলটির পারফরম্যান্স যাচাই করতে সাহায্য করবে।

import time
import copy

def train_model(model, criterion, optimizer, num_epochs=10):
    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0

    for epoch in range(num_epochs):
        print(f"Epoch {epoch + 1}/{num_epochs}")

        # প্রতিটি epoch এ ট্রেন এবং ভ্যালিডেশন মোডের জন্য লুপ চালানো
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
            
            running_loss = 0.0
            running_corrects = 0

            # ডেটা লোডার থেকে ডেটা লোড করা
            for inputs, labels in dataloaders[phase]:
                inputs = inputs.to(device)
                labels = labels.to(device)

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

                # Forward pass
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)

                    # Backward pass এবং optimizer step
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()

                # স্ট্যাটিস্টিক্স আপডেট করা
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)

            # epoch শেষে লস এবং একিউরেসি ক্যালকুলেট করা
            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects.double() / dataset_sizes[phase]

            print(f"{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}")

            # Best মডেল সংরক্ষণ
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())

    print(f"Best Validation Accuracy: {best_acc:.4f}")

    # Best মডেলের ওয়েট লোড করা
    model.load_state_dict(best_model_wts)
    return model

ধাপ ৭: মডেল ট্রেনিং চালানো

# মডেলকে device এ পাঠানো (GPU/CPU)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# মডেল ট্রেনিং শুরু করা
model = train_model(model, criterion, optimizer, num_epochs=10)

ধাপ ৮: মডেল সংরক্ষণ করা (Optional)

মডেল ট্রেনিং শেষে মডেলটি সংরক্ষণ করা যায়, যাতে পরে এটি ব্যবহার করা যায়।

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

সারসংক্ষেপ

এই প্রজেক্টে, আমরা ResNet-18 মডেলের প্রি-ট্রেনড ওয়েট ব্যবহার করে একটি Custom Image Classification মডেল তৈরি করেছি। আমরা মডেলের কিছু লেয়ার freeze করেছি এবং নতুন fully connected layer যোগ করেছি, যা আমাদের Custom ডেটাসেটের ক্লাসগুলোর সাথে মিলেছে। এরপর, মডেলটি train এবং validate করে Best accuracy পেয়েছি।

Transfer Learning এর মাধ্যমে Custom মডেল তৈরি করার এই প্রক্রিয়া কার্যকর, বিশেষত তখন যখন আমাদের কম ডেটা বা কম computational resources থাকে।