အကောင်းဆုံးအုပ်စုများကိုရှာရန် python ရှိ elbow method ကိုအသုံးပြုနည်း

machine learning တွင် အသုံးအများဆုံး အစုလိုက်အပြုံလိုက် အယ်လဂိုရီသမ်များထဲမှ တစ်ခုကို k-means အစုအဝေးပြုလုပ်ခြင်း ဟုခေါ်သည်။

K ဆိုသည်မှာ အစုအဝေးတစ်ခုစီကို K အစုအဝေးတစ်ခုသို့ ဒေတာအတွဲတစ်ခုမှ စူးစမ်းလေ့လာမှုတစ်ခုစီကို ထားရှိပေးသည့် နည်းလမ်းတစ်ခုဖြစ်သည်။

အဆုံးပန်းတိုင်မှာ အစုအဝေးတစ်ခုစီရှိ ရှုမြင်သုံးသပ်ချက်များသည် တစ်ခုနှင့်တစ်ခု အလွန်တူညီပြီး ကွဲပြားသောအစုအဝေးများတွင် လေ့လာမှုများသည် တစ်ခုနှင့်တစ်ခု အလွန်ကွာခြားသော်လည်း K အစုအဝေးများ ရှိရန်ဖြစ်သည်။

k-means အစုအဝေးပြုလုပ်သောအခါ၊ ပထမအဆင့်မှာ ကျွန်ုပ်တို့လေ့လာသုံးသပ်ချက်ထည့်လိုသောအစုအဝေးအရေအတွက် K အတွက်တန်ဖိုးကိုရွေးချယ်ရန်ဖြစ်သည်။

K အတွက် တန်ဖိုးတစ်ခုကို ရွေးချယ်ရန် အသုံးအများဆုံးနည်းလမ်းများထဲမှ တစ်ခုကို elbow method ဟုခေါ်သည် ၊ x-axis ပေါ်ရှိ အစုအစည်းများ၏ အရေအတွက်နှင့် y-ဝင်ရိုးပေါ်ရှိ စတုရန်းနှစ်ခုပေါင်း၏ စုစုပေါင်း ကွက်ကွက်ဖန်တီးခြင်း ပါဝင်သည့် elbow method ဟုခေါ်သည်၊ ထို့နောက် ခွဲခြားသတ်မှတ်ပါ။ “ဒူး” သို့မဟုတ် အလှည့်တစ်ခုသည် ကွက်ကွက်ထဲတွင် ပေါ်လာသည်။

“ဒူး” ဖြစ်ပေါ်လာသည့် x ဝင်ရိုးပေါ်ရှိ အမှတ်သည် k-ဆိုလိုသည် အစုလိုက်အပြုံလိုက် အယ်လဂိုရီသမ်တွင် အသုံးပြုရန် အကောင်းဆုံး အစုအဝေးအရေအတွက်ကို ပြောပြသည်။

အောက်ပါဥပမာသည် Python တွင်တံတောင်ဆစ်နည်းလမ်းကိုအသုံးပြုပုံကိုပြသထားသည်။

အဆင့် 1: လိုအပ်သော module များကိုတင်သွင်းပါ။

ဦးစွာ၊ ကျွန်ုပ်တို့သည် k-means အစုအဝေးပြုလုပ်ရန် လိုအပ်မည့် module အားလုံးကို တင်သွင်းပါမည်-

 import pandas as pd
import numpy as np
import matplotlib. pyplot as plt
from sklearn. cluster import KMeans
from sklearn. preprocessing import StandardScaler

အဆင့် 2: DataFrame ကိုဖန်တီးပါ။

ထို့နောက်၊ မတူညီသောဘတ်စကတ်ဘောကစားသမား 20 အတွက် variable သုံးခုပါ ၀ င်သော DataFrame တစ်ခုကိုဖန်တီးပါမည်။

 #createDataFrame
df = pd. DataFrame ({' points ': [18, np.nan, 19, 14, 14, 11, 20, 28, 30, 31,
                              35, 33, 29, 25, 25, 27, 29, 30, 19, 23],
                   ' assists ': [3, 3, 4, 5, 4, 7, 8, 7, 6, 9, 12, 14,
                               np.nan, 9, 4, 3, 4, 12, 15, 11],
                   ' rebounds ': [15, 14, 14, 10, 8, 14, 13, 9, 5, 4,
                                11, 6, 5, 5, 3, 8, 12, 7, 6, 5]})

#drop rows with NA values in any columns
df = df. dropna ()

#create scaled DataFrame where each variable has mean of 0 and standard dev of 1
scaled_df = StandardScaler(). fit_transform (df)

အဆင့် 3- အစုအဝေးများ၏ အကောင်းဆုံးအရေအတွက်ကိုရှာဖွေရန် တံတောင်နည်းလမ်းကို အသုံးပြုပါ။

ဤမက်ထရစ်သုံးခုအပေါ်အခြေခံ၍ အလားတူသရုပ်ဆောင်များကို အုပ်စုဖွဲ့ရန် k-Means ကို အသုံးပြုလိုသည်ဆိုကြပါစို့။

Python တွင် k-means အစုအဝေးကို လုပ်ဆောင်ရန်၊ ကျွန်ုပ်တို့သည် sklearn module မှ KMeans လုပ်ဆောင်ချက်ကို အသုံးပြုနိုင်သည်။

ဤလုပ်ဆောင်ချက်အတွက် အရေးအကြီးဆုံး အငြင်းအခုံမှာ n_clusters ဖြစ်သည်၊ ၎င်းသည် အစုအဝေးမည်မျှရှိသည်ကို သတ်မှတ်ပေးသည်။

အကောင်းဆုံးအစုအဝေးအရေအတွက်ကို ဆုံးဖြတ်ရန်၊ ကျွန်ုပ်တို့သည် မော်ဒယ်၏ SSE (နှစ်ထပ်ကိန်းအမှားများ) ကိုပြသမည့် ဂရပ်တစ်ခုကို ဖန်တီးပါမည်။

ထို့နောက် စတုရန်းများပေါင်းလဒ်သည် “ကွေးသည်” သို့မဟုတ် တည်ငြိမ်စပြုသည့် “ဒူး” ကို ရှာဖွေပါမည်။ ဤအချက်သည် အကောင်းဆုံးအစုအဝေးအရေအတွက်ကို ကိုယ်စားပြုသည်။

အောက်ဖော်ပြပါ ကုဒ်သည် x-axis နှင့် y-axis ပေါ်ရှိ အစုအစည်းများ၏ အရေအတွက်ကို ပြသသည့် ဤကွက်အမျိုးအစားကို ဖန်တီးနည်းကို ပြသသည်-

 #initialize kmeans parameters
kmeans_kwargs = {
" init ": " random ",
" n_init ": 10,
" random_state ": 1,
}

#create list to hold SSE values for each k
sse = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, ** kmeans_kwargs)
    kmeans. fit (scaled_df)
    sse. append (kmeans.inertia_)

#visualize results
plt. plot (range(1, 11), sse)
plt. xticks (range(1, 11))
plt. xlabel (" Number of Clusters ")
plt. ylabel (“ SSE ”)
plt. show () 

ဤဂရပ်တွင်၊ k = 3 ပြွတ် များတွင် အကွေးအကောက် သို့မဟုတ် “ ဒူး” ရှိနေသည်ကို တွေ့ရပါသည်။

ထို့ကြောင့်၊ နောက်တဆင့်တွင် ကျွန်ုပ်တို့၏ k-Means အစုလိုက်ပုံစံကို ကိုက်ညီသောအခါတွင် အစုအဖွဲ့ 3 ခုကို အသုံးပြုပါမည်။

အဆင့် 4- Optimal K ဖြင့် K-Means အစုအဝေးကို လုပ်ဆောင်ပါ။

အောက်ပါကုဒ်သည် k -3 အတွက် အကောင်းဆုံးတန်ဖိုးကို အသုံးပြု၍ ဒေတာအတွဲပေါ်တွင် k-ဆိုလိုရင်း အစုအဝေးကို မည်သို့လုပ်ဆောင်ရမည်ကို ပြသသည်-

 #instantiate the k-means class, using optimal number of clusters
kmeans = KMeans(init=" random ", n_clusters= 3 , n_init= 10 , random_state= 1 )

#fit k-means algorithm to data
kmeans. fit (scaled_df)

#view cluster assignments for each observation
kmeans. labels_

array([1, 1, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 2, 2, 2, 0, 0, 0]) 

ရလဒ်ဇယားသည် DataFrame ရှိ ကြည့်ရှုမှုတစ်ခုစီအတွက် အစုလိုက်တာဝန်များကို ပြသသည်။

ဤရလဒ်များကို အဓိပ္ပာယ်ဖွင့်ဆိုရန် ပိုမိုလွယ်ကူစေရန်၊ ကစားသမားတစ်ဦးစီ၏ အစုအဝေးတာဝန်ကို ပြသသည့် DataFrame တွင် ကော်လံတစ်ခုကို ထည့်နိုင်သည်-

 #append cluster assingments to original DataFrame
df[' cluster '] = kmeans. labels_

#view updated DataFrame
print (df)

points assists rebounds cluster
0 18.0 3.0 15 1
2 19.0 4.0 14 1
3 14.0 5.0 10 1
4 14.0 4.0 8 1
5 11.0 7.0 14 1
6 20.0 8.0 13 1
7 28.0 7.0 9 2
8 30.0 6.0 5 2
9 31.0 9.0 4 0
10 35.0 12.0 11 0
11 33.0 14.0 6 0
13 25.0 9.0 5 0
14 25.0 4.0 3 2
15 27.0 3.0 8 2
16 29.0 4.0 12 2
17 30.0 12.0 7 0
18 19.0 15.0 6 0
19 23.0 11.0 5 0

အစုအဝေး ကော်လံတွင် ကစားသမားတစ်ဦးစီမှ သတ်မှတ်ထားသော အစုနံပါတ် (0၊ 1 သို့မဟုတ် 2) ပါရှိသည်။

တူညီသော အစုအဝေးမှ ပိုင်ဆိုင်သည့် ကစားသမားများသည် အမှတ်များ ၊ ကူညီပေးခြင်း နှင့် ပြန်လှန်ခြင်း ကော်လံများအတွက် ခန့်မှန်းခြေတူညီသော တန်ဖိုးများရှိသည်။

မှတ်ချက် – sklearn ၏ KMeans လုပ်ဆောင်ချက်အတွက် စာရွက်စာတမ်းအပြည့်အစုံကို ဤနေရာတွင် ရှာနိုင်သည်။

ထပ်လောင်းအရင်းအမြစ်များ

အောက်ပါ သင်ခန်းစာများသည် Python တွင် အခြားသော အသုံးများသော အလုပ်များကို မည်သို့လုပ်ဆောင်ရမည်ကို ရှင်းပြသည်-

Python တွင် linear regression လုပ်နည်း
Python တွင် Logistic Regression ကို မည်သို့လုပ်ဆောင်မည်နည်း။
Python တွင် K-Fold အပြန်အလှန် validation လုပ်ဆောင်နည်း