Convolutional Neural Networks (CNN)

Convolutional Neural Networks (CNN): ব্যাখ্যা এবং উদাহরণ

Convolutional Neural Networks (CNN) হলো এমন একটি বিশেষ ধরনের নিউরাল নেটওয়ার্ক আর্কিটেকচার যা সাধারণত ইমেজ প্রসেসিং এবং কম্পিউটার ভিশন সমস্যায় ব্যবহৃত হয়। CNN মডেলটি ইমেজ থেকে গুরুত্বপূর্ণ বৈশিষ্ট্য (features) খুঁজে বের করতে সক্ষম এবং এগুলোকে বিভিন্ন লেয়ারে প্রক্রিয়াজাত করে।

CNN এর মূল উপাদানসমূহ

Convolutional Layer:

• এই লেয়ারটি ইমেজের বিভিন্ন অংশ থেকে বৈশিষ্ট্য খুঁজে বের করার জন্য ফিল্টার বা কর্ণেল ব্যবহার করে।
• ফিল্টার বা কর্ণেল ছবির ওপর কনভোলিউশন অপারেশন চালিয়ে ছোট ছোট বৈশিষ্ট্য ম্যাট্রিক্স তৈরি করে।

Pooling Layer:

• Pooling Layer ডেটা আকার কমাতে সাহায্য করে, যাতে মডেলটি কম প্যারামিটার নিয়ে কাজ করতে পারে।
• সাধারণত Max Pooling বা Average Pooling ব্যবহার করা হয়, যেখানে আউটপুট টাইলের (tile) মধ্যকার সর্বোচ্চ বা গড় মান নেওয়া হয়।

Fully Connected (FC) Layer:

• Fully Connected Layer একটি নিউরাল নেটওয়ার্কের সাধারণ লেয়ার, যেখানে সব নিউরন পরবর্তী লেয়ারের প্রতিটি নিউরনের সাথে সংযুক্ত থাকে।
• ইমেজ ক্লাসিফিকেশনের জন্য এই লেয়ারটি কনভোলিউশন এবং পুলিং লেয়ার থেকে পাওয়া বৈশিষ্ট্যগুলোর ভিত্তিতে চূড়ান্ত সিদ্ধান্ত গ্রহণ করে।

Activation Function:

• CNN এ সাধারণত ReLU (Rectified Linear Unit) অ্যাক্টিভেশন ফাংশন ব্যবহার করা হয়, যা নন-লিনিয়ারিটি যোগ করে এবং মডেলকে জটিল প্যাটার্ন শিখতে সাহায্য করে।

উদাহরণ: Chainer ব্যবহার করে একটি বেসিক CNN মডেল

নিচে Chainer লাইব্রেরি ব্যবহার করে একটি বেসিক CNN মডেল তৈরি করা হয়েছে যা MNIST ডেটাসেট (হাতে লেখা ডিজিট) ক্লাসিফাই করতে সক্ষম।

import chainer
import chainer.functions as F
import chainer.links as L
from chainer import Chain, optimizers, training, datasets, iterators
from chainer.training import extensions

# MNIST ডেটাসেট লোড করা
train, test = datasets.get_mnist(ndim=3)  # ndim=3 মানে চ্যানেল সহ ইমেজ লোড

# CNN মডেল তৈরি করা
class SimpleCNN(Chain):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        with self.init_scope():
            # Convolutional এবং Fully Connected লেয়ার ডিফাইন করা
            self.conv1 = L.Convolution2D(in_channels=1, out_channels=16, ksize=3)  # 3x3 ফিল্টার, 16 ফিল্টার
            self.conv2 = L.Convolution2D(in_channels=16, out_channels=32, ksize=3) # 3x3 ফিল্টার, 32 ফিল্টার
            self.fc1 = L.Linear(None, 128)  # None মানে ইনপুট ডাইমেনশন স্বয়ংক্রিয় হবে
            self.fc2 = L.Linear(128, 10)    # আউটপুট লেয়ার 10 ক্লাসের জন্য

    # Forward Propagation
    def __call__(self, x):
        h = F.relu(self.conv1(x))        # প্রথম কনভোলিউশন এবং ReLU
        h = F.max_pooling_2d(h, ksize=2) # Max Pooling
        h = F.relu(self.conv2(h))        # দ্বিতীয় কনভোলিউশন এবং ReLU
        h = F.max_pooling_2d(h, ksize=2) # Max Pooling
        h = F.relu(self.fc1(h))          # Fully Connected লেয়ার এবং ReLU
        y = self.fc2(h)                  # চূড়ান্ত Fully Connected লেয়ার (আউটপুট)
        return y

# মডেল এবং অপটিমাইজার সেটআপ
model = SimpleCNN()
classifier_model = L.Classifier(model)
optimizer = optimizers.Adam()
optimizer.setup(classifier_model)

# ট্রেনিং এবং টেস্ট ডেটা লোডার (DataLoader)
batch_size = 64
train_iter = iterators.SerialIterator(train, batch_size)
test_iter = iterators.SerialIterator(test, batch_size, repeat=False, shuffle=False)

# ট্রেনার সেটআপ
updater = training.StandardUpdater(train_iter, optimizer)
trainer = training.Trainer(updater, (10, 'epoch'), out='result')

# Extension যোগ করা
trainer.extend(extensions.Evaluator(test_iter, classifier_model))  # টেস্ট ডেটার ইভ্যালুয়েশন
trainer.extend(extensions.LogReport())                             # লস এবং অ্যাকুরেসি রিপোর্ট
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy']))
trainer.extend(extensions.ProgressBar())                           # প্রোগ্রেস বার

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

ব্যাখ্যা

Convolutional Layers (conv1 & conv2):

• conv1 লেয়ারটিতে ৩x৩ ফিল্টার আকারের ১৬টি ফিল্টার ব্যবহার করা হয়েছে এবং conv2 তে ৩x৩ ফিল্টার আকারের ৩২টি ফিল্টার ব্যবহার করা হয়েছে।

Pooling Layers:

• প্রতিটি কনভোলিউশন লেয়ারের পর Max Pooling ব্যবহার করা হয়েছে, যা ইমেজ সাইজ কমাতে এবং গুরুত্বপূর্ণ বৈশিষ্ট্য ধরে রাখতে সাহায্য করে।

Fully Connected Layers (fc1 & fc2):

• fc1 লেয়ারটি ১২৮টি নিউরনের Fully Connected লেয়ার এবং fc2 আউটপুট লেয়ার, যেখানে ১০টি নিউরন আছে কারণ MNIST ডেটাসেটে ১০টি ক্লাস (০-৯) রয়েছে।

Training এবং Evaluation:

• StandardUpdater এবং Trainer ব্যবহার করে মডেল ট্রেনিং করা হয়েছে, যেখানে বিভিন্ন মেট্রিক রিপোর্ট এবং ইভ্যালুয়েশন দেওয়া হয়েছে।

আউটপুট

প্রশিক্ষণ শেষে মডেলটি বিভিন্ন ইমেজ ক্লাসিফিকেশন টাস্কের জন্য ভালো পারফরম্যান্স করবে এবং টেস্ট ডেটার জন্য আউটপুট অ্যাকুরেসি দেখাবে।

সংক্ষেপে

Convolutional Neural Networks ইমেজ ডেটায় অসাধারণ পারফরম্যান্স প্রদান করে এবং Chainer এর মত ফ্রেমওয়ার্ক এই ধরনের মডেল তৈরিতে বেশ সহজ ও কার্যকর করে তোলে। CNN ব্যবহার করে ইমেজ ক্লাসিফিকেশন, অবজেক্ট ডিটেকশন, এবং কম্পিউটার ভিশনের অন্যান্য কাজে সাফল্যের সাথে ব্যবহার করা যায়।

Convolutional Neural Network (CNN) হলো এক ধরনের deep learning architecture যা বিশেষ করে image এবং video processing এর জন্য ব্যবহৃত হয়। CNN এমনভাবে ডিজাইন করা হয়েছে যাতে এটি ইনপুট ইমেজের বিভিন্ন বৈশিষ্ট্য বা features স্বয়ংক্রিয়ভাবে চিনতে পারে এবং গুরুত্বপূর্ণ pattern গুলো সনাক্ত করতে পারে। এটি image classification, object detection, এবং natural language processing এর মত কাজগুলোতে ব্যবহৃত হয়।

CNN কীভাবে কাজ করে?

CNN মূলত কয়েকটি প্রধান স্তরের মাধ্যমে কাজ করে:

Convolutional Layer:

• এই লেয়ার ইনপুট ডেটার উপর বিভিন্ন filter বা kernel প্রয়োগ করে।
• Filter গুলো ইনপুট ডেটা থেকে feature maps তৈরি করে, যা ডেটার মধ্যে বিভিন্ন patterns সনাক্ত করতে সাহায্য করে।
• এই লেয়ারে stride এবং padding ব্যবহার করে feature extraction আরও উন্নত করা হয়।

ReLU (Rectified Linear Unit) Activation:

• Convolutional লেয়ারের পর ReLU activation প্রয়োগ করা হয়, যা non-linearity introduce করে।
• এটি মডেলকে জটিল সম্পর্কগুলো সনাক্ত করতে সাহায্য করে এবং negative values গুলোকে zero তে পরিণত করে।

Pooling Layer:

• Pooling লেয়ার মূলত feature map এর dimensionality কমায়।
• সাধারণত Max Pooling ব্যবহার করা হয়, যা একটি নির্দিষ্ট অঞ্চলের মধ্যে সবচেয়ে বড় মান নির্বাচন করে।
• Dimensionality কমানোর মাধ্যমে computation কমে এবং overfitting এর সম্ভাবনাও কমে।

Fully Connected (FC) Layer:

• Convolutional এবং pooling লেয়ার শেষে feature maps গুলোকে flatten করা হয় এবং fully connected লেয়ারে প্রেরণ করা হয়।
• এই লেয়ার ইমেজ এর বিভিন্ন features থেকে চূড়ান্ত decision তৈরি করতে সাহায্য করে।

Softmax/Output Layer:

• Softmax বা অন্যান্য activation function ব্যবহার করে চূড়ান্ত output প্রদান করা হয়।
• Classification এর জন্য softmax output probabilities দেয়, যা image এর সম্ভাব্য class নির্দেশ করে।

CNN এর প্রয়োজনীয়তা কেন?

CNN ব্যবহারের প্রয়োজনীয়তা মূলত এর image এবং pattern recognition এর ক্ষমতা থেকে আসে। এর বিশেষ বৈশিষ্ট্যগুলো হলো:

Automatic Feature Extraction:

• CNN ইনপুট ডেটা থেকে গুরুত্বপূর্ণ feature গুলো স্বয়ংক্রিয়ভাবে extract করতে পারে। traditional machine learning এ feature engineering প্রায়ই ম্যানুয়ালি করতে হয় যা সময়সাপেক্ষ এবং দক্ষতার উপর নির্ভর করে।

Spatial Hierarchy শিখতে সক্ষম:

• CNN ইনপুট ইমেজের স্থানিক বৈশিষ্ট্যগুলো (spatial hierarchy) বুঝতে পারে এবং স্থানীয় প্যাটার্ন গুলো সনাক্ত করতে সক্ষম।
• এটি বিভিন্ন scale, orientation, এবং lighting condition এ object সনাক্ত করতে কার্যকর।

Parameter Sharing:

• CNN এ একই filter পুরো ইমেজে apply করা হয়, যাকে parameter sharing বলে। এটি মডেলটি কম parameter ব্যবহার করে এবং memory efficient হয়।

Translation Invariance:

• CNN বিভিন্ন অংশে object এর উপস্থিতি সনাক্ত করতে সক্ষম, যা translation invariance প্রদান করে।
• অর্থাৎ, object এর অবস্থান পরিবর্তন হলেও CNN এটি সনাক্ত করতে পারে।

Reducing Computational Cost:

• Convolutional এবং pooling লেয়ার dimensionality কমিয়ে ডেটার computation কমায়। এর ফলে বড় ইমেজ dataset নিয়ে কাজ করা সহজ হয়।

CNN এর ব্যবহার

CNN ব্যবহৃত কিছু সাধারণ ক্ষেত্র হলো:

• Image Classification: ছবি থেকে object এর class সনাক্ত করা। যেমন, কুকুর বা বিড়াল চেনা।
• Object Detection: ইমেজে নির্দিষ্ট object সনাক্ত করা। উদাহরণ: স্বয়ংক্রিয় গাড়ি, security surveillance ইত্যাদি।
• Image Segmentation: ইমেজের প্রতিটি pixel কে class অনুযায়ী ভাগ করা।
• Medical Imaging: CT scans, MRI ইত্যাদি ছবি থেকে anomaly সনাক্ত করা।
• Natural Language Processing (NLP): টেক্সট ডেটা প্রক্রিয়াকরণ এবং sentiment analysis, translation ইত্যাদি ক্ষেত্রে ব্যবহার।

সারসংক্ষেপ

CNN এর মাধ্যমে image এবং visual data সহজে এবং কার্যকরভাবে বিশ্লেষণ করা যায়। এটি স্বয়ংক্রিয়ভাবে বৈশিষ্ট্যগুলো শিখতে পারে এবং traditional methods এর তুলনায় performance উন্নত করে। Convolutional Neural Network আধুনিক deep learning এ computer vision এবং অন্যান্য ক্ষেত্রের জন্য একটি অতি গুরুত্বপূর্ণ এবং প্রয়োজনীয় টুল।

Chainer ব্যবহার করে একটি Convolutional Neural Network (CNN) মডেল তৈরি করতে হলে প্রথমে Convolutional Layers, Pooling Layers, এবং Fully Connected Layers সংজ্ঞায়িত করতে হবে। নিচে Chainer ব্যবহার করে একটি সহজ CNN মডেল তৈরি এবং ট্রেনিংয়ের জন্য উদাহরণ দেওয়া হলো।

উদাহরণ: MNIST ডেটাসেট ব্যবহার করে একটি CNN মডেল তৈরি

আমরা MNIST ডেটাসেট (হাতে লেখা ডিজিট) ব্যবহার করবো, যা প্রতিটি ইমেজ ২৮x২৮ আকারের এবং গ্রেস্কেল। লক্ষ্য হল এই ইমেজগুলোকে ০-৯ এর মধ্যে সঠিক শ্রেণীতে ক্লাসিফাই করা।

import chainer
import chainer.functions as F
import chainer.links as L
from chainer import Chain, optimizers, training, datasets, iterators
from chainer.training import extensions

# MNIST ডেটাসেট লোড করা
train, test = datasets.get_mnist(ndim=3)  # ndim=3 মানে এক্সট্রা চ্যানেল সহ ইমেজ লোড করা

# CNN মডেল তৈরি করা
class CNNModel(Chain):
    def __init__(self):
        super(CNNModel, self).__init__()
        with self.init_scope():
            # Convolutional এবং Fully Connected লেয়ার সংজ্ঞায়িত করা
            self.conv1 = L.Convolution2D(in_channels=1, out_channels=16, ksize=3, stride=1, pad=1)  # প্রথম কনভোলিউশন লেয়ার (৩x৩ ফিল্টার)
            self.conv2 = L.Convolution2D(in_channels=16, out_channels=32, ksize=3, stride=1, pad=1) # দ্বিতীয় কনভোলিউশন লেয়ার (৩x৩ ফিল্টার)
            self.fc1 = L.Linear(None, 128)  # Fully Connected লেয়ার (ইনপুট স্বয়ংক্রিয়)
            self.fc2 = L.Linear(128, 10)    # আউটপুট লেয়ার (১০টি ক্লাসের জন্য)

    # Forward Propagation
    def __call__(self, x):
        h = F.relu(self.conv1(x))        # প্রথম কনভোলিউশন এবং ReLU
        h = F.max_pooling_2d(h, ksize=2) # প্রথম Max Pooling
        h = F.relu(self.conv2(h))        # দ্বিতীয় কনভোলিউশন এবং ReLU
        h = F.max_pooling_2d(h, ksize=2) # দ্বিতীয় Max Pooling
        h = F.relu(self.fc1(h))          # Fully Connected লেয়ার এবং ReLU
        y = self.fc2(h)                  # চূড়ান্ত Fully Connected লেয়ার (আউটপুট)
        return y

# মডেল এবং অপটিমাইজার সেটআপ করা
model = L.Classifier(CNNModel())  # L.Classifier ফাংশন ক্লাসিফিকেশন জন্য ক্রস এন্ট্রপি লস এবং অ্যাকুরেসি গণনা সহজ করে দেয়
optimizer = optimizers.Adam()
optimizer.setup(model)

# ডেটা লোডার তৈরি করা
batch_size = 64
train_iter = iterators.SerialIterator(train, batch_size)
test_iter = iterators.SerialIterator(test, batch_size, repeat=False, shuffle=False)

# ট্রেনার সেটআপ করা
updater = training.StandardUpdater(train_iter, optimizer, device=-1)
trainer = training.Trainer(updater, (10, 'epoch'), out='result')

# Extensions যোগ করা
trainer.extend(extensions.Evaluator(test_iter, model, device=-1))  # টেস্ট ডেটার উপর ইভ্যালুয়েশন
trainer.extend(extensions.LogReport())                             # লস এবং অ্যাকুরেসি রিপোর্ট
trainer.extend(extensions.PrintReport(['epoch', 'main/loss', 'validation/main/loss', 'main/accuracy', 'validation/main/accuracy']))
trainer.extend(extensions.ProgressBar())                           # প্রোগ্রেস বার দেখানোর জন্য

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

ব্যাখ্যা

CNNModel ক্লাস:

• conv1 এবং conv2 নামে দুটি কনভোলিউশন লেয়ার রয়েছে। প্রতিটি লেয়ারের জন্য আমরা ৩x৩ ফিল্টার ব্যবহার করেছি এবং ReLU অ্যাক্টিভেশন প্রয়োগ করেছি।
• fc1 এবং fc2 হলো Fully Connected লেয়ার। fc1 তে ১২৮টি নিউরন রয়েছে এবং fc2 চূড়ান্ত আউটপুট লেয়ার যা ১০টি ক্লাসের মধ্যে যেকোনো একটি প্রেডিক্ট করে।

Data Loading:

• train_iter এবং test_iter ডেটাসেটকে ব্যাচ আকারে লোড করে। batch_size ৬৪ দেয়া হয়েছে, অর্থাৎ একবারে ৬৪টি ইমেজ প্রশিক্ষণে যায়।

Trainer এবং Extensions:

• StandardUpdater এবং Trainer ব্যবহার করে Training Loop সেটআপ করা হয়েছে।
• extensions.Evaluator দিয়ে টেস্ট ডেটার ইভ্যালুয়েশন এবং extensions.PrintReport দিয়ে প্রতিটি epoch এর শেষে লস এবং অ্যাকুরেসি রিপোর্ট করা হয়।

আউটপুট

মডেলটি ১০ epoch এর জন্য প্রশিক্ষণ চালানো হবে। প্রতিটি epoch শেষে মডেলের ট্রেনিং লস, ভ্যালিডেশন লস, ট্রেনিং অ্যাকুরেসি এবং ভ্যালিডেশন অ্যাকুরেসি প্রিন্ট হবে।

সংক্ষেপে

এই উদাহরণে আমরা Chainer ব্যবহার করে একটি বেসিক CNN মডেল তৈরি এবং ট্রেনিং করেছি যা MNIST ডেটাসেটে ভালোভাবে কাজ করতে সক্ষম। CNN মডেলটি ইমেজ ডেটা থেকে বৈশিষ্ট্যগুলো খুঁজে বের করে এবং শ্রেণীকরণ করতে সহায়তা করে। Chainer লাইব্রেরি CNN মডেল তৈরি এবং ট্রেনিং প্রক্রিয়াকে সহজ ও কার্যকর করে।

Convolutional Neural Network (CNN) এর প্রাথমিক তিনটি স্তর হলো Convolution Layer, Pooling Layer, এবং Fully Connected Layer। প্রতিটি স্তরের নিজস্ব ভূমিকা এবং কাজ রয়েছে, যা মডেলকে ইমেজ বা অন্য ধরনের ডেটা থেকে feature extraction, dimensionality reduction, এবং classification এ সাহায্য করে।

1. Convolution Layer

Convolution Layer CNN এর মূল স্তর এবং এটি মূলত feature extraction এর কাজ করে।

কিভাবে কাজ করে:

• Convolution লেয়ার একটি ইমেজের উপর filter বা kernel প্রয়োগ করে।
• প্রতিটি filter একটি ছোট matrix, যা input image এর উপর slide করে এবং dot product অপারেশন করে।
• এর মাধ্যমে একটি feature map বা activation map তৈরি হয়, যা ইমেজের বিভিন্ন features ধারণ করে।

বৈশিষ্ট্য:

• Filter/Kernels: Filter বা kernel একটি ছোট matrix (যেমন, 3x3 বা 5x5), যা input image এর উপর অপারেট করে এবং feature map তৈরি করে।
• Stride: এটি kernel এর চলমান গতির পরিমাণ নির্দেশ করে। Stride বড় হলে feature map ছোট হয়।
• Padding: Image এর চারপাশে zero-pixel যুক্ত করা হয়, যা output feature map এর shape পরিবর্তন করতে সাহায্য করে।

উদাহরণ:

ধরা যাক আমাদের একটি grayscale image আছে (8x8 dimension), এবং আমরা এতে একটি 3x3 filter প্রয়োগ করছি, stride = 1 এবং padding = 0।

2. Pooling Layer

Pooling Layer মূলত dimensionality কমানোর কাজ করে। এটি feature map এর গুরুত্বপূর্ণ অংশগুলো সংরক্ষণ করে এবং কম গুরুত্বপূর্ণ অংশ বাদ দেয়, যার মাধ্যমে computational efficiency বাড়ে।

কিভাবে কাজ করে:

• Pooling লেয়ার input feature map এর ছোট ছোট region থেকে একটি সংখ্যা নির্বাচন করে, সাধারণত সবচেয়ে বড় বা গড় মান।
• Pooling এর মাধ্যমে feature map এর spatial size ছোট হয়ে যায়, যা computation এবং overfitting কমাতে সাহায্য করে।

Pooling এর প্রকারভেদ:

• Max Pooling: প্রতিটি region এর সবচেয়ে বড় মান নির্বাচন করে।
• Average Pooling: প্রতিটি region এর গড় মান নির্বাচন করে।

উদাহরণ:

ধরা যাক, আমাদের একটি feature map আছে (4x4 dimension) এবং আমরা 2x2 max pooling প্রয়োগ করছি। Max pooling এর মাধ্যমে 4x4 feature map কে 2x2 এ রূপান্তরিত করা হবে এবং প্রতিটি 2x2 ব্লকের মধ্যে সবচেয়ে বড় মান নির্বাচন করা হবে।

বৈশিষ্ট্য:

• Dimensionality কমানো, যা computation কমাতে সাহায্য করে।
• Translation invariance বাড়ায়, যা object detection এ সাহায্য করে।

3. Fully Connected Layer

Fully Connected Layer (FC Layer) সাধারণত CNN এর শেষের দিকে ব্যবহৃত হয় এবং এটি feature map এর মাধ্যমে পাওয়া features গুলিকে output class এ ম্যাপ করে।

কিভাবে কাজ করে:

• Pooling এর পর যে feature vector পাওয়া যায়, সেটিকে flatten করে একটিমাত্র vector এ রূপান্তরিত করা হয়।
• এরপর, এই vector টি fully connected (dense) layer এ পাঠানো হয় যেখানে প্রত্যেকটি node এর সাথে আগের layer এর প্রতিটি node সংযুক্ত থাকে।
• FC লেয়ার output তৈরি করে, যা একটি final decision দেয়, যেমন image এর class।

উদাহরণ:

ধরা যাক, আমাদের pooling এর পর একটি flattened vector পাওয়া গেল এবং আমরা এটিকে fully connected layer এ পাঠাচ্ছি। এই লেয়ার features থেকে একটি class prediction তৈরি করে।

বৈশিষ্ট্য:

• Classification এর কাজ করে।
• প্রতিটি node এর সাথে আগের layer এর প্রতিটি node সংযুক্ত থাকে, যা মডেলকে output class নির্ধারণ করতে সাহায্য করে।

Convolution, Pooling, এবং Fully Connected Layer এর কাজের সারাংশ

সারসংক্ষেপ

• Convolution Layer ইমেজ থেকে বিভিন্ন features সনাক্ত করতে সাহায্য করে।
• Pooling Layer dimensionality কমিয়ে computation সহজ করে এবং object এর invariance বাড়ায়।
• Fully Connected Layer extracted features থেকে চূড়ান্ত output class নির্ধারণ করে।

এই তিনটি লেয়ার একত্রে কাজ করে CNN কে ইমেজ বা অন্যান্য ডেটা থেকে গুরুত্বপূর্ণ features সনাক্ত করতে এবং চূড়ান্ত output প্রদান করতে সক্ষম করে।

এখানে PyTorch ব্যবহার করে একটি বেসিক image classification মডেল তৈরি করা হয়েছে। মডেলটি একটি সাধারণ Convolutional Neural Network (CNN) যা MNIST ডেটাসেট (হাতে লেখা সংখ্যা) ব্যবহার করে 0 থেকে 9 পর্যন্ত সংখ্যাগুলো সনাক্ত করবে।

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

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

ধাপ ২: ডেটাসেট লোড করা এবং ট্রান্সফরমেশন প্রয়োগ করা

MNIST ডেটাসেট grayscale (1 channel) ইমেজ নিয়ে গঠিত, যার প্রতিটি ইমেজের সাইজ 28x28। আমরা ToTensor() এবং Normalize() ব্যবহার করে ইমেজ গুলোকে টেনসর এবং normalized করব।

# ডেটা ট্রান্সফরমেশন
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)

# DataLoader তৈরি করা
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)

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

এখানে আমরা একটি বেসিক CNN মডেল তৈরি করব, যা তিনটি convolutional লেয়ার এবং একটি fully connected লেয়ার নিয়ে গঠিত।

class BasicCNN(nn.Module):
    def __init__(self):
        super(BasicCNN, self).__init__()
        
        # Convolutional লেয়ার গুলো
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1)
        self.conv3 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, stride=1, padding=1)
        
        # Pooling লেয়ার
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
        
        # Fully Connected লেয়ার
        self.fc1 = nn.Linear(64 * 3 * 3, 128)
        self.fc2 = nn.Linear(128, 10)  # Output 10 classes for digits 0-9

    def forward(self, x):
        # Convolutional লেয়ার এবং Activation
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = self.pool(torch.relu(self.conv3(x)))
        
        # Flattening
        x = x.view(-1, 64 * 3 * 3)
        
        # Fully Connected লেয়ার এবং Output
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

ধাপ ৪: মডেল initialize, লস ফাংশন এবং optimizer নির্ধারণ করা

model = BasicCNN()
criterion = nn.CrossEntropyLoss()  # Cross-entropy loss for classification
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam optimizer

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

এখন মডেল training এর জন্য একটি লুপ চালানো হবে।

# ট্রেনিং ফাংশন
num_epochs = 5
for epoch in range(num_epochs):
    running_loss = 0.0
    for images, labels in train_loader:
        # Gradients reset করা
        optimizer.zero_grad()
        
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # Backward pass এবং optimize
        loss.backward()
        optimizer.step()
        
        # Loss update করা
        running_loss += loss.item()
    
    # প্রতি epoch শেষে average loss print করা
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}')

ধাপ ৬: মডেল Evaluation করা

মডেল training শেষে test ডেটাসেটে evaluate করা হবে।

# মডেল evaluation
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 on test data: {accuracy:.2f}%')

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

1. Data Transformation: MNIST ডেটাকে টেনসর এবং normalized করা হয়।
2. CNN Model: একটি বেসিক CNN মডেল তৈরি করা হয়েছে, যা তিনটি Convolutional এবং দুটি Fully Connected লেয়ার নিয়ে গঠিত।
3. Training Loop: num_epochs অনুযায়ী মডেল ট্রেন করা হয়, যেখানে মডেলের loss প্রতিটি epoch শেষে দেখা যায়।
4. Evaluation: টেস্ট ডেটাসেটের উপর মডেলের accuracy পরিমাপ করা হয়।

এই বেসিক CNN মডেলটি সহজেই MNIST dataset থেকে ০-৯ সংখ্যা সনাক্ত করতে পারে এবং তুলনামূলক ভালো accuracy প্রদান করে।