Torch (PyTorch) ব্যবহার করে একটি মডেল তৈরি করার জন্য, আমরা একটি সাধারণ প্রক্রিয়া অনুসরণ করব। PyTorch একটি জনপ্রিয় ডিপ লার্নিং ফ্রেমওয়ার্ক যা মডেল তৈরি, প্রশিক্ষণ, এবং টেস্ট করার জন্য ব্যবহৃত হয়। নিচে একটি উদাহরণসহ ধাপে ধাপে প্রক্রিয়াটি বর্ণনা করা হল:

ধাপ ১: PyTorch ইন্সটল করা

প্রথমে PyTorch ইন্সটল করতে হবে:

pip install torch
Copy

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

import torch
import torch.nn as nn
import torch.optim as optim
Copy

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

আমরা একটি সহজ ডেটাসেট তৈরি করতে পারি বা PyTorch এর torchvision ব্যবহার করতে পারি (যেমন MNIST)। উদাহরণস্বরূপ, আমরা ম্যানুয়ালি ডেটা তৈরি করতে পারি:

# এক্স এবং ওয়াই ডেটাসেট
X = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
Y = torch.tensor([[2.0], [4.0], [6.0], [8.0]])
Copy

ধাপ ৪: মডেলের স্ট্রাকচার তৈরি করা

একটি সাধারণ nn.Module শ্রেণী তৈরি করে মডেলের আর্কিটেকচার নির্ধারণ করা হয়:

class SimpleLinearModel(nn.Module):
    def __init__(self):
        super(SimpleLinearModel, self).__init__()
        self.linear = nn.Linear(1, 1)  # এক ইনপুট এবং এক আউটপুট

    def forward(self, x):
        return self.linear(x)
Copy

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

model = SimpleLinearModel()
criterion = nn.MSELoss()  # Mean Squared Error লস ফাংশন
optimizer = optim.SGD(model.parameters(), lr=0.01)  # Stochastic Gradient Descent
Copy

ধাপ ৬: মডেল প্রশিক্ষণ করা

প্রশিক্ষণের জন্য একটি লুপ ব্যবহার করা হয়, যেখানে প্রতিটি ধাপে লস কমানোর চেষ্টা করা হয়:

# প্রশিক্ষণ লুপ
epochs = 1000
for epoch in range(epochs):
    # ফরোয়ার্ড পাস
    predictions = model(X)
    loss = criterion(predictions, Y)
    
    # ব্যাকওয়ার্ড পাস এবং অপ্টিমাইজেশন
    optimizer.zero_grad()  # গ্রেডিয়েন্ট রিসেট
    loss.backward()  # ব্যাকপ্রোপাগেশন
    optimizer.step()  # ওজন আপডেট

    # মাঝে মাঝে লস প্রিন্ট করা
    if (epoch+1) % 100 == 0:
        print(f'Epoch {epoch+1}/{epochs}, Loss: {loss.item():.4f}')
Copy

ধাপ ৭: মডেল টেস্ট করা

with torch.no_grad():  # গ্রেডিয়েন্ট ক্যালকুলেশন বন্ধ
    test_input = torch.tensor([[5.0]])
    test_output = model(test_input)
    print(f'Prediction for input 5.0: {test_output.item()}')
Copy

সারসংক্ষেপ

উপরে বর্ণিত প্রক্রিয়াটি একটি সাধারণ লিনিয়ার মডেলের উদাহরণ। আপনি আরও জটিল মডেল (যেমন নিউরাল নেটওয়ার্ক, কনভলিউশনাল নিউরাল নেটওয়ার্ক) তৈরি করতে পারেন PyTorch ব্যবহার করে, একই কাঠামো অনুযায়ী। PyTorch অত্যন্ত ফ্লেক্সিবল এবং কাস্টম মডেল এবং লস ফাংশন তৈরির জন্য উপযোগী।

Neural Network (স্নায়বিক নেটওয়ার্ক) হচ্ছে এক ধরনের কৃত্রিম বুদ্ধিমত্তা (AI) এবং মেশিন লার্নিং (ML) মডেল, যা মানুষের মস্তিষ্কের নিউরন গঠন ও কাজের অনুকরণে ডিজাইন করা হয়েছে। এটি মূলত ডেটা থেকে প্যাটার্ন এবং সম্পর্ক শিখে ফলাফল নির্ধারণ করে। Neural Network সাধারণত বিভিন্ন স্তরের (Layer) সমন্বয়ে গঠিত হয়। এই স্তরগুলো হলো:

1. ইনপুট লেয়ার (Input Layer): এটি সেই লেয়ার যা ডেটা গ্রহণ করে। ডেটার ভিন্ন ভিন্ন বৈশিষ্ট্য বা ফিচার ইনপুট লেয়ারে স্থান পায়।
2. হিডেন লেয়ার (Hidden Layer): এই লেয়ারগুলোর কাজ হলো ইনপুট ডেটা থেকে বিভিন্ন প্যাটার্ন শিখে আউটপুট তৈরি করা। একটি মডেলে এক বা একাধিক হিডেন লেয়ার থাকতে পারে।
3. আউটপুট লেয়ার (Output Layer): এটি মডেলের চূড়ান্ত স্তর যেখানে মডেল ফলাফল প্রদান করে।

Neural Network এর কাজের প্রক্রিয়া

প্রথমে ইনপুট লেয়ারের মাধ্যমে ডেটা নেটওয়ার্কে প্রবেশ করে। এরপর হিডেন লেয়ারগুলো ইনপুট ডেটার উপর ভিত্তি করে বিভিন্ন গাণিতিক অপারেশন (যেমন: ম্যাট্রিক্স মাল্টিপ্লিকেশন, অ্যাক্টিভেশন ফাংশন প্রয়োগ) সম্পাদন করে এবং শেষ পর্যায়ে আউটপুট লেয়ারে ফলাফল প্রদান করে। নেটওয়ার্কটি এর মধ্যবর্তী ওজন (weights) এবং বায়াস (bias) আপডেট করতে ব্যাকপ্রোপাগেশন (Backpropagation) পদ্ধতি ব্যবহার করে, যাতে এটি ক্রমাগত সঠিক ফলাফল শিখতে পারে।

একটি Simple Neural Network তৈরি করার প্রক্রিয়া (Python এবং PyTorch ব্যবহার করে)

প্রথমে, PyTorch লাইব্রেরি ইনস্টল করতে হবে (যদি আগে ইনস্টল না থাকে):

pip install torch
Copy

এখন আমরা একটি সরল Neural Network তৈরি করতে পারি:

import torch
import torch.nn as nn
import torch.optim as optim

# Neural Network এর ক্লাস তৈরি
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.layer1 = nn.Linear(2, 3)  # ইনপুট ২ ফিচার, আউটপুট ৩ নিউরন
        self.layer2 = nn.Linear(3, 1)  # ৩ ইনপুট, ১ আউটপুট

    def forward(self, x):
        x = torch.relu(self.layer1(x))  # প্রথম লেয়ারে ReLU অ্যাক্টিভেশন
        x = torch.sigmoid(self.layer2(x))  # দ্বিতীয় লেয়ারে Sigmoid অ্যাক্টিভেশন
        return x

# মডেল, লস ফাংশন এবং অপ্টিমাইজার তৈরি
model = SimpleNN()
criterion = nn.MSELoss()  # Mean Squared Error লস ফাংশন
optimizer = optim.SGD(model.parameters(), lr=0.01)  # Stochastic Gradient Descent

# ডেটাসেট প্রস্তুত
inputs = torch.tensor([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
targets = torch.tensor([[0.0], [1.0], [1.0], [0.0]])  # XOR গেটের উদাহরণ

# ট্রেনিং লুপ
for epoch in range(1000):
    optimizer.zero_grad()  # গ্রেডিয়েন্ট রিসেট
    outputs = model(inputs)  # মডেলে ইনপুট প্রয়োগ
    loss = criterion(outputs, targets)  # লস গণনা
    loss.backward()  # ব্যাকপ্রোপাগেশন
    optimizer.step()  # অপ্টিমাইজেশন স্টেপ

# মডেল টেস্টিং
test_input = torch.tensor([[1.0, 0.0]])
prediction = model(test_input)
print("Prediction:", prediction.item())
Copy

ব্যাখ্যা:

1. SimpleNN ক্লাস: এটি একটি সরল নিউরাল নেটওয়ার্ক ক্লাস যা ইনপুট লেয়ার এবং দুটি লেয়ার নিয়ে গঠিত।
2. ReLU এবং Sigmoid: প্রথম হিডেন লেয়ারে ReLU (Rectified Linear Unit) এবং আউটপুট লেয়ারে Sigmoid ফাংশন ব্যবহার করা হয়েছে।
3. ট্রেনিং লুপ: মডেলটি ১০০০ ইপক পর্যন্ত ট্রেনিং করা হয় এবং প্রতিটি ইপকে লস আপডেট হয়।

এই পদ্ধতিতে, আপনি বিভিন্ন সমস্যার সমাধান করতে Neural Network ব্যবহার করতে পারেন।

PyTorch-এ nn.Module ব্যবহার করে একটি Custom Model তৈরি করতে হয় যা nn.Module class থেকে ইনহেরিট করে। এটি করার জন্য, প্রথমে মডেলের আর্কিটেকচার ডিফাইন করতে হবে এবং এরপরে forward মেথডে ডেটা কিভাবে প্রসেস হবে তা ডিফাইন করতে হবে। নিচে একটি সিম্পল উদাহরণ দেওয়া হল যেখানে একটি কাস্টম নিউরাল নেটওয়ার্ক মডেল তৈরি করা হয়েছে:

import torch
import torch.nn as nn
import torch.nn.functional as F

# Custom Model তৈরি
class CustomModel(nn.Module):
    def __init__(self):
        super(CustomModel, self).__init__()
        
        # Layers ডিফাইন করা
        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 = F.relu(self.fc1(x))
        
        # দ্বিতীয় লেয়ার এবং অ্যাক্টিভেশন ফাংশন
        x = F.relu(self.fc2(x))
        
        # আউটপুট লেয়ার
        x = self.fc3(x)
        return x

# মডেল ইনস্ট্যানশিয়েট করা
model = CustomModel()

# মডেল আউটপুট চেক করা
print(model)
Copy

ব্যাখ্যা:

1. __init__ মেথড:
   • এই মেথডে মডেলের লেয়ারগুলো ডিফাইন করা হয়। এখানে তিনটি লেয়ার ব্যবহার করা হয়েছে:
     • fc1: ইনপুট লেয়ার (28x28) -> হিডেন ইউনিট 128
     • fc2: হিডেন লেয়ার 128 -> 64
     • fc3: আউটপুট লেয়ার 64 -> 10
2. forward মেথড:
   • এই মেথডে ডেটা মডেলের মধ্য দিয়ে কিভাবে যাবে তা ডিফাইন করা হয়।
   • ইনপুটকে প্রথমে ফ্ল্যাট করা হয়েছে (এখানে 28x28 পিক্সেলের ইমেজ)।
   • এরপর প্রতিটি লেয়ারে ডেটা পাঠানো হয়েছে এবং ReLU অ্যাক্টিভেশন ফাংশন ব্যবহার করা হয়েছে।

ব্যবহার:

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

Forward Propagation (Forward Pass)

Forward Propagation হলো Deep Learning মডেলের একটি প্রক্রিয়া যেখানে ইনপুট ডেটা মডেলের মধ্যে দিয়ে প্রবাহিত হয় এবং আউটপুট জেনারেট করে। PyTorch-এ, এটি মডেলের forward মেথডের মাধ্যমে পরিচালিত হয়। মডেল ট্রেইনিং এবং prediction-এর সময় forward propagation হয়।

PyTorch-এ Forward Propagation উদাহরণ:

import torch
import torch.nn as nn

# একটি সাধারণ নিউরাল নেটওয়ার্ক ক্লাস তৈরি
class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNN, self).__init__()
        self.hidden = nn.Linear(input_size, hidden_size)
        self.output = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = torch.relu(self.hidden(x))
        x = self.output(x)
        return x

# মডেল ইনিশিয়ালাইজেশন
model = SimpleNN(input_size=2, hidden_size=5, output_size=1)

# ইনপুট টেন্সর
input_data = torch.tensor([[1.0, 2.0]])

# Forward pass
output = model(input_data)
print(output)
Copy

উপরের কোডে, SimpleNN একটি নিউরাল নেটওয়ার্ক মডেল যেখানে forward propagation মেথডে ইনপুট x দিয়ে hidden এবং output লেয়ার দিয়ে আউটপুট পাওয়া যায়।

Model Evaluation

Model Evaluation হলো মডেলের পারফর্ম্যান্স যাচাই করার একটি প্রক্রিয়া। এটি মডেল ট্রেইনিংয়ের পরে অথবা validation/testing dataset-এ মডেল কেমন কাজ করছে তা নির্ধারণের জন্য ব্যবহৃত হয়।

মডেল ইভ্যালুয়েশনের স্টেপসমূহ:

1. Loss Function: মডেলের আউটপুট এবং টার্গেট আউটপুটের পার্থক্য পরিমাপ করতে ব্যবহার করা হয়।
2. Evaluation Metrics: যেমন Accuracy, Precision, Recall, F1 Score, এবং ROC-AUC।
3. Confusion Matrix: ক্লাসিফিকেশন মডেলের পারফর্ম্যান্স বিশ্লেষণ করতে ব্যবহৃত হয়।

PyTorch-এ Model Evaluation উদাহরণ:

import torch
import torch.nn as nn
import torch.optim as optim

# Model, loss function এবং optimizer ইনিশিয়ালাইজ
model = SimpleNN(input_size=2, hidden_size=5, output_size=1)
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# কিছু ডেটাসেট উদাহরণ
input_data = torch.tensor([[1.0, 2.0], [3.0, 4.0]])
target = torch.tensor([[0.5], [1.5]])

# মডেলকে ইভ্যালুয়েট মোডে সেট করা
model.eval()

# আউটপুট জেনারেট করা
with torch.no_grad():  # Gradient না ক্যালকুলেট করার জন্য
    output = model(input_data)
    loss = criterion(output, target)
    print(f'Loss: {loss.item()}')

# মেট্রিক্স অনুযায়ী পর্যালোচনা
accuracy = ((output.round() == target).sum().float() / target.size(0)) * 100
print(f'Accuracy: {accuracy.item()}%')
Copy

উপরের উদাহরণে, আমরা মডেলটি ট্রেইন না করেই evaluation mode-এ সেট করেছি এবং টেস্ট ডেটাসেটে আউটপুট এবং টার্গেটের মধ্যে লস পরিমাপ করেছি।

এছাড়াও, মেট্রিক হিসেবে Accuracy পরিমাপ করা হয়েছে।

PyTorch ব্যবহার করে একটি বেসিক Neural Network মডেল তৈরি করার জন্য আমরা নিচের ধাপগুলো অনুসরণ করবো। এই উদাহরণে, আমরা একটি সহজ Feedforward Neural Network তৈরি করবো যা MNIST ডাটাসেট (হাতের লেখা সংখ্যা) ব্যবহার করে সংখ্যা শনাক্ত করবে।

ধাপ ১: PyTorch ইনস্টলেশন এবং ইমপোর্ট

প্রথমে, PyTorch এবং অন্যান্য প্রয়োজনীয় লাইব্রেরি ইনস্টল করুন (যদি এখনও না করা থাকে):

pip install torch torchvision
Copy

এখন Python কোডে প্রয়োজনীয় লাইব্রেরি ইমপোর্ট করুন:

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

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

আমরা MNIST ডাটাসেট ডাউনলোড এবং লোড করবো:

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True)

train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)
Copy

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

একটি সহজ ফিডফরোয়ার্ড নিউরাল নেটওয়ার্ক তৈরি করবো যা ইনপুট (28x28 পিক্সেল) গ্রহণ করে এবং আউটপুট হিসেবে 10টি ক্লাস (0-9) প্রদান করবে:

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 128) # প্রথম লেয়ার (784 থেকে 128)
        self.fc2 = nn.Linear(128, 64)      # দ্বিতীয় লেয়ার (128 থেকে 64)
        self.fc3 = nn.Linear(64, 10)       # আউটপুট লেয়ার (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()
Copy

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

আমরা ক্রস-এন্ট্রপি লস এবং স্টোকাস্টিক গ্রেডিয়েন্ট ডিসেন্ট (SGD) অপ্টিমাইজার ব্যবহার করবো:

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
Copy

ধাপ ৫: মডেল ট্রেইনিং

আমরা মডেলটি ট্রেইন করবো:

num_epochs = 5

for epoch in range(num_epochs):
    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}')
Copy

ধাপ ৬: মডেল টেস্টিং

এখন আমরা মডেলটি টেস্ট ডাটাসেটে কিভাবে পারফর্ম করে তা পরীক্ষা করবো:

model.eval()  # ইভালুয়েশন মোডে সেট করা
correct = 0
total = 0

with torch.no_grad():
    for images, labels in test_loader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

accuracy = 100 * correct / total
print(f'Accuracy of the model on the test dataset: {accuracy:.2f}%')
Copy

এই কোডটি আমাদের বেসিক Neural Network মডেলটি ট্রেইন ও টেস্ট করার জন্য। আপনি চাইলে বিভিন্ন হাইপারপ্যারামিটার ও লেয়ারের সংখ্যা পরিবর্তন করে মডেলের পারফরমেন্স উন্নত করতে পারেন।