Custom Data ব্যবহার করে Pretrained মডেল ফাইন-টিউন করা

Pretrained মডেল ব্যবহার করে ফাইন-টিউনিং একটি জনপ্রিয় এবং কার্যকরী কৌশল মেশিন লার্নিং ও ডিপ লার্নিং-এ, যেখানে একটি পূর্বে প্রশিক্ষিত মডেলকে নতুন ডেটা সেটের জন্য পুনরায় প্রশিক্ষণ দেয়া হয়। এটি সময় এবং রিসোর্স বাঁচায়, কারণ মডেলটি ইতিমধ্যে বড় ডেটাসেটের উপর প্রশিক্ষিত থাকে, এবং আপনি শুধু কিছু অতিরিক্ত ফাইন-টিউনিং করতে পারেন।

সাধারণ প্রক্রিয়া:

1. Pretrained মডেল নির্বাচন: সাধারণত ImageNet বা অন্যান্য বড় ডেটাসেটের উপর প্রশিক্ষিত মডেলগুলো থেকে শুরু করা হয়, যেমন ResNet, VGG, MobileNet, BERT, GPT ইত্যাদি।
2. Custom ডেটা সেট প্রস্তুত করা: আপনার টাস্কের জন্য কাস্টম ডেটা সংগ্রহ এবং প্রস্তুত করা।
3. Pretrained মডেল লোড করা: PyTorch বা TensorFlow এর মতো ফ্রেমওয়ার্কে pretrained মডেল লোড করা।
4. ফাইন-টিউনিং: pretrained মডেলটির কিছু অংশ (বিশেষ করে লাস্ট লেয়ার) কাস্টম ডেটা সেটের জন্য পুনরায় প্রশিক্ষণ করা।
5. মডেল সেভ এবং টেস্ট করা: নতুন ডেটার উপর মডেলটির পারফরম্যান্স পরীক্ষা করা।

1. PyTorch ব্যবহার করে Pretrained মডেল ফাইন-টিউনিং

ধরা যাক, আপনি কাস্টম ইমেজ ক্লাসিফিকেশন ডেটাসেট ব্যবহার করছেন এবং ResNet18 মডেলটি ব্যবহার করে ফাইন-টিউন করতে চান।

১.১. প্রথমে প্রয়োজনীয় লাইব্রেরি ইমপোর্ট করুন:

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

১.২. ডেটা প্রিপ্রসেসিং এবং ডেটা লোডার তৈরি করুন:

আপনার কাস্টম ডেটা সেটের জন্য উপযুক্ত ট্রান্সফরমেশন প্রয়োগ করুন। যেমন, চিত্রের সাইজ পরিবর্তন, নরমালাইজেশন ইত্যাদি:

# Image transformations
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),  # Standard ImageNet normalization
])

# Custom dataset directory
train_dataset = datasets.ImageFolder('path_to_train_data', transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

val_dataset = datasets.ImageFolder('path_to_val_data', transform=transform)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)

১.৩. Pretrained মডেল লোড করা:

PyTorch এর models লাইব্রেরি থেকে pretrained ResNet18 মডেলটি লোড করুন এবং এর লাস্ট লেয়ার পরিবর্তন করুন।

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

# Freeze the layers except the last fully connected layer
for param in model.parameters():
    param.requires_grad = False

# Change the last fully connected layer to match the number of classes in your custom dataset
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, len(train_dataset.classes))  # Assuming 'train_dataset.classes' is the number of classes in your dataset

১.৪. Loss function এবং Optimizer সেট করা:

# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()  # For classification tasks
optimizer = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)

১.৫. মডেল প্রশিক্ষণ:

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

# Training loop
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for inputs, labels in train_loader:
        inputs, labels = inputs.to(device), labels.to(device)

        # Zero the parameter gradients
        optimizer.zero_grad()

        # Forward pass
        outputs = model(inputs)
        loss = criterion(outputs, labels)

        # Backward pass
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    print(f"Epoch {epoch + 1}/{num_epochs}, Loss: {running_loss / len(train_loader)}")

১.৬. মডেল ভ্যালিডেশন:

প্রশিক্ষণ শেষ হলে, আপনার মডেলটি ভ্যালিডেশন ডেটাসেটের উপর পরীক্ষা করুন:

model.eval()  # Set the model to evaluation mode
correct = 0
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)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy on the validation set: {100 * correct / total}%')

১.৭. মডেল সেভ করা:

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

2. TensorFlow/Keras ব্যবহার করে Pretrained মডেল ফাইন-টিউনিং

এখন, একই কাজ TensorFlow/Keras দিয়ে কিভাবে করবেন তা দেখুন। ধরুন, আপনি VGG16 ব্যবহার করছেন:

২.১. লাইব্রেরি ইমপোর্ট:

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator

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

# Image Data Generators for train and validation
train_datagen = ImageDataGenerator(rescale=1./255, 
                                   rotation_range=20, 
                                   width_shift_range=0.2, 
                                   height_shift_range=0.2, 
                                   shear_range=0.2, 
                                   zoom_range=0.2, 
                                   horizontal_flip=True, 
                                   fill_mode='nearest')

train_generator = train_datagen.flow_from_directory('path_to_train_data', 
                                                    target_size=(224, 224), 
                                                    batch_size=32, 
                                                    class_mode='categorical')

val_datagen = ImageDataGenerator(rescale=1./255)
val_generator = val_datagen.flow_from_directory('path_to_val_data', 
                                                target_size=(224, 224), 
                                                batch_size=32, 
                                                class_mode='categorical')

২.৩. Pretrained মডেল লোড করা:

# Load pretrained VGG16 model without the top layer (fully connected layers)
base_model = tf.keras.applications.VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Freeze the base model
base_model.trainable = False

# Add custom layers
model = models.Sequential([
    base_model,
    layers.GlobalAveragePooling2D(),
    layers.Dense(1024, activation='relu'),
    layers.Dense(len(train_generator.class_indices), activation='softmax')  # number of classes
])

model.compile(optimizer=tf.keras.optimizers.Adam(), loss='categorical_crossentropy', metrics=['accuracy'])

২.৪. মডেল প্রশিক্ষণ:

model.fit(train_generator, epochs=10, validation_data=val_generator)

২.৫. ফাইন-টিউনিং:

ফাইন-টিউনিং করতে base model এর কিছু লেয়ার আনফ্রিজ করুন:

base_model.trainable = True
# Fine-tune from layer 15 onward (Example)
for layer in base_model.layers[:15]:
    layer.trainable = False

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001), loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(train_generator, epochs=10, validation_data=val_generator)

২.৬. মডেল সেভ করা:

model.save('finetuned_model.h5')

সারাংশ:

• Pretrained মডেল ফাইন-টিউনিং মূলত pretrained মডেলের কিছু অংশ (বিশেষ করে লাস্ট লেয়ার) কাস্টম ডেটা সেটের জন্য পুনরায় প্রশিক্ষণ দেয়।
• PyTorch এবং TensorFlow এর মতো লাইব্রেরি আপনাকে pretrained মডেল লোড, কাস্টম ডেটার জন্য ফাইন-টিউনিং, এবং প্রশিক্ষণ সহ সকল কার্যক্রম পরিচালনা করার সুবিধা দেয়।
• ফাইন-টিউনিং দ্রুত এবং কার্যকরী মডেল তৈরির একটি শক্তিশালী কৌশল, যা প্রাথমিক মডেলকে আপনার কাস্টম ড

েটা সেটের জন্য উপযুক্ত করে তোলে।