PyTorch দিয়ে Transfer Learning প্রয়োগ

Transfer Learning হল এমন একটি পদ্ধতি, যেখানে একটি মডেল একটি টাস্কে প্রশিক্ষিত হওয়ার পর তার অর্জিত জ্ঞান অন্য টাস্কে ব্যবহার করা হয়। ডিপ লার্নিং মডেলে সাধারণত বড় ডেটাসেটের উপর প্রশিক্ষণ করতে অনেক সময় এবং শক্তি লাগে, কিন্তু ট্রান্সফার লার্নিং আপনাকে পূর্বে প্রশিক্ষিত মডেল ব্যবহার করে নতুন টাস্কে দ্রুত উন্নতি করতে সাহায্য করে।

PyTorch এ Transfer Learning প্রয়োগ করা খুবই সহজ, কারণ PyTorch এ পূর্ব প্রশিক্ষিত মডেল এর জন্য ভাল সমর্থন রয়েছে। এখানে আমরা দেখব কিভাবে একটি পূর্ব প্রশিক্ষিত মডেল ব্যবহার করে Transfer Learning প্রয়োগ করা যায়, বিশেষ করে Image Classification টাস্কে।

১. PyTorch এ Transfer Learning এর জন্য পূর্ব প্রশিক্ষিত মডেল লোড করা

PyTorch এ বেশ কিছু জনপ্রিয় পূর্ব প্রশিক্ষিত মডেল রয়েছে, যেমন ResNet, VGG, Inception, AlexNet, ইত্যাদি। এই মডেলগুলো ImageNet ডেটাসেট ব্যবহার করে প্রশিক্ষিত এবং বিভিন্ন চিত্র সম্পর্কিত টাস্কে অত্যন্ত কার্যকর।

ধাপ ১: পূর্ব প্রশিক্ষিত মডেল লোড করা

প্রথমে, আমরা একটি পূর্ব প্রশিক্ষিত মডেল (যেমন ResNet18) লোড করব এবং তার শেষে একটি নতুন ক্লাসিফিকেশন লেয়ার যোগ করব, কারণ আমাদের টার্গেট ডেটাসেটের ক্লাস সংখ্যা আলাদা হতে পারে।

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

# Load pretrained ResNet model
model = models.resnet18(pretrained=True)

# Freeze the parameters of the pretrained layers
for param in model.parameters():
    param.requires_grad = False

# Modify the final layer (fully connected layer) for our new task
model.fc = nn.Linear(model.fc.in_features, 2)  # Assuming binary classification (2 classes)

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

ডেটা প্রিপ্রসেসিং এর মধ্যে সাধারণত ইমেজ রিসাইজিং, নরমালাইজেশন এবং টেনসর ফরম্যাটে কনভার্শন অন্তর্ভুক্ত থাকে। আমরা PyTorch এর DataLoader এবং ImageFolder ব্যবহার করে সহজেই ডেটা লোড করতে পারি।

# Define the image transformation (for training and validation)
transform = transforms.Compose([
    transforms.Resize(256),                  # Resize image
    transforms.CenterCrop(224),               # Center crop to match ResNet input size
    transforms.ToTensor(),                    # Convert to tensor
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # Normalize with ImageNet mean/std
])

# Load training and validation datasets
train_dataset = ImageFolder(root='path_to_train_data', transform=transform)
val_dataset = ImageFolder(root='path_to_val_data', transform=transform)

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

২. মডেল ট্রেনিং এবং অপটিমাইজেশন

এখন, আমাদের মডেলটি প্রস্তুত, এবং আমরা ট্রেনিং প্রক্রিয়া শুরু করতে পারি। অপটিমাইজার হিসেবে Adam বা SGD ব্যবহার করা যেতে পারে এবং Cross-Entropy Loss ক্লাসিফিকেশনের জন্য লস ফাংশন হিসেবে ব্যবহার করা হয়।

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

# Define the loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)  # Only train the final layer

# Training loop
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    for inputs, labels in train_loader:
        # Move data to GPU if available
        inputs, labels = inputs.to(device), labels.to(device)
        
        # Zero the gradients
        optimizer.zero_grad()
        
        # Forward pass
        outputs = model(inputs)
        
        # Calculate the loss
        loss = criterion(outputs, labels)
        
        # Backward pass and optimization
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    epoch_loss = running_loss / len(train_loader)
    accuracy = 100 * correct / total
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.4f}, Accuracy: {accuracy:.2f}%')

    # Validation phase
    model.eval()
    val_correct = 0
    val_total = 0
    with torch.no_grad():
        for inputs, labels in val_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            outputs = model(inputs)
            _, predicted = torch.max(outputs, 1)
            val_total += labels.size(0)
            val_correct += (predicted == labels).sum().item()

    val_accuracy = 100 * val_correct / val_total
    print(f'Validation Accuracy: {val_accuracy:.2f}%')

৩. Pre-trained Model Freeze এবং Fine-Tuning

Transfer learning এর দুটি প্রধান কৌশল হল:

1. Feature Extractor: পূর্ব প্রশিক্ষিত মডেলের সমস্ত স্তর ফ্রিজ (freeze) করা হয় এবং শুধুমাত্র আউটপুট লেয়ারটি প্রশিক্ষণ দেওয়া হয়।
2. Fine-Tuning: পূর্ব প্রশিক্ষিত মডেলের কিছু স্তর ফ্রিজ করা হয়, তবে কিছু স্তরের (বিশেষত হাই-লেভেল লেয়ারগুলো) জন্য প্রশিক্ষণ চালানো হয়।

Fine-Tuning উদাহরণ:

# Fine-tune the entire model (not just the final layer)
for param in model.parameters():
    param.requires_grad = True  # Unfreeze all layers

optimizer = optim.Adam(model.parameters(), lr=0.0001)

# Training loop (same as above)

৪. Evaluation এবং মডেল সংরক্ষণ

ট্রেনিং শেষে, আমরা মডেলটি পরীক্ষা করতে পারি এবং এটি সংরক্ষণ করতে পারি:

# Evaluate the model on test data
model.eval()
with torch.no_grad():
    correct = 0
    total = 0
    for inputs, labels in val_loader:
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Final Accuracy: {100 * correct / total}%')

# Save the model
torch.save(model.state_dict(), 'model.pth')

সারাংশ

Transfer Learning হল একটি শক্তিশালী কৌশল যা পূর্ব প্রশিক্ষিত মডেল ব্যবহার করে নতুন টাস্কে দ্রুত শিখতে সাহায্য করে। PyTorch এ Transfer Learning প্রয়োগ করার জন্য:

1. পূর্ব প্রশিক্ষিত মডেল লোড করতে হবে।
2. শেষের লেয়ারটিকে অফ-টু-টাস্ক কাস্টমাইজ করতে হবে।
3. মডেল ট্রেনিং এবং ফাইন টিউনিং করতে হবে।
4. মডেলটি টেস্ট এবং সংরক্ষণ করতে হবে।

PyTorch এ Transfer Learning খুব সহজে ব্যবহারযোগ্য এবং এটি মডেল প্রশিক্ষণের সময় অনেক সময় এবং রিসোর্স বাঁচায়।