اسکیٹ لرن کے ساتھ کے-مینز کلسٹرنگ کے لیے حتمی گائیڈ

تعارف

K- کا مطلب ہے کلسٹرنگ سب سے زیادہ استعمال کیے جانے والے غیر نگرانی شدہ مشین لرننگ الگورتھم میں سے ایک ہے جو ڈیٹا کی مثالوں کے درمیان مماثلت کی بنیاد پر ڈیٹا کے کلسٹر بناتا ہے۔

اس گائیڈ میں، ہم سب سے پہلے ایک سادہ مثال پر ایک نظر ڈالیں گے تاکہ یہ سمجھنے کے لیے کہ K-Means الگورتھم کیسے کام کرتا ہے اس کو Scikit-Learn کا استعمال کرتے ہوئے لاگو کرنے سے پہلے۔ اس کے بعد، ہم K-Means میں کلسٹرز (Ks) کی تعداد کا تعین کرنے کے طریقے پر تبادلہ خیال کریں گے، اور فاصلاتی میٹرکس، تغیر، اور K-Means کے فوائد اور نقصانات کا بھی احاطہ کریں گے۔

پریرتا

مندرجہ ذیل صورتحال کا تصور کریں۔ ایک دن، جب آپ محلے میں گھوم رہے تھے، آپ نے دیکھا کہ وہاں 10 سہولت والے اسٹورز ہیں اور آپ نے سوچنا شروع کیا کہ کون سے اسٹور ایک جیسے ہیں – قربت میں ایک دوسرے کے قریب۔ اس سوال کا جواب دینے کے طریقے تلاش کرتے ہوئے، آپ کو ایک دلچسپ نقطہ نظر ملا ہے جو اسٹورز کو نقشے پر ان کے نقاط کی بنیاد پر گروپس میں تقسیم کرتا ہے۔

مثال کے طور پر، اگر ایک اسٹور 5 کلومیٹر مغرب اور 3 کلومیٹر شمال میں واقع تھا - تو آپ تفویض کریں گے۔ (5, 3) کوآرڈینیٹ کرتا ہے، اور گراف میں اس کی نمائندگی کرتا ہے۔ آئیے اس پہلے نقطہ کو تصور کریں کہ کیا ہو رہا ہے:

import matplotlib.pyplot as plt

plt.title("Store With Coordinates (5, 3)")
plt.scatter(x=5, y=3)

یہ صرف پہلا نکتہ ہے، اس لیے ہمیں اندازہ ہو سکتا ہے کہ ہم اسٹور کی نمائندگی کیسے کر سکتے ہیں۔ کہتے ہیں کہ ہمارے پاس پہلے سے ہی 10 اسٹورز کے 10 کوآرڈینیٹ جمع کیے گئے ہیں۔ ایک میں ان کو منظم کرنے کے بعد numpy array، ہم ان کے مقامات کو بھی پلاٹ کر سکتے ہیں:

import numpy as np

points = np.array([[5, 3], [10, 15], [15, 12], [24, 10], [30, 45], [85, 70], [71, 80], [60, 78], [55, 52],[80, 91]])

xs = points[:,0] 
ys = points[:,1]  

plt.title("10 Stores Coordinates")
plt.scatter(x=xs, y=ys)

K-Means الگورتھم کو دستی طور پر کیسے لاگو کریں۔

اب ہم ایک گراف پر 10 اسٹورز کو دیکھ سکتے ہیں، اور اصل مسئلہ یہ تلاش کرنا ہے کہ کیا کوئی ایسا طریقہ ہے کہ انہیں قربت کی بنیاد پر مختلف گروپوں میں تقسیم کیا جا سکے۔ گراف پر ایک سرسری نظر ڈالنے سے، ہم شاید دیکھیں گے۔ دکانوں کے دو گروپ - ایک نیچے سے بائیں طرف نچلا پوائنٹس ہے، اور دوسرا اوپری دائیں پوائنٹ ہے۔ شاید، ہم درمیان میں ان دو پوائنٹس کو ایک الگ گروپ کے طور پر بھی الگ کر سکتے ہیں – اس لیے تخلیق کر رہے ہیں۔ تین مختلف گروپس.

اس سیکشن میں، ہم پوائنٹس کو دستی طور پر کلسٹر کرنے کے عمل پر جائیں گے – انہیں گروپوں کی دی گئی تعداد میں تقسیم کرنا۔ اس طرح، ہم بنیادی طور پر احتیاط کے ساتھ تمام مراحل پر جائیں گے۔ K- کا مطلب ہے کلسٹرنگ الگورتھم. اس سیکشن کے اختتام تک، آپ K-Means کلسٹرنگ کے دوران کئے گئے تمام اقدامات کی بدیہی اور عملی سمجھ حاصل کر لیں گے۔ اس کے بعد، ہم اسے Scikit-Learn کو سونپیں گے۔

اگر پوائنٹس کے دو یا تین گروپ ہوں تو تعین کرنے کا بہترین طریقہ کیا ہوگا؟ ایک آسان طریقہ یہ ہوگا کہ صرف ایک عدد گروپس کا انتخاب کریں - مثال کے طور پر، دو - اور پھر اس انتخاب کی بنیاد پر گروپ پوائنٹس کی کوشش کریں۔

ہم کہتے ہیں کہ ہم نے فیصلہ کیا ہے کہ وہاں موجود ہیں۔ دو گروپوں ہمارے اسٹورز (پوائنٹس)۔ اب ہمیں یہ سمجھنے کا راستہ تلاش کرنے کی ضرورت ہے کہ کون سے نکات کس گروہ سے تعلق رکھتے ہیں۔ یہ نمائندگی کرنے کے لیے ایک نقطہ کا انتخاب کر کے کیا جا سکتا ہے۔ گروپ 1 اور نمائندگی کرنے کے لیے ایک گروپ 2. ان پوائنٹس کو ایک حوالہ کے طور پر استعمال کیا جائے گا جب ہر گروپ کے دوسرے تمام پوائنٹس سے فاصلے کی پیمائش کی جائے گی۔

اس انداز میں، نقطہ کہتے ہیں (5, 3) گروپ 1 اور پوائنٹ سے تعلق رکھتا ہے۔ (79, 60) گروپ 2 میں۔ جب کوئی نیا نقطہ تفویض کرنے کی کوشش کر رہے ہوں۔ (6, 3) گروپوں کے لیے، ہمیں ان دو پوائنٹس تک اس کے فاصلے کی پیمائش کرنے کی ضرورت ہے۔ نقطہ کی صورت میں (6, 3) is قریب کرنے کے لئے (5, 3)لہذا اس کا تعلق اس گروپ سے ہے جس کی نمائندگی اس نقطہ سے ہوتی ہے - گروپ 1. اس طرح، ہم آسانی سے تمام پوائنٹس کو متعلقہ گروپس میں گروپ کر سکتے ہیں۔

اس مثال میں گروپوں کی تعداد کا تعین کرنے کے علاوہ (کلسٹر) – ہم کچھ نکات کا انتخاب بھی کر رہے ہیں۔ حوالہ ہر گروپ کے نئے پوائنٹس کے لیے فاصلہ۔

ہمارے اسٹورز کے درمیان مماثلتوں کو سمجھنے کا یہی عام خیال ہے۔ آئیے اسے عملی جامہ پہناتے ہیں – ہم پہلے دو حوالہ جات کا انتخاب کر سکتے ہیں۔ بے ترتیب. کا حوالہ نقطہ گروپ 1 ہو جائے گا (5, 3) اور حوالہ نقطہ گروپ 2 ہو جائے گا (10, 15). ہم اپنے دونوں نکات کو منتخب کر سکتے ہیں۔ numpy کی طرف سے صف [0] اور [1] اشاریہ جات بنائیں اور ان میں ذخیرہ کریں۔ g1 (گروپ 1) اور g2 (گروپ 2) متغیرات:

g1 = points[0]
g2 = points[1]

ایسا کرنے کے بعد، ہمیں دوسرے تمام پوائنٹس سے ان حوالہ جات کے فاصلے کا حساب لگانا ہوگا۔ اس سے ایک اہم سوال پیدا ہوتا ہے – اس فاصلے کی پیمائش کیسے کی جائے۔ ہم بنیادی طور پر کسی بھی فاصلے کی پیمائش کا استعمال کر سکتے ہیں، لیکن، اس گائیڈ کے مقصد کے لیے، آئیے یوکلیڈین فاصلہ_ استعمال کریں۔

یہ جاننا مفید ہو سکتا ہے کہ یوکلیڈین فاصلے کی پیمائش پائتھاگورس کے نظریہ پر مبنی ہے:

$$
c^2 = a^2 + b^2۔
$$

جب ہوائی جہاز میں پوائنٹس کے مطابق ڈھال لیا جائے - (a1, b1) اور (a2, b2)، پچھلا فارمولا بن جاتا ہے:

$$
c^2 = (a2-a1)^2 + (b2-b1)^2
$$

فاصلہ کا مربع جڑ ہوگا۔ c، لہذا ہم فارمولہ کو بھی لکھ سکتے ہیں:

$$
euclidean_{dist} = sqrt[2][(a2 – a1)^2 + (b2 – b1) ^2)]
$$

اب تک، ہم نے گروپوں کی نمائندگی کرنے کے لیے پوائنٹس کا انتخاب کیا ہے، اور ہم جانتے ہیں کہ فاصلوں کا حساب کیسے لگانا ہے۔ اب، آئیے اپنے جمع کردہ اسٹور پوائنٹس میں سے ہر ایک گروپ کو تفویض کرکے فاصلے اور گروپس کو ایک ساتھ رکھیں۔

اس کو بہتر انداز میں دیکھنے کے لیے، ہم تین فہرستوں کا اعلان کریں گے۔ پہلے گروپ کے پوائنٹس کو ذخیرہ کرنے والا پہلا - points_in_g1. دوسرا گروپ 2 سے پوائنٹس ذخیرہ کرنے کے لیے - points_in_g2، اور آخری - group، پر لیبل یا تو پوائنٹس 1 (گروپ 1 سے تعلق رکھتا ہے) یا 2 (گروپ 2 سے تعلق رکھتا ہے):

points_in_g1 = []
points_in_g2 = []
group = []

اب ہم اپنے پوائنٹس کے ذریعے اعادہ کر سکتے ہیں اور ان کے اور اپنے ہر گروپ کے حوالہ جات کے درمیان یوکلیڈین فاصلے کا حساب لگا سکتے ہیں۔ ہر ایک نکتہ ہوگا۔ قریب دو گروپوں میں سے ایک کو - اس بنیاد پر کہ کون سا گروپ سب سے قریب ہے، ہم ہر ایک پوائنٹ کو متعلقہ فہرست میں تفویض کریں گے، جبکہ 1 or 2 کرنے کے لئے group فہرست:

for p in points:
    x1, y1 = p[0], p[1]
    euclidean_distance_g1 = np.sqrt((g1[0] - x1)**2 + (g1[1] - y1)**2)
    euclidean_distance_g2 = np.sqrt((g2[0] - x1)**2 + (g2[1] - y1)**2)
    if euclidean_distance_g1 < euclidean_distance_g2:
        points_in_g1.append(p)
        group.append('1')
    else:
        points_in_g2.append(p)
        group.append('2')

آئیے اس تکرار کے نتائج کو دیکھتے ہیں کہ کیا ہوا:

print(f'points_in_g1:{points_in_g1}n 
npoints_in_g2:{points_in_g2}n 
ngroup:{group}')

جس کے نتیجے میں:

points_in_g1:[array([5, 3])]
 
points_in_g2:[array([10, 15]), array([15, 12]), 
              array([24, 10]), array([30, 45]), 
              array([85, 70]), array([71, 80]),
              array([60, 78]), array([55, 52]), 
              array([80, 91])]
 
group:[1, 2, 2, 2, 2, 2, 2, 2, 2, 2] 

ہم سیبورن کا استعمال کرتے ہوئے، تفویض کردہ گروپوں کی بنیاد پر مختلف رنگوں کے ساتھ، کلسٹرنگ کے نتیجے کو بھی پلاٹ کر سکتے ہیں۔ scatterplot() کے ساتھ group ایک hue دلیل:

import seaborn as sns

sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

یہ واضح طور پر نظر آتا ہے کہ صرف ہمارا پہلا پوائنٹ گروپ 1 کو تفویض کیا گیا ہے، اور باقی تمام پوائنٹس گروپ 2 کو تفویض کیے گئے ہیں۔ یہ نتیجہ اس سے مختلف ہے جس کا ہم نے شروع میں تصور کیا تھا۔ ہمارے نتائج اور ہماری ابتدائی توقعات کے درمیان فرق کو مدنظر رکھتے ہوئے - کیا کوئی ایسا طریقہ ہے جسے ہم تبدیل کر سکتے ہیں؟ ایسا لگتا ہے کہ وہاں ہے!

ایک طریقہ یہ ہے کہ اس عمل کو دہرایا جائے اور گروپوں کے حوالہ جات کے لیے مختلف نکات کا انتخاب کیا جائے۔ یہ ہمارے نتائج کو بدل دے گا، امید ہے کہ، ہم نے شروع میں جو تصور کیا ہے اس کے مطابق۔ اس دوسری بار، ہم ان کا انتخاب بے ترتیب طور پر نہیں کر سکتے تھے جیسا کہ ہم نے پہلے کیا تھا، بلکہ a حاصل کر کے مطلب ہمارے پہلے سے گروپ کردہ تمام پوائنٹس میں سے۔ اس طرح، ان نئے پوائنٹس کو متعلقہ گروپوں کے بیچ میں رکھا جا سکتا ہے۔

مثال کے طور پر، اگر دوسرے گروپ کے پاس صرف پوائنٹس تھے۔ (10, 15), (30, 45). نئے مرکزی نقطہ ہو گا (10 + 30)/2 اور (15+45)/2 - جو برابر ہے۔ (20, 30).

چونکہ ہم نے اپنے نتائج کو فہرستوں میں ڈال دیا ہے، اس لیے ہم انہیں پہلے میں تبدیل کر سکتے ہیں۔ numpy arrays، ان کے xs، ys کو منتخب کریں اور پھر حاصل کریں۔ مطلب:

g1_center = [np.array(points_in_g1)[:, 0].mean(), np.array(points_in_g1)[:, 1].mean()]
g2_center = [np.array(points_in_g2)[:, 0].mean(), np.array(points_in_g2)[:, 1].mean()]
g1_center, g2_center

اپنے نئے سینٹر پوائنٹس کے ساتھ اس عمل کو دہرانے میں مدد کرنے کے لیے، آئیے اپنے پچھلے کوڈ کو ایک فنکشن میں تبدیل کریں، اس پر عمل کریں اور دیکھیں کہ کیا پوائنٹس کو گروپ کرنے کے طریقے میں کوئی تبدیلی ہوئی ہے:

def assigns_points_to_two_groups(g1_center, g2_center):
    points_in_g1 = []
    points_in_g2 = []
    group = []

    for p in points:
        x1, y1 = p[0], p[1]
        euclidean_distance_g1 = np.sqrt((g1_center[0] - x1)**2 + (g1_center[1] - y1)**2)
        euclidean_distance_g2 = np.sqrt((g2_center[0] - x1)**2 + (g2_center[1] - y1)**2)
        if euclidean_distance_g1 < euclidean_distance_g2:
            points_in_g1.append(p)
            group.append(1)
        else:
            points_in_g2.append(p)
            group.append(2)
    return points_in_g1, points_in_g2, group

آئیے فنکشن کو کال کریں اور اس کے نتائج کو اسٹور کریں۔ points_in_g1, points_in_g2، اور group متغیر:

points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
points_in_g1, points_in_g2, group

اور گروپوں کی تقسیم کو دیکھنے کے لیے رنگین پوائنٹس کے ساتھ سکیٹر پلاٹ کو بھی پلاٹ کریں:

sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

ایسا لگتا ہے کہ ہمارے پوائنٹس کا جھرمٹ ہے۔ اچھا ہو رھا ہے. لیکن پھر بھی، گراف کے وسط میں دو پوائنٹس ہیں جو دونوں گروپوں کی قربت پر غور کرتے وقت کسی بھی گروپ کو تفویض کیے جا سکتے ہیں۔ ہم نے اب تک جو الگورتھم تیار کیا ہے وہ ان دونوں پوائنٹس کو دوسرے گروپ کو تفویض کرتا ہے۔

اس کا مطلب ہے کہ ہم Xs اور Ys کے ذرائع لے کر، دو نئے مرکزی نکات بنا کر اس عمل کو ایک بار پھر دہرا سکتے ہیں۔ (سینٹرائڈز) ہمارے گروپوں کو اور انہیں فاصلے کی بنیاد پر دوبارہ تفویض کرنا۔

آئیے سینٹروائڈز کو اپ ڈیٹ کرنے کے لیے ایک فنکشن بھی بنائیں۔ اس پورے عمل کو اب اس فنکشن کی متعدد کالوں تک کم کیا جا سکتا ہے:

def updates_centroids(points_in_g1, points_in_g2):
    g1_center = np.array(points_in_g1)[:, 0].mean(), np.array(points_in_g1)[:, 1].mean()
    g2_center = np.array(points_in_g2)[:, 0].mean(), np.array(points_in_g2)[:, 1].mean()
    return g1_center, g2_center

g1_center, g2_center = updates_centroids(points_in_g1, points_in_g2)
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

غور کریں کہ اس تیسری تکرار کے بعد، اب ہر ایک پوائنٹ کا تعلق مختلف کلسٹرز سے ہے۔ ایسا لگتا ہے کہ نتائج بہتر ہو رہے ہیں – آئیے ایک بار پھر کرتے ہیں۔ اب جا رہے ہیں۔ چوتھی تکرار ہمارے طریقہ کار سے:

g1_center, g2_center = updates_centroids(points_in_g1, points_in_g2)
points_in_g1, points_in_g2, group = assigns_points_to_two_groups(g1_center, g2_center)
sns.scatterplot(x=points[:, 0], y=points[:, 1], hue=group)

یہ چوتھی بار ہمیں ملا ایک ہی نتیجہ پچھلے ایک کے طور پر. تو ایسا لگتا ہے کہ ہمارے پوائنٹس گروپس کو مزید تبدیل نہیں کریں گے، ہمارا نتیجہ کسی طرح کے استحکام کو پہنچ گیا ہے - یہ ایک ناقابل تبدیلی حالت میں پہنچ گیا ہے، یا کنورجڈ. اس کے علاوہ، ہمارے پاس بالکل وہی نتیجہ ہے جیسا کہ ہم نے 2 گروپوں کے لیے تصور کیا تھا۔ ہم یہ بھی دیکھ سکتے ہیں کہ آیا یہ پہنچی ہوئی تقسیم معنی رکھتی ہے۔

آئیے فوری طور پر اس کا جائزہ لیں جو ہم نے اب تک کیا ہے۔ ہم نے اپنے 10 اسٹورز کو جغرافیائی طور پر دو حصوں میں تقسیم کیا ہے - ایک نچلے جنوب مغربی علاقوں میں اور دوسرے شمال مشرق میں۔ جو کچھ ہمارے پاس پہلے سے موجود ہے اس کے علاوہ مزید ڈیٹا اکٹھا کرنا دلچسپ ہو سکتا ہے – آمدنی، صارفین کی روزانہ کی تعداد، اور بہت کچھ۔ اس طرح ہم ایک بھرپور تجزیہ کر سکتے ہیں اور ممکنہ طور پر زیادہ دلچسپ نتائج پیدا کر سکتے ہیں۔

اس طرح کی کلسٹرنگ اسٹڈیز اس وقت کی جا سکتی ہیں جب پہلے سے قائم کردہ برانڈ نیا اسٹور کھولنے کے لیے کوئی علاقہ چننا چاہتا ہو۔ اس صورت میں، مقام کے علاوہ اور بھی بہت سے متغیرات کو مدنظر رکھا گیا ہے۔

اس سب کا K-Means الگورتھم سے کیا تعلق ہے؟

ان اقدامات پر عمل کرتے ہوئے آپ نے سوچا ہوگا کہ ان کا K-Means الگورتھم سے کیا تعلق ہے۔ ہم نے اب تک جو عمل کیا ہے وہ ہے۔ K- کا مطلب الگورتھم. مختصراً، ہم نے گروپس/کلسٹرز کی تعداد کا تعین کیا ہے، تصادفی طور پر ابتدائی پوائنٹس کا انتخاب کیا ہے، اور ہر تکرار میں سینٹروائڈز کو اپ ڈیٹ کیا ہے جب تک کہ کلسٹرز آپس میں نہ ہو جائیں۔ ہم نے بنیادی طور پر پورے الگورتھم کو ہاتھ سے انجام دیا ہے – ہر قدم کو احتیاط سے چلاتے ہوئے۔

۔ K K- مطلب میں سے آتا ہے۔ کلسٹرز کی تعداد جو تکرار کے عمل کو شروع کرنے سے پہلے سیٹ کرنے کی ضرورت ہے۔ ہمارے معاملے میں K = 2۔. یہ خصوصیت کبھی کبھی کے طور پر دیکھا جاتا ہے منفی اس بات پر غور کرتے ہوئے کہ کلسٹرنگ کے دیگر طریقے ہیں، جیسے ہیئرارکیکل کلسٹرنگ، جن کے لیے پہلے سے کلسٹرز کی ایک مقررہ تعداد کی ضرورت نہیں ہے۔

اسباب کے استعمال کی وجہ سے K کا مطلب بھی بن جاتا ہے۔ آؤٹ لیرز اور انتہائی اقدار کے لیے حساس - وہ تغیر کو بڑھاتے ہیں اور ہمارے سینٹروائڈز کے لیے اپنا کردار ادا کرنا مشکل بنا دیتے ہیں۔ لہذا، انجام دینے کی ضرورت سے آگاہ رہیں انتہائی اقدار اور بیرونی تجزیہ K-Means الگورتھم کا استعمال کرتے ہوئے کلسٹرنگ کرنے سے پہلے۔

اس کے علاوہ، دیکھیں کہ ہمارے پوائنٹس کو سیدھے حصوں میں تقسیم کیا گیا تھا، کلسٹرز بناتے وقت منحنی خطوط نہیں ہوتے ہیں۔ یہ K-Means الگورتھم کا بھی نقصان ہو سکتا ہے۔

K-Means میں بھی بہت سے ہیں۔ فوائد! یہ اچھی کارکردگی کا مظاہرہ کرتا ہے۔ بڑے ڈیٹاسیٹس جسے سنبھالنا مشکل ہو سکتا ہے اگر آپ کچھ قسم کے درجہ بندی کے کلسٹرنگ الگورتھم استعمال کر رہے ہیں۔ یہ بھی ہم آہنگی کی ضمانت دیتا ہے۔، اور آسانی سے کر سکتے ہیں عام کرنا اور اپنانے. اس کے علاوہ، یہ شاید سب سے زیادہ استعمال ہونے والا کلسٹرنگ الگورتھم ہے۔

اب جب کہ ہم K-Means الگورتھم میں کیے گئے تمام مراحل سے گزر چکے ہیں، اور اس کے تمام فوائد اور نقصانات کو سمجھ چکے ہیں، آخر کار ہم Scikit-Learn لائبریری کا استعمال کرتے ہوئے K-Means کو لاگو کر سکتے ہیں۔

K-Means الگورتھم کو استعمال کرنے کا طریقہ سککیٹ سیکھیں

اپنے نتیجہ کو دو بار چیک کرنے کے لیے، آئیے اس عمل کو دوبارہ کریں، لیکن اب اس کے ساتھ کوڈ کی 3 لائنیں استعمال کر رہے ہیں۔ sklearn:

from sklearn.cluster import KMeans


kmeans = KMeans(n_clusters=2, random_state=42) 
kmeans.fit(points)
kmeans.labels_

یہاں، لیبل ہمارے پچھلے گروپوں کی طرح ہی ہیں۔ آئیے جلدی سے نتیجہ تیار کریں:

sns.scatterplot(x = points[:,0], y = points[:,1], hue=kmeans.labels_)

نتیجہ خیز پلاٹ پچھلے حصے کے پلاٹ جیسا ہی ہے۔

Scikit-Learn کے ساتھ، آپ K-Means کو بھی ترتیب دے کر تیز تر کنورجنسی کے لیے شروع کر سکتے ہیں۔ init='k-means++' دلیل. وسیع تر الفاظ میں، K- کا مطلب++ اب بھی منتخب کرتا ہے k یکساں تقسیم کے بعد بے ترتیب طور پر ابتدائی کلسٹر مراکز۔ اس کے بعد، ہر بعد کے کلسٹر سینٹر کا انتخاب بقیہ ڈیٹا پوائنٹس سے کیا جاتا ہے نہ کہ صرف فاصلے کی پیمائش کے حساب سے – بلکہ امکان کا استعمال کرتے ہوئے۔ امکان کا استعمال الگورتھم کو تیز کرتا ہے اور بہت بڑے ڈیٹاسیٹس کے ساتھ کام کرتے وقت یہ مددگار ثابت ہوتا ہے۔

کہنی کا طریقہ - گروپوں کی بہترین تعداد کا انتخاب

اب تک، بہت اچھا! ہم نے پوائنٹس اور سینٹروائڈز کے درمیان یوکلیڈین فاصلے کی بنیاد پر 10 اسٹورز کو کلسٹر کیا ہے۔ لیکن گراف کے وسط میں ان دو پوائنٹس کا کیا ہوگا جن کا کلسٹر کرنا تھوڑا مشکل ہے؟ کیا وہ الگ گروپ بھی نہیں بنا سکتے تھے؟ کیا واقعی ہم نے انتخاب کرکے غلطی کی؟ K 2 = گروپس؟ شاید ہمارے پاس واقعی تھا۔ K 3 = گروپس؟ ہمارے پاس تین سے زیادہ گروہ بھی ہوسکتے ہیں اور اس سے آگاہ نہیں ہیں۔

یہاں جو سوال پوچھا جا رہا ہے۔ K-Means میں گروپس (K) کی تعداد کا تعین کیسے کریں۔. اس سوال کا جواب دینے کے لیے، ہمیں یہ سمجھنے کی ضرورت ہے کہ کیا K کی مختلف قدر کے لیے کوئی "بہتر" کلسٹر ہوگا۔

اس کو تلاش کرنے کا سادہ طریقہ یہ ہے کہ پوائنٹس کی مختلف اقدار کے ساتھ کلسٹرنگ K، اب تک K=2، K=3، K=4، وغیرہ:

for number_of_clusters in range(1, 11): 
    kmeans = KMeans(n_clusters = number_of_clusters, random_state = 42)
    kmeans.fit(points) 

لیکن، مختلف کے لیے کلسٹرنگ پوائنٹس Ks اکیلے کافی نہیں ہوگا یہ سمجھنے کے لیے کہ آیا ہم نے اس کے لیے مثالی قدر کا انتخاب کیا ہے۔ K. ہمیں ہر ایک کے لیے کلسٹرنگ کے معیار کا جائزہ لینے کے لیے ایک طریقہ کی ضرورت ہے۔ K ہم نے منتخب کیا ہے.

دستی طور پر حساب لگانا مربعوں کے کلسٹر سم کے اندر (WCSS)

ہمارے کلسٹرڈ پوائنٹس ایک دوسرے کے کتنے قریب ہیں اس کا اندازہ لگانے کے لیے یہاں مثالی جگہ ہے۔ یہ بنیادی طور پر کتنا بیان کرتا ہے۔ متغیر ہمارے پاس ایک ہی کلسٹر کے اندر ہے۔ اس پیمائش کو کہا جاتا ہے۔ مربعوں کے کلسٹر سم کے اندر، یا ڈبلیو سی ایس ایس مختصر کے لئے. ڈبلیو سی ایس ایس جتنا چھوٹا ہوگا، ہمارے پوائنٹس اتنے ہی قریب ہوں گے، اس لیے ہمارے پاس ایک زیادہ اچھی طرح سے تشکیل شدہ کلسٹر ہے۔ WCSS فارمولہ کسی بھی تعداد کے کلسٹرز کے لیے استعمال کیا جا سکتا ہے:

$$
WCSS = sum(Pi_1 – Centroid_1)^2 + cdots + sum(Pi_n – Centroid_n)^2
$$

اب ہم فرض کر سکتے ہیں کہ ہم نے دو کلسٹرز کا انتخاب کیا ہے اور WCSS کو بہتر طور پر سمجھنے کے لیے اسے لاگو کرنے کی کوشش کریں گے کہ WCSS کیا ہے اور اسے کیسے استعمال کیا جائے۔ جیسا کہ فارمولہ بیان کرتا ہے، ہمیں تمام کلسٹر پوائنٹس اور سینٹرائڈز کے درمیان مربع فرق کو جمع کرنے کی ضرورت ہے۔ لہذا، اگر پہلے گروپ سے ہمارا پہلا نقطہ ہے (5, 3) اور پہلے گروپ کا ہمارا آخری سنٹرائڈ (کنورجننس کے بعد) ہے۔ (16.8, 17.0)، WCSS ہو گا:

$$
WCSS = sum((5,3) - (16.8, 17.0))^2
$$

$$
WCSS = sum((5-16.8) + (3-17.0))^2
$$

$$
WCSS = sum((-11.8) + (-14.0))^2
$$

$$
WCSS = sum((-25.8))^2
$$

$$
WCSS = 335.24
$$

یہ مثال واضح کرتی ہے کہ ہم کس طرح کلسٹر سے ایک پوائنٹ کے لیے WCSS کا حساب لگاتے ہیں۔ لیکن کلسٹر میں عام طور پر ایک سے زیادہ پوائنٹ ہوتے ہیں، اور ہمیں WCSS کا حساب لگاتے وقت ان سب کو مدنظر رکھنا ہوگا۔ ہم ایک فنکشن کی وضاحت کرکے ایسا کریں گے جو پوائنٹس اور سینٹرائڈز کا ایک جھرمٹ حاصل کرتا ہے، اور مربعوں کا مجموعہ لوٹاتا ہے:

def sum_of_squares(cluster, centroid):
    squares = []
    for p in cluster:
        squares.append((p - centroid)**2)
        ss = np.array(squares).sum()
    return ss

اب ہم ہر کلسٹر کے مربعوں کا مجموعہ حاصل کر سکتے ہیں:

g1 = sum_of_squares(points_in_g1, g1_center)
g2 = sum_of_squares(points_in_g2, g2_center)

اور کل حاصل کرنے کے لیے نتائج کو جمع کریں۔ ڈبلیو سی ایس ایس:

g1 + g2

اس کے نتائج:

2964.3999999999996

تو، ہمارے معاملے میں، جب K 2 کے برابر ہے، کل WCSS ہے۔ 2964.39. اب، ہم Ks کو تبدیل کر سکتے ہیں اور ان سب کے لیے WCSS کا حساب لگا سکتے ہیں۔ اس طرح، ہم کس چیز کے بارے میں بصیرت حاصل کر سکتے ہیں۔ K ہمیں اپنے کلسٹرنگ کو بہترین کارکردگی دکھانے کا انتخاب کرنا چاہیے۔

حساب سے ڈبلیو سی ایس ایس کا استعمال کرتے ہوئے سککیٹ سیکھیں

خوش قسمتی سے، ہمیں ہر ایک کے لیے WCSS کو دستی طور پر شمار کرنے کی ضرورت نہیں ہے۔ K. کلسٹروں کے دیے گئے نمبر کے لیے K-Means کلسٹرنگ کرنے کے بعد، ہم اس کا استعمال کرکے WCSS حاصل کرسکتے ہیں۔ inertia_ وصف. اب، ہم اپنے K-Means پر واپس جا سکتے ہیں۔ for لوپ، کلسٹرز کی تعداد کے ساتھ اس کا استعمال کریں، اور متعلقہ WCSS اقدار کی فہرست بنائیں:

wcss = [] 
for number_of_clusters in range(1, 11): 
    kmeans = KMeans(n_clusters = number_of_clusters, random_state = 42)
    kmeans.fit(points) 
    wcss.append(kmeans.inertia_)
wcss

نوٹ کریں کہ فہرست میں دوسری قدر، بالکل وہی ہے جس کا ہم نے پہلے حساب لگایا ہے۔ K 2 =:

[18272.9, # For k=1 
 2964.3999999999996, # For k=2
 1198.75, # For k=3
 861.75,
 570.5,
 337.5,
 175.83333333333334,
 79.5,
 17.0,
 0.0]

ان نتائج کو دیکھنے کے لیے، آئیے اپنا منصوبہ بنائیں Ks WCSS اقدار کے ساتھ:

ks = [1, 2, 3, 4, 5 , 6 , 7 , 8, 9, 10]
plt.plot(ks, wcss)

ایک پلاٹ پر رکاوٹ ہے جب x = 2، لائن میں ایک نچلا نقطہ، اور اس سے بھی کم جب x = 3. یاد رکھیں کہ یہ ہمیں یاد دلاتا ہے۔ ایک کہنی کی شکل. WCSS کے ساتھ Ks پلاٹ کرکے، ہم استعمال کر رہے ہیں۔ کہنی کا طریقہ Ks کی تعداد منتخب کرنے کے لیے۔ اور منتخب کردہ K بالکل سب سے کم کہنی کا نقطہ ہے۔، تو، یہ ہو جائے گا 3 بجائے 2ہمارے معاملے میں:

ks = [1, 2, 3, 4, 5 , 6 , 7 , 8, 9, 10]
plt.plot(ks, wcss);
plt.axvline(3, linestyle='--', color='r')

ہم K-Means کلسٹر الگورتھم کو دوبارہ چلا سکتے ہیں، یہ دیکھنے کے لیے کہ ہمارا ڈیٹا کیسا نظر آئے گا۔ تین جھرمٹ:

kmeans = KMeans(n_clusters=3, random_state=42)
kmeans.fit(points)
sns.scatterplot(x = points[:,0], y = points[:,1], hue=kmeans.labels_)

ہم پہلے ہی دو کلسٹرز سے خوش تھے، لیکن کہنی کے طریقہ کار کے مطابق، تین کلسٹر ہمارے ڈیٹا کے لیے بہتر ہوں گے۔ اس صورت میں، ہمارے پاس دو کی بجائے تین قسم کے اسٹورز ہوں گے۔ کہنی کا طریقہ استعمال کرنے سے پہلے، ہم نے اسٹورز کے جنوب مغرب اور شمال مشرقی جھرمٹ کے بارے میں سوچا، اب ہمارے پاس مرکز میں بھی اسٹورز ہیں۔ ہو سکتا ہے کہ کوئی اور اسٹور کھولنے کے لیے یہ ایک اچھی جگہ ہو کیونکہ اس کے قریب مقابلہ کم ہوگا۔

متبادل کلسٹر کے معیار کے اقدامات

دیگر اقدامات بھی ہیں جو کلسٹر کے معیار کا جائزہ لیتے وقت استعمال کیے جا سکتے ہیں:

• سلہیٹ سکور - نہ صرف انٹرا کلسٹر پوائنٹس کے درمیان فاصلے کا تجزیہ کرتا ہے بلکہ خود کلسٹرز کے درمیان بھی
• کلسٹرز کے درمیان مربعوں کا مجموعہ (BCSS) - میٹرک WCSS کا تکمیلی
• مربع کی خرابی کا مجموعہ (SSE)
• زیادہ سے زیادہ رداس - ایک نقطہ سے اس کے سنٹرائڈ تک سب سے بڑے فاصلے کی پیمائش کرتا ہے۔
• اوسط رداس - کسی نقطہ سے اس کے سنٹرائڈ تک کے سب سے بڑے فاصلے کا مجموعہ کلسٹرز کی تعداد سے تقسیم۔

تجربہ کرنے اور ان میں سے ہر ایک کو جاننے کی سفارش کی جاتی ہے کیونکہ مسئلہ پر منحصر ہے، کچھ متبادل سب سے زیادہ استعمال شدہ میٹرکس سے زیادہ لاگو ہو سکتے ہیں۔ (WCSS اور Silhouette سکور).

آخر میں، جیسا کہ بہت سے ڈیٹا سائنس الگورتھم کے ساتھ، ہم ہر کلسٹر کے اندر فرق کو کم کرنا چاہتے ہیں اور مختلف کلسٹرز کے درمیان فرق کو زیادہ سے زیادہ کرنا چاہتے ہیں۔ لہذا ہمارے پاس مزید وضاحت شدہ اور الگ کرنے والے کلسٹرز ہیں۔

دوسرے ڈیٹا سیٹ پر K-Means کا اطلاق کرنا

آئیے استعمال کریں جو ہم نے سیکھا ہے دوسرے ڈیٹا سیٹ پر۔ اس بار، ہم اسی طرح کی شراب کے گروپس تلاش کرنے کی کوشش کریں گے۔

ہم درآمد سے شروع کرتے ہیں۔ pandas پڑھنے کے لئے wine-clustering CSV (کوما سے الگ کردہ اقدار) a میں فائل کریں۔ Dataframe ساخت:

import pandas as pd

df = pd.read_csv('wine-clustering.csv')

اسے لوڈ کرنے کے بعد، آئیے اس کے ساتھ ڈیٹا کے پہلے پانچ ریکارڈز پر ایک جھانکتے ہیں۔ head() طریقہ:

df.head()

اس کے نتائج:

	Alcohol 	Malic_Acid 	Ash 	Ash_Alcanity 	Magnesium 	Total_Phenols 	Flavanoids 	Nonflavanoid_Phenols 	Proanthocyanins 	Color_Intensity 	Hue 	OD280 	Proline
0 	14.23 		1.71 		2.43 	15.6 			127 		2.80 			3.06 		0.28 					2.29 				5.64 				1.04 	3.92 	1065
1 	13.20 		1.78 		2.14 	11.2 			100 		2.65 			2.76 		0.26 					1.28 				4.38 				1.05 	3.40 	1050
2 	13.16 		2.36 		2.67 	18.6 			101 		2.80 			3.24 		0.30 					2.81 				5.68 				1.03 	3.17 	1185
3 	14.37 		1.95 		2.50 	16.8 			113 		3.85 			3.49 		0.24 					2.18 				7.80 				0.86 	3.45 	1480
4 	13.24 		2.59 		2.87 	21.0 			118 		2.80 			2.69 		0.39 					1.82 				4.32 				1.04 	2.93 	735

ہمارے پاس شراب میں موجود مادوں کی بہت سی پیمائشیں ہیں۔ یہاں، ہمیں کلیدی کالموں کو تبدیل کرنے کی بھی ضرورت نہیں ہوگی کیونکہ یہ سب عددی ہیں۔ اب، کے ساتھ وضاحتی اعدادوشمار پر ایک نظر ڈالتے ہیں۔ describe() طریقہ:

df.describe().T 

تفصیلی جدول:

 						count 	mean 		std 		min 	25% 	50% 	75% 		max
Alcohol 				178.0 	13.000618 	0.811827 	11.03 	12.3625 13.050 	13.6775 	14.83
Malic_Acid 				178.0 	2.336348 	1.117146 	0.74 	1.6025 	1.865 	3.0825 		5.80
Ash 					178.0 	2.366517 	0.274344 	1.36 	2.2100 	2.360 	2.5575 		3.23
Ash_Alcanity 			178.0 	19.494944 	3.339564 	10.60 	17.2000 19.500 	21.5000 	30.00
Magnesium 				178.0 	99.741573 	14.282484 	70.00 	88.0000 98.000 	107.0000 	162.00
Total_Phenols 			178.0 	2.295112 	0.625851 	0.98 	1.7425 	2.355 	2.8000 		3.88
Flavanoids 				178.0 	2.029270 	0.998859 	0.34 	1.2050 	2.135 	2.8750 		5.08
Nonflavanoid_Phenols 	178.0 	0.361854 	0.124453 	0.13 	0.2700 	0.340 	0.4375 		0.66
Proanthocyanins 		178.0 	1.590899 	0.572359 	0.41 	1.2500 	1.555 	1.9500 		3.58
Color_Intensity 		178.0 	5.058090 	2.318286 	1.28 	3.2200 	4.690 	6.2000 		13.00
Hue 					178.0 	0.957449 	0.228572 	0.48 	0.7825 	0.965 	1.1200 		1.71
OD280 					178.0 	2.611685 	0.709990 	1.27 	1.9375 	2.780 	3.1700 		4.00
Proline 				178.0 	746.893258 	314.907474 	278.00 	500.500 673.500 985.0000 	1680.00

میز کو دیکھ کر یہ واضح ہے کہ کچھ ہے ڈیٹا میں تغیر - کچھ کالموں کے لیے جیسے Alchool زیادہ ہے، اور دوسروں کے لیے، جیسے Malic_Acid، کم اب ہم چیک کر سکتے ہیں کہ آیا کوئی موجود ہے۔ null، یا NaN ہمارے ڈیٹاسیٹ میں اقدار:

df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 178 entries, 0 to 177
Data columns (total 13 columns):
 #   Column                Non-Null Count  Dtype  
---  ------                --------------  -----  
 0   Alcohol               178 non-null    float64
 1   Malic_Acid            178 non-null    float64
 2   Ash                   178 non-null    float64
 3   Ash_Alcanity          178 non-null    float64
 4   Magnesium             178 non-null    int64  
 5   Total_Phenols         178 non-null    float64
 6   Flavanoids            178 non-null    float64
 7   Nonflavanoid_Phenols  178 non-null    float64
 8   Proanthocyanins       178 non-null    float64
 9   Color_Intensity       178 non-null    float64
 10  Hue                   178 non-null    float64
 11  OD280                 178 non-null    float64
 12  Proline               178 non-null    int64  
dtypes: float64(11), int64(2)
memory usage: 18.2 KB

ڈیٹا کو چھوڑنے یا ان پٹ کرنے کی ضرورت نہیں ہے، اس بات پر غور کرتے ہوئے کہ ڈیٹاسیٹ میں خالی اقدار نہیں ہیں۔ ہم سیبورن استعمال کر سکتے ہیں۔ pairplot() ڈیٹا کی تقسیم کو دیکھنے کے لیے اور یہ چیک کرنے کے لیے کہ آیا ڈیٹا سیٹ کالموں کے جوڑے بناتا ہے جو کلسٹرنگ کے لیے دلچسپ ہو سکتے ہیں:

sns.pairplot(df)

پیئر پلاٹ کو دیکھ کر، کلسٹرنگ کے مقاصد کے لیے دو کالم امید افزا معلوم ہوتے ہیں۔ Alcohol اور OD280 (جو شراب میں پروٹین کی حراستی کا تعین کرنے کا ایک طریقہ ہے)۔ ایسا لگتا ہے کہ ان میں سے دو کو ملا کر پلاٹوں پر 3 الگ الگ کلسٹر ہیں۔

اور بھی کالم ہیں جو بظاہر باہمی ربط میں ہیں۔ سب سے اہم Alcohol اور Total_Phenols، اور Alcohol اور Flavanoids. ان کے بڑے لکیری تعلقات ہیں جو جوڑے کے پلاٹ میں دیکھے جا سکتے ہیں۔

چونکہ ہمارا فوکس K-Means کے ساتھ کلسٹرنگ ہے، آئیے کالموں کا ایک جوڑا منتخب کریں، کہتے ہیں Alcohol اور OD280، اور اس ڈیٹاسیٹ کے لیے کہنی کے طریقہ کی جانچ کریں۔

آئیے سکیٹر پلاٹ کو ان دو کالموں کے ساتھ پلاٹ کریں جو اس کے محور کے طور پر سیٹ کیے گئے پوائنٹس پر گہری نظر ڈالیں جنہیں ہم گروپوں میں تقسیم کرنا چاہتے ہیں:

sns.scatterplot(data=df, x='OD280', y='Alcohol')

اب ہم اپنے کالموں کی وضاحت کر سکتے ہیں اور کلسٹرز کی تعداد کا تعین کرنے کے لیے کہنی کا طریقہ استعمال کر سکتے ہیں۔ ہم اس کے ساتھ الگورتھم بھی شروع کریں گے۔ kmeans++ صرف اس بات کو یقینی بنانے کے لیے کہ یہ زیادہ تیزی سے بدل جائے:

values = df[['OD280', 'Alcohol']]

wcss_wine = [] 
for i in range(1, 11): 
    kmeans = KMeans(n_clusters = i, init = 'k-means++', random_state = 42)
    kmeans.fit(values) 
    wcss_wine.append(kmeans.inertia_)

ہم نے WCSS کا حساب لگایا ہے، اس لیے ہم نتائج کی منصوبہ بندی کر سکتے ہیں:

clusters_wine = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
plt.plot(clusters_wine, wcss_wine)
plt.axvline(3, linestyle='--', color='r')

کہنی کے طریقہ کے مطابق ہمارے یہاں 3 کلسٹر ہونے چاہئیں۔ آخری مرحلے کے لیے، آئیے اپنے پوائنٹس کو 3 کلسٹرز میں کلسٹر کریں اور ان کلسٹرز کو پلاٹ کریں جن کی شناخت رنگوں سے ہوئی ہے:

kmeans_wine = KMeans(n_clusters=3, random_state=42)
kmeans_wine.fit(values)
sns.scatterplot(x = values['OD280'], y = values['Alcohol'], hue=kmeans_wine.labels_)

ہم کلسٹرز دیکھ سکتے ہیں۔ 0, 1، اور 2 گراف میں ہمارے تجزیہ کی بنیاد پر، گروپ 0 اعلی پروٹین مواد اور کم الکحل کے ساتھ شراب، گروپ 1 الکحل کی مقدار اور کم پروٹین والی شرابیں ہیں، اور گروپ 2 اس کی شراب میں اعلیٰ پروٹین اور زیادہ الکحل دونوں ہوتے ہیں۔

یہ ایک بہت ہی دلچسپ ڈیٹاسیٹ ہے اور میں آپ کو نارملائزیشن اور PCA کے بعد ڈیٹا کو کلسٹر کرکے تجزیہ میں مزید آگے جانے کی ترغیب دیتا ہوں – نتائج کی تشریح کرکے اور نئے کنکشن تلاش کرکے۔

نتیجہ

K- کا مطلب ہے۔ کلسٹرنگ ڈیٹا کلسٹرنگ کے لیے ایک سادہ لیکن انتہائی موثر غیر زیر نگرانی مشین لرننگ الگورتھم ہے۔ یہ ڈیٹا پوائنٹس کے درمیان یوکلیڈین فاصلے کی بنیاد پر ڈیٹا کو کلسٹر کرتا ہے۔ K-Means کلسٹرنگ الگورتھم کے متنی دستاویزات، تصاویر، ویڈیوز اور بہت کچھ گروپ بندی کے لیے بہت سے استعمالات ہیں۔