উদাহরণসহ মডেল অপটিমাইজেশন এবং লস ফাংশন

PyTorch-এ মডেল অপটিমাইজেশন এবং লস ফাংশন বেছে নেওয়া খুব গুরুত্বপূর্ণ। মডেল ট্রেনিং করার সময় সঠিক লস ফাংশন এবং অপ্টিমাইজার ব্যবহার করলে মডেলের পারফরমেন্স উন্নত হয়। নিচে PyTorch-এর উদাহরণসহ কীভাবে মডেল অপটিমাইজেশন এবং লস ফাংশন কাজ করে তা ব্যাখ্যা করা হয়েছে।

ধাপ ১: লস ফাংশন নির্বাচন করা

লস ফাংশন (Loss Function) একটি পরিমাপ যা বলে দেয় মডেল কতটা ভাল কাজ করছে। সাধারণত, ক্লাসিফিকেশন মডেলের জন্য CrossEntropyLoss এবং রিগ্রেশন মডেলের জন্য Mean Squared Error (MSE) ব্যবহার করা হয়।

উদাহরণ: আমরা MNIST ডাটাসেট নিয়ে একটি ক্লাসিফিকেশন সমস্যায় CrossEntropyLoss ব্যবহার করবো।

import torch.nn as nn

criterion = nn.CrossEntropyLoss()

ধাপ ২: অপ্টিমাইজার নির্বাচন করা

অপ্টিমাইজার (Optimizer) গ্রেডিয়েন্ট ব্যবহার করে মডেলের ওজন আপডেট করে যাতে লস কমানো যায়। PyTorch-এ অনেক ধরনের অপ্টিমাইজার আছে, যেমন:

• SGD (Stochastic Gradient Descent): সাধারণ অপ্টিমাইজার, কম্পিউটেশনালভাবে সহজ।
• Adam (Adaptive Moment Estimation): আরও উন্নত, দ্রুত কনভার্জ করে।

উদাহরণ: এখানে আমরা SGD এবং Adam অপ্টিমাইজার ব্যবহার করবো।

import torch.optim as optim

# SGD অপ্টিমাইজার
optimizer_sgd = optim.SGD(model.parameters(), lr=0.01)

# Adam অপ্টিমাইজার
optimizer_adam = optim.Adam(model.parameters(), lr=0.001)

ধাপ ৩: লস ফাংশন ও অপ্টিমাইজার ব্যবহার করে মডেল ট্রেনিং

এখন আমরা লস ফাংশন এবং অপ্টিমাইজার ব্যবহার করে মডেলটি ট্রেন করবো। এই উদাহরণে, আমরা CrossEntropyLoss এবং Adam অপ্টিমাইজার ব্যবহার করছি।

# ট্রেনিং লুপ
num_epochs = 5

for epoch in range(num_epochs):
    model.train()  # মডেলকে ট্রেনিং মোডে সেট করা
    for images, labels in train_loader:
        # ফোরওয়ার্ড পাস
        outputs = model(images)
        loss = criterion(outputs, labels)  # লস ক্যালকুলেশন
        
        # ব্যাকওয়ার্ড পাস এবং অপ্টিমাইজেশন
        optimizer_adam.zero_grad()  # গ্রেডিয়েন্ট শূন্য করা
        loss.backward()  # ব্যাকপ্রপাগেশন
        optimizer_adam.step()  # ওজন আপডেট
        
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

ধাপ ৪: অপ্টিমাইজেশন টেকনিকস

১. Learning Rate Scheduling

PyTorch-এ Learning Rate Scheduler ব্যবহার করে learning rate ডায়নামিক্যালি পরিবর্তন করা যায়। এতে মডেল ট্রেনিং সময়ে কনভার্জ করা সহজ হয়।

উদাহরণ: StepLR ব্যবহার করে প্রতি কয়েক এপকের পর লার্নিং রেট হ্রাস করা।

scheduler = optim.lr_scheduler.StepLR(optimizer_adam, step_size=2, gamma=0.1)

for epoch in range(num_epochs):
    model.train()
    for images, labels in train_loader:
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        optimizer_adam.zero_grad()
        loss.backward()
        optimizer_adam.step()
    
    # শিডিউলার আপডেট
    scheduler.step()
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

২. Weight Decay (L2 Regularization)

Weight decay ব্যবহার করে মডেল ওজনের উপর পেনাল্টি দেওয়া হয়, যা ওভারফিটিং রোধ করে।

optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=0.01)

ধাপ ৫: মডেল অপ্টিমাইজেশন টিপস

• Batch Normalization: মডেলের লেয়ারের মধ্যে Batch Normalization যোগ করলে মডেল দ্রুত কনভার্জ করে এবং ট্রেনিং স্থিতিশীল হয়।
• Dropout: Overfitting এড়ানোর জন্য Dropout লেয়ার ব্যবহার করা যায়।
• Gradient Clipping: ব্যাকপ্রপাগেশনের সময় গ্রেডিয়েন্ট সীমাবদ্ধ করলে ট্রেনিং আরও স্থিতিশীল হয়।

সম্পূর্ণ কোড উদাহরণ

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

# ডেটাসেট লোড করা
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)

# মডেল তৈরি করা
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)

# মডেল ট্রেনিং
num_epochs = 5

for epoch in range(num_epochs):
    model.train()
    for images, labels in train_loader:
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

এই উদাহরণে, আমরা Adam অপ্টিমাইজার এবং CrossEntropyLoss ব্যবহার করে মডেল ট্রেনিং করেছি। আপনি চাইলে বিভিন্ন অপ্টিমাইজার (যেমন: SGD, RMSprop) বা লস ফাংশন ব্যবহার করে মডেলটি কাস্টমাইজ করতে পারেন।