Optimizers এবং Training

Optimizers এবং Training: ব্যাখ্যা এবং উদাহরণ

1. Optimizer কী?

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

2. কীভাবে Optimizers কাজ করে?

Optimizers গ্রেডিয়েন্ট ডেসেন্ট নামক একটি পদ্ধতি ব্যবহার করে, যেখানে লস ফাংশনের ভিত্তিতে মডেলের প্রতিটি প্যারামিটার (যেমন ওজন ও বায়াস) ধীরে ধীরে পরিবর্তন করা হয়। কিছু সাধারণ Optimizer হলোঃ

• SGD (Stochastic Gradient Descent): মডেলের প্রতিটি উদাহরণের জন্য আলাদাভাবে ওজন আপডেট করে। এটি সরল কিন্তু মাঝে মাঝে ধীরে কনভার্জ হয়।
• Adam (Adaptive Moment Estimation): এটি গ্রেডিয়েন্টের ঐতিহাসিক তথ্য সংরক্ষণ করে এবং দ্রুত কনভার্জ করে।
• RMSprop (Root Mean Square Propagation): এটি লার্নিং রেটকে গ্রেডিয়েন্টের স্কেল অনুযায়ী সমন্বয় করে।

3. Training কী?

Training হলো একটি প্রক্রিয়া যেখানে মডেলটি ইনপুট ডেটা থেকে শেখে এবং লস কমানোর জন্য ওজন ও বায়াস আপডেট করে। মডেলটির প্রতিটি ইপোকের পর এটি ডেটাসেটের ওপর পুনরায় প্রশিক্ষিত হয় এবং মডেলের পারফরম্যান্স উন্নত হয়।

প্রতিটি Training ইপোকের সময় Forward Propagation এবং Backward Propagation প্রক্রিয়া সম্পন্ন হয়।

উদাহরণঃ XOR ফাংশনের জন্য Optimizer এবং Training ব্যবহার

এই উদাহরণে, আমরা SGD এবং Adam Optimizer ব্যবহার করে XOR ফাংশন প্রশিক্ষণ দেব।

import chainer
import chainer.functions as F
import chainer.links as L
from chainer import Chain, optimizers, Variable

# ডেটাসেট ডিফাইন করা হচ্ছে
x_data = [[0, 0], [0, 1], [1, 0], [1, 1]]
y_data = [[0], [1], [1], [0]]

# বেসিক নিউরাল নেটওয়ার্ক ডিফাইন করা হচ্ছে
class XORNetwork(Chain):
    def __init__(self):
        super(XORNetwork, self).__init__()
        # 2-ইনপুট এবং 3-হিডেন নিউরন
        with self.init_scope():
            self.l1 = L.Linear(2, 3)  # হিডেন লেয়ার
            self.l2 = L.Linear(3, 1)  # আউটপুট লেয়ার

    # Forward Propagation
    def __call__(self, x):
        h = F.sigmoid(self.l1(x))  # প্রথম লেয়ারের এক্টিভেশন
        y = F.sigmoid(self.l2(h))  # দ্বিতীয় লেয়ারের এক্টিভেশন
        return y

# মডেল তৈরি করা হচ্ছে
model = XORNetwork()

# SGD Optimizer
sgd_optimizer = optimizers.SGD(lr=0.1)
sgd_optimizer.setup(model)

# Adam Optimizer
adam_optimizer = optimizers.Adam()
adam_optimizer.setup(model)

# Training ফাংশন
def train_model(optimizer, epochs=5000):
    for epoch in range(epochs):
        loss = 0
        for i in range(len(x_data)):
            # ইনপুট ডেটা ভ্যারিয়েবল হিসেবে তৈরি
            x = Variable(chainer.backends.cuda.to_cpu(x_data[i]))
            y = Variable(chainer.backends.cuda.to_cpu(y_data[i]))

            # Forward Propagation
            y_pred = model(x)
            
            # লস হিসাব করা হচ্ছে
            loss += F.mean_squared_error(y_pred, y)
        
        # Backward Propagation এবং Optimizer Update
        model.cleargrads()
        loss.backward()
        optimizer.update()

        # ইপোকের প্রতি 1000 তম ধাপে লস প্রিন্ট
        if epoch % 1000 == 0:
            print(f'Epoch {epoch}, Loss: {loss.data}')

# SGD ব্যবহার করে Training
print("Training with SGD Optimizer:")
train_model(sgd_optimizer)

# Adam ব্যবহার করে Training
print("\nTraining with Adam Optimizer:")
train_model(adam_optimizer)

ব্যাখ্যা

1. মডেল ও Optimizer তৈরি: SGD এবং Adam Optimizer দিয়ে train_model ফাংশনে মডেলটি প্রশিক্ষণ দেবো।
2. Training লুপ: প্রতিটি ইপোকে Forward এবং Backward Propagation চলবে। optimizer.update() কল করার মাধ্যমে Optimizer ওজন আপডেট করবে।
3. লস প্রিন্ট করা: প্রতিটি ১০০০ তম ইপোকে আমরা লস আউটপুট প্রিন্ট করছি, যাতে মডেলের উন্নতি দেখা যায়।

সংক্ষেপে

এই উদাহরণ থেকে বোঝা যায় কিভাবে Optimizer মডেলের লার্নিং রেট পরিবর্তন করে Training-এ সাহায্য করে। SGD এবং Adam-এর মাধ্যমে মডেলটি ভিন্ন ভিন্ন পদ্ধতিতে উন্নতি করতে পারে এবং এটি নেটওয়ার্ককে দ্রুত কনভার্জ করতে সাহায্য করে।

Optimizer কী এবং এর প্রয়োজনীয়তা

Optimizer হল একটি অ্যালগরিদম বা কৌশল যা মেশিন লার্নিং এবং ডিপ লার্নিং মডেলগুলির প্রশিক্ষণ প্রক্রিয়ায় ব্যবহৃত হয়। এটি একটি নির্দিষ্ট লস ফাংশনকে (Loss Function) সর্বনিম্ন করতে সাহায্য করে, যাতে মডেলটির কার্যকারিতা উন্নত হয়। অপ্টিমাইজারগুলি মডেলের ওজন এবং পক্ষপাত (bias) আপডেট করে, যাতে তারা প্রশিক্ষণ ডেটার উপর ভিত্তি করে ভালভাবে কাজ করতে পারে।

১. Optimizer এর মৌলিক ধারণা

১.১ অপ্টিমাইজারের কাজ

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

১.২ সাধারণ অপ্টিমাইজার

1. Stochastic Gradient Descent (SGD): এটি একটি সাধারণ এবং জনপ্রিয় অপ্টিমাইজার যা লস ফাংশনের গ্রেডিয়েন্টের উপর ভিত্তি করে ওজন আপডেট করে।
2. Adam: একটি উন্নত অপ্টিমাইজার যা প্রথম এবং দ্বিতীয় মোমেন্টের অনুমান ব্যবহার করে। এটি দ্রুততর সঙ্কলনের জন্য ডিজাইন করা হয়েছে।
3. RMSprop: এটি SGD এর একটি সংস্করণ যা লার্নিং রেটকে অভিযোজিত করে, যাতে এটি আরও দ্রুত শিখতে পারে।

২. Optimizer এর প্রয়োজনীয়তা

২.১ কার্যকারিতা বৃদ্ধি

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

২.২ কনvergance ত্বরান্বিত করা

• দ্রুত সঙ্কলন: অপ্টিমাইজারগুলি মডেলটিকে দ্রুততার সাথে সর্বনিম্ন ক্ষতির দিকে নিয়ে যেতে সাহায্য করে।
• স্থানীয় এবং গ্লোবাল মিনিমা: সঠিক অপ্টিমাইজার নির্বাচনের মাধ্যমে স্থানীয় মিনিমা থেকে বেরিয়ে গ্লোবাল মিনিমায় পৌঁছানো সহজ হয়।

২.৩ বিভিন্ন পরিস্থিতিতে প্রয়োগ

• ডেটার প্রকার: বিভিন্ন অপ্টিমাইজার ডেটার বিভিন্ন বৈশিষ্ট্যের উপর ভিত্তি করে কার্যকরীভাবে কাজ করে। যেমন, সিজি, দৃষ্টি, এবং শব্দের মডেলগুলির জন্য ভিন্ন অপ্টিমাইজার প্রয়োগ করা যেতে পারে।

৩. উপসংহার

Optimizer হল একটি গুরুত্বপূর্ণ উপাদান যা মেশিন লার্নিং এবং ডিপ লার্নিং মডেলগুলির কার্যকারিতা এবং প্রশিক্ষণ প্রক্রিয়া নির্ধারণ করে। সঠিক অপ্টিমাইজারের ব্যবহার মডেলের প্রশিক্ষণকে সহজতর করে এবং কার্যকারিতাকে বৃদ্ধি করে। ডেটা এবং মডেলের বৈশিষ্ট্য অনুযায়ী সঠিক অপ্টিমাইজার নির্বাচন করা অত্যন্ত গুরুত্বপূর্ণ।

Optimizers এর ব্যবহার: SGD, Adam, এবং RMSprop

নিউরাল নেটওয়ার্ক ট্রেনিংয়ে বিভিন্ন ধরনের Optimizers ব্যবহার করা হয়, যাদের মধ্যে SGD, Adam, এবং RMSprop সবচেয়ে জনপ্রিয়। নিচে প্রতিটি Optimizer-এর বৈশিষ্ট্য এবং তাদের ব্যবহারের উদাহরণ দেওয়া হলো।

1. SGD (Stochastic Gradient Descent):

SGD হলো সবচেয়ে সাধারণ Optimizer, যা প্রতিটি ট্রেনিং উদাহরণের জন্য ওজন আপডেট করে। এটি সরল হলেও বড় ডেটাসেটের জন্য ধীরগতির হতে পারে। SGD মূলত তখনই উপযোগী যখন ডেটাসেটটি ছোট এবং মডেল সরল।

উদাহরণ:

# SGD Optimizer তৈরি এবং সেটআপ
optimizer = optimizers.SGD(lr=0.01)  # Learning rate 0.01
optimizer.setup(model)

# ট্রেনিং লুপ
for epoch in range(epochs):
    model.cleargrads()    # গ্রেডিয়েন্ট ক্লিয়ার
    loss = compute_loss(model, x_data, y_data)
    loss.backward()       # ব্যাকওয়ার্ড পাস
    optimizer.update()    # SGD অনুযায়ী ওজন আপডেট

নোট: এখানে compute_loss() একটি ফাংশন, যা মডেলের লস গণনা করে।

2. Adam (Adaptive Moment Estimation):

Adam Optimizer মডেলটিকে দ্রুত কনভার্জ করতে সাহায্য করে। এটি Learning Rate স্বয়ংক্রিয়ভাবে সামঞ্জস্য করে এবং দুইটি ভিন্ন মোমেন্টম (momentum) ধারণ করে। সাধারণত Adam ব্যবহার করা হয় যখন মডেলটি বড় এবং ডেটাসেটও বড়।

উদাহরণ:

# Adam Optimizer তৈরি এবং সেটআপ
optimizer = optimizers.Adam(alpha=0.001)  # Default learning rate
optimizer.setup(model)

# ট্রেনিং লুপ
for epoch in range(epochs):
    model.cleargrads()
    loss = compute_loss(model, x_data, y_data)
    loss.backward()
    optimizer.update()  # Adam অনুযায়ী ওজন আপডেট

নোট: Adam-এর alpha প্যারামিটারটি Learning Rate নির্দেশ করে, যা সাধারণত 0.001 হিসেবে সেট করা হয়।

3. RMSprop (Root Mean Square Propagation):

RMSprop অ্যালগরিদমটি গ্রেডিয়েন্টের স্কোয়ারড মুভিং অ্যাভারেজ ব্যবহার করে লার্নিং রেট সামঞ্জস্য করে। এটি বিশেষভাবে উপযোগী যখন ডেটা স্প্যারস (sparse) হয় এবং সঠিক গ্রেডিয়েন্ট হিসাব কঠিন হয়। Recurrent Neural Networks (RNN) ট্রেনিংয়ের সময় এটি অধিক কার্যকর।

উদাহরণ:

# RMSprop Optimizer তৈরি এবং সেটআপ
optimizer = optimizers.RMSprop(lr=0.001)  # Learning rate
optimizer.setup(model)

# ট্রেনিং লুপ
for epoch in range(epochs):
    model.cleargrads()
    loss = compute_loss(model, x_data, y_data)
    loss.backward()
    optimizer.update()  # RMSprop অনুযায়ী ওজন আপডেট

নোট: RMSprop-এর lr প্যারামিটারটি Learning Rate নির্দেশ করে।

চূড়ান্ত উদাহরণ: একাধিক Optimizers ব্যবহার করে Training

নিচে একসাথে SGD, Adam, এবং RMSprop Optimizers এর কাজ প্রদর্শনের জন্য এক্সপেরিমেন্টাল কোড দেখানো হলো। আপনি প্রতিটি Optimizer আলাদাভাবে ব্যবহার করে মডেল প্রশিক্ষণের জন্য এটি ব্যবহার করতে পারেন।

optimizers_dict = {
    "SGD": optimizers.SGD(lr=0.01),
    "Adam": optimizers.Adam(alpha=0.001),
    "RMSprop": optimizers.RMSprop(lr=0.001)
}

# প্রতিটি Optimizer-এর জন্য ট্রেনিং
for opt_name, optimizer in optimizers_dict.items():
    print(f"\nTraining with {opt_name} Optimizer:")
    optimizer.setup(model)

    for epoch in range(epochs):
        model.cleargrads()
        loss = compute_loss(model, x_data, y_data)
        loss.backward()
        optimizer.update()

        if epoch % 1000 == 0:
            print(f'Epoch {epoch}, Loss: {loss.data}')

কোন Optimizer কখন ব্যবহার করবেন?

• SGD: ছোট ডেটাসেট এবং সহজ মডেলের জন্য। এটি সরল এবং computationally কম ব্যয়বহুল।
• Adam: অধিকাংশ ক্ষেত্রে আদর্শ এবং বড় ডেটাসেট ও জটিল মডেলের জন্য কার্যকরী।
• RMSprop: স্প্যারস ডেটাসেট এবং Recurrent মডেলের জন্য ভালো ফলাফল দেয়।

এই উদাহরণগুলো থেকে আপনি বিভিন্ন Optimizer-এর বৈশিষ্ট্য এবং ব্যবহারের ধারণা পেয়েছেন।

Machine learning মডেল training এর সময় বিভিন্ন ধাপ অনুসরণ করা হয় এবং training এর performance পরিমাপ করার জন্য loss calculation করা হয়। মডেল training এবং loss calculation সম্পর্কে ধারণা পেতে নীচে বিস্তারিত ধাপগুলো দেওয়া হল।

মডেল Training এর ধাপ

মডেল training এর সাধারণত প্রধান ধাপগুলো হলো:

ডেটা সংগ্রহ এবং প্রি-প্রসেসিং:

• প্রথমে ডেটা সংগ্রহ করতে হয় এবং তারপর ডেটাকে মডেল training এর উপযোগী করতে প্রি-প্রসেসিং করতে হয়।
• প্রি-প্রসেসিং ধাপে feature scaling, normalization, categorical encoding ইত্যাদি করা হয়।

মডেল Initialize করা:

• মডেলের আর্কিটেকচার বা কাঠামো নির্ধারণ করা হয়।
• বিভিন্ন ধরনের model architecture রয়েছে, যেমন linear regression, neural networks ইত্যাদি।

Forward Pass (ফরোয়ার্ড পাস):

• মডেল ইনপুট ডেটার মাধ্যমে prediction তৈরি করে।
• মডেলের প্রতিটি লেয়ারে ইনপুট ডেটা পাশ হয় এবং output বা prediction তৈরি হয়।

Loss Calculation:

• prediction এবং actual output এর মধ্যে পার্থক্য মাপা হয়।
• এই পার্থক্যকে loss বলা হয় এবং এটি বোঝায় মডেল prediction এর error কতটা।

Backpropagation:

• এই ধাপে মডেল gradient descent এর মাধ্যমে error বা loss কমানোর চেষ্টা করে।
• মডেলের প্রতিটি ওয়েট বা প্যারামিটার আপডেট করা হয় যাতে loss কমে।

Optimization:

• Optimizer, যেমন stochastic gradient descent (SGD) বা Adam ব্যবহার করে model এর parameter গুলো adjust করা হয়।
• এই optimization process মডেলকে যতটা সম্ভব accurate করতে সাহায্য করে।

Evaluation:

• training data ছাড়া অন্য data, অর্থাৎ validation বা test data দিয়ে মডেল performance evaluate করা হয়।
• এর মাধ্যমে দেখা হয় মডেল overfit বা underfit করছে কি না।

Hyperparameter Tuning:

• মডেল এর accuracy বাড়াতে বিভিন্ন hyperparameter যেমন learning rate, batch size, epochs, optimizer ইত্যাদি পরিবর্তন করা হয়।

Loss Calculation

Loss calculation একটি গুরুত্বপূর্ণ অংশ কারণ এটি মডেলের performance নির্দেশ করে। Loss বিভিন্ন উপায়ে calculate করা যায়, যেমন:

Mean Squared Error (MSE) (Regression Problem এ ব্যবহৃত হয়):

• MSE=1N∑i=1N(yi−yi^)2\text{MSE} = \frac{1}{N} \sum_{i=1}^{N} (y_i - \hat{y_i})^2MSE=N1​∑i=1N​(yi​−yi​^​)2
• এখানে, yiy_iyi​ হলো actual value এবং yi^\hat{y_i}yi​^​ হলো predicted value।
• MSE পার্থক্যের square ব্যবহার করে error কে punish করে।

Mean Absolute Error (MAE):

• MAE=1N∑i=1N∣yi−yi^∣\text{MAE} = \frac{1}{N} \sum_{i=1}^{N} |y_i - \hat{y_i}|MAE=N1​∑i=1N​∣yi​−yi​^​∣
• এটি prediction এর absolute error মাপে।

Cross-Entropy Loss (Classification Problem এ ব্যবহৃত হয়):

• Cross-Entropy Loss=−∑i=1Nyilog⁡(yi^)+(1−yi)log⁡(1−yi^)\text{Cross-Entropy Loss} = - \sum_{i=1}^{N} y_i \log(\hat{y_i}) + (1 - y_i) \log(1 - \hat{y_i})Cross-Entropy Loss=−∑i=1N​yi​log(yi​^​)+(1−yi​)log(1−yi​^​)
• এটি class prediction এর পার্থক্য মাপে এবং categorical বা binary classification এ অধিক ব্যবহার হয়।

Huber Loss:

• এটি MSE এবং MAE এর সংমিশ্রণ, যেখানে outliers এর জন্য smooth penalty যোগ করা হয়।

Binary Cross-Entropy:

• Binary classification এর জন্য এটি loss calculate করতে ব্যবহৃত হয়।

Loss Minimization এবং Optimization

Loss minimize করার জন্য আমরা gradient descent বা optimization techniques ব্যবহার করি। এর মাধ্যমে মডেলটি তার parameters পরিবর্তন করতে পারে যাতে training শেষে model এর predicted output এবং actual output এর মধ্যে error যতটা সম্ভব কম থাকে।

এই ধাপগুলো এবং loss calculation মডেলকে উন্নত করতে সাহায্য করে, যাতে মডেল training data থেকে শিখে এবং unseen data বা test data তেও ভাল ফলাফল দিতে পারে।

Model Evaluation এবং Training Loop: উদাহরণ সহ ব্যাখ্যা

মেশিন লার্নিং এবং নিউরাল নেটওয়ার্ক মডেলের ট্রেনিংয়ের পর এটি মূল্যায়ন (Evaluation) করা অত্যন্ত গুরুত্বপূর্ণ, কারণ এটি মডেলের পারফরম্যান্স বিশ্লেষণ করতে সাহায্য করে। নিচে Training Loop এবং Model Evaluation নিয়ে একটি উদাহরণ দেওয়া হলো।

1. Training Loop কী?

Training Loop হলো মডেলের ট্রেনিং প্রক্রিয়ার একটি পুনরাবৃত্তি অংশ। এটি সাধারণত নীচের ধাপগুলো অন্তর্ভুক্ত করেঃ

• Forward Propagation চালিয়ে আউটপুট তৈরি করা
• লস (Loss) গণনা করা
• Backward Propagation করে গ্রেডিয়েন্ট আপডেট করা
• Optimizer এর মাধ্যমে ওজন এবং বায়াস আপডেট করা

2. Model Evaluation কী?

Model Evaluation হলো একটি প্রক্রিয়া যেখানে মডেলটি কতোটা সঠিকভাবে কাজ করছে তা পরীক্ষা করা হয়। এটি সাধারণত validation বা test ডেটাসেটের ওপর চালানো হয়। সাধারণভাবে ব্যবহার হওয়া Evaluation মেট্রিকগুলোর মধ্যে Accuracy, Precision, Recall, এবং F1 Score অন্তর্ভুক্ত।

উদাহরণ: XOR ফাংশনের জন্য Training Loop এবং Model Evaluation

আমরা একটি ছোট নিউরাল নেটওয়ার্ক তৈরি করবো যা XOR ফাংশন শিখবে এবং এর Training Loop ও Evaluation প্রসেস দেখবো।

import chainer
import chainer.functions as F
import chainer.links as L
from chainer import Chain, optimizers, Variable
from sklearn.metrics import accuracy_score

# ডেটাসেট ডিফাইন করা হচ্ছে
x_data = [[0, 0], [0, 1], [1, 0], [1, 1]]
y_data = [0, 1, 1, 0]  # XOR output values

# নিউরাল নেটওয়ার্ক মডেল ডিফাইন
class XORNetwork(Chain):
    def __init__(self):
        super(XORNetwork, self).__init__()
        with self.init_scope():
            self.l1 = L.Linear(2, 3)  # হিডেন লেয়ার
            self.l2 = L.Linear(3, 1)  # আউটপুট লেয়ার

    # Forward Propagation
    def __call__(self, x):
        h = F.sigmoid(self.l1(x))  # হিডেন লেয়ার
        y = F.sigmoid(self.l2(h))  # আউটপুট লেয়ার
        return y

# মডেল ও Optimizer সেটআপ
model = XORNetwork()
optimizer = optimizers.Adam()
optimizer.setup(model)

# Training Loop
epochs = 5000
for epoch in range(epochs):
    total_loss = 0
    for i in range(len(x_data)):
        x = Variable(chainer.backends.cuda.to_cpu(x_data[i]))
        y = Variable(chainer.backends.cuda.to_cpu([y_data[i]]))

        # Forward Propagation
        y_pred = model(x)
        
        # লস কম্পিউট
        loss = F.mean_squared_error(y_pred, y)
        total_loss += loss.data
        
        # Backward Propagation এবং Optimizer আপডেট
        model.cleargrads()
        loss.backward()
        optimizer.update()
    
    if epoch % 1000 == 0:
        print(f'Epoch {epoch}, Loss: {total_loss / len(x_data)}')

# Model Evaluation
print("\nEvaluating the trained model on XOR function:")
predictions = []
for x in x_data:
    y_pred = model(Variable(chainer.backends.cuda.to_cpu(x)))
    predictions.append(int(y_pred.data > 0.5))  # 0.5 এর উপরে হলে 1, অন্যথায় 0

accuracy = accuracy_score(y_data, predictions)
print(f"Predictions: {predictions}")
print(f"Actual Values: {y_data}")
print(f"Accuracy: {accuracy * 100}%")

ব্যাখ্যা

Training Loop:

• লস হিসাব: F.mean_squared_error() এর মাধ্যমে প্রতিটি উদাহরণের লস গণনা করা হয়।
• Backward Propagation এবং Optimizer আপডেট: প্রতিটি ইপোক শেষে গ্রেডিয়েন্ট ক্লিয়ার করে ও Optimizer দিয়ে ওজন আপডেট করা হয়।

Model Evaluation:

• প্রতিটি ইনপুটের জন্য মডেলটি প্রেডিকশন করে এবং 0.5 এর উপরে হলে 1 এবং নিচে হলে 0 হিসেবে প্রেডিকশন দেয়।
• accuracy_score ফাংশন ব্যবহার করে মডেলের পারফরম্যান্স দেখা হয়।

আউটপুট

প্রশিক্ষণ শেষে মডেলটি XOR ফাংশন শিখে যাবে এবং নিম্নলিখিত ফলাফল দেখাবে:

Predictions: [0, 1, 1, 0]
Actual Values: [0, 1, 1, 0]
Accuracy: 100%

সংক্ষেপে

Training Loop মডেলকে পুনরাবৃত্তি মাধ্যমে শেখায় এবং Model Evaluation এটি কেমন কাজ করছে তা পর্যালোচনা করতে সাহায্য করে। Accuracy, Precision, Recall প্রভৃতি মেট্রিক ব্যবহার করে মডেলের পারফরম্যান্স মূল্যায়ন করা যায়।