PyTorch-এ অপটিমাইজার এবং লস ফাংশন মডেল ট্রেনিংয়ের একটি অপরিহার্য অংশ। এরা মডেলকে শেখাতে সাহায্য করে এবং ত্রুটি (error) কমিয়ে মডেলকে আরও নির্ভুল করতে সহায়তা করে। নিচে PyTorch-এ অপটিমাইজার এবং লস ফাংশন সম্পর্কে বিস্তারিত আলোচনা এবং তাদের উদাহরণ দেওয়া হল:

লস ফাংশন (Loss Function)

লস ফাংশন মডেলের প্রেডিকশন এবং আসল ভ্যালুর মধ্যে পার্থক্য পরিমাপ করে। লস ফাংশন যত কম হয়, মডেলের প্রেডিকশন তত বেশি সঠিক হয়। PyTorch-এ কিছু সাধারণ লস ফাংশন হলো:

Mean Squared Error (MSE):

• সাধারণত রিগ্রেশন সমস্যার জন্য ব্যবহৃত হয়। এটি প্রেডিক্টেড এবং আসল মানের পার্থক্যের স্কোয়ার বের করে।

Cross-Entropy Loss:

• ক্লাসিফিকেশন সমস্যার জন্য ব্যবহৃত হয়, বিশেষ করে যখন আউটপুট মাল্টি-ক্লাস হয়।

Binary Cross-Entropy Loss (BCELoss):

• বাইনারি ক্লাসিফিকেশন (যেখানে আউটপুট দুটি ক্লাস) সমস্যার জন্য ব্যবহৃত হয়।

L1 Loss (Mean Absolute Error):

• এটি প্রেডিক্টেড এবং আসল মানের মধ্যে গড় পার্থক্য নির্ণয় করে।

অপটিমাইজার (Optimizer)

অপটিমাইজার মডেলের প্যারামিটার আপডেট করতে সাহায্য করে যাতে লস কমানো যায়। PyTorch-এ বেশ কিছু অপটিমাইজার রয়েছে যেগুলো বিভিন্ন প্রকার মডেলের জন্য উপযোগী। কয়েকটি সাধারণ অপটিমাইজার হলো:

Stochastic Gradient Descent (SGD):

• সাধারণ অপটিমাইজার যা প্যারামিটার আপডেট করতে লার্নিং রেট এবং গ্রেডিয়েন্ট ব্যবহার করে।

Adam (Adaptive Moment Estimation):

• একটি উন্নত অপটিমাইজার যা প্রতিটি প্যারামিটারের জন্য আলাদা লার্নিং রেট নির্ধারণ করে। এটি অনেক ক্ষেত্রে দ্রুত এবং নির্ভুল ফলাফল দেয়।

RMSprop:

• এটি এমন একটি অপটিমাইজার যা SGD-এর মতো তবে চলমান গড় (running average) ব্যবহার করে লার্নিং রেট অ্যাডাপ্ট করে।

AdamW:

• Adam-এর একটি ভ্যারিয়েন্ট যা ওয়েট ডিকেয় নিয়ন্ত্রণ করে।

লস ফাংশন এবং অপটিমাইজার ব্যবহার

নিচে একটি উদাহরণ দেওয়া হল কিভাবে PyTorch-এ লস ফাংশন এবং অপটিমাইজার ব্যবহার করে মডেল প্রশিক্ষণ করা যায়:

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

# একটি সাধারণ মডেল
class SimpleModel(nn.Module):
    def __init__(self):
        super(SimpleModel, self).__init__()
        self.linear = nn.Linear(1, 1)

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

# মডেল, লস ফাংশন এবং অপটিমাইজার সেট করা
model = SimpleModel()
criterion = nn.MSELoss()  # লস ফাংশন নির্বাচন করা (MSE)
optimizer = optim.SGD(model.parameters(), lr=0.01)  # SGD অপটিমাইজার নির্বাচন করা

# উদাহরণ ইনপুট এবং আউটপুট
X = torch.tensor([[1.0], [2.0], [3.0], [4.0]])
Y = torch.tensor([[2.0], [4.0], [6.0], [8.0]])

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

    if (epoch+1) % 100 == 0:
        print(f'Epoch {epoch+1}/{epochs}, Loss: {loss.item():.4f}')
Copy

সারসংক্ষেপ

PyTorch-এ লস ফাংশন মডেলের ত্রুটি নির্ধারণ করতে ব্যবহৃত হয় এবং অপটিমাইজার সেই ত্রুটি কমানোর জন্য মডেলের প্যারামিটার আপডেট করে। এই দুটি উপাদান একসাথে কাজ করে মডেলের পারফরম্যান্স অপ্টিমাইজ করে এবং মডেলকে আরও নির্ভুল করতে সাহায্য করে।

PyTorch-এ লস ফাংশন এবং অপটিমাইজার মডেল ট্রেনিং-এর গুরুত্বপূর্ণ অংশ। লস ফাংশন দিয়ে আমরা মডেলের আউটপুট ও টার্গেটের মধ্যে পার্থক্য মাপতে পারি, আর অপটিমাইজার দিয়ে সেই পার্থক্য কমানোর জন্য মডেলের প্যারামিটার আপডেট করতে পারি। নিচে লস ফাংশন এবং অপটিমাইজার ব্যবহারের একটি সাধারণ উদাহরণ দেয়া হলো:

ধাপ ১: লস ফাংশন তৈরি করা

লস ফাংশন হিসেবে nn মডিউল থেকে বিভিন্ন ধরনের ফাংশন নিতে পারেন। উদাহরণস্বরূপ, ক্লাসিফিকেশনের জন্য CrossEntropyLoss এবং রিগ্রেশনের জন্য MSELoss সাধারণত ব্যবহৃত হয়।

import torch
import torch.nn as nn

# লস ফাংশন নির্বাচন
criterion = nn.CrossEntropyLoss()  # ক্লাসিফিকেশন সমস্যার জন্য
Copy

ধাপ ২: অপটিমাইজার তৈরি করা

অপটিমাইজার তৈরি করতে হলে মডেলের প্যারামিটার এবং লার্নিং রেট নির্ধারণ করতে হবে। এখানে Adam অপটিমাইজার ব্যবহার করা হয়েছে, তবে SGD, RMSprop ইত্যাদি অপটিমাইজারও ব্যবহার করতে পারেন।

import torch.optim as optim

# অপটিমাইজার নির্বাচন
optimizer = optim.Adam(model.parameters(), lr=0.001)
Copy

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

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

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

সারাংশ

1. criterion দিয়ে লস ফাংশন তৈরি করুন।
2. optimizer দিয়ে অপটিমাইজার তৈরি করুন।
3. ট্রেনিং লুপে loss.backward() এবং optimizer.step() ব্যবহার করে প্যারামিটার আপডেট করুন।

এভাবে PyTorch ব্যবহার করে সহজেই মডেল ট্রেনিং করতে পারবেন।

PyTorch-এ বিভিন্ন ধরনের অপ্টিমাইজার রয়েছে, যেগুলি মডেল ট্রেনিং করার সময় গ্রেডিয়েন্টস আপডেট করার জন্য ব্যবহার করা হয়। প্রতিটি অপ্টিমাইজার বিভিন্ন উপায়ে লার্নিং রেট এবং গ্রেডিয়েন্টস ব্যবহার করে মডেলের ওজন (weights) আপডেট করে। নিচে সবচেয়ে প্রচলিত কয়েকটি অপ্টিমাইজার এবং তাদের ব্যবহার দেখানো হলো:

১. Stochastic Gradient Descent (SGD)

SGD হচ্ছে সবচেয়ে সাধারণ অপ্টিমাইজার, যা মডেলের গ্রেডিয়েন্ট আপডেট করে একটি ছোট লার্নিং রেটের মাধ্যমে।

import torch.optim as optim

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
Copy

SGD অপ্টিমাইজারে ব্যবহৃত কয়েকটি প্যারামিটার:

• lr: লার্নিং রেট, যা প্রতিটি স্টেপে ওজন আপডেটের পরিমাণ নির্ধারণ করে।
• momentum: এটি অতীতের গ্রেডিয়েন্টসের দিকে কিছুটা গতি রাখে, যাতে মডেল দ্রুত এবং ভালভাবে কনভার্জ করতে পারে।

২. Adam (Adaptive Moment Estimation)

Adam অপ্টিমাইজারটি হচ্ছে একটি অত্যন্ত কার্যকর অপ্টিমাইজার, যা লার্নিং রেট স্বয়ংক্রিয়ভাবে সামঞ্জস্য করে এবং প্রথম ও দ্বিতীয় অর্ডার মোমেন্ট ব্যবহার করে।

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

Adam অপ্টিমাইজারের প্যারামিটার:

• lr: লার্নিং রেট, যা সাধারনত SGD এর তুলনায় কম ব্যবহার করা হয় (যেমন 0.001)।
• betas: দুটি হাইপারপ্যারামিটার (ডিফল্ট হলো (0.9, 0.999)), যা প্রথম এবং দ্বিতীয় মোমেন্ট অনুমানের জন্য ব্যবহৃত হয়।
• eps: ছোট একটি ভ্যালু, যা জিরো ডিভিশন সমস্যা এড়ানোর জন্য যোগ করা হয় (ডিফল্ট হলো 1e-8)।

৩. RMSprop (Root Mean Square Propagation)

RMSprop অপ্টিমাইজারটি ডিপ লার্নিংয়ের জন্য বেশ উপযোগী, কারণ এটি গ্রেডিয়েন্টসের চলমান গড় ব্যবহার করে লার্নিং রেট আপডেট করে। এটি গ্রেডিয়েন্টসের স্কেল স্থিতিশীল রাখতে সাহায্য করে।

optimizer = optim.RMSprop(model.parameters(), lr=0.01)
Copy

RMSprop এর প্যারামিটার:

• lr: লার্নিং রেট।
• alpha: গ্রেডিয়েন্টসের চলমান গড়ে আপডেট করার জন্য হাইপারপ্যারামিটার (ডিফল্ট হলো 0.99)।
• eps: ছোট একটি ভ্যালু, যা জিরো ডিভিশন সমস্যা এড়ানোর জন্য যোগ করা হয় (ডিফল্ট হলো 1e-8)।

৪. Adagrad (Adaptive Gradient Algorithm)

Adagrad একটি অপ্টিমাইজার যা বিভিন্ন প্যারামিটারের জন্য আলাদা লার্নিং রেট ব্যবহার করে, যেগুলি পূর্বের গ্রেডিয়েন্টগুলির উপর নির্ভর করে।

optimizer = optim.Adagrad(model.parameters(), lr=0.01)
Copy

Adagrad এর প্যারামিটার:

• lr: লার্নিং রেট।
• lr_decay: লার্নিং রেটের জন্য ডেকে প্যারামিটার, যা সময়ের সাথে সাথে লার্নিং রেট কমায়।
• eps: জিরো ডিভিশন সমস্যা এড়ানোর জন্য ছোট একটি ভ্যালু।

৫. AdamW (Adam with Weight Decay)

AdamW হলো Adam অপ্টিমাইজারের একটি উন্নত সংস্করণ, যেখানে ওজন কমানোর (Weight Decay) কার্যকরী পদ্ধতি ব্যবহার করা হয়। এটি অত্যন্ত জনপ্রিয়, বিশেষ করে ট্রান্সফর্মার-ভিত্তিক মডেলের জন্য।

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

AdamW এর প্যারামিটার:

• lr: লার্নিং রেট।
• weight_decay: এটি ওজনের জন্য একটি ডেকে প্যারামিটার, যা মডেল ওভারফিটিং এড়াতে সহায়ক।
• betas: Adam এর মতই প্রথম ও দ্বিতীয় মোমেন্ট অনুমানের জন্য।

৬. Adadelta

Adadelta হচ্ছে Adagrad এর একটি উন্নত সংস্করণ, যা লার্নিং রেট ডেকেকে সীমিত করে এবং মডেলের উন্নতির জন্য বর্তমান ও অতীতের গ্রেডিয়েন্টের উপর ভিত্তি করে কাজ করে।

optimizer = optim.Adadelta(model.parameters(), lr=1.0)
Copy

Adadelta এর প্যারামিটার:

• lr: লার্নিং রেট (যদিও এটি সাধারণত বেশি রাখা হয়)।
• rho: গ্রেডিয়েন্টসের চলমান গড়ের জন্য প্যারামিটার।
• eps: জিরো ডিভিশন সমস্যা এড়ানোর জন্য ছোট একটি ভ্যালু।

অপ্টিমাইজার ব্যবহার করার পদ্ধতি

যে অপ্টিমাইজারই আপনি ব্যবহার করুন না কেন, PyTorch-এ প্রতিটি ট্রেনিং স্টেপে সাধারণত এই পদ্ধতি অনুসরণ করা হয়:

# ১. গ্রেডিয়েন্টস রিসেট করা
optimizer.zero_grad()

# ২. মডেলের মাধ্যমে আউটপুট বের করা
outputs = model(inputs)

# ৩. লস গণনা করা
loss = criterion(outputs, targets)

# ৪. ব্যাকপ্রোপাগেশন ব্যবহার করে গ্রেডিয়েন্ট আপডেট করা
loss.backward()

# ৫. অপ্টিমাইজারের মাধ্যমে ওজন আপডেট করা
optimizer.step()
Copy

কোন অপ্টিমাইজার ব্যবহার করবেন?

• SGD: যখন মডেলের সাধারণ গ্রেডিয়েন্টে কাজ করছেন এবং হাইপারপ্যারামিটার কন্ট্রোল করতে চান।
• Adam: ডিফল্ট এবং সাধারণভাবে সবচেয়ে কার্যকর অপ্টিমাইজার, বিশেষ করে ডিপ লার্নিং মডেলগুলোর জন্য।
• RMSprop: RNN বা ডিপ লার্নিংয়ে যেখানে গ্রেডিয়েন্ট স্থিতিশীল রাখতে হবে।
• AdamW: ট্রান্সফর্মার বা বৃহৎ মডেল ট্রেনিংয়ের জন্য।

এই অপ্টিমাইজারগুলির মধ্যে আপনার প্রয়োজন অনুসারে সঠিক অপ্টিমাইজারটি নির্বাচন করতে হবে।

PyTorch-এ Loss Function এবং Model Training এর ধাপগুলো নিচে আলোচনা করা হলো:

Loss Function

Loss Function হলো মডেলের প্রেডিকশন এবং আসল টার্গেটের মধ্যে পার্থক্য পরিমাপের একটি মেট্রিক্স। মডেল ট্রেনিংয়ের সময়, লস ফাংশন মডেলের আউটপুট এবং টার্গেটের মধ্যে পার্থক্য হিসাব করে, যা মডেল অপ্টিমাইজ করার জন্য প্রয়োজন।

PyTorch-এ Loss Function উদাহরণ:

Mean Squared Error Loss (MSELoss): রিগ্রেশন সমস্যায় ব্যবহৃত হয়।

criterion = nn.MSELoss()
Copy

Cross-Entropy Loss: ক্লাসিফিকেশন সমস্যায় ব্যবহৃত হয়।

criterion = nn.CrossEntropyLoss()
Copy

Loss function মডেলের আউটপুট এবং টার্গেট আউটপুটের মধ্যে পার্থক্য পরিমাপ করে এবং এই মানটি যত কম হয়, মডেল তত ভালো পারফর্ম করে।

মডেল ট্রেনিং এর ধাপ

মডেল ট্রেনিং মানে হলো মডেলকে ট্রেইনিং ডেটাসেট দিয়ে প্রশিক্ষণ দেওয়া এবং ওজন (weights) আপডেট করা যাতে মডেলটি সঠিকভাবে প্রেডিক্ট করতে পারে। PyTorch-এ মডেল ট্রেনিং করার জন্য নিচের ধাপগুলো অনুসরণ করা হয়:

1. Model Initialization: মডেল তৈরি করা।
2. Loss Function এবং Optimizer সেট করা: লস ফাংশন এবং optimizer ইনিশিয়ালাইজ করা।
3. Forward Pass: ইনপুট ডেটা দিয়ে মডেলের আউটপুট জেনারেট করা।
4. Loss Calculation: আউটপুট এবং টার্গেটের মধ্যে লস ফাংশন দিয়ে লস ক্যালকুলেট করা।
5. Backward Pass (Backpropagation): লস অনুযায়ী গ্রেডিয়েন্ট ক্যালকুলেট করা এবং ওজন আপডেট করা।
6. Optimizer Step: Optimizer ব্যবহার করে মডেলের প্যারামিটার আপডেট করা।
7. Iteration: Step 3 থেকে 6 পর্যন্ত লুপ চালিয়ে মডেলকে ট্রেন করা।

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

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

# একটি সাধারণ নিউরাল নেটওয়ার্ক তৈরি
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

# মডেল, লস ফাংশন এবং 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], [5.0, 6.0], [7.0, 8.0]])
target = torch.tensor([[0.5], [1.5], [2.5], [3.5]])

# মডেল ট্রেনিং লুপ
for epoch in range(100):  # ১০০ এপক পর্যন্ত ট্রেন করা
    optimizer.zero_grad()  # গ্রেডিয়েন্ট রিসেট করা
    output = model(input_data)  # Forward Pass
    loss = criterion(output, target)  # Loss Calculation
    loss.backward()  # Backward Pass
    optimizer.step()  # Optimizer Step

    # প্রতিটি ১০ এপক পর পর লস প্রিন্ট করা
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/100], Loss: {loss.item():.4f}')
Copy

ট্রেনিং এর প্রতিটি ধাপ ব্যাখ্যা:

1. Model Initialization: SimpleNN ক্লাসের মাধ্যমে মডেল তৈরি করা হয়েছে।
2. Loss Function এবং Optimizer: MSELoss এবং SGD optimizer ব্যবহার করা হয়েছে।
3. Forward Pass: ইনপুট ডেটা মডেলের মধ্যে দিয়ে আউটপুট বের করা হয়েছে।
4. Loss Calculation: criterion ব্যবহার করে আউটপুট এবং টার্গেটের মধ্যে লস ক্যালকুলেট করা হয়েছে।
5. Backward Pass: loss.backward() দিয়ে গ্রেডিয়েন্ট ক্যালকুলেট করা হয়েছে।
6. Optimizer Step: optimizer.step() দিয়ে মডেলের প্যারামিটার আপডেট করা হয়েছে।

এভাবে PyTorch ব্যবহার করে মডেল ট্রেনিং এবং লস ফাংশন ম্যানেজ করা হয়।

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

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

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

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

import torch.nn as nn

criterion = nn.CrossEntropyLoss()
Copy

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

অপ্টিমাইজার (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)
Copy

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

এখন আমরা লস ফাংশন এবং অপ্টিমাইজার ব্যবহার করে মডেলটি ট্রেন করবো। এই উদাহরণে, আমরা 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}')
Copy

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

১. 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}')
Copy

২. Weight Decay (L2 Regularization)

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

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

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

• 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}')
Copy

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