Python's Scikit-Learn کے ساتھ SVM اور Kernel SVM کو نافذ کرنا

تعارف

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

اگر آپ تمام گائیڈز کو پڑھنا چاہتے ہیں یا یہ دیکھنا چاہتے ہیں کہ آپ کو کس میں سب سے زیادہ دلچسپی ہے، تو ذیل میں ہر گائیڈ میں شامل عنوانات کا جدول ہے:

1. Python's Scikit-Learn کے ساتھ SVM اور Kernel SVM کو لاگو کرنا

• کیس استعمال کریں: بینک نوٹ بھول جائیں۔
• SVMs کا پس منظر
• سادہ (لکیری) SVM ماڈل
  • ڈیٹا سیٹ کے بارے میں
  • ڈیٹاسیٹ درآمد کرنا
  • ڈیٹا سیٹ کی تلاش
• Scikit-Learn کے ساتھ SVM کو نافذ کرنا
  • ڈیٹا کو ٹرین/ٹیسٹ سیٹ میں تقسیم کرنا
  • ماڈل کی تربیت
  • پیش گوئیاں کرنا
  • ماڈل کا اندازہ لگانا
  • نتائج کی ترجمانی کرنا

2. SVM ہائپر پیرامیٹرز کو سمجھنا (جلد آرہا ہے!)

• سی ہائپر پیرامیٹر
• گاما ہائپر پیرامیٹر

3. Python's Scikit-Learn کے ساتھ دیگر SVM ذائقوں کو نافذ کرنا (جلد آرہا ہے!)

• SVMs کا عمومی خیال (ایک خلاصہ)
• دانا (ٹرک) SVM
• Scikit-Learn کے ساتھ نان لکیری کرنل SVM کو لاگو کرنا
• لائبریریاں درآمد کرنا
  • ڈیٹاسیٹ درآمد کرنا
  • ڈیٹا کو خصوصیات (X) اور ہدف (y) میں تقسیم کرنا
  • ڈیٹا کو ٹرین/ٹیسٹ سیٹ میں تقسیم کرنا
  • الگورتھم کی تربیت
• متعدد دانا
  • پیش گوئیاں کرنا
  • الگورتھم کا اندازہ لگانا
• گاوسی دانا
  • پیشن گوئی اور تشخیص
• سگمائیڈ دانا
  • پیشن گوئی اور تشخیص
• غیر لکیری دانا کی کارکردگی کا موازنہ

کیس استعمال کریں: جعلی بینک نوٹ

بعض اوقات لوگ بینک نوٹوں کو جعلی بنانے کا راستہ تلاش کرتے ہیں۔ اگر کوئی شخص ان نوٹوں کو دیکھ رہا ہے اور ان کی درستگی کی تصدیق کر رہا ہے، تو ہو سکتا ہے کہ ان کے ذریعے دھوکہ کھا جانا مشکل ہو۔

لیکن کیا ہوتا ہے جب ہر نوٹ کو دیکھنے کے لیے کوئی شخص نہ ہو؟ کیا خود بخود معلوم کرنے کا کوئی طریقہ ہے کہ بینک نوٹ جعلی ہیں یا اصلی؟

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

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

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

SVMs کا پس منظر

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

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

مثال میں ہم نے ابھی دیکھا ہے، پوائنٹس کے دونوں گروپس کو آسانی سے الگ کیا جا سکتا ہے، کیونکہ ہر انفرادی پوائنٹ اپنے ایک جیسے پوائنٹس کے قریب ہے، اور دونوں گروپ ایک دوسرے سے دور ہیں۔

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

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

دلچسپ بات یہ ہے کہ صرف حالیہ برسوں میں SVM کو بڑے پیمانے پر اپنایا گیا ہے، جس کی بنیادی وجہ بعض اوقات 90 فیصد سے زیادہ درست جوابات حاصل کرنے کی صلاحیت ہے یا درستگیمشکل مسائل کے لیے۔

SVMs کو ایک منفرد انداز میں لاگو کیا جاتا ہے جب دوسرے مشین لرننگ الگورتھم کے مقابلے میں، ایک بار جب وہ اعدادوشمار کی وضاحت پر مبنی ہوتے ہیں کہ سیکھنا کیا ہے، یا اعداد و شمار سیکھنا تھیوری.

اس مضمون میں، ہم دیکھیں گے کہ سپورٹ ویکٹر مشینوں کے الگورتھم کیا ہیں، سپورٹ ویکٹر مشین کے پیچھے مختصر نظریہ، اور Python کی Scikit-Learn لائبریری میں ان کا نفاذ۔ اس کے بعد ہم ایک اور SVM تصور کی طرف بڑھیں گے، جسے جانا جاتا ہے۔ کرنل ایس وی ایم، یا دانا کی چال، اور اسے Scikit-Learn کی مدد سے لاگو بھی کرے گا۔

سادہ (لکیری) SVM ماڈل

ڈیٹا سیٹ کے بارے میں

تعارف میں دی گئی مثال کے بعد، ہم ایک ڈیٹا سیٹ استعمال کریں گے جس میں اصلی اور جعلی بینک نوٹوں کی تصاویر کی پیمائش ہوگی۔

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

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

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

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

ڈیٹاسیٹ درآمد کرنا

بینک نوٹ ڈیٹاسیٹ جسے ہم اس سیکشن میں استعمال کرنے جا رہے ہیں وہی ہے جو کہ درجہ بندی کے سیکشن میں استعمال کیا گیا تھا۔ فیصلے کے درخت ٹیوٹوریل.

آئیے ڈیٹا کو پانڈا میں امپورٹ کرتے ہیں۔ dataframe ساخت، اور اس کے ساتھ اس کی پہلی پانچ قطاروں پر ایک نظر ڈالیں۔ head() طریقہ.

نوٹ کریں کہ ڈیٹا کو a میں محفوظ کیا گیا ہے۔ txt (ٹیکسٹ) فائل فارمیٹ، کوما سے الگ کیا گیا ہے، اور یہ بغیر ہیڈر کے ہے۔ ہم اسے بطور ٹیبل پڑھ کر دوبارہ تشکیل دے سکتے ہیں۔ csv، کی وضاحت کرنا separator کوما کے طور پر، اور کالم کے نام کے ساتھ شامل کرنا names دلیل.

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

import pandas as pd data_link = "https://archive.ics.uci.edu/ml/machine-learning-databases/00267/data_banknote_authentication.txt"
col_names = ["variance", "skewness", "curtosis", "entropy", "class"] bankdata = pd.read_csv(data_link, names=col_names, sep=",", header=None)
bankdata.head()

اس کے نتائج:

	variance skewness curtosis entropy class
0 3.62160 8.6661 -2.8073 -0.44699 0
1 4.54590 8.1674 -2.4586 -1.46210 0
2 3.86600 -2.6383 1.9242 0.10645 0
3 3.45660 9.5228 -4.0112 -3.59440 0
4 0.32924 -4.4552 4.5718 -0.98880 0

ہم دیکھ سکتے ہیں کہ ہمارے ڈیٹاسیٹ میں پانچ کالم ہیں، یعنی، variance, skewness, curtosis, entropy، اور class. پانچ قطاروں میں، پہلے چار کالم نمبروں سے بھرے ہوئے ہیں جیسے کہ 3.62160، 8.6661، -2.8073 یا مسلسل اقدار، اور آخری class کالم کی پہلی پانچ قطاریں 0s، یا a سے بھری ہوئی ہیں۔ متفرد قدر.

چونکہ ہمارا مقصد یہ اندازہ لگانا ہے کہ آیا کوئی بینک کرنسی نوٹ مستند ہے یا نہیں، اس لیے ہم نوٹ کی چار صفات کی بنیاد پر ایسا کر سکتے ہیں:

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

• skewness ویولیٹ ٹرانسفارمڈ امیج کا۔ skewness ایک مسلسل قدر ہے جو تقسیم کی عدم توازن کی نشاندہی کرتی ہے۔ اگر وسط کے بائیں جانب مزید قدریں ہیں، تو تقسیم ہے۔ منفی طور پر ترچھا, اگر وسط کے دائیں طرف زیادہ قدریں ہیں تو تقسیم ہے۔ مثبت طور پر ترچھا، اور اگر وسط، موڈ اور میڈین ایک جیسے ہیں، تو تقسیم ہے۔ سڈول. تقسیم جتنی زیادہ ہموار ہوتی ہے، یہ عام تقسیم کے اتنا ہی قریب ہوتی ہے، اس کی قدریں بھی زیادہ اچھی طرح سے تقسیم ہوتی ہیں۔ موجودہ سیاق و سباق میں، یہ ان گتانکوں کی ترچھی ہے جو ویولیٹ ٹرانسفارم کے نتیجے میں ہوتی ہے۔ ہم جتنے زیادہ سڈول، گتانک اتنے ہی قریب ہوں گے۔variance, skewness, curtosis, entropyاصل تصویر کا ترجمہ کرنے کے لیے دوبارہ۔

• curtosis ویولیٹ ٹرانسفارمڈ امیج کا (یا کرٹوسس)۔ کرٹوسس ایک مسلسل قدر ہے جو ترچھی پن کی طرح تقسیم کی شکل کو بھی بیان کرتی ہے۔ کرٹوسس گتانک (k) پر منحصر ہے، ایک تقسیم - جب عام تقسیم کے مقابلے میں کم یا زیادہ فلیٹ ہو سکتی ہے - یا اس کی انتہا یا دم میں زیادہ یا کم ڈیٹا ہوتا ہے۔ جب تقسیم زیادہ پھیلی اور چاپلوسی کی جائے تو اسے کہتے ہیں۔ platykurtic; جب یہ کم پھیلا ہوا ہو اور درمیان میں زیادہ مرتکز ہو، mesokurtic; اور جب تقسیم تقریباً مکمل طور پر درمیان میں مرکوز ہو جائے تو اسے کہا جاتا ہے۔ leptokurtic. یہ وہی معاملہ ہے جیسا کہ متغیر اور ترچھا پن پہلے کے معاملات میں، تقسیم جتنی زیادہ میسوکورٹک ہوگی، گتانک اصل تصویر کا ترجمہ کرنے کے اتنے ہی قریب ہوں گے۔

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

پانچواں متغیر تھا۔ class متغیر، جس کی غالباً 0 اور 1 قدریں ہیں، جو کہتی ہیں کہ آیا نوٹ اصلی تھا یا جعلی۔

ہم چیک کر سکتے ہیں کہ آیا پانچویں کالم میں زیرو ہیں اور پانڈوں کے ساتھ unique() طریقہ:

bankdata['class'].unique()

مندرجہ بالا طریقہ واپس آتا ہے:

array([0, 1]) 

مندرجہ بالا طریقہ 0 اور 1 اقدار کے ساتھ ایک صف واپس کرتا ہے۔ اس کا مطلب ہے کہ ہماری کلاس کی قطاروں میں صرف وہی قدریں ہیں جو صفر اور ایک ہیں۔ یہ بطور استعمال کرنے کے لیے تیار ہے۔ ہدف ہماری زیر نگرانی سیکھنے میں۔

• class تصویر کا یہ ایک عددی قدر ہے، جب تصویر جعلی ہوتی ہے تو یہ 0 ہوتی ہے، اور جب تصویر اصلی ہوتی ہے تو 1 ہوتی ہے۔

چونکہ ہمارے پاس اصلی اور بھول جانے والی تصاویر کی تشریحات کے ساتھ ایک کالم ہے، اس کا مطلب ہے کہ ہماری سیکھنے کی قسم نگرانی.

ہم ڈیٹا میں قطاروں کی تعداد کو دیکھ کر یہ بھی دیکھ سکتے ہیں کہ ہمارے پاس کتنے ریکارڈ، یا تصاویر ہیں۔ shape جائیداد:

bankdata.shape

یہ نتائج:

(1372, 5)

اوپر کی سطر کا مطلب ہے کہ تبدیل شدہ بینک نوٹوں کی تصاویر کی 1,372 قطاریں اور 5 کالم ہیں۔ یہ وہ ڈیٹا ہے جس کا ہم تجزیہ کریں گے۔

ہم نے اپنا ڈیٹاسیٹ درآمد کیا ہے اور کچھ چیک کیے ہیں۔ اب ہم اسے بہتر طور پر سمجھنے کے لیے اپنے ڈیٹا کو دریافت کر سکتے ہیں۔

ڈیٹا سیٹ کی تلاش

ہم نے ابھی دیکھا ہے کہ کلاس کالم میں صرف صفر اور والے ہوتے ہیں، لیکن ہم یہ بھی جان سکتے ہیں کہ وہ کس تناسب سے ہیں - دوسرے لفظوں میں - اگر ایک سے زیادہ صفر ہیں، صفر سے زیادہ ہیں، یا اگر صفر ایک ہی تعداد کے برابر ہے، یعنی وہ ہیں۔ متوازن.

تناسب جاننے کے لیے ہم ڈیٹا میں ہر ایک صفر اور ایک قدر کو شمار کر سکتے ہیں۔ value_counts() طریقہ:

bankdata['class'].value_counts()

یہ نتائج:

0 762
1 610
Name: class, dtype: int64

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

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

پہلا قدم پانڈا استعمال کرنا ہے۔ value_counts() طریقہ پھر، لیکن اب دلیل کو شامل کرکے فیصد دیکھیں normalize=True:

bankdata['class'].value_counts(normalize=True)

۔ normalize=True ہر کلاس کے ڈیٹا کے فیصد کا حساب لگاتا ہے۔ اب تک، جعلی (0) اور حقیقی ڈیٹا (1) کا فیصد یہ ہے:

0 0.555394
1 0.444606
Name: class, dtype: float64

اس کا مطلب ہے کہ ہمارے ڈیٹاسیٹ کا تقریباً (~) 56% جعلی ہے اور اس میں سے 44% اصلی ہے۔ اس سے ہمیں 56%-44% تناسب ملتا ہے، جو کہ 12% فرق کے برابر ہے۔ اسے شماریاتی طور پر ایک چھوٹا سا فرق سمجھا جاتا ہے، کیونکہ یہ 10% سے تھوڑا اوپر ہے، اس لیے ڈیٹا کو متوازن سمجھا جاتا ہے۔ اگر 56:44 تناسب کے بجائے، 80:20 یا 70:30 کا تناسب تھا، تو ہمارے ڈیٹا کو غیر متوازن سمجھا جائے گا، اور ہمیں عدم توازن کا کچھ علاج کرنے کی ضرورت ہوگی، لیکن خوش قسمتی سے، ایسا نہیں ہے۔

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

bankdata['class'].plot.hist();

یہ ڈیٹا فریم ڈھانچہ کو براہ راست استعمال کرتے ہوئے ایک ہسٹوگرام تیار کرتا ہے۔ matplotlib لائبریری جو پردے کے پیچھے ہے۔

ہسٹوگرام کو دیکھ کر، ہم اس بات کا یقین کر سکتے ہیں کہ ہمارے ہدف کی اقدار یا تو 0 یا 1 ہیں اور یہ کہ ڈیٹا متوازن ہے۔

یہ اس کالم کا تجزیہ تھا جس کی ہم پیشین گوئی کرنے کی کوشش کر رہے تھے، لیکن ہمارے ڈیٹا کے دوسرے کالموں کا تجزیہ کیا جائے؟

ہم کے ساتھ شماریاتی پیمائش پر ایک نظر ڈال سکتے ہیں۔ describe() ڈیٹا فریم کا طریقہ ہم بھی استعمال کر سکتے ہیں۔ .T آف ٹرانسپوز - کالموں اور قطاروں کو الٹنے کے لیے، تمام اقدار کا موازنہ کرنے کے لیے اسے زیادہ سیدھا بناتا ہے:

bankdata.describe().T

اس کے نتائج:

 count mean std min 25% 50% 75% max
variance 1372.0 0.433735 2.842763 -7.0421 -1.773000 0.49618 2.821475 6.8248
skewness 1372.0 1.922353 5.869047 -13.7731 -1.708200 2.31965 6.814625 12.9516
curtosis 1372.0 1.397627 4.310030 -5.2861 -1.574975 0.61663 3.179250 17.9274
entropy 1372.0 -1.191657 2.101013 -8.5482 -2.413450 -0.58665 0.394810 2.4495
class 1372.0 0.444606 0.497103 0.0000 0.000000 0.00000 1.000000 1.0000

دھیان دیں کہ skewness اور curtosis کے کالموں میں وہ قدریں ہوتی ہیں جو معیاری انحراف کی قدروں سے بہت دور ہوتی ہیں، اس سے ظاہر ہوتا ہے کہ وہ قدریں جو ڈیٹا کے مرکزی رجحان سے آگے ہیں، یا ان میں زیادہ تغیر ہے۔

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

آئیے ہر خصوصیت کی تقسیم کے ساتھ شروع کریں، اور ہر ڈیٹا کالم کا ہسٹگرام پلاٹ کریں سوائے class کالم class بینک ڈیٹا کالم سرنی میں کالم کو اس کی پوزیشن پر غور نہیں کیا جائے گا۔ تمام کالموں کو منتخب کیا جائے گا سوائے آخری کے ساتھ columns[:-1]:

import matplotlib.pyplot as plt for col in bankdata.columns[:-1]: plt.title(col) bankdata[col].plot.hist() plt.show();

مندرجہ بالا کوڈ کو چلانے کے بعد، ہم دیکھ سکتے ہیں کہ دونوں skewness اور entropy ڈیٹا کی تقسیم منفی طور پر ترچھی ہے اور curtosis مثبت طور پر متزلزل ہے. تمام تقسیم متوازی ہیں، اور variance واحد تقسیم ہے جو معمول کے قریب ہے۔

اب ہم دوسرے حصے کی طرف بڑھ سکتے ہیں، اور ہر متغیر کے سکیٹر پلاٹ کو پلاٹ کر سکتے ہیں۔ ایسا کرنے کے لیے، ہم کلاس کے علاوہ تمام کالم بھی منتخب کر سکتے ہیں۔ columns[:-1]، سیبورن کا استعمال کریں۔ scatterplot() اور ہر فیچر کے لیے جوڑی بنانے میں تغیرات حاصل کرنے کے لیے لوپس کے لیے دو۔ ہم کسی خصوصیت کی جوڑی کو اپنے ساتھ بھی خارج کر سکتے ہیں، جانچ کر کے کہ آیا پہلی خصوصیت دوسری خصوصیت کے ساتھ برابر ہے if statement.

import seaborn as sns for feature_1 in bankdata.columns[:-1]: for feature_2 in bankdata.columns[:-1]: if feature_1 != feature_2: print(feature_1, feature_2) sns.scatterplot(x=feature_1, y=feature_2, data=bankdata, hue='class') plt.show();

نوٹ کریں کہ تمام گرافس میں اصلی اور جعلی دونوں ڈیٹا پوائنٹس ہیں جو واضح طور پر ایک دوسرے سے الگ نہیں ہوئے ہیں، اس کا مطلب ہے کہ کلاسز کی کسی نہ کسی طرح کی سپر پوزیشن ہے۔ چونکہ ایک SVM ماڈل کلاسوں کے درمیان الگ کرنے کے لیے ایک لائن کا استعمال کرتا ہے، کیا گراف میں ان گروپوں میں سے کسی کو صرف ایک لائن کا استعمال کرتے ہوئے الگ کیا جا سکتا ہے؟ اس کا امکان نہیں لگتا۔ یہ وہی ہے جو سب سے زیادہ حقیقی ڈیٹا کی طرح لگتا ہے. سب سے قریب ہم علیحدگی کے لئے حاصل کر سکتے ہیں کے مجموعہ میں ہے skewness اور variance، یا entropy اور variance پلاٹ یہ شاید اس کی وجہ سے ہے۔ variance ڈیٹا کی تقسیم کی شکل ہے جو معمول کے قریب ہے۔

لیکن ترتیب میں ان تمام گرافس کو دیکھنا تھوڑا مشکل ہوسکتا ہے۔ ہمارے پاس سیبورن کا استعمال کرتے ہوئے تمام تقسیم اور سکیٹر پلاٹ گراف کو ایک ساتھ دیکھنے کا متبادل ہے۔ pairplot().

پچھلے دونوں لوپس کو جو ہم نے کیا تھا صرف اس لائن سے بدلا جا سکتا ہے:

sns.pairplot(bankdata, hue='class');

جوڑے کو دیکھ کر ایسا لگتا ہے کہ اصل میں، curtosis اور variance خصوصیات کا سب سے آسان مجموعہ ہوگا، لہذا مختلف کلاسز کو ایک لائن سے الگ کیا جاسکتا ہے، یا لکیری طور پر الگ کیا جا سکتا ہے.

اگر زیادہ تر ڈیٹا لکیری طور پر الگ ہونے سے بہت دور ہے، تو ہم اس کے طول و عرض کو کم کر کے اسے پہلے سے پروسیس کرنے کی کوشش کر سکتے ہیں، اور تقسیم کو معمول کے قریب تر بنانے کی کوشش کرنے کے لیے اس کی اقدار کو بھی معمول بنا سکتے ہیں۔

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

Scikit-Learn کے ساتھ SVM کو نافذ کرنا

SVM کیسے کام کرتا ہے اس تھیوری میں مزید جاننے سے پہلے، ہم ڈیٹا کے ساتھ اپنا پہلا بیس لائن ماڈل بنا سکتے ہیں، اور Scikit-Learn's ویکٹر کلاسیفائر کو سپورٹ کریں۔ or ایسویسی کلاس.

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

ڈیٹا کو ٹرین/ٹیسٹ سیٹ میں تقسیم کرنا

پچھلے سیشن میں، ہم نے ڈیٹا کو سمجھا اور اس کی کھوج کی۔ اب، ہم اپنے ڈیٹا کو دو صفوں میں تقسیم کر سکتے ہیں - ایک چار خصوصیات کے لیے، اور دوسری پانچویں، یا ہدف کی خصوصیت کے لیے۔ چونکہ ہم طبقے کی پیشن گوئی کرنا چاہتے ہیں جس کا انحصار طول و عرض کے گتانک پر منحصر ہے، ہمارے y ہو گا class کالم اور ہمارے X کرے گا variance, skewness, curtosis، اور entropy کالم۔

ہدف اور خصوصیات کو الگ کرنے کے لیے، ہم صرف کو منسوب کر سکتے ہیں۔ class کالم y، بعد میں باقی کالموں کو منسوب کرنے کے لیے اسے ڈیٹا فریم سے چھوڑ کر X ساتھ .drop() طریقہ:

y = bankdata['class']
X = bankdata.drop('class', axis=1) 

ایک بار جب ڈیٹا کو صفات اور لیبلز میں تقسیم کر دیا جاتا ہے، تو ہم اسے مزید ٹرین اور ٹیسٹ سیٹ میں تقسیم کر سکتے ہیں۔ یہ ہاتھ سے کیا جا سکتا ہے، لیکن model_selection Scikit-Learn کی لائبریری پر مشتمل ہے۔ train_test_split() وہ طریقہ جو ہمیں ڈیٹا کو تصادفی طور پر ٹرین اور ٹیسٹ سیٹ میں تقسیم کرنے کی اجازت دیتا ہے۔

اسے استعمال کرنے کے لیے، ہم لائبریری کو درآمد کر سکتے ہیں، کال کریں۔ train_test_split() طریقہ، پاس X اور y ڈیٹا، اور وضاحت کریں a test_size ایک دلیل کے طور پر منتقل کرنے کے لئے. اس صورت میں، ہم اس کی تعریف کریں گے۔ 0.20- اس کا مطلب ہے کہ 20% ڈیٹا ٹیسٹنگ کے لیے استعمال کیا جائے گا، اور باقی 80% تربیت کے لیے۔

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

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

ایسا کرنے کے لیے آپ درج ذیل اسکرپٹ پر عمل کر سکتے ہیں۔

from sklearn.model_selection import train_test_split SEED = 42 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20, random_state = SEED)

نوٹ کریں کہ train_test_split() طریقہ پہلے ہی واپس کرتا ہے۔ X_train, X_test, y_train, y_test اس ترتیب میں سیٹ کرتا ہے۔ ہم ٹرین اور ٹیسٹ کے لیے الگ کیے گئے نمونوں کی تعداد کو پہلے (0) عنصر حاصل کرکے پرنٹ کرسکتے ہیں۔ shape جائیداد کی واپسی:

xtrain_samples = X_train.shape[0]
xtest_samples = X_test.shape[0] print(f'There are {xtrain_samples} samples for training and {xtest_samples} samples for testing.')

اس سے پتہ چلتا ہے کہ ٹریننگ کے لیے 1097 اور جانچ کے لیے 275 نمونے ہیں۔

ماڈل کی تربیت

ہم نے ڈیٹا کو ٹرین اور ٹیسٹ سیٹ میں تقسیم کیا ہے۔ اب وقت آگیا ہے کہ ٹرین ڈیٹا پر SVM ماڈل بنائیں اور اس کو تربیت دیں۔ ایسا کرنے کے لیے، ہم Scikit-Learn's درآمد کر سکتے ہیں۔ svm کے ساتھ ساتھ لائبریری ویکٹر کلاسیفائر کو سپورٹ کریں۔ کلاس، یا SVC کلاس.

کلاس کو درآمد کرنے کے بعد، ہم اس کی ایک مثال بنا سکتے ہیں - چونکہ ہم ایک سادہ SVM ماڈل بنا رہے ہیں، اس لیے ہم اپنے ڈیٹا کو لکیری طور پر الگ کرنے کی کوشش کر رہے ہیں، اس لیے ہم اپنے ڈیٹا کو تقسیم کرنے کے لیے ایک لکیر کھینچ سکتے ہیں - جو کہ استعمال کرنے کے مترادف ہے۔ لکیری فنکشن - وضاحت کے ذریعے kernel='linear' درجہ بندی کرنے والے کی دلیل کے طور پر:

from sklearn.svm import SVC
svc = SVC(kernel='linear')

اس طرح، درجہ بندی کرنے والا ایک لکیری فنکشن تلاش کرنے کی کوشش کرے گا جو ہمارے ڈیٹا کو الگ کرتا ہے۔ ماڈل بنانے کے بعد، آئیے اسے تربیت دیں، یا فٹ یہ، ٹرین کے اعداد و شمار کے ساتھ، ملازمت fit() طریقہ اور دینا X_train خصوصیات اور y_train اہداف بطور دلیل۔

ماڈل کو تربیت دینے کے لیے ہم درج ذیل کوڈ پر عمل کر سکتے ہیں:

svc.fit(X_train, y_train)

بس اسی طرح ماڈل کو تربیت دی جاتی ہے۔ اب تک، ہم نے ڈیٹا کو سمجھ لیا ہے، اسے تقسیم کیا ہے، ایک سادہ SVM ماڈل بنایا ہے، اور ماڈل کو ٹرین کے ڈیٹا میں فٹ کیا ہے۔

اگلا مرحلہ یہ سمجھنا ہے کہ وہ ہمارے ڈیٹا کی وضاحت کرنے میں کس حد تک فٹ ہے۔ دوسرے لفظوں میں، جواب دینے کے لیے کہ کیا لکیری SVM ایک مناسب انتخاب تھا۔

پیش گوئیاں کرنا

اگر ماڈل ڈیٹا کو بیان کرنے میں کامیاب ہو گیا تو جواب دینے کا ایک طریقہ حساب لگانا اور کچھ درجہ بندی کو دیکھنا ہے۔ میٹرکس.

اس بات پر غور کرتے ہوئے کہ سیکھنے کی نگرانی کی جاتی ہے، ہم اس کے ساتھ پیشین گوئیاں کر سکتے ہیں۔ X_test اور ان پیشین گوئی کے نتائج کا موازنہ کریں – جسے ہم کہہ سکتے ہیں۔ y_pred - اصل کے ساتھ y_test، یا زمینی حقائق.

کچھ اعداد و شمار کی پیشن گوئی کرنے کے لیے، ماڈل کا predict() طریقہ استعمال کیا جا سکتا ہے۔ یہ طریقہ ٹیسٹ کی خصوصیات حاصل کرتا ہے، X_test، ایک دلیل کے طور پر اور پیشین گوئی واپس کرتا ہے، یا تو 0 یا 1، ہر ایک کے لیے X_testکی قطاریں

پیشن گوئی کے بعد X_test ڈیٹا، نتائج a میں محفوظ کیے جاتے ہیں۔ y_pred متغیر لہذا سادہ لکیری SVM ماڈل کے ساتھ پیش گوئی کی گئی ہر کلاس اب میں ہے۔ y_pred متغیر.

یہ پیشین گوئی کوڈ ہے:

y_pred = svc.predict(X_test)

اس بات پر غور کرتے ہوئے کہ ہمارے پاس پیشین گوئیاں ہیں، اب ہم ان کا اصل نتائج سے موازنہ کر سکتے ہیں۔

ماڈل کا اندازہ لگانا

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

1. کنفیوژن میٹرکس: جب ہمیں یہ جاننے کی ضرورت ہوتی ہے کہ ہمیں کتنے نمونے صحیح یا غلط ملے ہر کلاس. ان اقدار کو کہا جاتا ہے جن کی صحیح اور درست پیش گوئی کی گئی تھی۔ حقیقی مثبت, جن کی پیشین گوئی مثبت کے طور پر کی گئی تھی لیکن وہ مثبت نہیں تھے کہلاتے ہیں۔ غلط مثبت. کا ایک ہی نام حقیقی منفی اور جھوٹے منفی منفی اقدار کے لیے استعمال کیا جاتا ہے؛

2. صحت سے متعلق: جب ہمارا مقصد یہ سمجھنا ہے کہ ہمارے درجہ بندی کرنے والے نے پیشین گوئی کی کن درست اقدار کو درست سمجھا ہے۔ درستگی ان حقیقی مثبت اقدار کو ان نمونوں سے تقسیم کرے گی جن کی پیشین گوئی مثبت کے طور پر کی گئی تھی۔

$$
precision = frac{text{true positives}}{text{true positives} + text{false positives}}
$$

3. یاد رکھیں: عام طور پر درستگی کے ساتھ حساب کیا جاتا ہے تاکہ یہ سمجھنے کے لیے کہ ہمارے درجہ بندی کرنے والے نے کتنے حقیقی مثبتات کی نشاندہی کی ہے۔ واپسی کا حساب حقیقی مثبت کو کسی بھی چیز سے تقسیم کرکے لگایا جاتا ہے جس کی مثبت پیشین گوئی کی جانی چاہیے تھی۔

$$
recall = frac{text{true positives}}{text{true positives} + text{false negatives}}
$$

4. F1 سکور: متوازن غذا ہے۔ ہارمونک مطلب درستگی اور یاد کی. سب سے کم قیمت 0 ہے اور سب سے زیادہ 1 ہے۔ کب f1-score 1 کے برابر ہے، اس کا مطلب ہے کہ تمام کلاسوں کی صحیح پیش گوئی کی گئی تھی - یہ حقیقی اعداد و شمار کے ساتھ حاصل کرنے کے لیے بہت مشکل اسکور ہے (استثنیات تقریباً ہمیشہ موجود ہیں)۔

$$
متن{f1-score} = 2* frac{text{precision} * text{recall}}{text{precision} + text{recall}}
$$

ہم کنفیوژن میٹرکس، درستگی، یاد کرنے، اور F1 سکور کے اقدامات سے پہلے ہی واقف ہو چکے ہیں۔ ان کا حساب لگانے کے لیے، ہم Scikit-Learn's درآمد کر سکتے ہیں۔ metrics کتب خانہ. اس لائبریری پر مشتمل ہے۔ classification_report اور confusion_matrix طریقوں، درجہ بندی کی رپورٹ کا طریقہ درستگی، یاد، اور f1 سکور واپس کرتا ہے۔ دونوں classification_report اور confusion_matrix ان تمام اہم میٹرکس کی قدروں کو تلاش کرنے کے لیے آسانی سے استعمال کیا جا سکتا ہے۔

میٹرکس کا حساب لگانے کے لیے، ہم طریقے درآمد کرتے ہیں، انہیں کال کرتے ہیں اور پیشین گوئی کی گئی درجہ بندیوں کو بطور دلیل پاس کرتے ہیں، y_test، اور درجہ بندی کے لیبلز، یا y_true.

کنفیوژن میٹرکس کے بہتر تصور کے لیے، ہم اسے سیبورن میں پلاٹ کر سکتے ہیں۔ heatmap مقدار کی تشریحات کے ساتھ، اور درجہ بندی کی رپورٹ کے لیے، اس کے نتائج کو پرنٹ کرنا بہتر ہے، اس لیے اس کے نتائج فارمیٹ کیے گئے ہیں۔ یہ درج ذیل کوڈ ہے:

from sklearn.metrics import classification_report, confusion_matrix cm = confusion_matrix(y_test,y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Confusion matrix of linear SVM') print(classification_report(y_test,y_pred))

یہ دکھاتا ہے:

 precision recall f1-score support 0 0.99 0.99 0.99 148 1 0.98 0.98 0.98 127 accuracy 0.99 275 macro avg 0.99 0.99 0.99 275
weighted avg 0.99 0.99 0.99 275

درجہ بندی کی رپورٹ میں، ہم جانتے ہیں کہ جعلی نوٹوں کے لیے 0.99 کی درستگی، 0.99 کی واپسی اور 1 کا f0.99 سکور ہے، یا کلاس 0۔ وہ پیمائشیں 148 نمونوں کا استعمال کرتے ہوئے حاصل کی گئیں جیسا کہ سپورٹ کالم میں دکھایا گیا ہے۔ دریں اثنا، کلاس 1، یا اصلی نوٹ کے لیے، نتیجہ ایک یونٹ نیچے، درستگی کا 0.98، یاد کرنے کا 0.98، اور وہی F1 سکور تھا۔ اس بار، ان نتائج کو حاصل کرنے کے لیے 127 تصویری پیمائشیں استعمال کی گئیں۔

اگر ہم کنفیوژن میٹرکس پر نظر ڈالیں، تو ہم یہ بھی دیکھ سکتے ہیں کہ 148 کلاس 0 کے نمونوں میں سے، 146 کو صحیح طور پر درجہ بندی کیا گیا تھا، اور 2 غلط مثبت تھے، جبکہ 127 کلاس 1 کے نمونوں کے لیے، 2 غلط منفی اور 125 سچے مثبت تھے۔

ہم درجہ بندی کی رپورٹ اور کنفیوژن میٹرکس کو پڑھ سکتے ہیں، لیکن ان کا کیا مطلب ہے؟

نتائج کی ترجمانی کرنا

معنی جاننے کے لیے، آئیے تمام میٹرکس کو ملا کر دیکھیں۔

کلاس 1 کے تقریباً تمام نمونوں کی صحیح درجہ بندی کی گئی تھی، اصل بینک نوٹوں کی شناخت کرتے وقت ہمارے ماڈل میں 2 غلطیاں تھیں۔ یہ 0.98، یا 98%، یاد کرنے کے برابر ہے۔ کلاس 0 کے بارے میں بھی کچھ ایسا ہی کہا جا سکتا ہے، صرف 2 نمونوں کی غلط درجہ بندی کی گئی تھی، جبکہ 148 صحیح منفی ہیں، مجموعی طور پر 99٪ کی درستگی۔

ان نتائج کے علاوہ، باقی سبھی 0.99 کو نشان زد کر رہے ہیں، جو کہ تقریباً 1 ہے، ایک بہت زیادہ میٹرک۔ زیادہ تر وقت، جب حقیقی زندگی کے اعداد و شمار کے ساتھ اتنا اعلیٰ میٹرک ہوتا ہے، تو یہ ایک ایسے ماڈل کی نشاندہی کر رہا ہو سکتا ہے جو ڈیٹا سے زیادہ ایڈجسٹ ہو گیا ہو، یا اوور فٹڈ.

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

یہ معلوم کرنے کے لیے کہ آیا اوور فٹ ہو رہا ہے ایک فوری ٹیسٹ ٹرین ڈیٹا کے ساتھ بھی ہے۔ اگر ماڈل نے ٹرین کا ڈیٹا کسی حد تک حفظ کر لیا ہے تو میٹرکس 1 یا 100% کے بہت قریب ہوں گے۔ یاد رکھیں کہ ٹرین کا ڈیٹا ٹیسٹ کے اعداد و شمار سے بڑا ہوتا ہے – اس وجہ سے – اسے متناسب طور پر دیکھنے کی کوشش کریں، زیادہ نمونے، غلطیوں کے زیادہ امکانات، جب تک کہ کچھ اوور فٹ نہ ہو۔

ٹرین ڈیٹا کے ساتھ پیشین گوئی کرنے کے لیے، ہم ٹیسٹ ڈیٹا کے لیے جو کچھ ہم نے کیا ہے اسے دہرا سکتے ہیں، لیکن اب اس کے ساتھ X_train:

y_pred_train = svc.predict(X_train) cm_train = confusion_matrix(y_train,y_pred_train)
sns.heatmap(cm_train, annot=True, fmt='d').set_title('Confusion matrix of linear SVM with train data') print(classification_report(y_train,y_pred_train))

یہ نتائج:

 precision recall f1-score support 0 0.99 0.99 0.99 614 1 0.98 0.99 0.99 483 accuracy 0.99 1097 macro avg 0.99 0.99 0.99 1097
weighted avg 0.99 0.99 0.99 1097

یہ دیکھنا آسان ہے کہ ایک اوور فٹ لگ رہا ہے، ایک بار جب ٹرین میٹرکس 99% ہو جاتا ہے جب 4 گنا زیادہ ڈیٹا ہوتا ہے۔ اس منظر نامے میں کیا کیا جا سکتا ہے؟

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

آپ اس گائیڈ کا دوسرا حصہ دیکھ سکتے ہیں (جلد آرہا ہے!یہ دیکھنے کے لیے کہ کراس توثیق کو کیسے نافذ کیا جائے اور ہائپر پیرامیٹر ٹیوننگ کیسے کی جائے۔

نتیجہ

اس مضمون میں ہم نے سادہ لکیری دانا SVM کا مطالعہ کیا۔ ہمیں SVM الگورتھم کے پیچھے بصیرت ملی، ایک حقیقی ڈیٹاسیٹ استعمال کیا، ڈیٹا کو دریافت کیا، اور دیکھا کہ اس ڈیٹا کو Python کی Scikit-Learn لائبریری کے ساتھ لاگو کرکے SVM کے ساتھ کس طرح استعمال کیا جا سکتا ہے۔

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

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

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