Python میں Scikit-Learn کے ساتھ DBSCAN

تعارف

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

طلباء کے مختلف گروپوں کے ڈیٹا کا معائنہ کرتے وقت، آپ کو پوائنٹس کے تین انداز نظر آتے ہیں، جیسا کہ ذیل میں 1، 2 اور 3:

دھیان دیں کہ پلاٹ 1 میں، جامنی رنگ کے پوائنٹس ایک نصف دائرے میں منظم ہیں، اس دائرے کے اندر گلابی پوائنٹس کے بڑے پیمانے پر، اس نیم دائرے کے باہر نارنجی پوائنٹس کا تھوڑا سا ارتکاز، اور پانچ گرے پوائنٹس ہیں جو باقی سب سے دور ہیں۔

پلاٹ 2 میں، جامنی رنگ کے پوائنٹس کا ایک گول ماس ہے، اورنج پوائنٹس کا ایک اور، اور چار گرے پوائنٹس ہیں جو باقی سب سے دور ہیں۔

اور پلاٹ 3 میں، ہم پوائنٹس کے چار ارتکاز دیکھ سکتے ہیں، ارغوانی، نیلے، نارنجی، گلابی، اور تین مزید دور دراز کے گرے پوائنٹس۔

اب، اگر آپ کسی ایسے ماڈل کا انتخاب کریں جو طلباء کے نئے ڈیٹا کو سمجھ سکے اور اسی طرح کے گروپس کا تعین کر سکے، تو کیا کوئی کلسٹرنگ الگورتھم ہے جو اس قسم کے ڈیٹا کو دلچسپ نتائج دے سکتا ہے؟

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

کثافت پر مبنی الگورتھم جو شور کو فلٹر کر سکتا ہے، جیسے ڈی بی ایس سی اے این (Dاحساس-Bعزم Sپٹیال Cکی چمک Aکے ساتھ درخواستیں Noise)، گھنے علاقوں، گول شکلوں اور شور والے حالات کے لیے ایک مضبوط انتخاب ہے۔

DBSCAN کے بارے میں

DBSCAN تحقیق میں سب سے زیادہ حوالہ شدہ الگورتھم میں سے ایک ہے، اس کی پہلی اشاعت 1996 میں ہوئی، یہ ہے اصل DBSCAN کاغذ. مقالے میں، محققین یہ ظاہر کرتے ہیں کہ الگورتھم کس طرح غیر لکیری مقامی کلسٹرز کی شناخت کر سکتا ہے اور اعلیٰ جہتوں کے ساتھ ڈیٹا کو مؤثر طریقے سے سنبھال سکتا ہے۔

DBSCAN کے پیچھے بنیادی خیال یہ ہے کہ پوائنٹس کی کم از کم تعداد ہے جو ایک مقررہ فاصلے کے اندر ہوں گے یا ریڈیو سب سے زیادہ "مرکزی" کلسٹر پوائنٹ سے، کہا جاتا ہے بنیادی نقطہ. اس رداس کے اندر پوائنٹس پڑوس کے پوائنٹس ہیں، اور اس پڑوس کے کنارے پر پوائنٹس ہیں سرحدی مقامات or باؤنڈری پوائنٹس. رداس یا پڑوس کا فاصلہ کہلاتا ہے۔ ایپیلون پڑوس, ε - پڑوس یا صرف ε (یونانی خط ایپسیلون کی علامت)۔

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

اس کا مطلب ہے کہ ہمارے پاس تین مختلف قسم کے پوائنٹس ہیں، یعنی، کور, سرحد اور شور. مزید برآں، یہ نوٹ کرنا ضروری ہے کہ مرکزی خیال بنیادی طور پر رداس یا فاصلے پر مبنی ہے، جو DBSCAN کو – جیسے کہ زیادہ تر کلسٹرنگ ماڈلز – کو اس فاصلے کے میٹرک پر منحصر کرتا ہے۔ یہ میٹرک Euclidean، Manhattan، Mahalanobis، اور بہت کچھ ہو سکتا ہے۔ لہذا، ایک مناسب فاصلہ میٹرک کا انتخاب کرنا بہت ضروری ہے جو ڈیٹا کے سیاق و سباق پر غور کرے۔ مثال کے طور پر، اگر آپ GPS سے ڈرائیونگ کی دوری کا ڈیٹا استعمال کر رہے ہیں، تو یہ ایک میٹرک استعمال کرنا دلچسپ ہو سکتا ہے جو سڑک کی ترتیب کو مدنظر رکھتا ہو، جیسے کہ مین ہٹن کا فاصلہ۔

بنیادی نقطہ تلاش کرنے کے لیے، DBSCAN سب سے پہلے بے ترتیب ایک پوائنٹ کا انتخاب کرے گا، اپنے ε-پڑوس کے اندر تمام پوائنٹس کا نقشہ بنائے گا، اور منتخب پوائنٹ کے پڑوسیوں کی تعداد کا پوائنٹس کی کم از کم تعداد سے موازنہ کرے گا۔ اگر منتخب پوائنٹ میں پوائنٹس کی کم از کم تعداد سے برابر تعداد یا زیادہ پڑوسی ہیں، تو اسے بنیادی نقطہ کے طور پر نشان زد کیا جائے گا۔ یہ بنیادی نقطہ اور اس کے پڑوس کے پوائنٹس پہلا کلسٹر تشکیل دیں گے۔

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

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

یہ جاننا دلچسپ ہے کہ DBSCAN الگورتھم کیسے کام کرتا ہے، اگرچہ، خوش قسمتی سے، الگورتھم کو کوڈ کرنے کی ضرورت نہیں ہے، ایک بار جب Python کی Scikit-Learn لائبریری میں پہلے سے ہی عمل درآمد ہو جاتا ہے۔

آئیے دیکھتے ہیں کہ یہ عملی طور پر کیسے کام کرتا ہے!

کلسٹرنگ کے لیے ڈیٹا درآمد کرنا

یہ دیکھنے کے لیے کہ DBSCAN عملی طور پر کیسے کام کرتا ہے، ہم پروجیکٹس کو تھوڑا سا تبدیل کریں گے اور ایک چھوٹا سا کسٹمر ڈیٹا سیٹ استعمال کریں گے جس کی صنف، عمر، سالانہ آمدنی، اور 200 صارفین کے اخراجات کا اسکور ہوگا۔

اخراجات کا اسکور 0 سے 100 تک ہوتا ہے اور یہ ظاہر کرتا ہے کہ ایک شخص مال میں 1 سے 100 کے پیمانے پر کتنی بار رقم خرچ کرتا ہے۔ دوسرے لفظوں میں، اگر کسی صارف کا اسکور 0 ہے، تو وہ کبھی بھی پیسہ خرچ نہیں کرتا، اور اگر اسکور 100، وہ سب سے زیادہ خرچ کرنے والے ہیں۔

ڈیٹا سیٹ ڈاؤن لوڈ کرنے کے بعد، آپ دیکھیں گے کہ یہ ایک CSV (کوما سے الگ کردہ اقدار) فائل ہے جسے کہا جاتا ہے۔ shopping-data.csv، ہم اسے پانڈاس کا استعمال کرتے ہوئے ڈیٹا فریم میں لوڈ کریں گے اور اسے میں اسٹور کریں گے۔ customer_data متغیر:

import pandas as pd path_to_file = '../../datasets/dbscan/dbscan-with-python-and-scikit-learn-shopping-data.csv'
customer_data = pd.read_csv(path_to_file)

ہمارے ڈیٹا کی پہلی پانچ قطاروں پر ایک نظر ڈالنے کے لیے، آپ عمل کر سکتے ہیں۔ customer_data.head():

اس کے نتائج:

 CustomerID Genre Age Annual Income (k$) Spending Score (1-100)
0 1 Male 19 15 39
1 2 Male 21 15 81
2 3 Female 20 16 6
3 4 Female 23 16 77
4 5 Female 31 17 40

ڈیٹا کی جانچ کرکے، ہم کسٹمر کے شناختی نمبر، صنف، عمر، k$ میں آمدنی، اور اخراجات کے اسکور دیکھ سکتے ہیں۔ ذہن میں رکھیں کہ ان میں سے کچھ یا تمام متغیر ماڈل میں استعمال ہوں گے۔ مثال کے طور پر اگر ہم استعمال کریں۔ Age اور Spending Score (1-100) DBSCAN کے متغیرات کے طور پر، جو کہ فاصلاتی میٹرک کا استعمال کرتا ہے، ان کو ایک عام پیمانے پر لانا ضروری ہے تاکہ بگاڑ کو متعارف کرانے سے بچایا جا سکے۔ Age سالوں میں ماپا جاتا ہے اور Spending Score (1-100) 0 سے 100 تک محدود رینج ہے۔ اس کا مطلب ہے کہ ہم کسی قسم کی ڈیٹا اسکیلنگ کریں گے۔

ہم یہ بھی چیک کر سکتے ہیں کہ آیا ڈیٹا کو اسکیلنگ کے علاوہ کسی اور پری پروسیسنگ کی ضرورت ہے یہ دیکھ کر کہ آیا ڈیٹا کی قسم مطابقت رکھتی ہے اور اس بات کی تصدیق کر سکتے ہیں کہ آیا کوئی ایسی قدریں موجود نہیں ہیں جن کا علاج Panda's پر عمل کرتے ہوئے کیا جانا چاہیے۔ info() طریقہ:

customer_data.info()

یہ دکھاتا ہے:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 5 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 CustomerID 200 non-null int64 1 Genre 200 non-null object 2 Age 200 non-null int64 3 Annual Income (k$) 200 non-null int64 4 Spending Score (1-100) 200 non-null int64 dtypes: int64(4), object(1)
memory usage: 7.9+ KB

ہم مشاہدہ کر سکتے ہیں کہ کوئی قدر غائب نہیں ہے کیونکہ ہر صارف کی خصوصیت کے لیے 200 غیر صفر اندراجات ہیں۔ ہم یہ بھی دیکھ سکتے ہیں کہ صرف صنف کے کالم میں متن کا مواد ہوتا ہے، کیونکہ یہ ایک واضح متغیر ہے، جو اس طرح ظاہر ہوتا ہے۔ object، اور دیگر تمام خصوصیات عددی ہیں، قسم کی int64. اس طرح، ڈیٹا کی قسم کی مستقل مزاجی اور کالعدم اقدار کی عدم موجودگی کے لحاظ سے، ہمارا ڈیٹا مزید تجزیہ کے لیے تیار ہے۔

ہم ڈیٹا کو دیکھنے کے لیے آگے بڑھ سکتے ہیں اور یہ تعین کر سکتے ہیں کہ DBSCAN میں کون سی خصوصیات استعمال کرنا دلچسپ ہوں گی۔ ان خصوصیات کو منتخب کرنے کے بعد، ہم ان کی پیمائش کر سکتے ہیں۔

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

ڈیٹا کا تصور کرنا

سیبورن کا استعمال کرکے pairplot()، ہم خصوصیات کے ہر ایک مجموعہ کے لیے ایک سکیٹر گراف بنا سکتے ہیں۔ چونکہ CustomerID صرف ایک شناخت ہے نہ کہ کوئی خصوصیت، ہم اسے ہٹا دیں گے۔ drop() سازش کرنے سے پہلے:

import seaborn as sns customer_data = customer_data.drop('CustomerID', axis=1) sns.pairplot(customer_data);

یہ نتائج:

کی طرف سے تیار خصوصیات کے مجموعہ کو دیکھ کر pairplot، کا گراف Annual Income (k$) ساتھ Spending Score (1-100) ایسا لگتا ہے کہ پوائنٹس کے تقریباً 5 گروپس ظاہر ہوتے ہیں۔ ایسا لگتا ہے کہ یہ خصوصیات کا سب سے زیادہ امید افزا مجموعہ ہے۔ ہم ان کے ناموں کے ساتھ ایک فہرست بنا سکتے ہیں، انہیں سے منتخب کریں۔ customer_data ڈیٹا فریم، اور انتخاب کو میں اسٹور کریں۔ customer_data ہمارے مستقبل کے ماڈل میں استعمال کے لیے دوبارہ متغیر۔

selected_cols = ['Annual Income (k$)', 'Spending Score (1-100)']
customer_data = customer_data[selected_cols]

کالموں کو منتخب کرنے کے بعد، ہم پچھلے حصے میں زیر بحث اسکیلنگ کو انجام دے سکتے ہیں۔ خصوصیات کو ایک ہی پیمانے پر لانے کے لیے یا معیاری انہیں، ہم Scikit-Lear's درآمد کر سکتے ہیں۔ StandardScalerاسے بنائیں، ہمارے ڈیٹا کو اس کے اوسط اور معیاری انحراف کا حساب لگانے کے لیے فٹ کریں، اور ڈیٹا کو اس کے اوسط کو گھٹا کر اور اسے معیاری انحراف سے تقسیم کر کے تبدیل کریں۔ یہ کے ساتھ ایک قدم میں کیا جا سکتا ہے fit_transform() طریقہ:

from sklearn.preprocessing import StandardScaler ss = StandardScaler() scaled_data = ss.fit_transform(customer_data)

متغیرات کو اب پیمانہ بنایا گیا ہے، اور ہم صرف کے مواد کو پرنٹ کرکے ان کی جانچ کر سکتے ہیں۔ scaled_data متغیر متبادل طور پر، ہم انہیں ایک نئے میں بھی شامل کر سکتے ہیں۔ scaled_customer_data کالم کے ناموں کے ساتھ ڈیٹا فریم اور استعمال کریں۔ head() دوبارہ طریقہ:

scaled_customer_data = pd.DataFrame(columns=selected_cols, data=scaled_data)
scaled_customer_data.head()

یہ نتائج:

 Annual Income (k$) Spending Score (1-100)
0 -1.738999 -0.434801
1 -1.738999 1.195704
2 -1.700830 -1.715913
3 -1.700830 1.040418
4 -1.662660 -0.395980 

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

کم سے کم کا انتخاب نمونے اور Epsilon

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

$$
متن{منٹ پوائنٹس} >= ٹیکسٹ{ڈیٹا ڈائمینشنز} + 1
$$

ڈائمینشنز ڈیٹا فریم میں کالموں کی تعداد ہیں، ہم 2 کالم استعمال کر رہے ہیں، لہذا کم سے کم۔ پوائنٹس یا تو 2+1، جو کہ 3، یا اس سے زیادہ ہونے چاہئیں۔ اس مثال کے لیے آئیے استعمال کرتے ہیں۔ 5 منٹ پوائنٹس.

$$
متن{5 (کم سے کم پوائنٹس)} >= متن{2 (ڈیٹا کے طول و عرض)} + 1
$$

اب، ε کے لیے قدر منتخب کرنے کے لیے ایک طریقہ ہے جس میں a قریب ترین پڑوسی الگورتھم کا استعمال ہر ایک پوائنٹ کے لیے قریب ترین پوائنٹس کی پہلے سے طے شدہ تعداد کے فاصلوں کو تلاش کرنے کے لیے کیا جاتا ہے۔ پڑوسیوں کی یہ پہلے سے طے شدہ تعداد کم سے کم ہے۔ پوائنٹس جو ہم نے ابھی مائنس 1 کا انتخاب کیا ہے۔ لہذا، ہمارے معاملے میں، الگورتھم ہمارے ڈیٹا کے ہر ایک پوائنٹ کے لیے 5-1، یا 4 قریب ترین پوائنٹس تلاش کرے گا۔ وہ ہیں کے پڑوسی اور ہماری k 4 کے برابر ہے۔

$$
text{k-neighbours} = text{min. پوائنٹس} – 1
$$

پڑوسیوں کو تلاش کرنے کے بعد، ہم ان کے فاصلوں کو سب سے بڑے سے چھوٹے تک ترتیب دیں گے اور y-axis کے فاصلوں اور x-axis پر پوائنٹس کو پلاٹ کریں گے۔ پلاٹ کو دیکھتے ہوئے، ہم دیکھیں گے کہ یہ کہنی کے جھکاؤ سے کہاں ملتا ہے اور y-axis پوائنٹ جو بیان کرتا ہے کہ کہنی کا جھکا ہوا تجویز کردہ ε قدر ہے۔

ان اقدامات کو انجام دینے کے لیے، ہم الگورتھم کو درآمد کر سکتے ہیں، اسے ڈیٹا میں فٹ کر سکتے ہیں، اور پھر ہم ہر نقطہ کے فاصلے اور اشاریے نکال سکتے ہیں۔ kneighbors() طریقہ:

from sklearn.neighbors import NearestNeighbors
import numpy as np nn = NearestNeighbors(n_neighbors=4) nbrs = nn.fit(scaled_customer_data)
distances, indices = nbrs.kneighbors(scaled_customer_data)

فاصلوں کو تلاش کرنے کے بعد، ہم انہیں سب سے بڑے سے چھوٹے میں ترتیب دے سکتے ہیں۔ چونکہ فاصلاتی سرنی کا پہلا کالم اپنے آپ کے نقطہ کا ہے (یعنی تمام 0 ہیں)، اور دوسرے کالم میں سب سے چھوٹی فاصلوں پر مشتمل ہے، اس کے بعد تیسرا کالم جس میں دوسرے سے زیادہ فاصلہ ہے، اور اسی طرح، ہم صرف منتخب کر سکتے ہیں دوسرے کالم کی قدریں اور انہیں میں اسٹور کریں۔ distances متغیر:

distances = np.sort(distances, axis=0)
distances = distances[:,1] 

اب جب کہ ہمارے پاس اپنی ترتیب کردہ سب سے چھوٹی فاصلے ہیں، ہم درآمد کر سکتے ہیں۔ matplotlib، فاصلوں کی منصوبہ بندی کریں، اور ایک سرخ لکیر کھینچیں جہاں "کہنی کا موڑ" ہے:

import matplotlib.pyplot as plt plt.figure(figsize=(6,3))
plt.plot(distances)
plt.axhline(y=0.24, color='r', linestyle='--', alpha=0.4) plt.title('Kneighbors distance graph')
plt.xlabel('Data points')
plt.ylabel('Epsilon value')
plt.show();

یہ نتیجہ ہے:

نوٹ کریں کہ لائن کھینچتے وقت، ہم ε کی قدر تلاش کریں گے، اس صورت میں، یہ ہے۔ 0.24.

آخر کار ہمارے پاس کم از کم پوائنٹس اور ε ہیں۔ دونوں متغیرات کے ساتھ، ہم DBSCAN ماڈل بنا اور چلا سکتے ہیں۔

DBSCAN ماڈل بنانا

ماڈل بنانے کے لیے، ہم اسے Scikit-Learn سے درآمد کر سکتے ہیں، اسے ε کے ساتھ تخلیق کر سکتے ہیں جو کہ eps دلیل، اور کم از کم پوائنٹس جن کی طرف mean_samples دلیل. اس کے بعد ہم اسے متغیر میں محفوظ کر سکتے ہیں، آئیے اسے کہتے ہیں۔ dbs اور اسے سکیلڈ ڈیٹا میں فٹ کریں:

from sklearn.cluster import DBSCAN dbs = DBSCAN(eps=0.24, min_samples=5)
dbs.fit(scaled_customer_data)

بالکل اسی طرح، ہمارے DBSCAN ماڈل کو ڈیٹا پر بنایا اور تربیت دی گئی ہے! نتائج نکالنے کے لیے، ہم تک رسائی حاصل کرتے ہیں۔ labels_ جائیداد ہم ایک نیا بھی بنا سکتے ہیں۔ labels کالم scaled_customer_data ڈیٹا فریم بنائیں اور اسے پیش گوئی شدہ لیبلز سے بھریں:

labels = dbs.labels_ scaled_customer_data['labels'] = labels
scaled_customer_data.head()

یہ حتمی نتیجہ ہے:

 Annual Income (k$) Spending Score (1-100) labels
0 -1.738999 -0.434801 -1
1 -1.738999 1.195704 0
2 -1.700830 -1.715913 -1
3 -1.700830 1.040418 0
4 -1.662660 -0.395980 -1

مشاہدہ کریں کہ ہمارے پاس لیبل ہیں۔ -1 اقدار یہ ہیں شور پوائنٹس، وہ جو کسی بھی کلسٹر سے تعلق نہیں رکھتے۔ یہ جاننے کے لیے کہ الگورتھم کو کتنے شور پوائنٹس ملے، ہم شمار کر سکتے ہیں کہ ہماری لیبل کی فہرست میں ویلیو -1 کتنی بار ظاہر ہوتی ہے:

labels_list = list(scaled_customer_data['labels'])
n_noise = labels_list.count(-1)
print("Number of noise points:", n_noise)

یہ نتائج:

Number of noise points: 62

ہم پہلے ہی جانتے ہیں کہ 62 پوائنٹس کے ہمارے اصل ڈیٹا کے 200 پوائنٹس کو شور سمجھا جاتا تھا۔ یہ بہت زیادہ شور ہے، جو اس بات کی نشاندہی کرتا ہے کہ شاید DBSCAN کلسٹرنگ نے بہت سے نکات کو کلسٹر کا حصہ نہیں سمجھا۔ ہم جلد ہی سمجھ جائیں گے کہ کیا ہوا، جب ہم ڈیٹا پلاٹ کریں گے۔

ابتدائی طور پر، جب ہم نے اعداد و شمار کا مشاہدہ کیا، تو ایسا لگتا تھا کہ اس میں پوائنٹس کے 5 کلسٹر ہیں۔ یہ جاننے کے لیے کہ DBSCAN نے کتنے کلسٹر بنائے ہیں، ہم ان لیبلوں کی تعداد گن سکتے ہیں جو -1 نہیں ہیں۔ اس کوڈ کو لکھنے کے بہت سے طریقے ہیں؛ یہاں، ہم نے لوپ کے لیے ایک لکھا ہے، جو اس ڈیٹا کے لیے بھی کام کرے گا جس میں DBSCAN کو بہت سے کلسٹر ملے ہیں:

total_labels = np.unique(labels) n_labels = 0
for n in total_labels: if n != -1: n_labels += 1
print("Number of clusters:", n_labels)

یہ نتائج:

Number of clusters: 6

ہم دیکھ سکتے ہیں کہ الگورتھم نے اعداد و شمار کے 6 کلسٹر ہونے کی پیش گوئی کی ہے، جس میں بہت سے شور پوائنٹس ہیں۔ آئیے اسے سمندری جانور کے ساتھ سازش کرکے تصور کرتے ہیں۔ scatterplot:

sns.scatterplot(data=scaled_customer_data, x='Annual Income (k$)', y='Spending Score (1-100)', hue='labels', palette='muted').set_title('DBSCAN found clusters');

اس کے نتائج:

پلاٹ کو دیکھتے ہوئے، ہم دیکھ سکتے ہیں کہ DBSCAN نے ان پوائنٹس کو پکڑ لیا ہے جو زیادہ گہرے طور پر جڑے ہوئے تھے، اور وہ پوائنٹس جنہیں ایک ہی کلسٹر کا حصہ سمجھا جا سکتا تھا یا تو شور تھا یا ایک اور چھوٹا کلسٹر بنانے کے لیے سمجھا جاتا تھا۔

اگر ہم کلسٹرز کو نمایاں کرتے ہیں، تو دیکھیں کہ کس طرح DBSCAN کلسٹر 1 کو مکمل طور پر حاصل کرتا ہے، جو کہ پوائنٹس کے درمیان کم جگہ والا کلسٹر ہے۔ پھر اسے کلسٹرز 0 اور 3 کے حصے ملتے ہیں جہاں پوائنٹس ایک دوسرے کے قریب ہوتے ہیں، زیادہ فاصلہ والے پوائنٹس کو شور سمجھ کر۔ یہ نچلے بائیں نصف حصے کے پوائنٹس کو بھی شور سمجھتا ہے اور نچلے دائیں حصے کے پوائنٹس کو 3 کلسٹرز میں تقسیم کرتا ہے، ایک بار پھر کلسٹر 4، 2 اور 5 کو پکڑتا ہے جہاں پوائنٹس ایک دوسرے کے قریب ہوتے ہیں۔

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

الگورتھم کا اندازہ لگانا

DBSCAN کا جائزہ لینے کے لیے ہم استعمال کریں گے۔ silhouette سکور جو ایک ہی کلسٹر کے پوائنٹس کے درمیان فاصلے اور کلسٹرز کے درمیان فاصلے کو مدنظر رکھے گا۔

سب سے پہلے، ہم درآمد کر سکتے ہیں silhouette_score Scikit-Learn سے، پھر، اسے ہمارے کالم اور لیبل پاس کریں:

from sklearn.metrics import silhouette_score s_score = silhouette_score(scaled_customer_data, labels)
print(f"Silhouette coefficient: {s_score:.3f}")

یہ نتائج:

Silhouette coefficient: 0.506

اس سکور کے مطابق، ایسا لگتا ہے کہ DBSCAN تقریباً 50% ڈیٹا حاصل کر سکتا ہے۔

نتیجہ

DBSCAN کے فوائد اور نقصانات

DBSCAN ایک بہت ہی منفرد کلسٹرنگ الگورتھم یا ماڈل ہے۔

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

اس کے لیے ہم سے کم از کم پوائنٹس اور ε کی وضاحت کرنے کی ضرورت ہے، لیکن مثال کے طور پر K-Means کی طرح، پہلے سے کلسٹرز کی تعداد بتانے کی ضرورت نہیں ہے۔ اسے بہت بڑے ڈیٹا بیس کے ساتھ بھی استعمال کیا جا سکتا ہے کیونکہ اسے اعلیٰ جہتی ڈیٹا کے لیے ڈیزائن کیا گیا تھا۔

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

DBSCAN ایکسٹینشنز

دوسرے الگورتھم ہیں، جیسے درجہ بندی DBSCAN (HDBSCAN) اور کلسٹرنگ ڈھانچے کی شناخت کے لیے پوائنٹس کو ترتیب دینا (OPTICS)، جو DBSCAN کی توسیع سمجھے جاتے ہیں۔

HDBSCAN اور OPTICS دونوں عام طور پر بہتر کارکردگی کا مظاہرہ کر سکتے ہیں جب ڈیٹا میں مختلف کثافتوں کے جھرمٹ ہوں اور انتخاب یا ابتدائی منٹ کے لیے بھی کم حساس ہوں۔ پوائنٹس اور ε پیرامیٹرز۔

• SEO سے چلنے والا مواد اور PR کی تقسیم۔ آج ہی بڑھا دیں۔
• پلیٹو بلاک چین۔ Web3 Metaverse Intelligence. علم میں اضافہ۔ یہاں تک رسائی حاصل کریں۔
• ماخذ: https://stackabuse.com/dbscan-with-scikit-learn-in-python/