প্র্যাকটিস প্রোজেক্টস

প্র্যাকটিস প্রোজেক্টস আপনাকে মেশিন লার্নিং, ডেটা সায়েন্স এবং প্রোগ্রামিং দক্ষতা উন্নত করতে সহায়তা করতে পারে। এখানে কিছু প্র্যাকটিস প্রোজেক্টের আইডিয়া দেওয়া হলো, যা আপনার শেখার জার্নিতে সহায়ক হতে পারে:

১. ইমেজ ক্লাসিফিকেশন

প্রজেক্ট: একটি সাধারণ ইমেজ ক্লাসিফায়ার তৈরি করা, যেমন কুকুর এবং বিড়াল চিহ্নিতকরণ।

• ব্যবহারিক জ্ঞান: Convolutional Neural Network (CNN)।
• ডেটাসেট: Cats vs. Dogs।

২. স্প্যাম ডিটেকশন সিস্টেম

প্রজেক্ট: একটি ইমেইল বা টেক্সট মেসেজ স্প্যাম ডিটেকশন সিস্টেম তৈরি করা।

• ব্যবহারিক জ্ঞান: Natural Language Processing (NLP) এবং Classification মডেল।
• ডেটাসেট: SMS Spam Collection Dataset।

৩. হাউজ প্রাইস প্রেডিকশন

প্রজেক্ট: হাউজিং ডেটা ব্যবহার করে বাড়ির মূল্য পূর্বাভাস দেওয়া।

• ব্যবহারিক জ্ঞান: Regression মডেল।
• ডেটাসেট: Boston Housing Dataset।

৪. স্টক প্রাইস প্রেডিকশন

প্রজেক্ট: স্টক মার্কেটের পূর্ববর্তী ডেটা বিশ্লেষণ করে পরবর্তী দিনের স্টক প্রাইস পূর্বাভাস।

• ব্যবহারিক জ্ঞান: Recurrent Neural Network (RNN) বা LSTM।
• ডেটাসেট: Yahoo Finance API অথবা Quandl।

৫. সেন্টিমেন্ট অ্যানালাইসিস

প্রজেক্ট: টুইট বা রিভিউ বিশ্লেষণ করে সেন্টিমেন্ট (Positive/Negative) নির্ধারণ।

• ব্যবহারিক জ্ঞান: NLP এবং Sentiment Analysis মডেল।
• ডেটাসেট: Twitter US Airline Sentiment Dataset।

৬. কাস্টমার চর্ন প্রেডিকশন

প্রজেক্ট: টেলিকম বা ব্যাংকিং ডেটা ব্যবহার করে কাস্টমার চর্ন প্রেডিকশন মডেল তৈরি করা।

• ব্যবহারিক জ্ঞান: Classification মডেল এবং Imbalanced Data Handling।
• ডেটাসেট: Telco Customer Churn Dataset।

৭. রিকমেন্ডেশন সিস্টেম

প্রজেক্ট: একটি রিকমেন্ডেশন সিস্টেম তৈরি করা, যেমন ফিল্ম বা প্রোডাক্ট সুপারিশ।

• ব্যবহারিক জ্ঞান: Collaborative Filtering বা Content-Based Filtering।
• ডেটাসেট: MovieLens Dataset।

৮. ল্যাঙ্গুয়েজ ট্রান্সলেশন মডেল

প্রজেক্ট: Seq2Seq মডেল ব্যবহার করে ইংরেজি থেকে অন্য ভাষায় অনুবাদ তৈরি করা।

• ব্যবহারিক জ্ঞান: RNN, LSTM, Seq2Seq মডেল।
• ডেটাসেট: ManyThings Dataset।

৯. COVID-19 কেস প্রেডিকশন

প্রজেক্ট: COVID-19 ডেটা ব্যবহার করে দৈনিক কেস সংখ্যা পূর্বাভাস দেওয়া।

• ব্যবহারিক জ্ঞান: Time-Series Analysis।
• ডেটাসেট: Johns Hopkins COVID-19 Dataset।

১০. রিয়েল-টাইম অবজেক্ট ডিটেকশন

প্রজেক্ট: YOLO বা SSD মডেল ব্যবহার করে ভিডিও ফিড থেকে অবজেক্ট ডিটেকশন।

• ব্যবহারিক জ্ঞান: Object Detection এবং OpenCV।
• ডেটাসেট: COCO Dataset.

প্র্যাকটিস প্রোজেক্ট করতে করতে আপনি নিজের মডেলগুলোতে নতুন নতুন ফিচার যোগ করতে এবং কাস্টমাইজ করতে শিখতে পারবেন, যা বাস্তব জীবনের সমস্যাগুলোর সমাধানেও সাহায্য করবে।

Chainer ব্যবহার করে একটি বেসিক Classification প্রজেক্ট তৈরি করতে আমরা একটি সরল নিউরাল নেটওয়ার্ক মডেল তৈরি করব যা MNIST ডেটাসেটের উপর ট্রেন করা হবে। MNIST ডেটাসেট হলো হাতে লেখা সংখ্যা (০-৯) নিয়ে গঠিত একটি সাধারণ ডেটাসেট যা image classification মডেল তৈরিতে ব্যবহৃত হয়।

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

Chainer এবং প্রয়োজনীয় লাইব্রেরি গুলো ইনস্টল করে এবং ইম্পোর্ট করে প্রজেক্ট শুরু করতে হবে।

import chainer
import chainer.functions as F
import chainer.links as L
from chainer import Chain, optimizers, training
from chainer.training import extensions
from chainer.datasets import mnist
import numpy as np

ধাপ ২: MNIST ডেটাসেট লোড করা

Chainer এ MNIST ডেটাসেট খুব সহজেই লোড করা যায়। আমরা ডেটাসেটটিকে train এবং test সেটে বিভক্ত করব।

# MNIST ডেটাসেট লোড করা
train, test = mnist.get_mnist()

ধাপ ৩: নিউরাল নেটওয়ার্ক মডেল তৈরি করা

এখানে আমরা একটি বেসিক Fully Connected নিউরাল নেটওয়ার্ক (Multilayer Perceptron) মডেল তৈরি করব যা MNIST ইমেজ ডেটা প্রসেস করবে।

# বেসিক নিউরাল নেটওয়ার্ক মডেল তৈরি
class MLP(Chain):
    def __init__(self):
        super(MLP, self).__init__()
        with self.init_scope():
            # Input layer থেকে hidden layer (100 units) এ সংযোগ
            self.fc1 = L.Linear(784, 100)
            # Hidden layer থেকে output layer (10 units) এ সংযোগ
            self.fc2 = L.Linear(100, 10)

    def forward(self, x):
        # Hidden layer এ relu activation function প্রয়োগ করা
        h = F.relu(self.fc1(x))
        # Output layer এ softmax activation প্রয়োগ করা
        return self.fc2(h)

এখানে,

• fc1 প্রথম fully connected লেয়ার যা 784 (28x28) ইনপুট পয়েন্ট এবং 100 ইউনিট ধারণ করে।
• fc2 দ্বিতীয় fully connected লেয়ার যা ১০টি ক্লাসের জন্য আউটপুট প্রদান করবে (0-9)।

ধাপ ৪: মডেল, লস ফাংশন এবং অপটিমাইজার ইনিশিয়ালাইজ করা

Chainer এ model setup করার জন্য classifier wrapper ব্যবহার করা হয়, যাতে loss এবং accuracy এর মতো মেট্রিক্স স্বয়ংক্রিয়ভাবে calculate করা যায়।

# মডেল ইনিশিয়ালাইজ করা
model = L.Classifier(MLP())

# Optimizer তৈরি করা (SGD ব্যবহার করা হচ্ছে)
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(model)

ধাপ ৫: ট্রেইনার এবং এক্সটেনশন সেটআপ করা

Chainer এ training এবং evaluation process পরিচালনার জন্য Trainer ব্যবহার করা হয়। এটি dataset এবং optimizer নিয়ে কাজ করে এবং training process এর বিভিন্ন পর্যায়ে extension গুলো যোগ করতে দেয়।

# Data iterators তৈরি করা
train_iter = chainer.iterators.SerialIterator(train, batch_size=64, shuffle=True)
test_iter = chainer.iterators.SerialIterator(test, batch_size=64, repeat=False, shuffle=False)

# Updater এবং Trainer তৈরি করা
updater = training.updaters.StandardUpdater(train_iter, optimizer)
trainer = training.Trainer(updater, (10, 'epoch'), out='result')

# Extensions যোগ করা
trainer.extend(extensions.Evaluator(test_iter, model))          # মডেল evaluate করা
trainer.extend(extensions.LogReport())                          # Training log রাখা
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy']))  # Report print করা
trainer.extend(extensions.ProgressBar())                        # Progress bar দেখানো

ধাপ ৬: মডেল ট্রেনিং করা

Trainer ব্যবহার করে মডেল ট্রেনিং প্রক্রিয়া শুরু করা হবে।

# মডেল ট্রেনিং করা
trainer.run()

ধাপ ৭: মডেল Evaluate করা

মডেল ট্রেনিং শেষে test ডেটাসেটে এর accuracy নির্ণয় করা হবে।

# Test ডেটাসেটে মডেল evaluate করা
test_evaluator = extensions.Evaluator(test_iter, model)
results = test_evaluator()
print(f"Test Accuracy: {results['main/accuracy']:.4f}")

কোডের সংক্ষিপ্ত সারাংশ

1. Model Definition: MLP ক্লাস তৈরি করে একটি বেসিক ফিড-ফরোয়ার্ড নিউরাল নেটওয়ার্ক মডেল তৈরি করা হয়েছে।
2. Optimizer এবং Trainer Setup: মডেলের জন্য SGD optimizer এবং training extensions ব্যবহার করা হয়েছে।
3. Model Training এবং Evaluation: 10 epochs ধরে মডেলটি train করা হয়েছে এবং test dataset এ এর accuracy পরিমাপ করা হয়েছে।

এই বেসিক classification প্রজেক্টের মাধ্যমে Chainer এর মাধ্যমে image classification এর মৌলিক ধারণা শেখা যায় এবং MNIST ডেটাসেট এর মতো ডেটার উপর মডেল ট্রেনিং এর কৌশল জানা যায়।

Convolutional Neural Network (CNN) ব্যবহার করে Image Classification প্রজেক্ট তৈরি করা একটি চমৎকার প্র্যাকটিস প্রজেক্ট। এই প্রজেক্টে আমরা কুকুর এবং বিড়াল চিহ্নিত করতে একটি CNN মডেল তৈরি করব।

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

pip install tensorflow numpy matplotlib

ধাপ ২: ডেটাসেট লোড করা

আপনি Kaggle বা Microsoft-এর Cats vs. Dogs ডেটাসেট ব্যবহার করতে পারেন। ডেটাসেটটি ডাউনলোড করে train এবং validation ফোল্ডারে বিভক্ত করুন।

ফোল্ডার স্ট্রাকচার:

data/
    train/
        cats/
            cat1.jpg
            cat2.jpg
            ...
        dogs/
            dog1.jpg
            dog2.jpg
            ...
    validation/
        cats/
        dogs/

ধাপ ৩: প্রয়োজনীয় লাইব্রেরি এবং ডেটা লোড করা

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt

ধাপ ৪: ডেটা প্রি-প্রসেসিং এবং অগমেন্টেশন

ImageDataGenerator ব্যবহার করে ইমেজগুলোকে নরমালাইজ করা এবং ট্রেনিং ডেটাতে কিছু অগমেন্টেশন করা হবে।

# ডেটা অগমেন্টেশন
train_datagen = ImageDataGenerator(rescale=1./255, rotation_range=40, width_shift_range=0.2, height_shift_range=0.2, shear_range=0.2, zoom_range=0.2, horizontal_flip=True)

# ভ্যালিডেশন ডেটা
validation_datagen = ImageDataGenerator(rescale=1./255)

# ডেটা লোড করা
train_generator = train_datagen.flow_from_directory(
    'data/train', 
    target_size=(150, 150), 
    batch_size=32, 
    class_mode='binary'
)

validation_generator = validation_datagen.flow_from_directory(
    'data/validation', 
    target_size=(150, 150), 
    batch_size=32, 
    class_mode='binary'
)

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

CNN মডেলে Convolutional এবং MaxPooling লেয়ার ব্যবহার করে একটি সিম্পল আর্কিটেকচার তৈরি করা।

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout

model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),
    MaxPooling2D(2, 2),
    
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D(2, 2),
    
    Conv2D(128, (3, 3), activation='relu'),
    MaxPooling2D(2, 2),
    
    Conv2D(128, (3, 3), activation='relu'),
    MaxPooling2D(2, 2),
    
    Flatten(),
    Dense(512, activation='relu'),
    Dropout(0.5),
    Dense(1, activation='sigmoid')
])

model.summary()

ধাপ ৬: মডেল কম্পাইল করা

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

ধাপ ৭: মডেল Training করা

history = model.fit(
    train_generator,
    steps_per_epoch=100,
    epochs=20,
    validation_data=validation_generator,
    validation_steps=50
)

ধাপ ৮: মডেল Performance মূল্যায়ন

Training এবং Validation accuracy এবং loss এর পরিবর্তন দেখতে গ্রাফ আঁকা হবে।

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

plt.plot(epochs, acc, 'b', label='Training accuracy')
plt.plot(epochs, val_acc, 'r', label='Validation accuracy')
plt.title('Training and Validation Accuracy')
plt.legend()
plt.show()

plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()

ধাপ ৯: মডেল সংরক্ষণ করা

model.save("cats_vs_dogs_classifier.h5")

ধাপ ১০: নতুন ইমেজে পূর্বাভাস করা

মডেলটি নতুন ইমেজে পূর্বাভাস দিতে লোড করে ব্যবহার করা যেতে পারে।

from tensorflow.keras.preprocessing import image
import numpy as np

# মডেল লোড করা
model = tf.keras.models.load_model("cats_vs_dogs_classifier.h5")

# নতুন ইমেজ লোড করা এবং প্রি-প্রসেসিং
img = image.load_img('data/test/cat1.jpg', target_size=(150, 150))
img_array = image.img_to_array(img) / 255.0
img_array = np.expand_dims(img_array, axis=0)

# পূর্বাভাস
prediction = model.predict(img_array)
if prediction[0][0] > 0.5:
    print("It's a Dog!")
else:
    print("It's a Cat!")

সারসংক্ষেপ

1. ডেটা প্রি-প্রসেসিং ও অগমেন্টেশন: ImageDataGenerator ব্যবহার।
2. CNN মডেল তৈরি: Conv2D, MaxPooling, এবং Dropout লেয়ার।
3. মডেল Training: মডেল প্রশিক্ষণ ও মূল্যায়ন।
4. মডেল সংরক্ষণ ও পূর্বাভাস: .h5 ফরম্যাটে সংরক্ষণ এবং নতুন ইমেজে পূর্বাভাস।

এই প্রজেক্টটি Image Classification-এ প্রাথমিক দক্ষতা অর্জনের জন্য উপযোগী।

Text generation একটি সাধারণ প্রকল্প যেখানে Recurrent Neural Network (RNN) ব্যবহার করে ধারাবাহিক টেক্সট তৈরি করা হয়। RNN এর sequential data প্রসেস করার ক্ষমতার কারণে text generation প্রকল্পে এটি অত্যন্ত কার্যকর। এই প্রকল্পে আমরা একটি RNN মডেল ব্যবহার করে text generation করব, যেখানে মডেলটি একাধিক শব্দের মাধ্যমে নির্দিষ্ট প্যাটার্ন শিখে সেই প্যাটার্ন অনুসারে নতুন টেক্সট তৈরি করতে পারবে।

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

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import Dataset, DataLoader

ধাপ ২: ডেটাসেট প্রস্তুত করা

প্রথমে আমরা একটি উদাহরণস্বরূপ টেক্সট তৈরি করব এবং তারপর ডেটাকে প্রসেস করব যাতে এটি RNN মডেলে ইনপুট হিসেবে ব্যবহারযোগ্য হয়। উদাহরণ হিসেবে আমরা Shakespeare এর লেখার কিছু অংশ ব্যবহার করব।

# Text ডেটাসেট (উদাহরণস্বরূপ)
text = "To be or not to be, that is the question."

# সমস্ত ইউনিক ক্যারেক্টারগুলো সংরক্ষণ করা
chars = sorted(set(text))
char_to_idx = {ch: i for i, ch in enumerate(chars)}
idx_to_char = {i: ch for i, ch in enumerate(chars)}

# Hyperparameters
seq_length = 10  # input sequence length
batch_size = 64  # training batch size
n_epochs = 100   # number of epochs
hidden_size = 128  # hidden state size of RNN
learning_rate = 0.01  # learning rate for optimizer

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

প্রতিটি sequence এর জন্য input-output pair তৈরি করা হবে। উদাহরণস্বরূপ, যদি আমাদের টেক্সট "To be or not to be" হয়, তাহলে আমরা "To be or n" কে ইনপুট এবং "o be or no" কে টার্গেট হিসেবে ব্যবহার করব।

# ডেটাসেট তৈরি
input_seq = []
target_seq = []

for i in range(0, len(text) - seq_length):
    in_seq = text[i:i + seq_length]
    out_seq = text[i + 1:i + seq_length + 1]
    input_seq.append([char_to_idx[ch] for ch in in_seq])
    target_seq.append([char_to_idx[ch] for ch in out_seq])

input_seq = np.array(input_seq)
target_seq = np.array(target_seq)

ধাপ ৪: Custom Dataset এবং DataLoader তৈরি করা

class TextDataset(Dataset):
    def __init__(self, input_seq, target_seq):
        self.input_seq = torch.tensor(input_seq, dtype=torch.long)
        self.target_seq = torch.tensor(target_seq, dtype=torch.long)
    
    def __len__(self):
        return len(self.input_seq)
    
    def __getitem__(self, idx):
        return self.input_seq[idx], self.target_seq[idx]

# ডেটাসেট এবং ডেটা লোডার তৈরি
dataset = TextDataset(input_seq, target_seq)
data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)

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

একটি RNN মডেল তৈরি করা, যা ইনপুট হিসাবে একটি character sequence নেবে এবং প্রেডিক্টেড character sequence আউটপুট দিবে।

class TextGenerationRNN(nn.Module):
    def __init__(self, vocab_size, hidden_size, output_size):
        super(TextGenerationRNN, self).__init__()
        self.hidden_size = hidden_size
        self.rnn = nn.RNN(vocab_size, hidden_size, batch_first=True)
        self.fc = nn.Linear(hidden_size, output_size)
    
    def forward(self, x, hidden):
        out, hidden = self.rnn(x, hidden)
        out = self.fc(out)
        return out, hidden
    
    def init_hidden(self, batch_size):
        return torch.zeros(1, batch_size, self.hidden_size)

# মডেল ইনিশিয়ালাইজ করা
vocab_size = len(chars)
model = TextGenerationRNN(vocab_size, hidden_size, vocab_size)

ধাপ ৬: লস ফাংশন এবং অপটিমাইজার সেট করা

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)

ধাপ ৭: মডেল ট্রেনিং করা

RNN মডেলটি প্রতিটি character sequence নিয়ে ট্রেনিং করা হবে এবং লস কমানোর চেষ্টা করা হবে।

for epoch in range(n_epochs):
    hidden = model.init_hidden(batch_size)
    total_loss = 0
    
    for inputs, targets in data_loader:
        # One-hot encoding input data
        inputs = nn.functional.one_hot(inputs, num_classes=vocab_size).float()
        
        # Hidden state detach করা
        hidden = hidden.detach()
        
        # মডেল আউটপুট এবং লস ক্যালকুলেট করা
        outputs, hidden = model(inputs, hidden)
        loss = criterion(outputs.view(-1, vocab_size), targets.view(-1))
        
        # Backward এবং optimizer স্টেপ
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        total_loss += loss.item()
    
    print(f"Epoch [{epoch+1}/{n_epochs}], Loss: {total_loss/len(data_loader):.4f}")

ধাপ ৮: Text Generation

এখন আমরা মডেলটিকে একটি seed text দিয়ে নতুন টেক্সট জেনারেট করতে বলব।

def generate_text(model, start_str, gen_length=100):
    input_seq = [char_to_idx[ch] for ch in start_str]
    input_seq = torch.tensor(input_seq, dtype=torch.long).unsqueeze(0)
    hidden = model.init_hidden(1)
    
    generated_text = start_str
    
    for _ in range(gen_length):
        inputs = nn.functional.one_hot(input_seq, num_classes=vocab_size).float()
        outputs, hidden = model(inputs, hidden)
        predicted_idx = torch.argmax(outputs[0, -1]).item()
        generated_text += idx_to_char[predicted_idx]
        
        input_seq = torch.cat((input_seq[:, 1:], torch.tensor([[predicted_idx]])), dim=1)
    
    return generated_text

# Example text generation
start_str = "To be or "
generated_text = generate_text(model, start_str)
print(generated_text)

কোডের সারাংশ:

1. Dataset Creation: টেক্সট ডেটাসেট তৈরি করা হয় character sequence অনুযায়ী, যাতে RNN মডেল টেক্সটের ধারাবাহিকতা শিখতে পারে।
2. Model Definition: একটি বেসিক RNN মডেল তৈরি করা হয়েছে, যা input text sequence থেকে আউটপুট text sequence প্রদান করে।
3. Training: মডেলটি একাধিক epoch ধরে train করা হয়।
4. Text Generation: একটি seed text দিয়ে মডেলকে নতুন টেক্সট জেনারেট করতে বলা হয়।

এই বেসিক প্রজেক্টের মাধ্যমে RNN ব্যবহার করে text generation এর প্রাথমিক ধারণা পাওয়া যায় এবং ভবিষ্যতে আরও উন্নত মডেল তৈরির ভিত্তি তৈরি হয়।

Transfer Learning ব্যবহার করে Custom মডেল তৈরি করার প্রক্রিয়া অনেক সহজ এবং কার্যকর, কারণ এটি মডেলের দক্ষতা বাড়াতে এবং কম ডেটা বা কম computational resources থাকা সত্ত্বেও ভাল ফলাফল পেতে সহায়ক। Transfer Learning এর মাধ্যমে আমরা একটি pre-trained মডেল ব্যবহার করে, নতুন ডেটাসেট বা সমস্যা অনুযায়ী মডেলটিকে fine-tune করব।

এই প্রজেক্টে, আমরা PyTorch ব্যবহার করে Image Classification এর জন্য একটি Custom মডেল তৈরি করব, যা ResNet মডেলের pre-trained ওয়েট ব্যবহার করে fine-tune করা হবে।

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

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

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

আমরা ইমেজ ডেটাসেট নিয়ে কাজ করব, যেখানে আমাদের একটি Custom ডেটাসেট আছে। এটি train এবং val নামে দুটি ফোল্ডারে ভাগ করা হয়েছে, যেখানে train ফোল্ডারে ট্রেনিং ডেটা এবং val ফোল্ডারে ভ্যালিডেশন ডেটা সংরক্ষিত।

# ট্রান্সফর্মেশন ডিফাইন করা
data_transforms = {
    'train': transforms.Compose([
        transforms.RandomResizedCrop(224),
        transforms.RandomHorizontalFlip(),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
    'val': transforms.Compose([
        transforms.Resize(256),
        transforms.CenterCrop(224),
        transforms.ToTensor(),
        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    ]),
}

# ডেটাসেট লোড করা
data_dir = 'data'
image_datasets = {x: datasets.ImageFolder(root=f"{data_dir}/{x}", transform=data_transforms[x])
                  for x in ['train', 'val']}

# ডেটা লোডার তৈরি করা
dataloaders = {x: DataLoader(image_datasets[x], batch_size=32, shuffle=True, num_workers=4)
               for x in ['train', 'val']}

# ডেটাসেটের সাইজ
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes

ধাপ ৩: Pre-trained Model লোড করা

আমরা PyTorch এর ResNet মডেল ব্যবহার করব, যা ImageNet ডেটাসেটে প্রি-ট্রেন করা।

# Pre-trained ResNet18 মডেল লোড করা
model = models.resnet18(pretrained=True)

# শেষের Fully Connected লেয়ার পরিবর্তন করা
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, len(class_names))

ধাপ ৪: মডেলের কিছু লেয়ার Freeze করা (Optional)

আমরা মডেলের কিছু লেয়ার freeze করে রাখতে পারি, যাতে training এর সময় সেই লেয়ারগুলো পরিবর্তিত না হয়। এটি training কে আরও দ্রুত করে তোলে।

# মডেলের সমস্ত লেয়ার freeze করা
for param in model.parameters():
    param.requires_grad = False

# শুধু নতুন Fully Connected লেয়ারটি trainable রাখা
for param in model.fc.parameters():
    param.requires_grad = True

ধাপ ৫: লস ফাংশন এবং অপটিমাইজার সেট করা

# Loss function এবং optimizer ডিফাইন করা
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)

ধাপ ৬: মডেল ট্রেনিং ফাংশন তৈরি করা

মডেল ট্রেন এবং ভ্যালিডেশন করার জন্য একটি ফাংশন তৈরি করা হয়, যা আমাদের মডেলটির পারফরম্যান্স যাচাই করতে সাহায্য করবে।

import time
import copy

def train_model(model, criterion, optimizer, num_epochs=10):
    best_model_wts = copy.deepcopy(model.state_dict())
    best_acc = 0.0

    for epoch in range(num_epochs):
        print(f"Epoch {epoch + 1}/{num_epochs}")

        # প্রতিটি epoch এ ট্রেন এবং ভ্যালিডেশন মোডের জন্য লুপ চালানো
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
            
            running_loss = 0.0
            running_corrects = 0

            # ডেটা লোডার থেকে ডেটা লোড করা
            for inputs, labels in dataloaders[phase]:
                inputs = inputs.to(device)
                labels = labels.to(device)

                # Optimizer এর গ্রেডিয়েন্ট reset করা
                optimizer.zero_grad()

                # Forward pass
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    _, preds = torch.max(outputs, 1)
                    loss = criterion(outputs, labels)

                    # Backward pass এবং optimizer step
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()

                # স্ট্যাটিস্টিক্স আপডেট করা
                running_loss += loss.item() * inputs.size(0)
                running_corrects += torch.sum(preds == labels.data)

            # epoch শেষে লস এবং একিউরেসি ক্যালকুলেট করা
            epoch_loss = running_loss / dataset_sizes[phase]
            epoch_acc = running_corrects.double() / dataset_sizes[phase]

            print(f"{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}")

            # Best মডেল সংরক্ষণ
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())

    print(f"Best Validation Accuracy: {best_acc:.4f}")

    # Best মডেলের ওয়েট লোড করা
    model.load_state_dict(best_model_wts)
    return model

ধাপ ৭: মডেল ট্রেনিং চালানো

# মডেলকে device এ পাঠানো (GPU/CPU)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)

# মডেল ট্রেনিং শুরু করা
model = train_model(model, criterion, optimizer, num_epochs=10)

ধাপ ৮: মডেল সংরক্ষণ করা (Optional)

মডেল ট্রেনিং শেষে মডেলটি সংরক্ষণ করা যায়, যাতে পরে এটি ব্যবহার করা যায়।

# মডেল সংরক্ষণ
torch.save(model.state_dict(), 'custom_model.pth')

সারসংক্ষেপ

এই প্রজেক্টে, আমরা ResNet-18 মডেলের প্রি-ট্রেনড ওয়েট ব্যবহার করে একটি Custom Image Classification মডেল তৈরি করেছি। আমরা মডেলের কিছু লেয়ার freeze করেছি এবং নতুন fully connected layer যোগ করেছি, যা আমাদের Custom ডেটাসেটের ক্লাসগুলোর সাথে মিলেছে। এরপর, মডেলটি train এবং validate করে Best accuracy পেয়েছি।

Transfer Learning এর মাধ্যমে Custom মডেল তৈরি করার এই প্রক্রিয়া কার্যকর, বিশেষত তখন যখন আমাদের কম ডেটা বা কম computational resources থাকে।