Training Progress Visualization (Loss, Accuracy)

ডিপ লার্নিং মডেলের ট্রেনিং প্রক্রিয়ায় লস এবং অ্যাকিউরেসি ভিজ্যুয়ালাইজেশন খুবই গুরুত্বপূর্ণ। এর মাধ্যমে আমরা দেখতে পারি মডেল কতটা সঠিকভাবে কাজ করছে এবং এটি কিভাবে ট্রেনিং প্রক্রিয়ার সময় কনভার্জ করছে। সাধারণত দুটি মেট্রিক, লস এবং অ্যাকিউরেসি ব্যবহার করা হয়:

• লস: মডেল কতটা ভুল করছে তা নির্ধারণ করে। কম লস মানে মডেল সঠিকভাবে কাজ করছে।
• অ্যাকিউরেসি: এটি সঠিক পূর্বাভাসের হার পরিমাপ করে। উচ্চ অ্যাকিউরেসি মানে মডেল সঠিকভাবে অনেক পূর্বাভাস করছে।

এখানে Keras/TensorFlow এবং PyTorch দিয়ে লস এবং অ্যাকিউরেসি ভিজ্যুয়ালাইজেশন কিভাবে করবেন তা দেখানো হয়েছে।

1. Keras/TensorFlow ব্যবহার করে ট্রেনিং প্রগ্রেস ভিজ্যুয়ালাইজেশন

Keras (বা TensorFlow 2.x) এ ট্রেনিং প্রগ্রেস ভিজ্যুয়ালাইজেশন করার জন্য, আপনি ট্রেনিংয়ের ইতিহাস (history) থেকে লস এবং অ্যাকিউরেসি তথ্য পেয়ে তা Matplotlib দিয়ে প্লট করতে পারেন।

1.1. Keras/TensorFlow উদাহরণ:

import matplotlib.pyplot as plt
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.datasets import mnist

# MNIST ডেটাসেট লোড করা
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# ডেটা প্রিপ্রসেসিং
x_train = x_train.reshape(x_train.shape[0], -1).astype('float32') / 255
x_test = x_test.reshape(x_test.shape[0], -1).astype('float32') / 255
y_train = y_train.astype('float32')
y_test = y_test.astype('float32')

# সিম্পল মডেল তৈরি
model = Sequential([
    Dense(128, input_dim=x_train.shape[1], activation='relu'),
    Dense(10, activation='softmax')
])

# মডেল কম্পাইল করা
model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam(), metrics=['accuracy'])

# মডেল ট্রেন করা এবং ইতিহাস সংগ্রহ করা
history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_test, y_test))

# লস প্লট করা
plt.figure(figsize=(12, 5))

# লস গ্রাফ
plt.subplot(1, 2, 1)
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.title('Loss during training')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

# অ্যাকিউরেসি গ্রাফ
plt.subplot(1, 2, 2)
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.title('Accuracy during training')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()

plt.tight_layout()
plt.show()

1.2. ব্যাখ্যা:

• history.history['loss']: ট্রেনিং লসের মান প্রতি ইপোকের জন্য।
• history.history['val_loss']: ভ্যালিডেশন লসের মান।
• history.history['accuracy']: ট্রেনিং অ্যাকিউরেসির মান প্রতি ইপোকের জন্য।
• history.history['val_accuracy']: ভ্যালিডেশন অ্যাকিউরেসি।

এই স্ক্রিপ্টটি ট্রেনিং এবং ভ্যালিডেশন লস এবং অ্যাকিউরেসি গ্রাফ দুটি আলাদা সাবপ্লটে প্লট করবে।

2. PyTorch ব্যবহার করে ট্রেনিং প্রগ্রেস ভিজ্যুয়ালাইজেশন

PyTorch এও একইভাবে ট্রেনিং প্রগ্রেস ভিজ্যুয়ালাইজেশন করা যায় এবং Matplotlib ব্যবহার করে লস এবং অ্যাকিউরেসি প্লট করা যায়।

2.1. PyTorch উদাহরণ:

import torch
import torch.nn as nn
import torch.optim as optim
import matplotlib.pyplot as plt
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# সিম্পল নিউরাল নেটওয়ার্ক মডেল
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)
        self.fc2 = nn.Linear(128, 10)
        self.softmax = nn.Softmax(dim=1)

    def forward(self, x):
        x = x.view(-1, 28*28)  # ইমেজ ফ্ল্যাট করা
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return self.softmax(x)

# ডেটাসেট লোড করা
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_data = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

train_loader = DataLoader(train_data, batch_size=64, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1000, shuffle=False)

# মডেল, লস ফাংশন এবং অপটিমাইজার
model = SimpleModel()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# ট্রেনিং লুপ এবং লস, অ্যাকিউরেসি ট্র্যাক করা
train_losses, val_losses, train_accuracies, val_accuracies = [], [], [], []

for epoch in range(10):  # 10 ইপোকের জন্য ট্রেনিং
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0

    for data in train_loader:
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

    train_losses.append(running_loss / len(train_loader))
    train_accuracies.append(100 * correct / total)

    # ভ্যালিডেশন ফেজ
    model.eval()
    val_loss = 0.0
    correct = 0
    total = 0

    with torch.no_grad():
        for data in test_loader:
            inputs, labels = data
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            val_loss += loss.item()

            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    val_losses.append(val_loss / len(test_loader))
    val_accuracies.append(100 * correct / total)

    print(f'Epoch {epoch+1}: Train Loss = {train_losses[-1]:.4f}, Train Accuracy = {train_accuracies[-1]:.2f}%')
    print(f'Validation Loss = {val_losses[-1]:.4f}, Validation Accuracy = {val_accuracies[-1]:.2f}%')

# ট্রেনিং প্রগ্রেস প্লট করা
plt.figure(figsize=(12, 5))

# লস গ্রাফ
plt.subplot(1, 2, 1)
plt.plot(train_losses, label='Training Loss')
plt.plot(val_losses, label='Validation Loss')
plt.title('Loss during training')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

# অ্যাকিউরেসি গ্রাফ
plt.subplot(1, 2, 2)
plt.plot(train_accuracies, label='Training Accuracy')
plt.plot(val_accuracies, label='Validation Accuracy')
plt.title('Accuracy during training')
plt.xlabel('Epochs')
plt.ylabel('Accuracy (%)')
plt.legend()

plt.tight_layout()
plt.show()

2.2. ব্যাখ্যা:

• ট্রেনিং লুপ: প্রতি ইপোকের জন্য, মডেল লস এবং অ্যাকিউরেসি হিসাব করা হয়।
• অ্যাকিউরেসি হিসাব: সঠিক পূর্বাভাসের সংখ্যা গুণে অ্যাকিউরেসি হিসাব করা হয়।
• প্লটিং: ট্রেনিং এবং ভ্যালিডেশন লস এবং অ্যাকিউরেসি তালিকায় জমা করা হয় এবং Matplotlib দিয়ে তা প্লট করা হয়।

সারাংশ:

ট্রেনিং প্রগ্রেস ভিজ্যুয়ালাইজেশন (লস এবং অ্যাকিউরেসি) মডেল ট্রেনিংয়ের কার্যকারিতা পর্যবেক্ষণ করতে সহায়ক। এটি আপনাকে বুঝতে সাহায্য

করে যে মডেলটি কিভাবে কনভার্জ করছে এবং ওভারফিটিং বা আন্ডারফিটিং হচ্ছে কি না। Matplotlib ব্যবহার করে সহজেই এই প্রগ্রেস প্লট করা যায়।