Deep Learning සිංහලෙන් | Neural Networks Basics | Activation Functions | Loss Functions | Optimization Algorithms

ආයුබෝවන් යාළුවනේ! අද අපි කතා කරන්න යන්නේ AI ලෝකයේ හරිම වැදගත් කොටසක් ගැන – ඒ තමයි Deep Learning. මේ නම ඇහෙනකොට සමහරවිට ඔලුව අවුල් වෙන්න පුළුවන්, ‘මේ මොනවද මේ කියන්නේ?’ කියලා. ඒත් බයවෙන්න එපා! අපි මේක හරිම සරලව, පහසුවෙන් තේරුම් ගන්න පුළුවන් විදිහට කතා කරමු. මොකද, අද කාලේ Tech ලෝකයේ රැකියා වලට වගේම, අපේ දෛනික ජීවිතයටත් Deep Learning කියන දේ කොයිතරම් බලපානවද කියලා හිතාගන්නවත් අමාරුයි. Self-driving cars ඉඳලා, Facial Recognition, Voice Assistants (Siri, Alexa වගේ) දක්වා හැමතැනම මේක තියෙනවා.

ඉතින්, මේ ටියුටෝරියල් එකෙන් අපි Deep Learning වල මූලිකාංග, ඒ කියන්නේ Neural Networks, Activation Functions, Loss Functions, සහ Optimization Algorithms ගැන පියවරෙන් පියවර ඉගෙන ගමු. මේ හැම සංකල්පයක්ම මොකක්ද, ඒවා ක්‍රියා කරන්නේ කොහොමද, සහ ඇයි ඒවා වැදගත් වෙන්නේ කියලා අපි බලමු. අපි මේක පටන් ගමුද?

Deep Learning කියන්නේ මොකක්ද?

හරි, මුලින්ම බලමු Deep Learning කියන්නේ මොකක්ද කියලා. සරලව කිව්වොත්, මේක Machine Learning කියන ලොකු ක්ෂේත්‍රයේම කොටසක්. Machine Learning වලදී අපි Algorithm වලට Data දීලා, ඒවාට ඉගෙන ගන්න පුළුවන්කම දෙනවා. Deep Learning කියන්නේ ඊටත් එහාට ගිය දෙයක්. මේක මිනිස් මොළයේ තියෙන Neural Networks වගේ ක්‍රියා කරන Computer Networks හදලා, ඒවට ලොකු Data ප්‍රමාණයක් දීලා, සංකීර්ණ Patterns හඳුනාගන්න පුහුණු කරන එක.

මේවාට ‘Deep’ කියන්නේ, ඒ Network එකේ Layers ගොඩක් තියෙන නිසා. හරියට ළමයෙක්ට වචන, රූප හඳුනාගන්න පුරුදු කරනවා වගේ, අපි මේ Networks වලට Data දීලා ඒවාට ඉගෙන ගන්න පුළුවන්කම දෙනවා. හිතන්න, Facebook එකේ Photo එකක කෙනෙක්ව Tag කරන එක, නැත්නම් Google Translate එකේ භාෂා පරිවර්තනය වගේ දේවල් Deep Learning වලින් තමයි වෙන්නේ. Deep Learning වලට තියෙන ලොකුම වාසිය තමයි, මේවට Feature Engineering (Data වලින් වැදගත් Features extract කරන එක) කියන වෙහෙසකර වැඩේ තනියම කරන්න පුළුවන් වීම.

Neural Networks වල මූලිකාංග

Deep Learning වල හදවත තමයි Neural Networks. මේවා මිනිස් මොළයේ Neurons එකිනෙක සම්බන්ධ වෙලා තියෙන විදිහ ආදර්ශයට අරන් හදපු Computer Programs. එක Neuron එකක් කියන්නේ පොඩි Processing Unit එකක් වගේ. මේවා එකතු වෙලා Layer ගොඩක් හදනවා.

1. Input Layer: මේකට තමයි අපි Data දෙන්නේ. උදාහරණයක් විදිහට, ඔයාට Image එකක් හඳුනාගන්න ඕන නම්, ඒ Image එකේ Pixels මේ Layer එකට යනවා.
2. Hidden Layers: මේ Layer තමයි 'Deep' කියන එකේ තේරුම දෙන්නේ. මේවා එකක් හෝ කීපයක් තියෙන්න පුළුවන්. Input Layer එකෙන් ආපු Data Process කරලා, ඒකෙන් සංකීර්ණ Patterns හඳුනාගන්නේ මේ Layer වලින්. හැම Neuron එකක්ම කලින් Layer එකේ හැම Neuron එකක් එක්කම වගේ සම්බන්ධ වෙලා තියෙනවා.
3. Output Layer: මේකෙන් තමයි අපිට අවසාන ප්‍රතිඵලය ලැබෙන්නේ. Image එකේ තියෙන්නේ බල්ලෙක්ද, බළලෙක්ද කියලා කියන එක වගේ.

හැම සම්බන්ධතාවයකටම Weight එකක් තියෙනවා. මේකෙන් පෙන්නුම් කරන්නේ ඒ සම්බන්ධතාවයේ තියෙන වැදගත්කම. ඒ වගේම Bias එකක් කියන්නේ, Neuron එකක් Activation වෙන්න ඕන අවම Threshold එක වගේ දෙයක්. අපි Training කරනකොට මේ Weights සහ Biases තමයි වෙනස් වෙන්නේ, ඒ Neural Network එක ඉගෙන ගන්නවා කියන්නේ මේවා adjust වෙන එක තමයි.

සරල ඉදිරි ගමනක් (Forward Propagation)

මෙන්න බලන්න, Data එකක් Neural Network එකක් හරහා යන විදිහ සරලව:

# Python වගේ සරල Pseudocode එකක්
# Input Layer: x1, x2, x3 (ඔබේ දත්ත)
# Hidden Layer: h1, h2 (සැඟවුණු Processing Units)
# Output Layer: o1 (අවසාන ප්‍රතිඵලය)

# Weights and Biases (මුලින් Random අගයන්, Training කරන විට වෙනස් වේ)
w = {
    'input_to_hidden': [[w_x1_h1, w_x1_h2], [w_x2_h1, w_x2_h2], [w_x3_h1, w_x3_h2]], 
    'hidden_to_output': [[w_h1_o1], [w_h2_o1]]
}
b = {
    'hidden': [b_h1, b_h2],
    'output': [b_o1]
}

# උදාහරණයක් ලෙස Inputs
x1, x2, x3 = 0.5, 0.2, 0.8 

# 1. Input Layer එකෙන් Hidden Layer එකට Calculation
# h1 හි Input එක (sum of (input * weight) + bias)
input_to_h1 = (x1 * w['input_to_hidden'][0][0]) + \
              (x2 * w['input_to_hidden'][1][0]) + \
              (x3 * w['input_to_hidden'][2][0]) + b['hidden'][0]

# h2 හි Input එක
input_to_h2 = (x1 * w['input_to_hidden'][0][1]) + \
              (x2 * w['input_to_hidden'][1][1]) + \
              (x3 * w['input_to_hidden'][2][1]) + b['hidden'][1]

# 2. Activation Function එකක් යොදා Output හදනවා
# e.g., ReLU Activation Function (max(0, x))
output_h1 = max(0, input_to_h1)
output_h2 = max(0, input_to_h2)

# 3. Hidden Layer එකෙන් Output Layer එකට Calculation
# o1 හි Input එක
input_to_o1 = (output_h1 * w['hidden_to_output'][0][0]) + \
              (output_h2 * w['hidden_to_output'][1][0]) + b['output'][0]

# 4. Final Output (e.g., Sigmoid for binary classification)
# exp is the exponential function (e^x)
import math
final_output = 1 / (1 + math.exp(-input_to_o1))

print(f"Final Output: {final_output}")

මේ විදිහට තමයි Input එකක් Neural Network එකක් හරහා ගිහින් Output එකක් බවට පත් වෙන්නේ. මේ ක්‍රියාවලියට කියන්නේ Forward Propagation කියලා. මේකෙන් තමයි අපේ Network එකට පුරෝකථනයක් (prediction) කරන්න පුළුවන් වෙන්නේ.

Activation Functions - මොළයේ ක්‍රියාකාරිත්වය

හරි, දැන් අපි කතා කරමු Activation Functions ගැන. Neural Network එකක් ඇතුළේ Neuron එකක් 'ක්‍රියාත්මක' වෙන්න ඕනද නැද්ද කියලා තීරණය කරන්නේ මේ Function එකෙන්. හරියට අපේ මොළයේ Neuron එකක් උත්තේජනය වුණාම Signal එකක් යවනවා වගේ.

මේවා නැත්නම්, අපේ Network එකට Linearity විතරක් තියෙන Complex නොවන Problems විසඳන්න පුළුවන්. ඒත් Deep Learning වලින් අපි කරන්නේ Complex Patterns හඳුනාගන්න එකනේ. ඒකට Non-Linearity අවශ්‍යයි. Activation Functions තමයි ඒ Non-Linearity එක Network එකට ගේන්නේ.

බහුලව භාවිතා වෙන Activation Functions කීපයක් මෙන්න:

• Sigmoid Function: මේක 0 සහ 1 අතර Output එකක් දෙනවා. Binary Classification (දෙකක් අතරින් එකක් තෝරන) Problems වලදී Output Layer එකේ බහුලව භාවිතා වෙනවා. ඒත්, Gradient Vanishing කියන ප්‍රශ්නය නිසා Hidden Layers වලට එතරම් සුදුසු නැහැ.
• ReLU (Rectified Linear Unit) Function: මේක තමයි අද කාලේ ගොඩක් ජනප්‍රිය එකක්. max(0, x) කියන සරල සමීකරණයෙන් තමයි මේක ක්‍රියාත්මක වෙන්නේ. Input එක Positive නම් ඒකම Output කරනවා, Negative නම් 0 Output කරනවා. මේක වේගවත්, Gradient Vanishing ප්‍රශ්නයත් අඩුයි.
• Tanh (Hyperbolic Tangent) Function: Sigmoid වගේමයි, ඒත් මේක -1 සහ 1 අතර Output එකක් දෙනවා. සමහර වෙලාවට Sigmoid එකට වඩා හොඳට වැඩ කරනවා.
• Softmax Function: මේක Output Layer එකේ, Classifications ගොඩක් තියෙන (Multi-class Classification) Problems වලදී භාවිතා වෙනවා. මේක හැම Output එකකම Probability එකක් විදිහට දෙනවා, ඒ හැම Probability එකකම එකතුව 1 ට සමාන වෙනවා.

ප්‍රයෝගික උදාහරණය:

අපි හිතමු අපිට x = -2 සහ x = 3 කියන Values දෙකක් තියෙනවා කියලා.

• Sigmoid(x):
  • Sigmoid(-2) = 1 / (1 + e^-(-2)) ≈ 0.119
  • Sigmoid(3) = 1 / (1 + e^-3) ≈ 0.952
• ReLU(x):
  • ReLU(-2) = max(0, -2) = 0
  • ReLU(3) = max(0, 3) = 3

මේකෙන් තේරෙනවා නේද, Sigmoid එකෙන් Output එක Compress කරනවා 0-1 පරාසයට. ReLU එක Positive Value 그대로 දෙනවා, Negative Value 0 කරනවා. මේ වෙනස Networks වලට කොච්චර බලපානවද කියලා හිතාගන්න පුළුවන්. ReLU වල සරල බව සහ කාර්යක්ෂමතාව නිසා තමයි අද ගොඩක් Hidden Layers වලට ReLU භාවිතා වෙන්නේ.

Loss Functions - වැරදි හඳුනාගැනීම

Neural Network එකක් Training කරනකොට, ඒක Output එකක් දෙනවා. ඒ Output එක හරි Output එකට (අපි දීපු Label එකට) කොයිතරම් දුරින්ද තියෙන්නේ කියලා මනින්න තමයි Loss Function එකක් භාවිතා කරන්නේ. සරලව කිව්වොත්, මේක Network එකේ 'වැරැද්ද' මනිනවා. Loss එක වැඩි නම්, Network එක වැරදියි, Loss එක අඩු නම් Network එක හරි. අපේ Training එකේ ප්‍රධානම අරමුණ තමයි මේ Loss එක අවම කරන එක.

බහුලව භාවිතා වන Loss Functions කීපයක් මෙන්න:

• Mean Squared Error (MSE): මේක Regression Problems වලදී (ගණනක් පුරෝකථනය කරනකොට) බහුලව භාවිතා වෙනවා. මේකෙන් කරන්නේ පුරෝකථනය කරපු අගය (Predicted Value) සහ සත්‍ය අගය (Actual Value) අතර වෙනසෙහි වර්ගය (Squared Difference) අරගෙන, ඒකෙන් මධ්‍යන්‍යය (Mean) ගන්න එක.
• Binary Cross-Entropy: මේක Binary Classification Problems වලදී (දෙකක් අතරින් එකක් තෝරනකොට) භාවිතා වෙනවා. උදාහරණයක් විදිහට, Image එකක බල්ලෙක් ඉන්නවද නැත්ද කියලා කියන එක.
• Categorical Cross-Entropy: මේක Multi-class Classification Problems වලදී (Classes ගොඩක් තියෙනකොට) භාවිතා වෙනවා. උදාහරණයක් විදිහට, Image එකක බල්ලෙක්ද, බළලෙක්ද, හාවෙක්ද කියලා කියන එක.

ප්‍රයෝගික උදාහරණය (MSE):

අපි හිතමු අපේ Network එක Predict කරපු අගය (Predicted) 5 කියලා, ඒත් ඇත්ත අගය (Actual) 7 කියලා.

Loss = (Actual - Predicted)^2
Loss = (7 - 5)^2
Loss = 2^2
Loss = 4

තව Predict කරපු අගය 6, Actual අගය 7 නම්:

Loss = (Actual - Predicted)^2
Loss = (7 - 6)^2
Loss = 1^2
Loss = 1

දැන් බලන්න, 6 Predict කරපු එකේ Loss එක 1, 5 Predict කරපු එකේ Loss එක 4. Network එක 6 Predict කරපු එක තමයි ඇත්ත අගයට ළඟින්ම තියෙන්නේ. ඉතින් Loss එක අඩු වෙන තරමට, Network එකේ Performance එක හොඳයි.

Optimization Algorithms - ඉගෙන ගන්නා ආකාරය

හරි, දැන් අපි Loss එක මැනගත්තා. ඊළඟට මොකද කරන්නේ? Loss එක අඩු කරන්න ඕනේ නේද? ඒ Loss එක අවම කරන්න, ඒ කියන්නේ Network එකේ Weights සහ Biases හොඳම විදිහට Adjust කරන්න උදව් වෙන්නේ Optimization Algorithms. මේවා හරියට ගුරුවරයෙක් වගේ, Network එකට 'මොනවද වෙනස් කරන්න ඕනේ' කියලා කියලා දෙනවා.

මේ Algorithms වල ප්‍රධානම අරමුණ තමයි Loss Function එකේ Minimum Point එක හොයාගන්න එක. මේ ක්‍රියාවලියට Backpropagation කියලා කියනවා, ඒ කියන්නේ Output Layer එකේ ඉඳලා Input Layer එක දක්වා Loss එකේ Gradient එක ගණනය කරමින් Weights සහ Biases යාවත්කාලීන කරන එක.

බහුලව භාවිතා වන Optimization Algorithms කීපයක් මෙන්න:

• Gradient Descent: මේක තමයි මූලිකම Optimizer එක. මේකෙන් කරන්නේ Loss Function එකේ Gradient එක (ඒ කියන්නේ බෑවුම) ගණනය කරලා, ඒක පල්ලම් බහින විදිහට Weights සහ Biases Adjust කරන එක. හරියට කඳු මුදුනක ඉඳන් නිම්නයට යනවා වගේ.
• Learning Rate: මේක හරිම වැදගත් Parameter එකක්. මේකෙන් කියන්නේ හැම පියවරකදීම Weights සහ Biases කොච්චර ප්‍රමාණයක් වෙනස් කරන්න ඕනද කියලා. Learning Rate එක වැඩියි නම්, අපිට Minimum Point එක මඟ හැරෙන්න පුළුවන් (overshoot). අඩු නම්, Training එක හරිම හෙමින් වෙන්න පුළුවන්. මේක හොඳින් තෝරාගන්න එක හරිම වැදගත්.
• Stochastic Gradient Descent (SGD): සම්පූර්ණ Data Set එකම අරන් Gradient Descent කරනවා වෙනුවට, මේකෙන් කරන්නේ එක Sample එකක් අරන් Weights Adjust කරන එක. මේක වේගවත්, ඒත් ටිකක් Noisy.
• Mini-batch Gradient Descent: SGD සහ Batch Gradient Descent අතර තියෙන හොඳම විසඳුම මේක. Data Set එක පොඩි පොඩි Batch වලට කඩලා, ඒ හැම Batch එකකින්ම Weights Adjust කරනවා. මේක වේගවත් වගේම Stable.
• Adam, RMSprop: මේවා Advanced Optimizers. මේවා Learning Rate එක Automatic Adjust කරනවා වගේ සංකීර්ණ දේවල් කරන්න පුළුවන්. අද කාලේ ගොඩක් Project වලදී මේවා තමයි බහුලව භාවිතා වෙන්නේ.

ප්‍රයෝගික උපදෙස (Learning Rate):

Learning Rate එක තෝරාගැනීම හරිම අභියෝගාත්මකයි. අපි හිතමු ඔයාට කන්දක අඩියටම යන්න ඕනේ කියලා.

• ඔයා ලොකු පියවර තියනවා නම් (High Learning Rate), ඔයාට අඩිය මඟ ඇරිලා කඳු මුදුන උඩින් යන්න පුළුවන් (Overshoot).
• ඔයා හරිම පොඩි පියවර තියනවා නම් (Low Learning Rate), ඔයාට අඩියට යන්න ගොඩක් වෙලා යයි.
• හොඳම විදිහ තමයි, මුලින් ලොකු පියවර තියලා, අඩියට ළං වෙනකොට පොඩි පියවර තියන එක. මේකට Learning Rate Schedulers වගේ ක්‍රම භාවිතා කරන්න පුළුවන්.

මේ විදිහට තමයි Network එකක් Loss එක අඩු කරගෙන, Data වලින් ඉගෙන ගන්නේ. මේ Weights සහ Biases ටිකෙන් ටික Adjust කරලා Network එක දෙන Output එක Actual Output එකට ළං කරගන්න එක තමයි මේ ඔක්කොම වල අරමුණ.

අවසාන වශයෙන් (Conclusion)

ඉතින් යාළුවනේ, මේ Deep Learning කියන විෂය ගැන අපේ මුල්ම පියවර තැබුවා. අපි අද Neural Networks වල මූලිකාංග, Activation Functions වලින් Network එකට Non-linearity ලැබෙන හැටි, Loss Functions වලින් වැරදි මනින හැටි, සහ Optimization Algorithms වලින් Network එක ඉගෙන ගන්න හැටි ගැන කතා කළා.

මේ හැම සංකල්පයක්ම Deep Learning Model එකක් තේරුම් ගන්න සහ ගොඩනඟන්න හරිම වැදගත්. මේක AI ලෝකයේ තියෙන පුදුම හිතෙන තාක්ෂණයක්.

දැන් ඔයාලට මේ මූලිකාංග ගැන හොඳ අවබෝධයක් ඇති කියලා හිතනවා. ඊළඟට ඔයාලට පුළුවන් Python වල Keras හෝ TensorFlow වගේ Library එකක් භාවිතා කරලා පොඩි Neural Network එකක් හදලා බලන්න. එතකොට මේක තවත් හොඳින් තේරෙයි.

මේ ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහළින් Comment කරන්න. ඔයාල මේ වගේ මොන වගේ Project වලටද Deep Learning භාවිතා කරලා තියෙන්නේ? අපි ඒ ගැන කතා කරමු! තවත් මේ වගේ Tech Tutorial එකකින් හමුවෙමු!