Classification කියන්නේ දේවල් කාණ්ඩ වලට බෙදන එක. මේක Supervised Learning වල තියෙන ප්‍රධානම කොටසක්. මෙතනදී අපි කරන්නේ අලුතින් ලැබෙන දත්තයක් (Data point) කලින් හඳුනාගත් කාණ්ඩයකට (Class/Category) අයිති කරන්නේ කොහොමද කියලා මොඩල් එකට උගන්වන එකයි.

Article 14: K-Nearest Neighbours (KNN) – Let’s learn from neighbours 🏘🤝

KNN කියන්නේ Machine Learning වල තියෙන සරලම ඒත් හරිම බලසම්පන්න algorithm එකක්. මේකේ විශේෂත්වය තමයි මේක Lazy Learner කෙනෙක් වීම. ඒ කියන්නේ මෙයා කලින්ම මොඩල් එකක් හදලා තියාගන්නේ නැහැ, අලුත් දත්තයක් ආපු වෙලාවට විතරයි වැඩ පටන් ගන්නේ. මේකේ තියෙන Intuition එක මොකද්ද? මේක සරලව තේරුම් ගමු. ඔයා අලුත් පළාතකට පදිංචියට ගියොත් ඒ පැත්තේ මිනිස්සු මොන වගේද කියලා දැනගන්නේ ඔයාගේ ගේ වටේ ඉන්න අසල්වැසියෝ කීප දෙනෙක් (K=5) දිහා බලලනේ. අන්න ඒ වගේ තමයි KNN. අලුත් data point එකක් ආවම ඒකට ලඟින්ම ඉන්න අසල්වැසියෝ k ප්‍රමාණයක් බලලා ඒ වැඩි දෙනෙක් අයිති කාණ්ඩයට අලුත් එකත් දානවා. 😴⚡️🗳

01. The Mathematical Foundation - KNN වැඩ කරන්නේ සම්පූර්ණයෙන්ම දුර මැනීම මතයි. 📐🔢

I. Minkowski Distance (General equation) - අපි හැමෝම දන්න පයිතගරස් ප්‍රමේයයෙන් එන Euclidean දුර කියන්නේ ඇත්තටම Minkowski distance එකේ විශේෂ අවස්ථාවක්.

D(x,y) = (∑ᵢᷠ₌₁ ∣ xᵢ − yᵢ ∣ ᵖ)⁽¹/ᵖ⁾ (සමීකරණේ පැහැදිලි නැත්නම් මෙතනින් බලන්න)

p = 1 වෙද්දි මේක Manhattan Distance (L1 Norm) වෙනවා.
p = 2 වෙද්දි මේක Euclidean Distance (L2 Norm) වෙනවා.

II. Hamming Distance - ප්‍රොජෙක්ට් වලදී වචන (Categorical data) අතර වෙනස මනින්න පාවිච්චි කරන්නේ මේක. මේකෙන් බලන්නේ අගයන් දෙකක් එකිනෙකට වෙනස් වන ස්ථාන ගණන.

02. Engineering Challenges & Advanced Optimisation 🏗⚙️

දැන් අපි බලමු ඇත්තම KNN පාවිච්චි කරද්දී මුහුණ දෙන ප්‍රශ්න සහ ඒවා විසඳන හැටි.

I. The Curse of Dimensionality - දත්ත වල තීරු (Features/Dimensions) ගණන වැඩි වෙද්දී ලග කියන සංකල්පය නැති වෙලා යනවා. මොකද හැම දත්තයක්ම එකිනෙකෙන් හුඟක් ඈතින් පිහිටන නිසා. මේක විසඳන්න අනිවාර්යයෙන්ම PCA (Dimensionality Reduction) වගේ තාක්ෂණයක් පාවිච්චි කරලා වැදගත්ම features ටික විතරක් ඉතිරි කරගන්න ඕනේ.

II. Feature Scaling - මේක අනිවාර්ය පියවරක්. KNN සම්පූර්ණයෙන්ම දුර මත පදනම් වන නිසා අගයන් විශාල දත්ත (උදා: ආදායම) අගයන් කුඩා දත්ත (උදා: වයස) වලට වඩා බලපෑමක් කරනවා. ඒ නිසා Standardization (Z-score scaling) මගින් දත්ත සියල්ලම එකම මට්ටමකට ගෙන ඒම අනිවාර්යයි. ✅

III. Speed Optimization (KD-Trees & Ball Trees) - දත්ත මිලියන ගණනක් තියෙද්දි හැම එකකටම දුර මනින එක (O(n)) time wasting. ඒ නිසා අපි data store කරන්නේ Trees ව්‍යුහයන් වල.
● KD-Tree - data ටික dimension කිපයක් අනුව බෙදලා වෙන් කරනවා.
● Ball Tree - data වලට dimension ගොඩක් තියෙන අවස්ථාවලදී (High dimensions) වඩාත් කාර්යක්ෂමයි.

03. Choosing the K: Hyperparameter Tuning 🎯🔧

K අගය තෝරා ගැනීම හරිම වැදගත්.
● Small K (e.g., K=1) - මේකේදී Noise වලට හුඟක් සංවේදීයි (Overfitting).
● Large K - මේකෙදී patterns මග හැරෙන්න පුළුවන් (Underfitting).

හොඳම K අගය හොයාගන්න අපි Square root of N (දත්ත ගණන) පාවිච්චි කරනවා නැත්නම් Cross-validation හරහා check කරලා බලනවා.

අද අපි KNN සංකල්පයේ ඉදලා KD-Trees සහ Minkowski distance වගේ maths කොටස් දක්වාම කතා කළා. 🎓✅ ඊලග ආටිකල් එකෙන් (Article 15) අපි කතා කරන්නේ probability base කරගත්තු algorithm එකක් වෙන Logistic Regression ගැන. 📉🧠 🙊😁

✍️ @TheInfinityAI

Article 15: Logistic Regression – Make decisions with probability 📈🎲

මුලින්ම මේ නම ගැන පොඩි පැහැදිලි කිරීමක් කරන්න ඕනේ. මේකේ නමට Regression කෑල්ලක් තිබුණට මේක පාවිච්චි කරන්නේ Classification සඳහා. මේකේ පදනම වැටෙන්නේ Statistics සහ Probability මත. මේකේ Intuition එක මොකද්ද කියලා සරලව තේරුම් ගමු. අපි මෙහෙම හිතමු, ඔයාට ලැබෙන මැසේජ් එකක් Scam එකක්ද නැද්ද කියලා තීරණය කරන්න Probability ඕනේ වෙනවා. උදාහරණයක් විදිහට මැසේජ් එකක් Scam එකක් වෙන්න තියෙන ඉඩ 0.85 (85%) ක් නම් අපිට කියන්න පුළුවන් ඒක Scam එකක් කියලා. 0.5 ට වඩා අඩු නම් ඒක Legit මැසේජ් එකක්. 📧⚖️✅

01. The Sigmoid Function 📉

අපි Linear Regression වලදී ඉගෙන ගත්ත y = mx + c සමීකරණයෙන් ඕනෑම අගයක් ලැබෙන්න පුළුවන් (-∞ සිට +∞ දක්වා). හැබැයි Probability එක තියෙන්න ඕනේ 0 සහ 1 අතර විතරයි. අන්න ඒ නිසයි අපි Sigmoid (Logistic) Function එක පාවිච්චි කරන්නේ.

σ(z) = (1 / (1 + e⁻ᶻ))

මෙතැනදී z = β₀ + β₁x₁ + … + βₙxₙ වෙනවා. ඕනම විශාල හෝ කුඩා z අගයක් මේ function එක ඇතුළට දැම්මම ඒක 0 සහ 1 අතර අගයකට squash වෙනවා.

02. The Mathematical Deep Dive 🧬🧮

දැන් අපි බලමු ඇයි අපි මේකට සාමාන්‍ය Linear Regression වල පාවිච්චි කරන Mean Squared Error (MSE) පාවිච්චි නොකරන්නේ කියලා. 🤔

I. Why not MSE? 🎢

Logistic Regression වලදී MSE පාවිච්චි කළොත් ලැබෙන Cost Function එක Non-Convex එකක් වෙනවා. ඒ කියන්නේ ඒකේ ගොඩක් Local Minima තියෙන්න පුළුවන්. එතකොට Gradient Descent වලට නියම Global Minimum එක හොයාගන්න බැරිව හිර වෙන්න පුළුවන්.(තේරුනේ නෑ නේද? ඉන්න පැහැදිලි කරන්නම්)

👉 Minima කියන්නේ Cost එක එහෙමත් නැත්නම් Error එක අඩුම තැන. Local Minima කියන්නේ අපි සලකන සම්පූර්ණ surface එකේ පොඩි ප්‍රදේශයක තියෙන ගැඹුරුම තැන. Global Minimum කියන්නේ සම්පූර්ණ surface එකම බලද්දී ලැබෙන අඩුම තැන. එතකොට Gradient Descent කියන්නේ Error එක අඩුවෙන දිශාවට step by step යන algorithm එක.

දැන් මොකද්ද Problem එක? Gradient Descent algorithm එක Local Minima එකකට ගියොත්, Gradient = 0 වෙනවා එතකොට Algorithm එක හිතනවා “අහ්, minimum එක හම්බුණා” කියලා, එත් ඒක Global Minimum නෙවෙයි කියලා algorithm එක දන්නේ නෑ. 🛑

එක නිසා Logistic Regression වලදී MSE පාවිච්චි කළොත් Cost Function එක Non-Convex වෙනවා. Non-Convex senario එකකදී Local Minima ගොඩක් තියෙන නිසා Gradient Descent එක Local Minima එකක හිර වෙලා True Global Minimum එක miss වෙනවා.

II. Binary Cross-Entropy (Log-Loss) 🪵📉

මේ ප්‍රශ්නය විසඳන්න අපි පාවිච්චි කරන්නේ Log-Loss function එක. මේක පදනම් වෙන්නේ Maximum Likelihood Estimation (MLE) කියන Statistical concept එක මත.

J(θ) =− (1 / m)∑ᵢͫ₌₁[y⁽ⁱ⁾log(ŷ⁽ⁱ⁾) + (1 − y⁽ⁱ⁾)log(1 −ŷ⁽ⁱ⁾)] (සමීකරණේ පැහැදිලි නැත්නම් මෙතනින් බලන්න)

● y = 1 නම් (උදා: Scam) පළවෙනි කොටස විතරක් වැඩ කරනවා.
● y = 0 නම් (උදා: Legit) දෙවෙනි කොටස විතරක් වැඩ කරනවා.
● මැෂින් එක වැරදි අනුමානයක් කළොත් මේ function එක හරහා ලැබෙන Loss එක ඉතා විශාල වෙනවා.

03. Regularization - Let's control overfitting 🛡⚙️

දත්ත වල තියෙන හැම පොඩි දෙයක්ම කටපාඩම් කරන්න ගියොත් අපේ මොඩල් එක අසාර්ථක වෙනවා. ඒක නවත්තන්න අපි සංකීර්ණ weights වලට changes කරනවා.

● L1 Regularization (Lasso) - සමහර අනවශ්‍ය features වල weights බින්දුව කරනවා. (Feature selection වලට වැදගත්).

● L2 Regularization (Ridge) - weights වල අගයන් කුඩා කරලා මොඩල් එකේ සංකීර්ණ බව අඩු කරනවා.

04. Decision Boundary 📏🛣

අපි සම්භාවිතාව 0.5 ට වඩා වැඩිනම් එක පැත්තකටත් අඩුනම් අනිත් පැත්තකටත් දානවා. ඒ මැදින් ඇඳෙන රේඛාව තමයි Decision Boundary එක. Logistic Regression වලදී මේ මායිම නිතරම Linear එකක් වෙනවා.

අද අපි කතා කළේ දත්තයක සම්භාවිතාව හොයලා ඒක වර්ගීකරණය කරන හැටි. 🎓✅ ඊලග ආටිකල් එකෙන් (Article 16) අපි කතා කරන්නේ සංකීර්ණ දත්ත වෙන් කරන්න පුළුවන් Support Vector Machines (SVM) ගැන. 🧠⏭️ 🙊😁

✍️ @TheInfinityAI

Article 16: Support Vector Machines (SVM) – Maximum Gap Classification 🛡⚖️

SVM වල මූලික අරමුණ වෙන්නේ කාණ්ඩ දෙකක් වෙන් කරන කොට ඒ දෙක අතර තියෙන හිස් අවකාශය එහෙමත් නැත්නම් Margin එක උපරිම වන විදිහට මායිම් රේඛාව අදින එක. මුලින්ම මෙකේ Intuition එක මොකද්ද කියලා සරලව තේරුම් ගමු. හිතන්න පාරක දෙපැත්තේ කඩවල් තියෙනවා කියලා. අපිට ඕනේ පාර මැදින් ඉරක් අඳින්න. හැබැයි ඒ ඉර දෙපැත්තේම තියෙන කඩවල් වලට ගෑවෙන්නේ නැති වෙන්න පුළුවන් තරම් ලොකු පරතරයක් තියෙන විදිහට. අන්න ඒ පරතරය තමයි Margin එක. ඒ පරතරය තීරණය කරන්න උදව් වෙන පාරට කිට්ටුවෙන්ම තියෙන කඩවල් වලට අපි කියනවා Support Vectors කියලා.

01. The Mathematical Part 🧬🔢

දැන් අපි බලමු SVM වලින් ඇත්තටම මේ පරතරය උපරිම කරන්නේ කොහොමද කියලා.

I. The Hyperplane Equation 📍

අපි වෙන් කරන මායිම (Hyperplane) මෙහෙම ලියන්න පුළුවන්,

wᵀx + b = 0

මේකේ w කියන්නේ Weight vector එකක්. b කියන්නේ Bias එක. අපේ Margin එක වෙන්නේ 2/w අගයයි. මේක උපරිම කරන්න නම් අපිට w අගය අවම (Minimize) කරන්න වෙනවා.

II. Hard Margin vs Soft Margin (C Parameter) 🚦

Hard Margin - දත්ත අතර කිසිම වැරදීමකට ඉඩ දෙන්නේ නැ. හැබැයි ප්‍රායෝගික ලෝකයේදී දත්ත මිශ්‍ර වෙලා තියෙන්න පුළුවන්.

Soft Margin - මෙතැනදී අපි Slack Variables පාවිච්චි කරනවා. මෙතැනදී C parameter එක හරිම වැදගත්. High C වැරදි වලට ඉඩ දෙන්නේ නැහැ (Overfitting වෙන්න පුළුවන්). Low C ලොකු පරතරයක් ගන්න උත්සාහ කරනවා (Generalization හොඳයි).

02. The Kernel Trick 🪄🌀

සමහර වෙලාවට දත්ත සරල රේඛාවකින් (Linear) වෙන් කරන්න බැහැ. උදාහරණයක් විදිහට රවුමක් ඇතුලේ තියෙන දත්ත සහ ඒ වටේ තියෙන දත්ත වෙන් කරන්න බැහැ. මෙන්න මෙතැනදී SVM එක කරන්නේ ඒ දත්ත 2D තලයක ඉදලා 3D හෝ ඊට වඩා වැඩි මානයකට (Higher Dimension) ගෙන යන එක. එතකොට අපිට පුළුවන් ඒවා මැදින් තලයක් (Plane) දාලා වෙන් කරන්න.

● Polynomial Kernel - දත්ත වල බලයන් (Squares/Cubes) පාවිච්චි කරලා වෙන් කරනවා.
● RBF (Radial Basis Function) - මේකෙන් දත්ත අනන්ත මානයකට (Infinite Dimensions) මැප් කරනවා. මේකේ තියෙන Gamma අගය මගින් එක් දත්ත ලක්ෂ්‍යයක බලපෑම කොච්චර දුරකට තියෙනවද කියලා තීරණය කරනවා.

Support Vector Machines (SVM) කියන්නේ හුදෙක් data category දෙකක් මැදින් ඉරක් ඇඳලා වෙන් කරනවාට වඩා ඒ category දෙක අතර තියෙන වෙනස Maximize කරන්න උත්සාහ කරන ඉතාමත් බුද්ධිමත් algorithm එකක්. මේකේ මූලිකම සිද්ධාන්තය වෙන්නේ Maximum Margin Classifier ලෙස ක්‍රියා කරන එක. ඒ කියන්නේ data category දෙක වෙන් කරන ප්‍රධාන රේඛාව හෙවත් Hyperplane එක අදිද්දී ඒ රේඛාවට දෙපැත්තෙන් තියෙන data points අතර පවතින Margin එක උපරිම අගයක තබා ගන්න එක තමා මේකේ අරමුණ. 🎯✅

ඊළඟ ආටිකල් එකෙන් (Article 17) අපි කතා කරන්නේ අපේ Supervised Learning පියවරේ තවත් වැදගත්ම කොටසක් වන Regression වල තියෙන දියුණු මට්ටම් (Polynomial, Lasso, Ridge) ගැන. 📈⏭️ 🙊😁

✍️ @TheInfinityAI

Article 17: Advanced Regression – The Mathematics of Curves and Penalties 📈⚙️

සාමාන්‍ය Linear Regression එකෙන් කරන්නේ දත්ත අතර තියෙන සරල රේඛීය සම්බන්ධතාවය හොයන එක වුණාට ප්‍රායෝගික ලෝකයේ දත්ත මීට වඩා හුඟක් සංකීර්ණයි. ඒ නිසා අද අපි Polynomial Regression සහ මොඩල් එකක් ඕනෑවට වඩා සංකීර්ණ වීම පාලනය කරන Regularization (Lasso, Ridge, ElasticNet) ගැන කතා කරමු.

1. Polynomial Regression - Beyond the straight line 🎢

සමහර දත්ත අතර තියෙන සම්බන්ධය සරල රේඛාවකින් පෙන්වන්න බැහැ 🚫. උදාහරණයක් විදිහට ශාකයක වර්ධනය මුල් කාලයේ වේගවත් වෙලා පස්සේ ස්ථාවර වෙනවා. මෙන්න මේ වගේ Curves පෙන්වන්න අපි දත්ත වල ඇති features වල බලයන් (Squares, Cubes) පාවිච්චි කරනවා. මෙහිදී අපි කරන්නේ අපේ x අගය x²,x³,…,xⁿ ලෙස ඉහළ බලයන්ට පරිවර්තනය කරන එක.

y = β₀ + β₁x + β₂x² + … + βₙxⁿ + ϵ

මේකේ n අගය (Degree) වැඩි වෙන්න වැඩි වෙන්න රේඛාව ඕනෑම සංකීර්ණ හැඩයක් ගැනීමට සමත් වෙනවා. හැබැයි මෙතැනදී ඇති වන ලොකුම ප්‍රශ්නය තමයි Overfitting. ඒ කියන්නේ රේඛාව දත්තවල තියෙන හැම Noise එකක්ම අල්ලන්න ගිහින් අන්තිමට model predictions වැරදි යාම. ⚠️

2. The Bias-Variance Tradeoff ⚖️🎯

Advanced ML වලදී අපි නිතරම කතා කරන සංකල්පයක් තමයි මේක.Bias => Underfitting සහ Variance => Overfitting. අපේ ඉලක්කය වෙන්නේ මේ දෙකම අවම වන Sweet Spot එක සොයා ගැනීම. ඒකට තමයි අපි Regularization පාවිච්චි කරන්නේ.

3. Regularization 🛡🔧

Regularization වලින් කරන්නේ අපේ Cost Function එකට අමතර Penalty term එකතු කරන එක. මේකෙන් කරන්නේ අපේ Weights ඕනෑවට වඩා විශාල වීම පාලනය කරන එක.

I. Ridge Regression (L2 Regularization) ⭕️

මේකෙදි අපි Weights වල වර්ගයන්ගේ එකතුව Penalty term එකක් විදියට එකතු කරනවා.

Cost = MSE + λ∑ⱼᷮ₌₁βⱼ² (සමීකරණේ පැහැදිලි නැත්නම් මෙතනින් බලන්න)

මේකෙදි අපි λ වලින් Weights වල බලපෑම අඩු කරනවා, නමුත් බින්දුවටම අඩු කරන්නේ නෑ. දත්ත අතර ඉහළ සම්බන්ධතාවයක් එහෙමත් නැත්තන් Multicollinearity එකක් තියෙන අවස්තා වලදි මේක පාවිච්චි වෙනවා.

II. Lasso Regression (L1 Regularization) 💎

මේකෙදි අපි Weights වල Absolute values වල එකතුව Penalty term එකක් විදියට එකතු කරනවා.

Cost = MSE + λ∑ⱼᷮ₌₁∣βⱼ∣ (සමීකරණේ පැහැදිලි නැත්නම් මෙතනින් බලන්න)

මේකෙදි අපි සමහර අනවශ්‍ය features වල weights හරියටම බින්දුව (0) බවට පත් කරනවා. ඒ නිසා මෙක Feature Selection සඳහා ඉතාමත් වැදගත්.

III. ElasticNet Regression 🧬🤝

Lasso (L1) සහ Ridge (L2) යන දෙකෙහිම ගුණාංග මිශ්‍ර කරලා හදපු ක්‍රමයක්. දත්ත පද්ධතියක features විශාල ප්‍රමාණයක් ඇති විට සහ ඒවා එකිනෙකට තදින් සම්බන්ධ වී ඇති විට ElasticNet මගින් වඩාත් ස්ථාවර ප්‍රතිඵල ලබා ගත හැකියි.

Advanced Regression කියන්නේ දත්තවල පවතින සරල නොවන වක්‍ර සම්බන්ධතාවයන් හඳුනා ගැනීමටත් එම ක්‍රියාවලියේදී සිදුවිය හැකි Overfitting දෝෂය ගණිතමය වශයෙන් පාලනය කිරීමටත් යොදා ගන්නා උසස් ක්‍රමවේදයක්. Polynomial Regression හරහා දත්තවල හැඩය නිරූපණය කරන අතර Lasso සහ Ridge වැනි Regularization තාක්ෂණයන් මගින් මොඩල් එකේ weights පාලනය කරමින් වඩාත් Generalized මොඩල් එකක් ගොඩනැගීමට මේක උපකාරී වෙනවා. ✅ ✨

ඊළඟ ආටිකල් එකෙන් (Article 18) අපි ‍යන්නෙ Phase 7: Unsupervised Learning වලට. එතැනදී අපි Labels නැති දත්ත කාණ්ඩ කරන Clustering ගැන කතා කරමු. 🧠⏭️ 🙊😁

✍️ @TheInfinityAI

Article 18: Clustering – Let's group hidden patterns in the data 🧩🔍

මුලින්ම අපි බලමු මොකද්ද Clustering කියන්නේ කියලා. Clustering හෙවත් කාණ්ඩ කිරීම කියන්නේ දත්තවල තියෙන ලක්ෂණ අනුව සමාන දත්ත එකම කාණ්ඩයකට (Cluster) ගොනු කිරීම. මෙතැනදී අපි මොඩල් එකට Labelled dataset එකක් දෙන්නේ නැහැ. මොඩල් එක කරන්නේ දත්ත අතර තියෙන සමානකම් සහ රටාවන් තනියම හොයාගෙන ඒවා කාණ්ඩ කරන එක.

දැන් අපි එමු මාතෘකාවට, K-Means කියන්නේ Unsupervised Learning ලෝකයේ තියෙන ජනප්‍රියම Centroid-based algorithm එක. මේකේ මූලික ඉලක්කය වෙන්නේ දත්ත කාණ්ඩ K ප්‍රමාණයකට බෙදලා ඒ ඒ කාණ්ඩයේ දත්ත සහ එහි කේන්ද්‍රය (Centroid) අතර ඇති දුර අවම කිරීම.

01. The Core Logic: Lloyd’s Algorithm 🔄⚙️

K-Means ක්‍රියා කරන්නේ පියවර තුනක චක්‍රයක් විදිහට.

i. Initialization - randomly කේන්ද්‍රස්ථාන K ප්‍රමාණයක් තෝරා ගැනීම.
ii. Assignment - හැම data point එකක්ම තමන්ට ලඟම කේන්ද්‍රයට අයිති කිරීම.
iii. Update - අලුතින් හැදුන කාණ්ඩයේ සාමාන්‍ය අගය ගණනය කර කේන්ද්‍රය අලුත් තැනකට ගෙන යාම.

මෙ ක්‍රියාවලිය කේන්ද්‍රයන් තවදුරටත් වෙනස් නොවන තෙක් (Convergence) දිගටම සිද්ධ වෙනවා.

02. Math: The Objective Function 📐🔢

K-Means ඇත්තටම කරන්නේ Within Cluster Sum of Squares (WCSS) හෙවත් Inertia අගය අවම කරන එක.

J = ∑ⱼᴷ₌₁∑_₍ᵢ∈Cⱼ₎xᵢ − μⱼ² (සමීකරණේ පැහැදිලි නැත්නම් මෙතනින් බලන්න)

K = කාණ්ඩ ගණන.
Cⱼ = j වන කාණ්ඩයට අයිති data point.
μⱼ = j වන කාණ්ඩයේ මධ්‍යන්‍යය (Centroid).

මේක ඇත්තටම Expectation-Maximization (EM) algorithm එකේ සරල අවස්ථාවක්.

03. Advanced Optimization: K-Means++ 🚀✨

සාමාන්‍ය K-Means වල තියෙන ලොකුම ප්‍රශ්නය තමයි Initial centroids අහඹු ලෙස තෝරා ගැනීම. මේවා වැරදි තැන්වලින් තේරුණොත් මොඩල් එක වැරදි ප්‍රතිඵල දෙන්න පුළුවන්. ⚠️ මේකට විසඳුම තමයි K-Means++. මෙහිදී, පළමු කේන්ද්‍රය අහඹු ලෙස තෝරා ගන්නවා. ඊට පස්සේ ඊළඟ කේන්ද්‍රය තෝරා ගන්නේ දැනට තියෙන කේන්ද්‍රයට වැඩිම දුරකින් ඇති දත්ත ලක්ෂ්‍යයකින් වීමේ වැඩි සම්භාවිතාවක් ඇති ආකාරයට. මෙය හරහා වඩාත් වේගවත් සහ නිවැරදි Convergence එකක් ලබාගන්න පුලුවන්.

04. Technical Limitations & Mathematical Assumptions 🚧🛑

K-Means පාවිච්චි කරන්න කලින් මේ සීමාවන් ගැන අනිවාර්යයෙන්ම දැනගන්න ඕනේ,

● Spherical Clusters - K-Means උපකල්පනය කරන්නේ හැම කාණ්ඩයක්ම රවුම් (Spherical) හැඩයක් ගන්නා බව. ඒ නිසා දිගැටි හෝ වක්‍ර හැඩැති දත්ත වලට මෙය අසාර්ථකයි.

● Sensitivity to Scaling - මේක Euclidean distance එක මනින නිසා data Scale (Standardize) කරලා නොතිබුණොත් වැරදි ප්‍රතිඵල ලැබෙනවා.

● Sensitivity to Outliers - එක Outlier එකක් නිසා මුළු කේන්ද්‍රයම විශාල ලෙස වෙනස් වෙන්න පුළුවන්.

05. Advanced Evaluation: Silhouette Analysis 📊📉

අපි K අගය තෝරන්න පාවිච්චි කරන Elbow Method එක නිතරම පැහැදිලි නැ. ඒ නිසා අපි පාවිච්චි කරන වඩාත් දියුණු ක්‍රමය තමයි Silhouette Score. හැම data point එකක් සඳහාම Silhouette Coefficient (s) ගණනය කරන්නේ මෙහෙම,

s(i) = ((b(i) − a(i)) / (max{a(i),b(i)})) (සමීකරණේ පැහැදිලි නැත්නම් මෙතනින් බලන්න)

● a(i) - තමන්ගේම කාණ්ඩයේ අනෙක් දත්ත වලට ඇති සාමාන්‍ය දුර.
● b(i) - ලගම ඇති ඊලග කාණ්ඩයේ දත්ත වලට ඇති සාමාන්‍ය දුර.

මේකෙදි s(i) අගය +1 ට කිට්ටු නම් දත්තය නිවැරදි කාණ්ඩයේ සහ -1 නම් එය වැරදි කාණ්ඩයක තියෙනවා. 🧐✅

දත්ත මිලියන ගණනක් තියෙද්දී සාමාන්‍ය K-Means ගොඩක් ප්‍රමාදයි. මෙහිදී අපි මුළු දත්ත පද්ධතියම වෙනුවට කුඩා කොටස් (Mini-batches) ලෙස අරන් කේන්ද්‍රයන් යාවත්කාලීන කරනවා. මෙය O(n) වල සිට ඉතා අඩු සංකීර්ණතාවයකට ගෙන එනවා. ඊලග ආටිකල් එකෙන් (Article 19) අපි කතා කරන්නේ ඝනත්වය පදනම් කරගත්ව ඩාත් සංකීර්ණ DBSCAN algorithm එක ගැන. 🧠⏭️ 🙊😁

✍️ @TheInfinityAI