Custom Training Loop তৈরি করা এবং অপ্টিমাইজ করা

Custom training loop তৈরি করা এবং অপ্টিমাইজ করা ডীপ লার্নিং মডেল প্রশিক্ষণের জন্য একটি গুরুত্বপূর্ণ প্রক্রিয়া। একটি কাস্টম ট্রেইনিং লুপ ব্যবহার করার মাধ্যমে আপনি প্রশিক্ষণের নিয়ন্ত্রণ নিতে পারেন এবং আপনার মডেলটির জন্য সুনির্দিষ্ট পদ্ধতি ও কৌশলগুলি কার্যকর করতে পারেন। এখানে আমরা PyTorch ব্যবহার করে একটি কাস্টম ট্রেইনিং লুপ তৈরি করার প্রক্রিয়া এবং তা অপ্টিমাইজ করার পদ্ধতি আলোচনা করব।

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

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

ধাপ ২: ডেটাসেট তৈরি করা

একটি ডেটাসেট তৈরি করুন। এখানে আমরা একটি সিম্পল সিনস ফাংশন দিয়ে ডেটা তৈরি করব:

# সিম্পল ডেটাসেট তৈরি
X = torch.linspace(-10, 10, 100).view(-1, 1)
y = torch.sin(X) + 0.1 * torch.randn(X.size())  # সাইন ফাংশন + কিছু নইজি

# DataLoader তৈরি করা
dataset = TensorDataset(X, y)
train_loader = DataLoader(dataset, batch_size=16, shuffle=True)

ধাপ ৩: মডেল তৈরি করা

এখন একটি সিম্পল নিউরাল নেটওয়ার্ক তৈরি করা যাক:

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(1, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

model = SimpleNN()

ধাপ ৪: Custom Training Loop তৈরি করা

এখন কাস্টম ট্রেইনিং লুপ তৈরি করার সময় এসেছে।

# Loss function এবং optimizer নির্ধারণ
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Training Loop
num_epochs = 100
for epoch in range(num_epochs):
    model.train()  # মডেলকে training মোডে সেট করা
    running_loss = 0.0

    for inputs, labels in train_loader:
        optimizer.zero_grad()  # গ্র্যাডিয়েন্টস রিসেট করা

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

        # Backward pass
        loss.backward()
        optimizer.step()  # অপটিমাইজার স্টেপ

        running_loss += loss.item()

    # Epoch শেষে গড় লস প্রিন্ট করা
    epoch_loss = running_loss / len(train_loader)
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.4f}')

ধাপ ৫: Model Evaluation

Training এর পর model evaluation এর জন্য একটি ফাংশন তৈরি করা যাক:

def evaluate_model(model, dataloader):
    model.eval()  # মডেলকে evaluation মোডে সেট করা
    total_loss = 0.0

    with torch.no_grad():  # Gradient calculation বন্ধ করা
        for inputs, labels in dataloader:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            total_loss += loss.item()

    avg_loss = total_loss / len(dataloader)
    print(f'Validation Loss: {avg_loss:.4f}')

# Evaluation ডেটাসেট তৈরি করা
val_loader = DataLoader(dataset, batch_size=16, shuffle=False)
evaluate_model(model, val_loader)

অপ্টিমাইজেশন কৌশল

কাস্টম ট্রেইনিং লুপ তৈরি করার সময় কিছু অপ্টিমাইজেশন কৌশল অনুসরণ করা যেতে পারে:

Learning Rate Scheduling:

• Learning rate ধীরে ধীরে পরিবর্তন করার জন্য learning rate scheduler ব্যবহার করা যেতে পারে।

Gradient Clipping:

• Training এর সময় gradients clipping করতে পারেন, যা training stability উন্নত করে।

Checkpointing:

• Training এর সময় model checkpointing ব্যবহার করে মডেলের উন্নত সংস্করণ সংরক্ষণ করতে পারেন।

Early Stopping:

• Training প্রক্রিয়া বন্ধ করার জন্য validation loss নিরীক্ষণ করতে পারেন এবং একটি threshold-এর নিচে গেলে training বন্ধ করতে পারেন।

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

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset

# সিম্পল ডেটাসেট তৈরি
X = torch.linspace(-10, 10, 100).view(-1, 1)
y = torch.sin(X) + 0.1 * torch.randn(X.size())  # সাইন ফাংশন + কিছু নইজি
dataset = TensorDataset(X, y)
train_loader = DataLoader(dataset, batch_size=16, shuffle=True)

# মডেল তৈরি
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(1, 64)
        self.fc2 = nn.Linear(64, 32)
        self.fc3 = nn.Linear(32, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        return self.fc3(x)

model = SimpleNN()
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Training Loop
num_epochs = 100
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0

    for inputs, labels in train_loader:
        optimizer.zero_grad()

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

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

        running_loss += loss.item()

    epoch_loss = running_loss / len(train_loader)
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {epoch_loss:.4f}')

# Model Evaluation
def evaluate_model(model, dataloader):
    model.eval()
    total_loss = 0.0

    with torch.no_grad():
        for inputs, labels in dataloader:
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            total_loss += loss.item()

    avg_loss = total_loss / len(dataloader)
    print(f'Validation Loss: {avg_loss:.4f}')

val_loader = DataLoader(dataset, batch_size=16, shuffle=False)
evaluate_model(model, val_loader)

উপসংহার

Custom training loop তৈরি করা আপনাকে model training প্রক্রিয়া এবং বিভিন্ন hyperparameter management এর উপর পূর্ণ নিয়ন্ত্রণ দেয়। এটি বিভিন্ন optimization techniques (যেমন learning rate scheduling, gradient clipping, এবং checkpointing) প্রয়োগ করার সুযোগ দেয়। এর ফলে model efficiency বৃদ্ধি করা সম্ভব, যা training process কে আরও কার্যকর এবং ফলদায়ক করে।