04/05/2026
🎯2.K-Nearest Neighbors (KNN)
- Ebook Download Link ကို Comment မှာ ချထားပေးပါတယ်ဗျာ့။
-
Aritificial Intelligence , Machine Learning တို့ရဲ့ Core Concepts များကို လေ့လာ လိုသူများအတွက်
🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯🎯
-
KNN ၏ အခြေခံ သဘောတရား
K-Nearest Neighbors သည် Machine Learning တွင် အသုံးများသော supervised learning algorithm တစ်ခု ဖြစ်ပါတယ်။ ဤ Algorithm သည် classification နှင့် regression နှစ်မျိုးလုံးအတွက် အသုံးပြုနိုင်သည့် algorithm ဖြစ်ကြောင်း သိရှိရပါမည်။ KNN ၏ အခြေခံ အတွေးအခေါ်မှာ အလွန်ရိုးရှင်းသော်လည်း ထိရောက်မှု မြင့်မားသည့် နည်းလမ်းတစ်ခု ဖြစ်ပါတယ် အသစ်ဝင်လာသော data point တစ်ခုကို classify လုပ်ရာတွင် ထို point နှင့် အနီးဆုံး ရှိနေသော training data K အရေအတွက်ကို ရှာဖွေပြီး အများစုက ဘယ် class နှင့် သက်ဆိုင်သည်ကို ကြည့်ရှုခြင်း ဖြစ်ပါတယ်။ AI နဲ့ မရင်နှီးတဲ့ သူတွေ အတွက် အခုလို ဖော်ပြမှု ဟာ ရှုပ်နေဉီးမှာပါ သို့သော် နောက်ပိုင်းတွေမှာ Beginner များပင် နားလည် သဘောပေါက်အောင် အသေးစိတ် ဉပမာ များ တွက်ချက်မှု များနှင့် ဖော်ပြ ပေးသွား မှာပါ။
ဥပမာအားဖြင့် ကျောင်းသားတစ်ဦး၏ စာမေးပွဲရမှတ်နှင့် တက်ရောက်မှုကို အခြေခံ၍ အောင်မြင်မှု မအောင်မြင်မှုကို ခန့်မှန်းလိုသည် ဆိုပါစို့ အသစ်ဝင်လာသော ကျောင်းသားတစ်ဦး၏ အချက်အလက်ကို ရရှိသောအခါ အရင်က သိရှိပြီးသား ကျောင်းသားများ အထဲမှ အနီးဆုံး ကျောင်းသား K ယောက်ကို ရှာဖွေပါသည်။ အကယ်၍ K=5 ဟု သတ်မှတ်ထားပြီး အနီးဆုံး ကျောင်းသား ငါးယောက်အနက် လေးယောက်က အောင်မြင်သူများ ဖြစ်ကြလျှင် အသစ်ဝင်သော ကျောင်းသားသည် အောင်မြင်နိုင်သည်ဟု ခန့်မှန်းနိုင်ပါသည်။အရမ်း ရိုးရှင်းပါသည်။
အကွာအဝေး တွက်ချက်ခြင်း (Distance Metrics)
KNN algorithm တွင် အဓိက အရေးကြီးဆုံးသော အစိတ်အပိုင်းမှာ data points နှစ်ခုကြား အကွာအဝေးကို မည်သို့ တွက်ချက်သည်ကို သတ်မှတ်ရခြင်း ဖြစ်ပါတယ် အသုံးများသော distance metrics အမျိုးမျိုး ရှိပါတယ် ။
Euclidean Distance
Euclidean distance က အသုံးအများဆုံး distance metric ဖြစ်ပြီး နှစ်ဖက်မြင် သို့မဟုတ် သုံးဖက်မြင် နေရာတွင် အမှတ်နှစ်ခုကြား တိုက်ရိုက် အကွာအဝေးကို တိုင်းတာခြင်း ဖြစ်ပါတယ် သင်္ချာဖော်မြူလာကို ကြည့်ရလျှင် အမှတ် နှစ်ခု p = (p₁, p₂, ..., pₙ) နှင့် q = (q₁, q₂, ..., qₙ) ရှိသည် ဆိုပါစို့။ Euclidean distance ကို အောက်ပါ အတိုင်း တွက်ချက်နိုင်ပါတယ်
d(p,q) = √[(p₁-q₁)² + (p₂-q₂)² + ... + (pₙ-qₙ)²]
ဒါမှမဟုတ် summation notation နဲ့ ရေးရင်
d(p,q) = √[Σᵢ₌₁ⁿ (pᵢ-qᵢ)²]
တကယ့် ဥပမာ တစ်ခုနဲ့ လေ့လာကြည့်ရအောင်။ အမှတ် A = (2, 3) နှင့် အမှတ် B = (5, 7) တို့ကြား အကွာအဝေးကို တွက်ချက်ရမည်။
ပထမဦးဆုံး x-coordinate ကွာခြားချက်ကို ရှာရမည် = 5 - 2 = 3 နောက်တစ်ခု y-coordinate ကွာခြားချက်ကို ရှာရမည် = 7 - 3 = 4
အဲဒီ ကွာခြားချက် နှစ်ခုစလုံးကို နှစ်ထပ်ကိန်း ချပါမည် 3² = 9, 4² = 16
ထို နှစ်ထပ်ကိန်းတွေကို ပေါင်းလိုက်ရင် = 9 + 16 = 25
နောက်ဆုံး square root ယူရမည် = √25 = 5
ထို့ကြောင့် အမှတ် A နှင့် B တို့ကြား Euclidean distance သည် 5 units ဖြစ်ပါသည်။
သုံးဖက်မြင် space တွင်လည်း အလားတူ တွက်ချက်နိုင်ပါသည်။ အမှတ် P = (1, 2, 3) နှင့် Q = (4, 6, 8) ရှိသည် ဆိုပါစို့။
x ကွာခြားချက် = 4 - 1 = 3, နှစ်ထပ်ကိန်း = 9 y ကွာခြားချက် = 6 - 2 = 4, နှစ်ထပ်ကိန်း = 16 z ကွာခြားချက် = 8 - 3 = 5, နှစ်ထပ်ကိန်း = 25
ပေါင်းလိုက်ရင် = 9 + 16 + 25 = 50 √50 = 7.071 units (အနီးစပ်ဆုံး)
1.Euclidean_Distance Example Program Python Source Code လေး ဖြစ်ပါတယ်။ Python Programming အခြေခံပိုင်းကိုတော့ နားလည်ထားဖို့ လိုပါတယ်။
Manhattan Distance
Manhattan distance သည် တက္ကစီမောင်းသူတစ်ဦးက မြို့လမ်းကွက်များဖြတ်၍ သွားရသကဲ့သို့ အကွာအဝေးကို တွက်ချက်သည့် နည်းလမ်း ဖြစ်ပါတယ်။ ဤနည်းလမ်းမှာ ထောင့်မတ် သို့မဟုတ် အလျားလိုက် လမ်းကြောင်းများကိုသာ လိုက်နိုင်ပြီး ထောင့်ဖြတ် မသွားနိုင်ပါ။
Manhattan distance formula
d(p,q) = |p₁-q₁| + |p₂-q₂| + ... + |pₙ-qₙ| = Σᵢ₌₁ⁿ |pᵢ-qᵢ|
အမှတ် A = (2, 3) နှင့် B = (5, 7) အတွက် Manhattan distance ကို တွက်ကြည့်ရအောင်။
x ကွာခြားချက် = |5 - 2| = 3 y ကွာခြားချက် = |7 - 3| = 4 Manhattan distance = 3 + 4 = 7 units
Euclidean distance က 5 units ဖြစ်ခဲ့သော်လည်း Manhattan distance က 7 units ဖြစ်နေသည်ကို တွေ့ရမည်။ Manhattan distance သည် အမြဲတမ်း Euclidean distance ထက် ကြီးမည် သို့မဟုတ် ညီမျှမည် ဖြစ်ကြောင်း သတိပြုရပါမည်။
2.Manhattan_Distance Example Program လေး ဖြစ်ပါတယ်။
Minkowski Distance
Minkowski distance သည် Euclidean နှင့် Manhattan distance များကို ယေဘုယျ ဖော်ပြထားသော ဖော်မြူလာ ဖြစ်သည်။
d(p,q) = [Σᵢ₌₁ⁿ |pᵢ-qᵢ|ᵖ]^(1/p)
ဤနေရာတွင် p သည် parameter တစ်ခု ဖြစ်ပါသည်။ p = 1 ဆိုလျှင် Manhattan distance ရမည် p = 2 ဆိုလျှင် Euclidean distance ရမည် p = ∞ ဆိုလျှင် Chebyshev distance ရမည်
အမှတ် A = (1, 2) နှင့် B = (4, 6) အတွက် p = 3 ဖြင့် Minkowski distance ကို တွက်ကြည့်ရအောင်။
|4-1|³ + |6-2|³ = 3³ + 4³ = 27 + 64 = 91 d(A,B) = 91^(1/3) = 4.498 units (အနီးစပ်ဆုံး)
Cosine Similarity
အချို့ သောအခြေအနေများတွင် vector များကြား ထောင့်ကို တိုင်းတာခြင်းက ပိုမိုသင့်တော်သည်။ Cosine similarity သည် vector နှစ်ခုကြား ထောင့်ကို တိုင်းတာပြီး -1 မှ 1 အတွင်း တန်ဖိုးရနိုင်သည်။
cos(θ) = (p·q) / (||p|| × ||q||)
ဤနေရာတွင် p·q သည် dot product ဖြစ်ပြီး ||p|| နှင့် ||q|| တို့သည် vector magnitude များ ဖြစ်ကြသည်။
Vector A = (3, 4) နှင့် B = (6, 8) အတွက် တွက်ကြည့်ရအောင်။
Dot product: A·B = (3×6) + (4×8) = 18 + 32 = 50
Magnitude of A: ||A|| = √(3² + 4²) = √(9 + 16) = √25 = 5 Magnitude of B: ||B|| = √(6² + 8²) = √(36 + 64) = √100 = 10
cos(θ) = 50 / (5 × 10) = 50/50 = 1
ဒါကြောင့် vector နှစ်ခုသည် လုံးဝ တူညီသော ဦးတည်ချက်ရှိကြောင်း သိနိုင်ပါသည်။
3.Minkowski_Distance Example Program ဖြစ်ပါတယ်။
K တန်ဖိုး ရွေးချယ်ခြင်း
KNN algorithm တွင် K တန်ဖိုးကို မည်သို့ ရွေးချယ်မည်ကို သိရှိရန် အလွန် အရေးကြီးပါသည်။ K ၏ တန်ဖိုးသည် model ၏ စွမ်းဆောင်ရည်ကို သိသိသာသာ သက်ရောက်စေနိုင်ပါသည်။ K သည် ငယ်လွန်းလျှင် (ဥပမာ K=1) model သည် noise များကို လွန်စွာ အာရုံစိုက်ပြီး overfitting ဖြစ်နိုင်ခြေ များပါသည်။ တစ်ဖက်တွင် K သည် ကြီးလွန်းလျှင် underfitting ဖြစ်နိုင်ပြီး decision boundary များသည် လွန်စွာ ချောမွေ့သွားနိုင်ပါသည်။
K တန်ဖိုး ရွေးချယ်ရာတွင် အသုံးများသော နည်းလမ်းများမှာ Cross-validation နည်းလမ်း ဖြစ်ပါသည် မတူညီသော K တန်ဖိုးများကို စမ်းသပ်ပြီး accuracy အမြင့်ဆုံး ရရှိသည့် K ကို ရွေးချယ်ခြင်း ဖြစ်သည်။ ပုံမှန်အားဖြင့် K သည် မ မြောက်သော ကိန်း ဖြစ်သင့်ပါသည်။ အထူးသဖြင့် binary classification ပြဿနာများတွင် တူညီသော မဲရခြင်း ကို ရှောင်ရှားနိုင်ရန် ဖြစ်သည်။ ဥပမာ K=4 ဆိုလျှင် class နှစ်ခုမှ အမှတ် နှစ်ခုစီ ရနိုင်ပြီး ဆုံးဖြတ်ရန် ခက်ခဲနိုင်ပါသည်။
လက်တွေ့ ဥပမာတစ်ခု ကြည့်ရအောင်။ training data မှာ အမှတ် ၁၀၀ ခု ရှိသည် ဆိုပါစို့။ အသစ်ဝင်လာသော test point တစ်ခုအတွက် classification လုပ်ရမည်။ K=1 ဆိုလျှင် အနီးဆုံး အမှတ် တစ်ခုတည်းကို ကြည့်မည်။ အဲဒီ အမှတ်က class A ဆိုရင် test point ကိုလည်း class A လို့ သတ်မှတ်မည်။ ဒါပေမယ့် အဲဒီ အမှတ်က noise ဖြစ်နေလျှင် မှားယွင်းသွားနိုင်ပါသည်။
K=5 ဆိုလျှင် အနီးဆုံး အမှတ် ငါးခုကို ကြည့်မည်။ ငါးခုအနက် သုံးခုက class A၊ နှစ်ခုက class B ဆိုရင် test point သည် class A လို့ သတ်မှတ်မည်။ ဒါက ပိုမို ယုံကြည်စိတ်ချရသော ဆုံးဖြတ်ချက် ဖြစ်ပါသည် K=50 ဆိုလျှင် အမှတ် ၅၀ ခုကို ကြည့်ရမည်။ ဒါက ကောင်းတာလား ဆိုးတာလား ဆိုတာ data distribution ပေါ် မူတည်ပါတယ် Class များ ရောနှောနေလျှင် decision boundary များက ချောမွေ့သွားနိုင်ပါသည်။
သင်္ချာအရ ကြည့်လျှင် K သည် အောက်ပါ ဆက်နွယ်မှုကို လိုက်နာသင့်ပါသည်။
K ≈ √N
ဤနေရာတွင် N သည် training samples အရေအတွက် ဖြစ်ပါသည်။ ဒါပေမယ့် ဒါက အကြမ်းဖျဉ်း ဖော်ပြချက် တစ်ခုသာ ဖြစ်ပြီး လက်တွေ့တွင် cross-validation နဲ့ စမ်းသပ်ရန် အကောင်းဆုံး ဖြစ်ပါသည်။
K တန်ဘိုး ရှာခြင်းသည် အရမ်း အရေးကြီးသည့် အတွက် အသေးစိတ် တွက်ချက်နည်းကို ဖော်ပြပေးသွားပါမည်။
Training Data အနေနဲ့ ကျွန်တော်တို့မှာ အမှတ် ၆ ခု ရှိတယ်လို့ သတ်မှတ်ပါမယ်။ အထက်က ပုံထဲမှာလည်း ကြည့်နိုင်ပါတယ်။ Point စုစုပေါင်း ၆ ခု ရှိပါတယ်။ အလယ်က အဝါရောင်ကတော့ Test လုပ်ဖို့ပါ သူ့ကို ထည့်မတွက်ပါနဲ့။
Class A (အနီ)-
Point 1: (1, 1)
Point 2: (2, 2)
Point 3: (3, 3)
Class B (အပြာ)-
Point 4: (6, 6)
Point 5: (7, 7)
Point 6: (8, 8)
ပထမဉီးမှာ ယခု အမှတ် ၆ ခုကို ပုံထဲမှာ မြင်အောင် ကြည့်ထားပေးပြီး Class A, B တို့ကိုလည်း ခွဲထားထားပါ။ Test Point (ခန့်မှန်းချင်တဲ့ အမှတ်သစ်) က Test Point: (4, 4) ဒီ အမှတ်က Class A လား Class B လား သိချင်တာဖြစ်ပါတယ်။
အဆင့် ၁ - အကွာအဝေး တွက်ချက်ခြင်း
Test point (4,4) ကနေ training point တိုင်းအထိ အကွာအဝေး တွက်မယ်။ အဲ့တော့ ၆ ခုစာ တွက်ပေးရမှာ ဖြစ်ပါတယ်။ ထိုသို့တွက်ရာတွင် Euclidean Distance Formula ကိုသုံးပါမည်။
d = √[(x₂-x₁)² + (y₂-y₁)²]
Point 1: (1,1) အတွက်
x ကွာခြားချက် = 4 - 1 = 3
y ကွာခြားချက် = 4 - 1 = 3
ယခု နေရာမှာ သတိပြုရမှာက Test point သည် 4,4 ဖြစ်သည့်အတွက် x2, y2 တန်ဘိုး ယူလိုက်ခြင်း ဖြစ်ပါတယ်။
(x ကွာခြားချက်)² = 3² = 9
(y ကွာခြားချက်)² = 3² = 9
ပေါင်း = 9 + 9 = 18
d₁ = √18 = 4.24 ( ပထမဆုံး တွက်လို့ ရတဲ့ Point ရဲ့ တန်ဘိုးပါ နောက် point တွေကိုလည်း ယခု နည်းအတိုင်းပဲ ဆက်တွက်ရမှာ ဖြစ်ပါတယ်။ )
Point 2: (2,2) အတွက်
x ကွာခြားချက် = 4 - 2 = 2
y ကွာခြားချက် = 4 - 2 = 2
(x ကွာခြားချက်)² = 2² = 4
(y ကွာခြားချက်)² = 2² = 4
ပေါင်း = 4 + 4 = 8
d₂ = √8 = 2.83
Point 3: (3,3) အထိ
x ကွာခြားချက် = 4 - 3 = 1
y ကွာခြားချက် = 4 - 3 = 1
(x ကွာခြားချက်)² = 1² = 1
(y ကွာခြားချက်)² = 1² = 1
ပေါင်း = 1 + 1 = 2
d₃ = √2 = 1.41 ← အနီးဆုံး!
Point 4: (6,6) အထိ
x ကွာခြားချက် = 6 - 4 = 2
y ကွာခြားချက် = 6 - 4 = 2
(x ကွာခြားချက်)² = 2² = 4
(y ကွာခြားချက်)² = 2² = 4
ပေါင်း = 4 + 4 = 8
d₄ = √8 = 2.83
Point 5: (7,7) အထိ
x ကွာခြားချက် = 7 - 4 = 3
y ကွာခြားချက် = 7 - 4 = 3
(x ကွာခြားချက်)² = 3² = 9
(y ကွာခြားချက်)² = 3² = 9
ပေါင်း = 9 + 9 = 18
d₅ = √18 = 4.24
Point 6: (8,8) အထိ
x ကွာခြားချက် = 8 - 4 = 4
y ကွာခြားချက် = 8 - 4 = 4
(x ကွာခြားချက်)² = 4² = 16
(y ကွာခြားချက်)² = 4² = 16
ပေါင်း = 16 + 16 = 32
d₆ = √32 = 5.66
အဆင့် ၂ - အနေနဲ့ အနီးဆုံး K ခု ရွေးချယ်မှာ ဖြစ်ပါတယ်။ အကွာအဝေးများကို အငယ်ဆုံးကနေ စီ သွားပါမယ်။
အစဉ်
Point
Distance
Class
1
Point 3 (3,3)
1.41
A
2
Point 2 (2,2)
2.83
A
3
Point 4 (6,6)
2.83
B
4
Point 1 (1,1)
4.24
A
5
Point 5 (7,7)
4.24
B
6
Point 6 (8,8)
5.66
B
အဆင့် ၃ - Voting က မဲပေးတာ ဖြစ်ပါတယ် ပုံထဲကို ပြန်ကြည့်ပါ အနီးဆုံး တစ်ခုကို စရွေးတာ ဖြစ်ပါတယ် အဲ့အတွက် K=1 လို့ သတ်မှတ်ပြီး
Case 1: K = 1
အနီးဆုံး ၁ ခု ပဲ ကြည့်မယ်:
Point 3 (3,3) → Class A (ဘာလို့ Class A လို့ သတ်မှတ်တာလဲ ဆိုတော့ သူက အနီရောင်တွေ ရှိတဲ့ class A ထဲမှာ ပါတာမို့ပါ )
ရလဒ်: Class A ✓
Case 2: K = 3 ( K တန်ဘိုး က ၃ ဖြစ်သည့် အတွက် 4.4 နဲ့ အနီးဆုံး ၃ ခုကို ကြည့်မှာ ဖြစ်ပါတယ် )
အနီးဆုံး ၃ ခု ကြည့်မယ်:
1. Point 3 (3,3) → Class A
2. Point 2 (2,2) → Class A
3. Point 4 (6,6) → Class B
Voting ပေးရာမှာ Class A က နှစ်ခု ဖြစ်ပြီး Class B က တစ်ခုတည်း ဖြစ်တဲ့အတွက် မဲ Class A ကပဲ နိုင်သွားပါတယ်။
Class A: 2 votes ✓
Class B: 1 vote
Case 3: K = 5
အနီးဆုံး ၅ ခု ကြည့်မယ်:
1. Point 3 (3,3) → Class A
2. Point 2 (2,2) → Class A
3. Point 4 (6,6) → Class B
4. Point 1 (1,1) → Class A
5. Point 5 (7,7) → Class B
Voting ပေးရာတွင် Class A သည် အထက်ပါ ပုံအတိုင်းအများစု ဖြစ်တဲ့တွက် မဲကတော့ Class A ပဲ နိုင်သွားပါတယ်။
Class A: 3 votes ✓
Class B: 2 votes
ယခု ဆက်လက်ပြီး K တန်ဖိုး ရွေးချယ်ခြင်းကို ဆက်သွားပါမယ်
Formula:
K ≈ √N
ယခု နေရာတွင် N = training samples အရေအတွက်
ကျွန်တော်တို့ရဲ့ ဥပမာမှာ point ၆ ခု ထားခဲ့တဲ့အတွက်
N = 6
K ≈ √6 = 2.45 ≈ 2 or 3
အကြံပြုချက်အရ K သည် မမြောက်သော ကိန်း ဖြစ်သင့်ပါတယ် (1, 3, 5, 7...) အကြောင်းရင်း ကတော့ Class နှစ်ခုရှိရင် K=4 သုံးမယ် ဆိုရင် 2-2 တူနိုင်ပါတယ်။ ဒါဆို ဘယ် class ရွေးမလဲ ဆုံးဖြတ်ဖို့ ခက်သွားမှာ ဖြစ်ပါတယ်။ ထို့ကြောင့် Test Point (4,4) သည် Class A ဖြစ်တယ် ဆိုပြီး ခန့်မှန်းလိုက်ပါတယ်။ ဘာကြောင့်လည်းဆိုတော့ Point (4,4) က Point 3 (3,3) နဲ့ အနီးဆုံး ဖြစ်တယ် (distance = 1.41) အနီးဆုံး အမှတ် ၃ ခု (K=3) ကြည့်ရင် Class A က ၂ ခု၊ Class B က ၁ ခု ပါတယ်ဒါကြောင့် အများစု voting အရ Class A လို့ သတ်မှတ်ခြင်း ဖြစ်ပါတယ်။
4.Finding_K K တန်ဘိုးရှာတာရဲ့ Example Program လေး ဖြစ်ပါတယ်။ အောက်မှာ အသေးစိတ် ရှင်းပြ ပေးထားပါတယ်။
import numpy as np
from collections import Counter
ဒီနေရာမှာ library နှစ်ခု ခေါ်သုံးတယ်။ numpy က array တွေ၊ တွက်ချက်မှုတွေ အတွက်ပါ။ Counter က list ထဲမှာ ဘယ် element က ဘယ်နှစ်ခါ ပေါ်လဲဆိုတာ ရေတွက်ဖို့ သုံးတယ်။
def knn_predict(train_X, train_y, test_point, k):
Function တစ်ခု လုပ်ပါတယ်။ train_X က training data တွေရဲ့ coordinates များ၊ train_y က သူတို့ရဲ့ class များ၊ test_point က ခန့်မှန်းချင်တဲ့ အမှတ်၊ k က အနီးဆုံး ဘယ်နှစ်ခု ကြည့်မလဲဆိုတာပါ။
distances = [np.linalg.norm(np.array(train_X[i]) - np.array(test_point))
for i in range(len(train_X))]
ယခု line က အရေးကြီးပါတယ်။ training data အမှတ်တိုင်းနဲ့ test point ကြား အကွာအဝေး တွက်ပါတယ်။ np.linalg.norm က Euclidean distance တွက်ပေးတဲ့ function ပါ။ Loop လုပ်ပြီး distance အားလုံးကို list တစ်ခုအဖြစ် သိမ်းတယ်။
nearest_indices = np.argsort(distances)[:k]
argsort က distance တွေကို အငယ်ဆုံးကနေ စီပြီး index တွေ ပြန်ပေးတယ်။ [:k] ဆိုတာက အရှေ့ဆုံး k ခုပဲ ယူမယ်ဆိုတာပါ။ ဥပမာ k=3 ဆိုရင် အနီးဆုံး သုံးခုရဲ့ index တွေ ရမယ်။
nearest_labels = [train_y[i] for i in nearest_indices]
အနီးဆုံး အမှတ်တွေရဲ့ index သိပြီးတော့ သူတို့ရဲ့ class label တွေကို ယူတယ်။ ဥပမာ index [0,1,4] ရရင် အဲဒီ ရဲ့ label တွေဖြစ်တဲ့ ['A','A','B'] ကို ရမယ်။
prediction = Counter(nearest_labels).most_common(1)[0][0]
Counter က label တစ်ခုချင်းစီ ဘယ်နှစ်ခါ ပေါ်သလဲ ရေတွက်တယ်။ most_common(1) က အများဆုံး ပေါ်တဲ့ label ကို ပေးတယ်။ [0][0] က result ကနေ label ကိုပဲ ထုတ်ယူတာပါ။
print(f"K={k}: Nearest={nearest_labels} → Predict: {prediction}")
return prediction
ရလဒ်ကို ပြပါတယ်။ k တန်ဖိုး၊ အနီးဆုံး အမှတ်တွေရဲ့ class များနဲ့ နောက်ဆုံး ခန့်မှန်းတဲ့ class ကို ပြပြီး return လုပ်ပါတယ်။
train_X = [[1,1], [2,2], [3,3], [6,6], [7,7], [8,8]]
train_y = ['A', 'A', 'A', 'B', 'B', 'B']
Training data ပြင်ဆင်ပါတယ်။ အမှတ် ခြောက်ခု ရှိတယ်။ ပထမ သုံးခုက class A၊ နောက် သုံးခုက class B ပါ။
print("Training Data:")
for i in range(len(train_X)):
print(f" {train_X[i]} → Class {train_y[i]}")
Training data တွေကို ဖော်ပြပါတယ်။ Loop နဲ့ အမှတ်တစ်ခုချင်းစီနဲ့ သူ့ရဲ့ class ကို ပြပါတယ်။
test_point = [4, 4]
print(f"\nTest Point: {test_point}")
ခန့်မှန်းချင်တဲ့ အမှတ်သစ် သတ်မှတ်တယ်။ [4,4] ဆိုတဲ့ အမှတ်က class A နဲ့ B တို့ကြား အလယ်မှာ ရှိတယ်။
knn_predict(train_X, train_y, test_point, k=1)
knn_predict(train_X, train_y, test_point, k=3)
knn_predict(train_X, train_y, test_point, k=5)
k တန်ဖိုး မတူညီတဲ့ သုံးမျိုးနဲ့ စမ်းကြည့်ပါတယ်။ k=1 ဆိုရင် အနီးဆုံး တစ်ခုပဲ ကြည့်မယ်။ k=3 ဆိုရင် သုံးခု၊ k=5 ဆိုရင် ငါးခု ကြည့်မယ်။ ဒီလို စမ်းကြည့်မှ k ဘယ်လောက် သင့်လဲ သိနိုင်မှာ ဖြစ်ပါတယ်။
print(f"\nRecommended K ≈ √{len(train_X)} ≈ {int(np.sqrt(len(train_X)))}")
နောက်ဆုံး သင်္ချာ formula အရ အကြံပြုတဲ့ k တန်ဖိုး တွက်ပြတယ်။ training samples အရေအတွက်ရဲ့ square root ပါ။ ဒီ example မှာ data ခြောက်ခု ရှိတော့ √6 ≈ 2 လို့ ရပါမည်။ ယခုလောက်ဆိုရင်တော့ K တန်ဘိုး ရှာခြင်းကိုအသေးစိတ် နားလည်သွားလိမ့်မယ်လို့ မျှော်လင့်ပါတယ်။
Weighted KNN (အလေးပေး KNN)
ရိုးရှင်းသော KNN တွင် အနီးဆုံး အမှတ် K ခုစလုံးကို တူညီစွာ အလေးထား သတ်မှတ်ကြသည်။ သို့သော် Weighted KNN တွင် အကွာအဝေး အလိုက် အလေးပေးချက် ကွဲပြားစေပါသည်။
အလေးပေးချက်ကို တွက်ချက်သည့် အသုံးများသော နည်းလမ်းမှာ အကွာအဝေး၏ ပြောင်းပြန် (inverse) ကို အသုံးပြုခြင်း ဖြစ်သည်။
w_i = 1 / d_i
ဤနေရာတွင် w_i သည် i-th neighbor ၏ အလေးပေးချက် ဖြစ်ပြီး d_i သည် အကွာအဝေး ဖြစ်ပါသည်။
တကယ့် ဥပမာ ကြည့်ရအောင်။ test point X ရှိပြီး K=3 ဖြစ်သည် ဆိုပါစို့။ အနီးဆုံး သုံးခု၏ အကွာအဝေးနှင့် class များမှာ
Point 1: distance = 2, class = A Point 2: distance = 3, class = B Point 3: distance = 5, class = A
အလေးပေးချက်များကို တွက်ရမည်
w₁ = 1/2 = 0.5 w₂ = 1/3 = 0.333 w₃ = 1/5 = 0.2
Class A အတွက် စုစုပေါင်း အလေးပေးချက် = 0.5 + 0.2 = 0.7 Class B အတွက် စုစုပေါင်း အလေးပေးချက် = 0.333
Class A က ပိုမိုများပြားသော အလေးပေးချက်ရှိသောကြောင့် test point X သည် class A လို့ သတ်မှတ်မည်။
တခြား အလေးပေးချက် နည်းလမ်းတစ်ခုမှာ Gaussian kernel ကို အသုံးပြုခြင်း ဖြစ်သည်။
w_i = exp(-d_i² / 2σ²)
ဤနေရာတွင် σ သည် bandwidth parameter ဖြစ်ပါသည်။
σ = 2 ဖြင့် အထက်ပါ ဥပမာကို ပြန်တွက်ကြည့်ရအောင်။
w₁ = exp(-2²/(2×2²)) = exp(-4/8) = exp(-0.5) = 0.606 w₂ = exp(-3²/(2×2²)) = exp(-9/8) = exp(-1.125) = 0.325 w₃ = exp(-5²/(2×2²)) = exp(-25/8) = exp(-3.125) = 0.044
Class A အတွက် = 0.606 + 0.044 = 0.65 Class B အတွက် = 0.325
ဤနေရာတွင်လည်း Class A က ပိုမို အလေးချိန် များပြီး classification ရလဒ် အတူတူ ဖြစ်ပါသည်။
KNN Classification လုပ်ငန်းစဉ်
KNN ကို အသုံးပြု၍ classification လုပ်သည့် လုပ်ငန်းစဉ် အပြည့်အစုံကို အဆင့်ဆင့် ကြည့်ရအောင်။
Training data set တစ်ခု ရှိသည် ဆိုပါစို့။ အမှတ် ၁၀ ခု ရှိပြီး feature နှစ်ခု (x, y coordinates) နှင့် class label ရှိကြသည်။
Class A ရှိ points: A1 = (1, 2) A2 = (2, 3) A3 = (3, 1) A4 = (2, 1)
Class B ရှိ points: B1 = (6, 5) B2 = (7, 7) B3 = (8, 6) B4 = (7, 5)
Class C ရှိ points: C1 = (4, 8) C2 = (5, 9)
အသစ် ဝင်လာသော test point X = (5, 4) ကို classify လုပ်ရမည်။ K=3 သုံးမည်။
ပထမဦးဆုံး X မှ training points အားလုံးသို့ Euclidean distance တွက်ရမည်။
d(X, A1) = √[(5-1)² + (4-2)²] = √(16 + 4) = √20 = 4.472 d(X, A2) = √[(5-2)² + (4-3)²] = √(9 + 1) = √10 = 3.162 d(X, A3) = √[(5-3)² + (4-1)²] = √(4 + 9) = √13 = 3.606 d(X, A4) = √[(5-2)² + (4-1)²] = √(9 + 9) = √18 = 4.243
d(X, B1) = √[(5-6)² + (4-5)²] = √(1 + 1) = √2 = 1.414 d(X, B2) = √[(5-7)² + (4-7)²] = √(4 + 9) = √13 = 3.606 d(X, B3) = √[(5-8)² + (4-6)²] = √(9 + 4) = √13 = 3.606 d(X, B4) = √[(5-7)² + (4-5)²] = √(4 + 1) = √5 = 2.236
d(X, C1) = √[(5-4)² + (4-8)²] = √(1 + 16) = √17 = 4.123 d(X, C2) = √[(5-5)² + (4-9)²] = √(0 + 25) = √25 = 5.000
အကွာအဝေး အားလုံးကို စီစဉ်လိုက်ရင်
B1: 1.414 (Class B) B4: 2.236 (Class B) A2: 3.162 (Class A) A3: 3.606 (Class A) B2: 3.606 (Class B) B3: 3.606 (Class B) C1: 4.123 (Class C) A4: 4.243 (Class A) A1: 4.472 (Class A) C2: 5.000 (Class C)
K=3 ဖြစ်သောကြောင့် အနီးဆုံး သုံးခုကို ယူမည်
B1 (Class B)
B4 (Class B)
A2 (Class A)
အနီးဆုံး သုံးခုထဲမှ နှစ်ခုက Class B ဖြစ်ကြောင့် test point X သည် Class B လို့ သတ်မှတ်မည်။
Weighted voting သုံးလျှင် အောက်ပါ အတိုင်း တွက်နိုင်သည်။
Class B အတွက်: w(B1) + w(B4) = 1/1.414 + 1/2.236 = 0.707 + 0.447 = 1.154 Class A အတွက်: w(A2) = 1/3.162 = 0.316
Class B က အလေးချိန် ပိုများသောကြောင့် classification ရလဒ် မပြောင်းပါ။
KNN Regression
KNN သည် classification အတွက်သာမက regression အတွက်လည်း အသုံးပြုနိုင်ပါသည်။ Classification တွင် class label တစ်ခု ရွေးခြင်း ဖြစ်ပြီး regression တွင် continuous value တစ်ခု ခန့်မှန်းခြင်း ဖြစ်ပါသည်။
KNN regression တွင် အနီးဆုံး K neighbors များ၏ target values များကို average လုပ်၍ ရလဒ် ထုတ်ပါသည်။
y_pred = (1/K) × Σᵢ₌₁ᴷ yᵢ
Weighted regression အတွက်ဆိုရင်
y_pred = Σᵢ₌₁ᴷ (wᵢ × yᵢ) / Σᵢ₌₁ᴷ wᵢ
ကိန်းဂဏန်း ဥပမာတစ်ခု ကြည့်ရအောင်။ အိမ်တစ်လုံး၏ နေရာ (ကီလိုမီတာဖြင့် မြို့လယ်မှ အကွာအဝေး) အပေါ် အခြေခံ၍ အိမ်ဈေး ခန့်မှန်းရမည် ဆိုပါစို့။
Training data: အိမ် 1: အကွာအဝေး = 2 km, ဈေး = 300 သိန်း အိမ် 2: အကွာအဝေး = 3 km, ဈေး = 250 သိန်း
အိမ်3: အကွာအဝေး = 5 km, ဈေး = 200 သိန်း အိမ် 4: အကွာအဝေး = 7 km, ဈေး = 150 သိန်း အိမ် 5: အကွာအဝေး = 8 km, ဈေး = 120 သိန်း
အသစ် အိမ်တစ်လုံး၏ အကွာအဝေး = 4 km ဆိုလျှင် ဈေးကို ခန့်မှန်းရမည်။ K=3 သုံးမည်။
အကွာအဝေးများ တွက်ရမည် (one-dimensional ဖြစ်သောကြောင့် absolute difference သာ ယူရမည်)
|4 - 2| = 2 |4 - 3| = 1 |4 - 5| = 1 |4 - 7| = 3 |4 - 8| = 4
အနီးဆုံး သုံးခုမှာ အိမ် 2, အိမ် 3, နှင့် အိမ် 1 ဖြစ်ကြသည်။
Simple average: y_pred = (250 + 200 + 300) / 3 = 750/3 = 250 သိန်း
Weighted average ဆိုလျှင်
w₁ = 1/2 = 0.5 (အိမ် 1) w₂ = 1/1 = 1.0 (အိမ် 2) w₃ = 1/1 = 1.0 (အိမ် 3)
y_pred = (0.5×300 + 1.0×250 + 1.0×200) / (0.5 + 1.0 + 1.0) = (150 + 250 + 200) / 2.5 = 600 / 2.5 = 240 သိန်း
Weighted version က နည်းနည်း ကွာခြားသော ရလဒ် ပေးပါသည်။
ယခု ဆိုရင် KNN Algorithm အကြောင်းကို အကျဉ်းသိပြီဟု ယူဆပါသည် ဆက်လက်ပြီး KNN အကြောင်းကို လက်တွေ့ အသုံးပြုပုံနှင့် Real World Projects များ အကြောင်း အသေးစိတ် ဆက်လက် ဖော်ပြ ပေးပါဉီးမည်။
