AI සඳහා Calculus: Derivatives, Gradients, Backpropagation Sinhala Tutorial | AI Math

හැඳින්වීම: AI කියන්නේ Magic එකක්ද, නැත්නම් Math එකක්ද?

ආයුබෝවන් හැමෝටම! ✋ ඔයාලා හැමෝම අහලා ඇතිනේ AI (Artificial Intelligence) සහ Machine Learning (ML) ගැන. අද ලෝකේ හැමතැනම මේවා ගැන කතා වෙනවා. Google search එකේ ඉඳන් Netflix recommendations වෙනකම්, self-driving cars වල ඉඳන් medical diagnosis වෙනකම්, AI නැති තැනක් නැති තරම්. මේ ඔක්කොම දැක්කම, 'මේක කොහොමද වෙන්නේ?' කියලා ඔයාලට හිතෙන්න ඇති. සමහරු හිතනවා ඇති මේක 'magic' එකක් කියලා. 🧙‍♂️

ඇත්තටම කිව්වොත්, AI කියන්නේ magic එකක් නෙවෙයි, ඒක ගොඩනැගිලා තියෙන්නේ ගණිතය (Mathematics) මත. විශේෂයෙන්ම, Calculus කියන ගණිත ශාඛාව තමයි AI models වලට 'ඉගෙනගන්න' (learn) උදව් කරන ප්‍රධානම එන්ජිම. ⚙️ ඒ නිසා, ඔයාට AI ක්ෂේත්‍රයේ සාර්ථක වෙන්න ඕන නම්, නැත්නම් අඩුම ගානේ AI models ඇතුළත සිදුවන්නේ කුමක්දැයි තේරුම් ගන්න ඕන නම්, Calculus දැනගැනීම අත්‍යවශ්‍යයි.

බය වෙන්න එපා! 😱 Calculus කියන නම ඇහුනම සමහරවිට ඔයාගේ ඉස්කෝලේ කාලේ මතක් වෙලා ඔලුව අවුල් වෙන්න පුළුවන්. ඒත් අපි මේ tutorial එකෙන් calculus වල තියෙන සංකීර්ණ දේවල් පැත්තකින් තියලා, AI වලට අවශ්‍ය කරන මූලික සංකල්ප ටික විතරක්, පුළුවන් තරම් සරලව, ඔයාලට තේරෙන සිංහලෙන් කියලා දෙන්නයි හදන්නේ. කල්පනා කරලා බලන්න, ඔයාගේ Machine Learning model එක 'ඉගෙනගන්නේ' කොහොමද? ඒක වැරදි අඩු කරගන්නේ කොහොමද? මේ ප්‍රශ්නවලට උත්තර දෙන්න Calculus අපිට උදව් කරනවා.

මේ tutorial එකෙන් අපි සාකච්ඡා කරන ප්‍රධාන මාතෘකා තමයි:

• Derivatives (අවකල): වෙනස් වීමේ වේගය
• Gradients (ප්‍රවණතා): බහු විචල්‍ය ශ්‍රිතවල වෙනස් වීමේ දිශාව
• Chain Rule (දම්වැල් නීතිය): සංකීර්ණ ශ්‍රිතවල අවකලනය
• Optimization (ප්‍රශස්තකරණය): හොඳම විසඳුම සොයා ගැනීම
• Backpropagation (පසු ප්‍රචාරණය): Neural Networks ඉගෙනගන්නා ආකාරය

එහෙනම් අපි පටන් ගමු! 🚀

1. Derivatives (අවකල): වෙනස් වීමේ වේගය

අපි මුලින්ම Derivatives ගැන කතා කරමු. Derivatives කියන්නේ Calculus වල තියෙන මූලිකම සංකල්පයක්. සරලවම කිව්වොත්, Derivative එකකින් කියවෙන්නේ යම් ශ්‍රිතයක (function) වෙනස් වීමේ වේගය (rate of change) කොච්චරද කියලා, ඒකේ input එක වෙනස් වෙනකොට. ඒ කියන්නේ, function එකක ග්‍රාෆ් එකක යම් ලක්ෂ්‍යයකට අඳින ලද tangent line එකේ slope (ආනතිය) තමයි Derivative එක.

ඉක්මන වෙනස් වීම

උදාහරණයක් විදිහට, ඔයාගේ වාහනයක වේගය ගැන හිතන්න. වේගය කියන්නේ දුර කාලයත් එක්ක වෙනස් වෙන වේගයනේ (distance over time). ඔයාගේ වාහනය ගිය දුර කියන function එකේ, කාලය (time) කියන input එක වෙනස් වෙනකොට, වේගය කියන්නේ ඒ දුර වෙනස් වෙන වේගය. මේක තමයි Derivative එක. 🚗

AI වලට වැදගත් වෙන්නේ ඇයි?

AI සහ Machine Learning වලදී, අපිට තියෙනවා Loss Function (හෝ Cost Function) එකක්. මේ Loss Function එකෙන් මනිනවා අපේ model එකේ අනාවැකි (predictions) ඇත්ත අගයන්ගෙන් (actual values) කොච්චර දුරට වෙනස්ද, නැත්නම් කොච්චර වැරදිද කියලා. අපේ ඉලක්කය තමයි මේ Loss Function එකේ අගය අඩුම මට්ටමකට ගේන එක.

අපේ model එකේ තියෙන parameters (මේවා සාමාන්‍යයෙන් weights සහ biases කියලා හඳුන්වනවා) ටිකක් වෙනස් කරද්දි, Loss Function එක කොච්චර ඉක්මනට වෙනස් වෙනවද කියලා Derivative එකෙන් අපිට දැනගන්න පුළුවන්. මේකෙන් අපිට තේරෙනවා Loss එක අඩු කරන්න නම්, parameters ටික කොයි දිශාවට වෙනස් කරන්න ඕනද කියලා. 📉

සරල උදාහරණයක්:

අපි හිතමු අපිට තියෙනවා f(x) = x^2 කියන සරල function එක. මේකේ Derivative එක 2x. ගණිතමය වශයෙන් මේක ලියන්නේ මෙහෙමයි:

d/dx (x^n) = nx^(n-1)

ඉතින් f(x) = x^2 නම්, n=2. ඒ අනුව Derivative එක 2 * x^(2-1) = 2x.

මේ 2x කියන්නේ f(x) ග්‍රාෆ් එකේ ඕනෑම x ලක්ෂ්‍යයකදී tangent line එකේ slope එක. උදාහරණයක් විදිහට:

• x = 1 නම්, slope එක 2 * 1 = 2
• x = 3 නම්, slope එක 2 * 3 = 6
• x = -2 නම්, slope එක 2 * -2 = -4

මේකෙන් කියන්නේ, x=3 කියන ලක්ෂ්‍යයේදී function එක x=1 කියන ලක්ෂ්‍යයට වඩා වේගයෙන් ඉහළ යනවා කියන එකයි. AI වලදී මේකෙන් කියන්නේ, parameter එකක් ටිකක් වෙනස් කරද්දි Loss එක කොච්චර වෙනස් වෙනවද කියන එකයි. 💡

2. Gradients (ප්‍රවණතා): බහු විචල්‍ය ශ්‍රිතවල වෙනස් වීමේ දිශාව

දැන් අපි Derivatives සංකල්පය තව ටිකක් ඉදිරියට ගෙනියමු. Machine Learning models වලදී, අපිට තියෙන්නේ එක parameter එකක් විතරක් තියෙන functions නෙවෙයි. සාමාන්‍යයෙන්, Loss Function එකක parameters දහස් ගණනක්, සමහරවිට මිලියන ගණනක් තියෙන්න පුළුවන්. 🤯 මේ වගේ අවස්ථාවලදී, අපි පාවිච්චි කරන්නේ Gradients කියන සංකල්පය.

Partial Derivatives (ආංශික අවකල)

Gradient එක තේරුම් ගන්න කලින්, අපි Partial Derivatives ගැන පොඩ්ඩක් දැනගමු. Partial Derivative එකක් කියන්නේ, function එකක විචල්‍ය කිහිපයක් තිබුණත්, අපි එක විචල්‍යයක් සම්බන්ධයෙන් විතරක් Derivative එක ගණනය කරනවා. අනිත් හැම විචල්‍යයක්ම නියතයක් (constant) විදිහට සලකලා.

උදාහරණයක් විදිහට, f(x, y) = x^2 + y^2 කියන function එක ගනිමු. මේකේ x සහ y කියන විචල්‍ය දෙකම තියෙනවා.

• x සම්බන්ධයෙන් Partial Derivative එක: ∂f/∂x = 2x (මෙහිදී y නියතයක් ලෙස සලකනවා).
• y සම්බන්ධයෙන් Partial Derivative එක: ∂f/∂y = 2y (මෙහිදී x නියතයක් ලෙස සලකනවා).

මෙතනදී ∂ (del or partial) කියන සංකේතය පාවිච්චි කරන්නේ partial derivative එකක් කියන එක පෙන්වන්න.

Gradient Vector එක

Gradient එකක් කියන්නේ මේ වගේ හැම Partial Derivative එකක්ම තියෙන vector එකක්. මේ vector එකෙන් පෙන්නන්නේ function එකේ අගය වැඩි වන වේගවත්ම දිශාව (direction of steepest ascent) මොකක්ද කියලා. ඒ කියන්නේ, ඔයා කන්දක් නගිනවා වගේ හිතන්න. Gradient එක ඔයාට පෙන්නනවා, කන්දේ උසම තැනට යන්න පුළුවන් කෙටිම, වේගවත්ම පාර මොකක්ද කියලා. ⛰️

f(x, y) කියන function එකේ Gradient එක මෙහෙම ලියන්න පුළුවන්:

∇f(x,y) = [∂f/∂x, ∂f/∂y]

මෙහි ∇ (nabla or del) කියන සංකේතය Gradient එක පෙන්වන්න පාවිච්චි කරනවා.

අපේ f(x, y) = x^2 + y^2 කියන උදාහරණයට අනුව, Gradient එක වෙන්නේ:

∇f(x,y) = [2x, 2y]

මේ Gradient vector එකේ දිශාවට ගියොත් function එකේ අගය වැඩි වෙනවා. නමුත් අපිට Loss Function එකේ අගය අඩු කරගන්නයි ඕන. ඒ නිසා අපි Gradient එකේ ප්‍රතිවිරුද්ධ දිශාවට යන්න ඕනේ. (ඒ කියන්නේ -∇f දිශාවට). ඒකෙන් තමයි අපි Loss Function එකේ අඩුම ලක්ෂ්‍යයට (minimum) ලඟා වෙන්නේ.

AI වලට Gradient එක වැදගත් වෙන්නේ ඇයි?

AI models වල තියෙන Loss functions වලට සාමාන්‍යයෙන් parameters ගොඩක් තියෙනවා. මේ හැම parameter එකක්ම එක පාරට කොයි දිශාවට වෙනස් කරන්න ඕනද කියලා Gradient එක අපිට පෙන්නනවා, Loss එක අඩු කරන්න. මේක තමයි Gradient Descent වැනි optimization algorithms වල මූලිකම හරය. 💡

3. The Chain Rule (දම්වැල් නීතිය): ස්ථර වලින් සමන්විත ශ්‍රිතයන්

දැන් අපි කතා කරමු Chain Rule එක ගැන. මේක Neural Networks වලදී අතිශයින්ම වැදගත් සංකල්පයක්. සරලව කිව්වොත්, Chain Rule එක පාවිච්චි කරන්නේ එකක් ඇතුළේ තව function එකක් තියෙන (composite functions) function එකක Derivative එක හොයන්න. ඒ කියන්නේ f(g(x)) වගේ function එකක Derivative එක හොයන්න.

Chain Rule එක ක්‍රියා කරන හැටි

හිතන්න අපිට z = f(y) කියන function එකක් තියෙනවා, සහ y = g(x) කියන තව function එකක් තියෙනවා. එතකොට z කියන්නේ x මත රඳා පවතින function එකක් නේ (z = f(g(x))). dz/dx හොයන්න අපි Chain Rule එක පාවිච්චි කරනවා:

dz/dx = dz/dy * dy/dx

මේක කියන්නේ, z කියන function එක x සම්බන්ධයෙන් කොච්චර වෙනස් වෙනවද කියලා දැනගන්න, අපි මුලින්ම z කියන function එක y සම්බන්ධයෙන් වෙනස් වෙන වේගය අරගෙන, ඒක y කියන function එක x සම්බන්ධයෙන් වෙනස් වෙන වේගයෙන් ගුණ කරන්න ඕන.

සරල උදාහරණයක්:

අපි හිතමු z = y^2 සහ y = x + 1 කියලා.

මුලින්ම, dz/dy හොයමු:

dz/dy = d/dy (y^2) = 2y

ඊළඟට, dy/dx හොයමු:

dy/dx = d/dx (x + 1) = 1

දැන්, Chain Rule එක පාවිච්චි කරලා dz/dx හොයමු:

dz/dx = dz/dy * dy/dx = (2y) * (1) = 2y

y = x + 1 නිසා, අපිට y වෙනුවට x + 1 ආදේශ කරන්න පුළුවන්:

dz/dx = 2(x + 1)

මේක තවත් සරල උදාහරණයක්, නමුත් මේකේ තියෙන මූලික සංකල්පය Neural Networks වලදී අතිශයින්ම වැදගත් වෙනවා.

AI වලට Chain Rule එක වැදගත් වෙන්නේ ඇයි?

Neural Networks කියන්නේ, සරලව කිව්වොත්, එකිනෙකට සම්බන්ධ වෙච්ච Layers ගොඩක් තියෙන සංකීර්ණ functions පද්ධතියක්. එක Layer එකක Output එක ඊළඟ Layer එකට Input වෙනවා. මේක හරියට Assembly Line එකක් වගේ. 🏭

AI model එකක Loss Function එකේ Gradient එක ගණනය කරන්න, ඒකේ තියෙන හැම Weight එකක්ම සම්බන්ධයෙන්, අපි මේ Layer වලින් Layer වලට Chain Rule එක පාවිච්චි කරලා 'පසුපසට' (backward) ගමන් කරන්න ඕනේ. මේ ක්‍රියාවලියට තමයි Backpropagation කියලා කියන්නේ. Chain Rule එක නැතුව Backpropagation කරන්න බැහැ. ඒක තමයි Neural Networks වලට ඉගෙනගන්න පුළුවන් වෙලා තියෙන ප්‍රධානම හේතුව. 🔗

4. Optimization (ප්‍රශස්තකරණය): හොඳම විසඳුම සොයා ගැනීම

Calculus සංකල්ප ගැන කතා කරද්දි, Optimization ගැන කතා නොකර ඉන්න බැහැ. AI සහ Machine Learning වලදී, අපේ ප්‍රධානම ඉලක්කය තමයි model එකේ performance එක හොඳම මට්ටමට ගේන එක. ඒ කියන්නේ Loss Function එකේ අගය අඩුම මට්ටමකට ගේන එක.

Loss Function එක

අපි කලින් කතා කළා Loss Function එකක් ගැන. මේකෙන් මනින්නේ අපේ model එකේ අනාවැකි කොච්චර වැරදිද කියලා. අපි ඉස්සරහට යන්න යන්න, මේ Loss Function එකේ අගය අඩු වෙන්න ඕනේ. ඒකට තමයි Optimization Algorithms පාවිච්චි කරන්නේ.

Gradient Descent (ප්‍රවණතා අවරෝහණය)

Machine Learning වලදී පාවිච්චි කරන ප්‍රධානම සහ ජනප්‍රියම Optimization Algorithm එක තමයි Gradient Descent. මේක හරියට ඔයාගේ ඇස් බැඳගෙන කන්දකින් පහළට යනවා වගේ. 🚶‍♂️ කන්දේ බෑවුම (Gradient එක) දැනගෙන, හැම පියවරකදීම පහළට යන දිශාවට පොඩි අඩියක් තියනවා.

Gradient Descent එක ක්‍රියා කරන්නේ මෙහෙමයි:

1. මුලින්ම, model එකේ parameters (weights සහ biases) වලට අහඹු (random) අගයන් දෙනවා.
2. ඊට පස්සේ, Loss Function එකේ Gradient එක ගණනය කරනවා (මේකට තමයි Derivatives සහ Partial Derivatives පාවිච්චි කරන්නේ).
3. Gradient එක අපිට පෙන්නනවා Loss එක වැඩි වෙන වේගවත්ම දිශාව. අපිට ඕන Loss එක අඩු කරගන්න නිසා, අපි Gradient එකේ ප්‍රතිවිරුද්ධ දිශාවට parameters ටික වෙනස් කරනවා.
4. මේ ක්‍රියාවලිය නැවත නැවතත් සිදු කරනවා (iterations), Loss එක අවම වෙනකම් හෝ වෙනස් වීම නතර වෙනකම්.

Learning Rate (ඉගෙනුම් අනුපාතය)

Gradient Descent වලදී තියෙන තවත් වැදගත් සංකල්පයක් තමයි Learning Rate (η - eta) එක. මේකෙන් තීරණය වෙනවා අපි හැම පියවරකදීම Gradient එකේ දිශාවට කොච්චර ලොකු 'අඩියක්' තියනවද කියලා. 👣

• ලොකු Learning Rate එකක්: අපිට ඉක්මනට minimum එකට යන්න පුළුවන්. ඒත් සමහරවිට minimum එක පහුකරලා ගිහින් (overshoot) stable වෙන්නේ නැති වෙන්න පුළුවන්.
• පොඩි Learning Rate එකක්: minimum එකට යන්න ගොඩක් වෙලා යන්න පුළුවන්, සමහරවිට minimum එකට ලඟා වෙන්නෙම නැති වෙන්නත් පුළුවන්.

හොඳම Learning Rate එකක් හොයාගන්න එක Optimization වලදී අතිශයින්ම වැදගත් වෙනවා.

Gradient Descent හි මූලික යාවත්කාලීන කිරීමේ රීතිය:

Parameters (Weights - W) යාවත්කාලීන කරන ආකාරය මෙහෙම ලියන්න පුළුවන්:

W_new = W_old - η * ∇L(W_old)

• W_new: අලුත් weight එක
• W_old: පරණ weight එක
• η (eta): Learning Rate එක
• ∇L(W_old): වර්තමාන weights වලදී Loss function එකේ Gradient එක

මේ සරල සමීකරණය තමයි AI models වලට 'ඉගෙනගන්න' මූලිකම හේතුව. මේකෙන් කියන්නේ, අපි Loss එකේ Gradient එකේ ප්‍රතිවිරුද්ධ දිශාවට, Learning Rate එකට සමානුපාතිකව, අපේ weights වෙනස් කරනවා කියන එකයි. 🔄

5. Backpropagation (පසු ප්‍රචාරණය): Neural Networks වල ඉගෙනගැනීමේ එන්ජිම

අවසාන වශයෙන්, අපි මේ හැම සංකල්පයක්ම එකතු වෙලා වැඩ කරන, Neural Networks වල 'හදවත' බඳු ක්‍රියාවලිය ගැන කතා කරමු: Backpropagation.

Backpropagation කියන්නේ AI models (විශේෂයෙන්ම Neural Networks) වලට තමන්ගේ parameters (weights සහ biases) adjust කරගෙන, වැරදි අඩු කරගෙන, නිවැරදි අනාවැකි කියන්න 'ඉගෙනගන්න' උදව් කරන algorithm එකක්. මේක තමයි AI ක්ෂේත්‍රයේ විප්ලවීය වෙනසක් ඇති කළේ. 🚀

Backpropagation ක්‍රියා කරන ආකාරය

Backpropagation ක්‍රියාවලිය ප්‍රධාන වශයෙන් පියවර දෙකකින් සමන්විත වෙනවා:

1. Forward Pass (ඉදිරි ප්‍රචාරණය):

මේක තමයි model එක පුහුණු කිරීමේ (training) මුල්ම පියවර. 👣

1. Input data එක Neural Network එකට ඇතුළු කරනවා.
2. මේ data එක Layer එකෙන් Layer එකට ගමන් කරනවා (weights සහ activation functions හරහා ගමන් කරමින්).
3. අවසාන Layer එකෙන් model එකේ Output (prediction) එක ලැබෙනවා.
4. ඊට පස්සේ, මේ Output එක සහ ඇත්ත අගය (actual value) අතර වෙනස (error) ගණනය කරනවා. මේක තමයි Loss Function එකේ අගය.

2. Backward Pass (පසු ප්‍රචාරණය):

මේක තමයි Backpropagation එකේ ඇත්ත වැඩේ. ⏪

1. අපි මුලින්ම ගණනය කරපු Loss එක (output Layer එකේ) අරගෙන, Loss එකේ Gradient එක ගණනය කරනවා, Network එකේ තියෙන හැම weight එකක්ම සම්බන්ධයෙන්.
2. මේ Gradient එක ගණනය කිරීම සිදුවන්නේ Chain Rule එක පාවිච්චි කරලා, output Layer එකේ ඉඳන් input Layer එකට 'පසුපසට' ගමන් කරමින්. මේකෙන් අපිට දැනගන්න පුළුවන් Loss එකට බලපාන්නේ කොයි weight එක කොච්චරද කියලා.
3. දැන්, අපිට හැම weight එකක්ම සම්බන්ධයෙන් Loss එකේ Gradient එක තියෙන නිසා, අපි කලින් කතා කරපු Gradient Descent algorithm එක පාවිච්චි කරලා, මේ weights ටික යාවත්කාලීන කරනවා (update කරනවා). ඒ කියන්නේ Loss එක අඩු වෙන දිශාවට weights ටික වෙනස් කරනවා.

මේ ක්‍රියාවලිය පුහුණු කිරීමේ (training) දත්ත කට්ටලය (dataset) මත නැවත නැවතත් සිදුවෙනවා. හැම iteration එකකදීම (හෝ batch එකකදීම), model එකේ weights ටික ටික adjust වෙලා Loss එක අඩු වෙනවා. කාලයත් එක්ක, model එක 'ඉගෙනගෙන' නිවැරදි අනාවැකි කියන්න පටන් ගන්නවා.

සරල සංකල්පීය රූප සටහනක්:

Input Data
   ↓
Hidden Layer 1
   ↓
Hidden Layer 2
   ↓
Output Layer (Prediction)
   ↓
Calculate Loss
   |
   ↓ (Backpropagation starts here)
Calculate Gradients (using Chain Rule)
   ↓
Update Weights (using Gradient Descent)
   ↑
(Repeat for next batch/epoch)

මේකෙන් පැහැදිලි වෙනවා AI models වල learning process එක කොච්චර systematic ද කියලා. ඒක අහඹු දෙයක් නෙවෙයි, ගණිතමය මූලධර්ම මත පදනම් වූ ක්‍රියාවලියක්. ✨

නිගමනය: Calculus කියන්නේ AI වල බලය

ඉතින් යාලුවනේ, මේ tutorial එකෙන් ඔයාලට තේරෙන්න ඇති AI කියන්නේ magic එකක් නෙවෙයි, ඒක පිටිපස්සේ තියෙන්නේ අපූරු ගණිතමය සංකල්ප ටිකක් කියලා. 📐 විශේෂයෙන්ම, Calculus තමයි AI models වලට 'ඉගෙනගන්න' උදව් කරන ප්‍රධානම මෙවලම.

• Derivatives වලින් අපි ඉගෙනගත්තා function එකක වෙනස් වීමේ වේගය හොයන හැටි, ඒක Loss Function එකේ parameter sensitivity එක තේරුම් ගන්න වැදගත් වෙන හැටි.
• Gradients වලින් අපි දැනගත්තා බහු විචල්‍ය functions වලදී Loss එක අඩු කරගන්න parameters කොයි දිශාවට වෙනස් කරන්න ඕනද කියලා.
• Chain Rule එක තමයි Neural Networks වගේ සංකීර්ණ function structures වල Gradient ගණනය කරන්න අත්‍යවශ්‍ය මූලධර්මය.
• Optimization, විශේෂයෙන්ම Gradient Descent, කියන්නේ මේ Gradients පාවිච්චි කරලා Loss Function එකේ minimum එක හොයන ක්‍රියාවලිය.
• අවසාන වශයෙන්, Backpropagation කියන්නේ මේ හැම සංකල්පයක්ම එකතු වෙලා Neural Networks වලට ඉගෙනගන්න උදව් කරන algorithm එක.

මේ සංකල්ප තේරුම් ගැනීමෙන්, ඔයාට AI models ක්‍රියා කරන ආකාරය පිළිබඳව ගැඹුරු අවබෝධයක් ලැබෙනවා. මේක AI Engineer කෙනෙක් විදිහට, Data Scientist කෙනෙක් විදිහට, නැත්නම් AI ගැන උනන්දුවක් දක්වන කෙනෙක් විදිහට ඔයාට අතිශයින්ම වැදගත්.

දැන් ඔයාලට මේ මූලික සංකල්ප ටික ගැන හොඳ අවබෝධයක් තියෙනවා. මේක තවදුරටත් වර්ධනය කරගන්න පුළුවන් හොඳම විදිහ තමයි, ඔයාලම මේවා implement කරලා බලන එක. Python වල PyTorch, TensorFlow වගේ libraries මේ ගණිතය ඔක්කොම automate කරනවා තමයි. ඒත් මේ මූලික ගණිතය තේරුම් ගැනීමෙන් ඔයාට model performance එක improve කරන්න, debugging කරන්න, අලුත් architectures හදන්න ගොඩක් උදව් වෙයි.

ඉතින්, ඔයාලගේ අදහස්, ප්‍රශ්න, අත්දැකීම් පහලින් comment කරන්න! මේ දැනුම ඔයාලගේ ඊළඟ AI project එකට පාවිච්චි කරන්න. මතක තියාගන්න, හැමදාම අලුත් දේවල් ඉගෙනගන්න. 🎓

ඔයාට ජය! 🙏