Neural Network মডেল তৈরি

Chainer ব্যবহার করে Neural Network মডেল তৈরি

এখানে Chainer ব্যবহার করে একটি মৌলিক নিউরাল নেটওয়ার্ক মডেল তৈরি করার সম্পূর্ণ প্রক্রিয়া দেওয়া হলো। আমরা MNIST ডেটাসেট ব্যবহার করবো, যা হাতের লেখা সংখ্যা শনাক্তকরণের জন্য পরিচিত। চলুন দেখি কিভাবে একটি সিম্পল নিউরাল নেটওয়ার্ক তৈরি করা যায়।

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

প্রথমে, আমরা Chainer এবং অন্যান্য প্রয়োজনীয় লাইব্রেরি ইমপোর্ট করবো।

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

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

এখন আমরা MNIST ডেটাসেট লোড করবো।

# MNIST ডেটাসেট ডাউনলোড এবং লোড করা
train, test = datasets.get_mnist()

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

এখন আমরা একটি মৌলিক মাল্টি-লেয়ার পার্সেপট্রন (MLP) তৈরি করবো।

class MLP(chainer.Chain):
    def __init__(self):
        super(MLP, self).__init__()
        with self.init_scope():
            self.l1 = L.Linear(None, 100)  # প্রথম লেয়ার (100 নিউরন)
            self.l2 = L.Linear(100, 10)     # দ্বিতীয় লেয়ার (10 নিউরন)

    def forward(self, x):
        h = F.relu(self.l1(x))  # ReLU অ্যাক্টিভেশন ফাংশন
        return self.l2(h)        # আউটপুট

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

এখন আমরা আমাদের মডেল এবং অপটিমাইজার সেট আপ করবো।

# মডেল তৈরি করা
model = MLP()

# অপটিমাইজার কনফিগার করা
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(model)

ধাপ ৫: প্রশিক্ষণ প্রক্রিয়া সেটআপ

প্রশিক্ষণের জন্য ডেটা ইনপুট এবং প্রশিক্ষণের আপডেটার তৈরি করা।

# প্রশিক্ষণ ডেটা ইনপুট করার জন্য ডেটা প্রস্তুত করা
train_iter = chainer.iterators.SerialIterator(train, batch_size=64)

# আপডেটার তৈরি করা
updater = training.StandardUpdater(train_iter, optimizer)

ধাপ ৬: প্রশিক্ষণের জন্য ট্রেইনার তৈরি করা

# প্রশিক্ষণ সাইকেল তৈরি করা
trainer = training.Trainer(updater, (10, 'epoch'), out='result')

# প্রশিক্ষণ চলাকালীন ফলাফল দেখতে চাইলে
trainer.extend(extensions.LogReport())
trainer.run()

ধাপ ৭: মডেল পরীক্ষা করা

অবশেষে, আমরা টেস্ট ডেটা দিয়ে আমাদের মডেলটিকে পরীক্ষা করবো।

from chainer import Variable

# টেস্ট ডেটাসেটের উপর পরীক্ষামূলক পূর্বাভাস
test_iter = chainer.iterators.SerialIterator(test, batch_size=64, shuffle=False)

# মডেল টেস্ট করা
correct = 0
for batch in test_iter:
    x, t = chainer.dataset.convert.concat_examples(batch)
    x = Variable(x)
    y = model(x)
    correct += F.accuracy(y, t).data

print("Test accuracy: {:.2f}%".format(correct / len(test) * 100))

সারসংক্ষেপ

এই উদাহরণে, আমরা Chainer ব্যবহার করে MNIST ডেটাসেটের উপর ভিত্তি করে একটি মৌলিক মাল্টি-লেয়ার পার্সেপট্রন (MLP) তৈরি করেছি। আমরা ডেটাসেট লোড করেছি, মডেল তৈরি করেছি, অপটিমাইজার কনফিগার করেছি, প্রশিক্ষণ সম্পন্ন করেছি এবং পরে মডেলটির কার্যকারিতা পরীক্ষা করেছি। Chainer এর সহজ API এবং ডাইনামিক কম্পিউটেশন গ্রাফের মাধ্যমে এই প্রক্রিয়া খুবই সহজ ও কার্যকর।

Neural Network এবং Multi-Layer Perceptron (MLP)

Neural Networks এবং Multi-Layer Perceptron (MLP) হল কৃত্রিম বুদ্ধিমত্তার (AI) একটি গুরুত্বপূর্ণ অংশ, যা ডেটা থেকে শিখতে এবং জটিল সমস্যাগুলি সমাধান করতে ব্যবহৃত হয়। নিচে এই দুইটির মধ্যে পার্থক্য এবং সম্পর্ক বর্ণনা করা হলো।

Neural Networks

Neural Networks হল একটি কম্পিউটেশনাল মডেল যা মানুষের মস্তিষ্কের নিউরনের আচরণের অনুকরণ করে কাজ করে। এটি বিভিন্ন স্তরের (layers) নিউরন ব্যবহার করে যা ডেটার মধ্যে সম্পর্ক এবং প্যাটার্ন শিখতে সক্ষম।

বৈশিষ্ট্য

নোড এবং লেয়ার:

• নিউরাল নেটওয়ার্ক বিভিন্ন লেয়ারের সমন্বয়ে গঠিত হয়। প্রতিটি লেয়ারে একাধিক নোড (নিউরন) থাকে।

ফরওয়ার্ড পাস:

• ইনপুট ডেটা নিউরাল নেটওয়ার্কের মাধ্যমে প্রবাহিত হয় এবং বিভিন্ন লেয়ারের মাধ্যমে প্রক্রিয়াকৃত হয়, যা আউটপুট উৎপন্ন করে।

ব্যাকপ্রোপাগেশন:

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

বিভিন্ন ধরনের:

• নিউরাল নেটওয়ার্কের বিভিন্ন ধরনের মডেল রয়েছে, যেমন:
  • Convolutional Neural Networks (CNN)
  • Recurrent Neural Networks (RNN)
  • Generative Adversarial Networks (GAN)

Multi-Layer Perceptron (MLP)

Multi-Layer Perceptron (MLP) হল একটি নিউরাল নেটওয়ার্কের একটি নির্দিষ্ট ধরনের স্থাপনা যা একটি বা একাধিক লুকানো লেয়ার নিয়ে গঠিত।

বৈশিষ্ট্য

আর্কিটেকচার:

• MLP-এ তিনটি প্রাথমিক লেয়ার থাকে:
  • Input Layer: ডেটা গ্রহণ করে।
  • Hidden Layer(s): একটি বা একাধিক লুকানো স্তর, যা ইনপুট থেকে বৈশিষ্ট্য শিখতে সাহায্য করে।
  • Output Layer: ফাইনাল আউটপুট প্রদান করে।

নিউরন ও ওজন:

• প্রতিটি নিউরন আউটপুট তৈরি করার জন্য ওজন এবং একটি বাইয়াস ব্যবহার করে।

অ্যাক্টিভেশন ফাংশন:

• MLP বিভিন্ন অ্যাক্টিভেশন ফাংশন ব্যবহার করে, যেমন:
  • ReLU (Rectified Linear Unit)
  • Sigmoid
  • Tanh

শিক্ষণ:

• MLP সাধারণত সুপারভাইজড লার্নিংয়ের জন্য প্রশিক্ষিত হয় এবং ব্যাকপ্রোপাগেশন অ্যালগরিদম ব্যবহার করে।

Neural Network এবং MLP এর মধ্যে পার্থক্য

সারসংক্ষেপ

Neural Networks হল একটি বিস্তৃত গাণিতিক মডেল যা বিভিন্ন লেয়ারের মাধ্যমে তথ্য প্রক্রিয়া করে, যেখানে Multi-Layer Perceptron (MLP) হল একটি নির্দিষ্ট ধরনের নিউরাল নেটওয়ার্ক যা তিনটি স্তর (ইনপুট, হিডেন, আউটপুট) নিয়ে গঠিত। MLP একটি মৌলিক নিউরাল নেটওয়ার্ক স্থাপনা, যা বিভিন্ন প্রয়োগে ব্যবহৃত হয়, বিশেষত ক্লাসিফিকেশন এবং রিগ্রেশন সমস্যা সমাধানে।

Chainer-এ Chain ক্লাস ব্যবহার করে মডেল তৈরি

Chainer এর Chain ক্লাস ব্যবহার করে নিউরাল নেটওয়ার্ক মডেল তৈরি করা খুব সহজ। এখানে একটি মৌলিক মাল্টি-লেয়ার পার্সেপট্রন (MLP) মডেল তৈরি করার প্রক্রিয়া দেওয়া হলো, যা MNIST ডেটাসেটের উপর ভিত্তি করে কাজ করবে।

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

প্রথমে, আমরা Chainer এবং অন্যান্য প্রয়োজনীয় লাইব্রেরি ইমপোর্ট করবো।

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

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

এখন আমরা MNIST ডেটাসেট লোড করবো।

# MNIST ডেটাসেট ডাউনলোড এবং লোড করা
train, test = datasets.get_mnist()

ধাপ ৩: Chain ক্লাস ব্যবহার করে মডেল তৈরি করা

এখন আমরা Chain ক্লাস ব্যবহার করে একটি মৌলিক মাল্টি-লেয়ার পার্সেপট্রন (MLP) তৈরি করবো।

class MLP(chainer.Chain):
    def __init__(self):
        super(MLP, self).__init__()
        with self.init_scope():
            self.l1 = L.Linear(None, 100)  # প্রথম লেয়ার (100 নিউরন)
            self.l2 = L.Linear(100, 10)     # দ্বিতীয় লেয়ার (10 নিউরন)

    def forward(self, x):
        h = F.relu(self.l1(x))  # ReLU অ্যাক্টিভেশন ফাংশন
        return self.l2(h)        # আউটপুট

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

এখন আমরা আমাদের মডেল এবং অপটিমাইজার সেট আপ করবো।

# মডেল তৈরি করা
model = MLP()

# অপটিমাইজার কনফিগার করা
optimizer = optimizers.SGD(lr=0.01)
optimizer.setup(model)

ধাপ ৫: প্রশিক্ষণ প্রক্রিয়া সেটআপ

প্রশিক্ষণের জন্য ডেটা ইনপুট এবং প্রশিক্ষণের আপডেটার তৈরি করা।

# প্রশিক্ষণ ডেটা ইনপুট করার জন্য ডেটা প্রস্তুত করা
train_iter = chainer.iterators.SerialIterator(train, batch_size=64)

# আপডেটার তৈরি করা
updater = training.StandardUpdater(train_iter, optimizer)

ধাপ ৬: প্রশিক্ষণের জন্য ট্রেইনার তৈরি করা

# প্রশিক্ষণ সাইকেল তৈরি করা
trainer = training.Trainer(updater, (10, 'epoch'), out='result')

# প্রশিক্ষণ চলাকালীন ফলাফল দেখতে চাইলে
trainer.extend(extensions.LogReport())
trainer.run()

ধাপ ৭: মডেল পরীক্ষা করা

অবশেষে, আমরা টেস্ট ডেটা দিয়ে আমাদের মডেলটিকে পরীক্ষা করবো।

from chainer import Variable

# টেস্ট ডেটাসেটের উপর পরীক্ষামূলক পূর্বাভাস
test_iter = chainer.iterators.SerialIterator(test, batch_size=64, shuffle=False)

# মডেল টেস্ট করা
correct = 0
for batch in test_iter:
    x, t = chainer.dataset.convert.concat_examples(batch)
    x = Variable(x)
    y = model(x)
    correct += F.accuracy(y, t).data

print("Test accuracy: {:.2f}%".format(correct / len(test) * 100))

সারসংক্ষেপ

এই উদাহরণে, আমরা Chainer এর Chain ক্লাস ব্যবহার করে MNIST ডেটাসেটের উপর ভিত্তি করে একটি মৌলিক মাল্টি-লেয়ার পার্সেপট্রন (MLP) তৈরি করেছি। আমরা ডেটাসেট লোড করেছি, মডেল তৈরি করেছি, অপটিমাইজার কনফিগার করেছি, প্রশিক্ষণ সম্পন্ন করেছি এবং পরে মডেলটির কার্যকারিতা পরীক্ষা করেছি। Chainer এর Chain ক্লাসের মাধ্যমে মডেল তৈরি করা সহজ এবং কার্যকরী।

Forward Propagation এবং Backward Propagation কী?

1. Forward Propagation:

Forward Propagation হলো নেটওয়ার্কের মধ্য দিয়ে ইনপুট ডেটা থেকে আউটপুট পর্যন্ত তথ্যের প্রবাহের প্রক্রিয়া। এটি সাধারণত নিচের ধাপগুলোতে সম্পন্ন হয়ঃ

• ইনপুট ডেটা প্রথমে প্রথম লেয়ারে প্রবেশ করে।
• প্রতিটি লেয়ার তার নিজস্ব ওজন ও বায়াস ব্যবহার করে ইনপুটের ওপর গণনা সম্পন্ন করে এবং একটি আউটপুট তৈরি করে।
• প্রতিটি লেয়ারের আউটপুট পরবর্তী লেয়ারের ইনপুট হিসেবে ব্যবহৃত হয়।
• অবশেষে, আউটপুট লেয়ারে পৌঁছানোর পর একটি ফলাফল তৈরি হয়।

উদাহরণঃ ধরে নিই, আপনি একটি নিউরাল নেটওয়ার্কে একটি ছবির শ্রেণীকরণ করতে চান। Forward Propagation এর মাধ্যমে ছবির ডেটা নেটওয়ার্কের মধ্য দিয়ে যায় এবং চূড়ান্ত স্তরে পৌঁছে এটি কোন শ্রেণীতে পড়ে তা জানায়।

2. Backward Propagation:

Backward Propagation একটি প্রশিক্ষণ প্রক্রিয়া যা মূলত Forward Propagation এর ফলাফল ব্যবহার করে মডেলটি কতটুকু সঠিকভাবে কাজ করছে তা পরিমাপ করে এবং মডেলের ভুলগুলোকে সংশোধন করে। এটি Gradient Descent অ্যালগরিদমের মাধ্যমে ওজন এবং বায়াস আপডেট করেঃ

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

উদাহরণঃ যদি আপনার মডেল একটি ছবিকে ভুল শ্রেণীতে ফেলে, তাহলে Backward Propagation এর মাধ্যমে ওজন ও বায়াস এমনভাবে আপডেট হয় যেন পরবর্তীতে মডেলটি সঠিক সিদ্ধান্ত নিতে পারে।

এই দুটি প্রক্রিয়া একসাথে নিউরাল নেটওয়ার্ককে প্রশিক্ষণ করতে সহায়ক, যেখানে Forward Propagation তথ্য প্রেরণ করে এবং Backward Propagation ভুল শোধরানোর মাধ্যমে মডেলটি আরও নির্ভুল করতে সাহায্য করে।

নিচে একটি বেসিক নিউরাল নেটওয়ার্কের উদাহরণ দেওয়া হলো যা একটি ছোট ডেটাসেটের ওপর ভিত্তি করে তৈরি করা হয়েছে। আমরা Python এর Chainer লাইব্রেরি ব্যবহার করে এটি তৈরি করবো, যাতে আপনি Forward Propagation এবং Backward Propagation বোঝার জন্য কোড এবং তার সাথে ব্যাখ্যা দেখতে পারেন।

উদাহরণ: XOR ফাংশনের জন্য একটি নিউরাল নেটওয়ার্ক

আমরা এমন একটি নিউরাল নেটওয়ার্ক তৈরি করবো যা XOR ফাংশন (যেমন, দুটি ইনপুটের XOR আউটপুট) শিখতে পারবে। 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()
optimizer = optimizers.SGD(lr=0.1)
optimizer.setup(model)

# প্রশিক্ষণ লুপ
epochs = 10000
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
    model.cleargrads()  # গ্রেডিয়েন্ট ক্লিয়ার করা হচ্ছে
    loss.backward()     # ব্যাকওয়ার্ড পাস
    optimizer.update()  # ওজন আপডেট

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

# পরীক্ষার জন্য মডেল চালানো
print("Testing the trained model:")
for x in x_data:
    y_pred = model(Variable(chainer.backends.cuda.to_cpu(x)))
    print(f'Input: {x}, Predicted Output: {y_pred.data > 0.5}')  # >0.5 মানে 1, না হলে 0

ব্যাখ্যা

ডেটাসেট: x_data এবং y_data হলো ইনপুট এবং আউটপুট। এই ডেটা XOR ফাংশন শিখতে মডেলকে সাহায্য করবে।

মডেল নির্মাণ: XORNetwork নামে একটি ক্লাস তৈরি করা হয়েছে, যেখানে l1 হলো হিডেন লেয়ার (৩টি নিউরন সহ) এবং l2 হলো আউটপুট লেয়ার (১টি নিউরন সহ)।

Forward Propagation: __call__() মেথডে Forward Propagation সম্পন্ন হয়। প্রথম লেয়ারে ইনপুট পাস করার পর সিগময়েড ফাংশন ব্যবহার করা হয়েছে, যা এক্টিভেশন হিসেবে কাজ করে। এরপর দ্বিতীয় লেয়ারে পাস হয়ে আউটপুট তৈরি হয়।

Backward Propagation: loss.backward() ফাংশনটি গ্রেডিয়েন্ট হিসাব করে এবং optimizer.update() ফাংশনটি মডেলের ওজনগুলো আপডেট করে, যাতে লস কম হয়।

আউটপুট দেখা: প্রশিক্ষণ শেষে মডেলটিকে কিছু ইনপুট দিয়ে পরীক্ষা করা হয়েছে। যদি আউটপুট 0.5-এর বেশি হয়, তবে সেটিকে 1 এবং কম হলে 0 হিসাবে ধরেছি।

আউটপুট

প্রশিক্ষণের পরে মডেলটি XOR ফাংশন শিখে যাবে এবং আমরা নিচের মত আউটপুট পাবোঃ

Input: [0, 0], Predicted Output: False
Input: [0, 1], Predicted Output: True
Input: [1, 0], Predicted Output: True
Input: [1, 1], Predicted Output: False

এই উদাহরণটি দেখাচ্ছে কিভাবে Forward Propagation এবং Backward Propagation মিলে মডেলটিকে প্রশিক্ষণ দেয় এবং XOR ফাংশন শিখতে সহায়ক হয়।