CNN Architecture, Layers & Applications Explained | Sinhala Guide

කොහොමද යාලුවනේ! අද අපි කතා කරන්න යන්නේ කෘත්‍රිම බුද්ධිය (Artificial Intelligence) ක්ෂේත්‍රයේ, විශේෂයෙන්ම Computer Vision වලට Game Changer එකක් වුණ Convolutional Neural Networks (CNNs) ගැන. මේ දවස්වල AI ගැන කතා කරනකොට, Machine Learning, Deep Learning කියන දේවල් ගොඩක් දෙනෙක් අතර ජනප්‍රියයි. හැබැයි මේ Deep Learning ඇතුළේ තියෙන CNN කියන Model එක තමයි Computer වලට Images & Video තේරුම් ගන්න පුළුවන් කරවන්නේ.

හිතන්නකෝ... ඔයාගේ ෆෝන් එකේ Face ID එක, Self-Driving Cars පාරේ යන වාහන සහ පදිකයින් හඳුනාගන්න හැටි, නැත්නම් Google Photos වල ඔයාගේ යාළුවෙක්ව Tag කරන්න පුළුවන් වෙන්නේ කොහොමද කියලා. මේ හැම දේකටම පදනම දාන්නේ මේ CNN කියන Algorithm එක. ඒක නියමයි නේද?

ඉතින් අද අපි මේ Tutorial එකෙන් CNN එකක් කියන්නේ මොකක්ද, ඒකේ තියෙන Layers මොනවද, ඒ Layers වැඩ කරන්නේ කොහොමද, ඒ වගේම අපේ එදිනෙදා ජීවිතයේදී මේවා පාවිච්චි කරන Applications මොනවද කියලා සරලව, පහසුවෙන් තේරුම් ගන්න පුළුවන් විදිහට කතා කරමු. ඒ වගේම Keras/TensorFlow පාවිච්චි කරලා සරල CNN Model එකක් හදාගන්න හැටිත් බලමු. එහෙනම්, අපි පටන් ගමු!

CNN කියන්නේ මොකක්ද? (What is a CNN?)

කලින් කාලේ කම්පියුටර් වලට ෆොටෝ එකක් දැක්කාම ඒකේ තියෙන දේවල් identify කරන එක හරිම අමාරු වැඩක්. මොකද කම්පියුටර් එකකට ෆොටෝ එකක් කියන්නේ 그냥 Numbers ගොඩක් විතරයි. හැබැයි අද වෙනකොට අපේ ෆෝන් එකේ ෆොටෝ ගැලරියේ ඉඳලා, Self-Driving Cars වලට පවා Computer Vision වලට පදනම දාන්නේ මේ Convolutional Neural Networks (CNNs) කියන පට්ට Powerful Deep Learning Model එක. සරලව කිව්වොත්, CNN කියන්නේ Images වගේ Grid-like Data Process කරන්නම හදපු විශේෂ Neural Network වර්ගයක්.

සාමාන්‍ය Neural Networks (Artificial Neural Networks – ANNs) වලදී Image එකක් input එක විදියට දෙන්න කලින්, අපි ඒකේ හැම Pixel එකක්ම එක පේලියකට Flat කරන්න ඕනේ. ඒකෙන් Image එකේ spatial relation එක නැතිවෙලා යනවා. ඒ වගේම Big Images වලට Input Neurons ගොඩක් ඕන වෙනවා. හැබැයි CNNs මේ ප්‍රශ්නෙට නියම විසඳුමක් දෙනවා. CNN එකක් හරියට, Image එකක තියෙන පොඩි පොඩි කොටස් (Features) හඳුනාගෙන, ඒ ටික එකතු කරලා මුළු Object එකම මොකක්ද කියලා තීරණය කරන දක්ෂ රහස් පරීක්ෂකයෙක් වගෙයි.

CNN Architecture එකේ Layers (Layers of a CNN Architecture)

CNN එකක් ගොඩනැගිලා තියෙන්නේ එකිනෙකට සම්බන්ධ වෙන Layers ගොඩකින්. මේ හැම Layer එකකටම තමන්ටම ආවේණික වැඩ කොටසක් තියෙනවා. මේ Layers එකට එකතු වෙලා තමයි Image එකක තියෙන සංකීර්ණ Patterns තේරුම් ගන්නේ. අපි මේ ප්‍රධාන Layers ටික එකින් එක බලමු.

Convolutional Layer

මේක තමයි CNN එකේ හදවත කියලා කියන්න පුළුවන්. Image එකක තියෙන Features (දාර, texture, patterns) detect කරන වැඩේ කරන්නේ මේ Layer එකෙන්. මේ Layer එක වැඩ කරන්නේ Filters (නැත්නම් Kernels) කියන පොඩි Matrix එකක් පාවිච්චි කරලා.

• Filters/Kernels: මේවා පොඩි Matrix (3x3, 5x5 වගේ) එකක්. මේ Filter එක input Image එකේ හැම තැනකම slide වෙනවා (ඒ කියන්නේ එක තැනක ඉඳලා තව තැනකට යනවා). මේක හරියට පොඩි Magnifying Glass එකක් වගේ.
• Convolution Operation: Filter එක slide වෙනකොට, ඒ Filter එකේ තියෙන අගයන් Image එකේ අදාල Pixel අගයන් එක්ක multiply කරලා, ඒ හැම Product එකක්ම එකතු කරලා Single Output Value එකක් හදනවා. මේක කරන එකට තමයි Convolution Operation එක කියලා කියන්නේ.
• Feature Maps (Activation Maps): මේ Operation එකෙන් පස්සේ අපිට ලැබෙන Output Image එකට කියන්නේ Feature Map එකක් කියලා. මේ Feature Map එකේ තියෙන්නේ Filter එක detect කරපු feature එක. (උදා: දාරයක්, වක්‍රයක්).
• Stride: Filter එක Image එක උඩින් slide වෙනකොට, එක පාරකට කොච්චර Pixels ගණනක් පැත්තට යනවද කියලා තීරණය කරන්නේ Stride එකෙන්. Stride එක 1 නම් හැම Pixel එකක්ම ගානේ යනවා. Stride එක 2 නම්, Pixel දෙකක් පැනලා යනවා. Stride එක වැඩි වෙන තරමට Output Feature Map එකේ Size එක අඩු වෙනවා.
• Padding: Convolution Operation එක නිසා Image එකේ Size එක පොඩි වෙන්න පුළුවන්. ඒක වළක්වන්න Image එක වටේට Zeros (0s) එකතු කරන එකට තමයි Padding කියන්නේ. 'same' padding කියන්නේ Output එක Input එකේ Size එකට සමාන කරන එකට, 'valid' padding වලදී Padding එකක් නැහැ.

Code Example Explanation:

layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1))

මේකේ 32 කියන්නේ Filters ගණන. ඒ කියන්නේ මේ Layer එකෙන් අපිට Feature Maps 32ක් ලැබෙනවා. (3, 3) කියන්නේ Filter එකේ Size එක. activation='relu' කියන්නේ Activation Function එක. input_shape=(28, 28, 1) කියන්නේ මේ Layer එකට එන Image එකේ Height, Width සහ Channels (1 කියන්නේ Grayscale Image එකක්).

Activation Layer (ReLU)

Convolution Layer එකෙන් පස්සේ එන්නේ Activation Layer එක. මේකේ ප්‍රධානම කාර්යය තමයි Network එකට Non-linearity එකතු කරන එක. Non-linearity නැත්නම් Network එකට තේරුම් ගන්න පුළුවන් වෙන්නේ Linear Relationships විතරයි. Real-world Data වල තියෙන්නේ Complex, Non-linear Patterns. ඒ Patterns තේරුම් ගන්න මේ Non-linearity එක අත්‍යවශ්‍යයි.

බහුලවම පාවිච්චි කරන Activation Function එක තමයි ReLU (Rectified Linear Unit). මේක හරිම සරලයි: f(x) = max(0, x). ඒ කියන්නේ Input Value එක Positive නම් ඒක එහෙම්මම Output කරනවා, Negative නම් Zero (0) කරනවා. මේක ගණනය කරන්න ලේසි නිසා, Deep Neural Networks වලට ගොඩක්ම සුදුසුයි.

Pooling Layer (Subsampling Layer)

Pooling Layer එකේ ප්‍රධාන අරමුණු දෙකක් තියෙනවා:

1. Dimensionality Reduction: Feature Maps වල Size එක අඩු කරනවා. ඒකෙන් Computation එක අඩු වෙනවා, ඒ වගේම Memory Usage එකත් අඩු වෙනවා.
2. Robustness: Image එකේ පොඩි වෙනස්කම් වලට (උදා: Shift කිරීමක්, Scale කිරීමක්) Network එකේ සංවේදීතාවය අඩු කරනවා. ඒ කියන්නේ, Object එකේ Position එක පොඩ්ඩක් වෙනස් වුණත් Network එකට ඒක හඳුනාගන්න පුළුවන් වෙනවා.

බහුලවම පාවිච්චි කරන Pooling වර්ගය තමයි Max Pooling. මේකත් Convolution Layer එක වගේම Filter එකක් (window) පාවිච්චි කරලා වැඩ කරනවා. Max Pooling වලදී, Filter එකට අහු වෙන Area එකේ තියෙන Maximum Value එක Output එක විදියට ගන්නවා. මේකෙන් එම ප්‍රදේශයේ තියෙන වැදගත්ම feature එක ඉස්මතු වෙනවා.

Code Example Explanation:

layers.MaxPooling2D((2, 2))

මේකේ (2, 2) කියන්නේ Pooling window එකේ Size එක. ඒ කියන්නේ හැම 2x2 Area එකකින්ම Maximum Value එක ගන්නවා. මේකේදී Stride එකත් සාමාන්‍යයෙන් (2, 2) විදියටම තමයි සලකන්නේ.

Fully Connected Layer (Dense Layer)

Convolutional සහ Pooling Layers වලින් පස්සේ, Image එකේ තියෙන High-level Features ටික Extract කරලා ඉවරයි. දැන් මේ Features ටික Actual Classification (අදාල Object එක මොකක්ද කියලා කියන එක) කරන්න Fully Connected Layer එකකට දෙනවා. මේකට කලින්, Convolutional සහ Pooling Layers වලින් ලැබුණ 3D Feature Maps ටික 1D Vector එකක් බවට පත් කරන්න ඕනේ. මේකට කියන්නේ Flattening කියලා. හරියට 3D පින්තූරයක් Flat කරනවා වගේ.

Flatten කරපු Vector එක සාමාන්‍ය Neural Network එකක වගේ Fully Connected Layers වලට යනවා. මේ Layers වලදී, මේ Features ටික පාවිච්චි කරලා අවසාන Output එක Generate කරනවා. මේක තමයි අවසාන තීරණය ගන්නේ.

Code Example Explanation:

layers.Flatten(),
layers.Dense(64, activation='relu'),
layers.Dense(10, activation='softmax')

Flatten() Layer එකෙන් කලින් තිබුණ 3D Data 1D Vector එකක් බවට පත් කරනවා. Dense(64, activation='relu') කියන්නේ මේ Fully Connected Layer එකේ Neurons 64ක් තියෙනවා කියන එකයි. අවසාන Dense(10, activation='softmax') Layer එකේ 10 කියන්නේ අපි Classify කරන්න බලාපොරොත්තු වෙන Classes ගණන (උදා: MNIST Dataset එකේ Digits 0-9). softmax Activation එකෙන් අපිට Output Probabilities (සෑම Class එකකටම අයිති වීමේ සම්භාවිතාව) ලැබෙනවා.

CNN වැඩ කරන්නේ කොහොමද? (How Does a CNN Work?)

සරලව කිව්වොත් CNN එකක් වැඩ කරන්නේ මේ විදියටයි:

1. Feature Extraction: Input Image එක මුලින්ම Convolutional Layer එකකට යනවා. මේ Layer එකේ Filters වලින් Image එකේ තියෙන Basic Features (දාර, වක්‍ර) detect කරනවා. මේක හරියට පොඩි පොඩි කෑලි වෙන් කරනවා වගේ වැඩක්.
2. Dimensionality Reduction: ඊට පස්සේ Pooling Layer එකකට ගිහින් Feature Map එකේ Size එක අඩු කරනවා, ඒ වගේම Important Information ටික විතරක් තියාගන්නවා. අනවශ්‍ය Details අයින් කරනවා.
3. මේ Convolutional සහ Pooling Layers කිහිප වතාවක් එකට යොදලා (Stacked Layers), Network එකට Image එකේ Low-level Features (දාර) වල ඉඳලා High-level Features (මුළු Object එකක්ම) දක්වා සංකීර්ණ Patterns තේරුම් ගන්න පුළුවන් වෙනවා. Layers වැඩි වෙන තරමට Network එකට වඩාත් සංකීර්ණ Patterns හඳුනාගන්න පුළුවන්.
4. Classification: අවසානයේදී මේ Extract කරපු High-level Features Flatten කරලා Fully Connected Layers ටිකකට දෙනවා. මේ Layers වලින් තමයි Image එක අයිති Class එක මොකක්ද කියලා Predict කරන්නේ.

Training කාලය තුළදී, Network එක Backpropagation සහ Gradient Descent වගේ Algorithms පාවිච්චි කරලා Filters වල Values (Weights) automatically adjust කරනවා. ඒකෙන් Network එකට Image එකේ තියෙන Patterns හරි විදියට detect කරන්න ඉගෙන ගන්න පුළුවන් වෙනවා. මේක හරියට පොඩි ළමයෙක්ට පින්තූර පෙන්නලා, 'මේ බල්ලෙක්', 'මේ බළලෙක්' කියලා උගන්නනවා වගේ දෙයක්.

CNN වල Practical Applications (Practical Applications of CNNs)

CNNs අද Computer Vision ක්ෂේත්‍රයේ Game Changer එකක් වෙලා තියෙනවා. අපේ එදිනෙදා ජීවිතයේදී මේවායේ බලපෑම දිනෙන් දින වැඩි වෙනවා. මේ තියෙන්නේ ඒවායේ ප්‍රධාන Applications කිහිපයක්:

• Image Classification: Image එකක් අයිති Category එක මොකක්ද කියලා හඳුනාගන්නවා. (උදා: බල්ලෙක්ද, බළලෙක්ද, කාරයක්ද කියලා හඳුනාගැනීම). Medical Imaging වලදී X-ray scans හෝ MRI images වලින් රෝග හඳුනාගැනීමට පවා මේවා පාවිච්චි කරනවා.
• Object Detection: Image එකක තියෙන Objects හඳුනාගෙන, ඒ Object එක කොතනද තියෙන්නේ කියලා Bounding Box එකකින් පෙන්නනවා. Self-Driving Cars වලට පාරේ තියෙන වාහන, පදිකයින්, මාර්ග සංඥා හඳුනාගන්න මේක අත්‍යවශ්‍යයි. ආරක්ෂක කැමරා පද්ධති වලත් මේක පාවිච්චි කරනවා.
• Image Segmentation: Image එකක තියෙන හැම Pixel එකක්ම අදාල Object එකට අයිතිද කියලා Classify කරනවා. මේක Object Detection එකට වඩා Detail. (උදා: Photos වල Background Blur කරනකොට, Person කෙනා සහ Background එක වෙන් කරන්න මේ Segmentation පාවිච්චි වෙනවා).
• Facial Recognition: පුද්ගලයන්ගේ මුහුණු හඳුනාගැනීම (Smartphones unlocking, Security Systems, Airport Security).
• Style Transfer: එක Image එකක Artistic Style එක තව Image එකකට Apply කරන එක. (අපේ ෆෝන් වල Photos Edit කරන Apps වලදීත් මේවා තියෙනවා, උදා: Prisma App එක).
• Handwritten Digit Recognition: බැංකු චෙක්පත් වල තියෙන අංක හඳුනාගැනීම වගේ දේවල් වලට මේවා මුලින්ම පාවිච්චි වුණා.

සරල CNN Model එකක් (A Simple CNN Model)

අපි Keras/TensorFlow පාවිච්චි කරලා කොහොමද සරල CNN Model එකක් හදාගන්නේ කියලා බලමු. මේ Code එකෙන් අපි 28x28 Pixel Grayscale Images (MNIST Dataset එක වගේ) Classify කරන්න පුළුවන් Model එකක් හදන හැටි පෙන්නනවා. මේකෙන් ඔයාලට CNN Architecture එක කොහොමද Code එකකින් Represent කරන්නේ කියලා හොඳ අවබෝධයක් ගන්න පුළුවන්.

import tensorflow as tf
from tensorflow.keras import layers, models

# Sequential Model එකක් හදාගමු. Sequential model එකක් කියන්නේ layers එක පිට එකට දාගෙන යන Model එකක්.
model = models.Sequential([
    # Convolutional Layer 1: Filters 32ක්, 3x3 Size එකේ. Input එක 28x28 Grayscale Image එකක්.
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    # Max Pooling Layer 1: 2x2 Size එකේ window එකකින් Max Value එක ගන්නවා.
    layers.MaxPooling2D((2, 2)),
    # Convolutional Layer 2: Filters 64ක්, 3x3 Size එකේ.
    layers.Conv2D(64, (3, 3), activation='relu'),
    # Max Pooling Layer 2: 2x2 Size එකේ window එකකින් Max Value එක ගන්නවා.
    layers.MaxPooling2D((2, 2)),
    # Convolutional Layer 3: Filters 64ක්, 3x3 Size එකේ.
    layers.Conv2D(64, (3, 3), activation='relu'),
    # Flatten Layer: 3D Output එක 1D Vector එකක් බවට පත් කරනවා.
    layers.Flatten(),
    # Fully Connected Layer 1: Neurons 64ක් එක්ක ReLU Activation එකක්.
    layers.Dense(64, activation='relu'),
    # Output Layer: Neurons 10ක් (Classes 10ක් සඳහා) එක්ක Softmax Activation එකක්.
    layers.Dense(10, activation='softmax')
])

# Model එකේ Summary එක බලමු. මේකෙන් හැම Layer එකකම Output Shape එකයි, trainable parameters ගණනයි පෙන්නනවා.
model.summary()

මේ Code එකේ තියෙන Layers අපි කලින් කතා කරපු විදියටම තමයි වැඩ කරන්නේ. model.summary() එකෙන් අපිට Model එකේ හැම Layer එකකම Output Shape එකයි, Parameters ගණනයි බලාගන්න පුළුවන්. මේකෙන් ඔයාලට Model එකේ Flow එක ගැන හොඳ අවබෝධයක් ගන්න පුළුවන්. මේ Model එක ඊට පස්සේ compile කරලා, training data දීලා train කරන්න පුළුවන්.

නිගමනය (Conclusion)

ඉතින් යාලුවනේ, අද අපි Convolutional Neural Networks (CNNs) කියන්නේ මොනවද, ඒවායේ තියෙන Layers මොනවද, ඒ Layers එකට එකතු වෙලා වැඩ කරන්නේ කොහොමද, ඒ වගේම අපේ එදිනෙදා ජීවිතයේදී මේවා පාවිච්චි කරන Applications මොනවද කියලා ගොඩක් දේවල් කතා කළා. CNNs තමයි Computer Vision ක්ෂේත්‍රයේ දියුණුවට ලොකුම දායකත්වය දුන්නේ. Images තේරුම් ගන්න, classify කරන්න, object detect කරන්න වගේ ගොඩක් දේවල් වලට මේවා අද අත්‍යවශ්‍යයි.

Deep Learning සහ AI ගැන ඉගෙන ගන්න පටන් ගන්න අයට CNNs කියන්නේ අනිවාර්යයෙන්ම දැනගෙන ඉන්න ඕන දෙයක්. මේ Theory එක තේරුම් ගත්තා වගේම, Keras/TensorFlow වගේ Libraries පාවිච්චි කරලා පොඩි පොඩි Project කරලා බලන්න. ඒකෙන් ඔයාලගේ දැනුම තවත් වැඩි කරගන්න පුළුවන්.

ඔයාලගේ අදහස්, මේ Tutorial එක ගැන තියෙන ප්‍රශ්න, නැත්නම් CNNs එක්ක වැඩ කරද්දී ලැබුණ අත්දැකීම් පහලින් comment කරන්න! මීළඟ Project එකට මේක Try කරලා බලන්න. තවත් මේ වගේ වැදගත් Tutorial එකකින් හමුවෙමු!