ازگر میں لاجسٹک ریگریشن کے لیے حتمی گائیڈ

تعارف

کبھی کبھی الجھ جاتا ہے۔ لکیری رجعت novices کی طرف سے - اصطلاح کا اشتراک کرنے کی وجہ سے رجعت - لاجسٹک رجعت سے بہت مختلف ہے لکیری رجعت. جبکہ لکیری رجعت 2، 2.45، 6.77 یا جیسی اقدار کی پیش گوئی کرتی ہے۔ مسلسل اقدار، اسے بنانا a رجعت الگورتھم ، لاجسٹک رجعت 0 یا 1، 1 یا 2 یا 3 جیسی قدروں کی پیش گوئی کرتا ہے، جو کہ ہیں۔ مجرد اقدار، اسے بنانا a درجہ بندی الگورتھم ہاں، اسے کہا جاتا ہے۔ رجعت لیکن ایک ہے درجہ بندی الگورتھم ایک لمحے میں اس پر مزید۔

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

اس گائیڈ میں، ہم Scikit-Learn لائبریری کے ساتھ Python میں لاجسٹک ریگریشن انجام دیں گے۔ ہم یہ بھی بتائیں گے کہ لفظ کیوں؟ "رجعت" نام میں موجود ہے اور لاجسٹک ریگریشن کیسے کام کرتا ہے۔

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

پریرتا

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

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

ترک فارم کدو کے بیجوں کی دو اقسام کے ساتھ کام کرتا ہے، ایک کہلاتا ہے۔ Çerçevelik اور دوسرا Ürgüp Sivrisi.

کدو کے بیجوں کی درجہ بندی کرنے کے لیے، آپ کی ٹیم نے 2021 کے پیپر کی پیروی کی ہے۔ کدو کے بیجوں کی درجہ بندی میں مشین سیکھنے کے طریقوں کا استعمال (Cucurbita pepo L.) جینیاتی وسائل اور فصل کا ارتقاء" کوکلو، سارگیل اور اوزبیک سے - اس مقالے میں، تصویروں سے بیجوں کی پیمائش اور نکالنے کا طریقہ کار موجود ہے۔

کاغذ میں بیان کردہ عمل کو مکمل کرنے کے بعد، درج ذیل پیمائشیں نکالی گئیں:

• علاقے - کدو کے بیج کی حدود میں پکسلز کی تعداد
• احاطہ - کدو کے بیج کے پکسلز میں فریم
• بڑے محور کی لمبائی - کدو کے بیج کے پکسلز میں فریم بھی
• معمولی محور کی لمبائی - کدو کے بیج کا چھوٹا محور کا فاصلہ
• سنجیدگی - کدو کے بیج کی سنکی پن
• محدب علاقہ - کدو کے بیج سے بننے والے خطے میں سب سے چھوٹے محدب خول کے پکسلز کی تعداد
• بظاہر - کدو کے بیج کے حصے کا باؤنڈنگ باکس پکسلز کا تناسب
• مساوی قطر - کدو کے بیج کے رقبے کے ضرب کی مربع جڑ کو چار سے تقسیم کرکے پائی
• کومپیکٹینس - کدو کے بیج کے رقبے کا تناسب اسی فریم کے ساتھ دائرے کے رقبے کے نسبت
• سالمیت - کدو کے بیجوں کی محدب اور محدب حالت
• گول ہونا - کدو کے بیجوں کی اوولٹی اس کے کناروں کی بگاڑ پر غور کیے بغیر
• جانبی تناسب - کدو کے بیجوں کا پہلو تناسب

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

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

ڈیٹا سیٹ کو سمجھنا

ڈیٹا سیٹ کو ڈاؤن لوڈ کرنے کے بعد، ہم اسے استعمال کر کے ڈیٹا فریم ڈھانچے میں لوڈ کر سکتے ہیں۔ pandas کتب خانہ. چونکہ یہ ایکسل فائل ہے، اس لیے ہم استعمال کریں گے۔ read_excel() طریقہ:

import pandas as pd

fpath = 'dataset/pumpkin_seeds_dataset.xlsx' 
df = pd.read_excel(fpath)

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

df.head() 

اس کے نتائج:

	Area 	Perimeter 	Major_Axis_Length 	Minor_Axis_Length 	Convex_Area 	Equiv_Diameter 	Eccentricity 	Solidity 	Extent 	Roundness 	Aspect_Ration 	Compactness 	Class
0 	56276 	888.242 	326.1485 			220.2388 			56831 			267.6805 		0.7376 			0.9902 		0.7453 	0.8963 		1.4809 			0.8207 			Çerçevelik
1 	76631 	1068.146 	417.1932 			234.2289 			77280 			312.3614 		0.8275 			0.9916 		0.7151 	0.8440 		1.7811 			0.7487 			Çerçevelik
2 	71623 	1082.987 	435.8328 			211.0457 			72663 			301.9822 		0.8749 			0.9857 		0.7400 	0.7674 		2.0651 			0.6929 			Çerçevelik
3 	66458 	992.051 	381.5638 			222.5322 			67118 			290.8899 		0.8123 			0.9902 		0.7396 	0.8486 		1.7146 			0.7624 			Çerçevelik
4 	66107 	998.146 	383.8883 			220.4545 			67117 			290.1207 		0.8187 			0.9850 		0.6752 	0.8338 		1.7413 			0.7557 			Çerçevelik

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

df.shape 

پیداوار یہ ہے:

(2500, 13)

شکل کا نتیجہ ہمیں بتاتا ہے کہ ڈیٹاسیٹ میں 2500 اندراجات (یا قطاریں) اور 13 کالم ہیں۔ چونکہ ہم جانتے ہیں کہ ایک ٹارگٹ کالم ہے – اس کا مطلب ہے کہ ہمارے پاس 12 فیچر کالم ہیں۔

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

یہ معائنہ ہر بیج کے نمونے کے ساتھ گن کر کیا جا سکتا ہے۔ value_counts() طریقہ:

df['Class'].value_counts() 

مندرجہ بالا کوڈ دکھاتا ہے:

Çerçevelik       1300
Ürgüp Sivrisi    1200
Name: Class, dtype: int64

ہم دیکھ سکتے ہیں کہ اس کے 1300 نمونے ہیں۔ Çerçevelik بیج اور 1200 نمونے Ürgüp Sivrisi بیج دھیان دیں کہ ان کے درمیان فرق 100 نمونوں کا ہے، ایک بہت ہی چھوٹا فرق، جو ہمارے لیے اچھا ہے اور اس بات کی نشاندہی کرتا ہے کہ نمونوں کی تعداد کو دوبارہ متوازن کرنے کی ضرورت نہیں ہے۔

آئیے اپنی خصوصیات کے وضاحتی اعدادوشمار کو بھی دیکھیں describe() یہ دیکھنے کا طریقہ کہ ڈیٹا کتنی اچھی طرح سے تقسیم کیا گیا ہے۔ ہم نتیجے کی میز کو بھی منتقل کریں گے۔ T اعداد و شمار میں موازنہ کرنا آسان بنانے کے لیے:

df.describe().T

نتیجہ کی میز یہ ہے:

					count 	mean 			std 			min 		25% 			50% 			75% 			max
Area 				2500.0 	80658.220800 	13664.510228 	47939.0000 	70765.000000 	79076.00000 	89757.500000 	136574.0000
Perimeter 			2500.0 	1130.279015 	109.256418 		868.4850 	1048.829750 	1123.67200 		1203.340500 	1559.4500
Major_Axis_Length 	2500.0 	456.601840 		56.235704 		320.8446 	414.957850 		449.49660 		492.737650 		661.9113
Minor_Axis_Length 	2500.0 	225.794921 		23.297245 		152.1718 	211.245925 		224.70310 		240.672875 		305.8180
Convex_Area 		2500.0 	81508.084400 	13764.092788 	48366.0000 	71512.000000 	79872.00000 	90797.750000 	138384.0000
Equiv_Diameter 		2500.0 	319.334230 		26.891920 		247.0584 	300.167975 		317.30535 		338.057375 		417.0029
Eccentricity 		2500.0 	0.860879 		0.045167 		0.4921 		0.831700 		0.86370 		0.897025 		0.9481
Solidity 			2500.0 	0.989492 		0.003494 		0.9186 		0.988300 		0.99030 		0.991500 		0.9944
Extent 				2500.0 	0.693205 		0.060914 		0.4680 		0.658900 		0.71305 		0.740225 		0.8296
Roundness 			2500.0 	0.791533 		0.055924 		0.5546 		0.751900 		0.79775 		0.834325 		0.9396
Aspect_Ration 		2500.0 	2.041702 		0.315997 		1.1487 		1.801050 		1.98420 		2.262075 		3.1444
Compactness 		2500.0 	0.704121 		0.053067 		0.5608 		0.663475 		0.70770 		0.743500 		0.9049

میز کو دیکھ کر، موازنہ کرتے وقت مطلب اور معیاری انحراف (std) کالم، یہ دیکھا جا سکتا ہے کہ زیادہ تر خصوصیات کا ایک مطلب ہے جو معیاری انحراف سے بہت دور ہے۔ اس سے ظاہر ہوتا ہے کہ اعداد و شمار کی قدریں اوسط قدر کے ارد گرد مرکوز نہیں ہیں، بلکہ اس کے ارد گرد زیادہ بکھرے ہوئے ہیں - دوسرے الفاظ میں، ان کے پاس اعلی تغیر.

اس کے علاوہ، کو دیکھتے وقت کم سے کم (min) اور زیادہ سے زیادہ (max) کالم، کچھ خصوصیات، جیسے Area، اور Convex_Area، کم از کم اور زیادہ سے زیادہ اقدار کے درمیان بڑا فرق ہے۔ اس کا مطلب ہے کہ ان کالموں میں بہت چھوٹا ڈیٹا ہوتا ہے اور ڈیٹا کی بہت بڑی قدریں بھی ہوتی ہیں، یا اعلی طول و عرض ڈیٹا کی قدروں کے درمیان۔

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

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

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

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

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

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

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

import seaborn as sns


sns.pairplot(data=df, hue='Class')

پیئر پلاٹ کو دیکھتے ہوئے، ہم دیکھ سکتے ہیں کہ زیادہ تر معاملات میں پوائنٹس Çerçevelik کلاس واضح طور پر پوائنٹس سے الگ ہیں۔ Ürgüp Sivrisi کلاس یا تو ایک کلاس کے پوائنٹس دائیں طرف ہوتے ہیں جب دوسرے بائیں طرف ہوتے ہیں، یا کچھ اوپر ہوتے ہیں جبکہ دوسرے نیچے ہوتے ہیں۔ اگر ہم کلاسوں کو الگ کرنے کے لیے کسی قسم کا منحنی خطوط یا لکیر استعمال کریں، تو یہ ظاہر کرتا ہے کہ انہیں الگ کرنا آسان ہے، اگر وہ ملایا جاتا تو درجہ بندی ایک مشکل کام ہوتا۔

میں Eccentricity, Compactness اور Aspect_Ration کالم، کچھ نکات جو "الگ تھلگ" ہیں یا عام ڈیٹا کے رجحان سے ہٹ رہے ہیں - آؤٹ لئیر - بھی آسانی سے دیکھے جا سکتے ہیں۔

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

ترتیب میں، ہم تمام متغیرات کے باکس پلاٹ کو کے ساتھ بھی پلاٹ کر سکتے ہیں۔ sns.boxplot() طریقہ اکثر اوقات، باکس پلاٹس کو افقی طور پر اورینٹ کرنا مددگار ثابت ہوتا ہے، اس لیے باکس پلاٹس کی شکلیں تقسیم کی شکلوں جیسی ہوتی ہیں، ہم اس کے ساتھ ایسا کر سکتے ہیں۔ orient دلیل:

sns.boxplot(data=df, orient='h') 

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

ایسا کرنے سے پہلے، آئیے صرف یہ سمجھ لیں کہ اگر ایسی خصوصیات کی قدریں ہیں جن کا دیگر اقدار سے گہرا تعلق ہے، مثال کے طور پر - اگر ایسی اقدار ہیں جو بھی بڑی ہو جاتی ہیں جب دیگر خصوصیات کی قدریں بڑی ہو جاتی ہیں، مثبت سہسنبند; یا اگر ایسی قدریں ہیں جو اس کے برعکس کرتی ہیں، چھوٹی ہو جائیں جبکہ دوسری قدریں چھوٹی ہو جائیں، a کے ساتھ منفی سہسنبند.

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

آئیے متغیرات کے درمیان ارتباط پر ایک نظر ڈالیں اور پھر ہم ڈیٹا کو پہلے سے پروسیس کرنے کی طرف بڑھ سکتے ہیں۔ ہم کے ساتھ ارتباط کا حساب لگائیں گے۔ corr() طریقہ اور سیبورن کے ساتھ ان کا تصور کریں۔ heatmap(). ہیٹ میپ کا معیاری سائز چھوٹا ہوتا ہے، لہذا ہم درآمد کریں گے۔ matplotlib (جنرل ویژولائزیشن انجن/لائبریری جس کے اوپر Seaborn بنایا گیا ہے) اور اس کے ساتھ سائز تبدیل کریں figsize:

import matplotlib.pyplot as plt
plt.figure(figsize=(15, 10))

correlations = df.corr()
sns.heatmap(correlations, annot=True) 

اس ہیٹ میپ میں، 1 یا -1 کے قریب کی قدریں وہ اقدار ہیں جن پر ہمیں توجہ دینے کی ضرورت ہے۔ پہلی صورت، ایک اعلیٰ مثبت ارتباط اور دوسری، ایک اعلیٰ منفی ارتباط کو ظاہر کرتی ہے۔ دونوں قدریں، اگر 0.8 یا -0.8 سے اوپر نہ ہوں تو ہمارے لاجسٹک ریگریشن ماڈل کے لیے فائدہ مند ہوں گی۔

جب اعلی ارتباط ہوتے ہیں جیسے کہ ایک 0.99 کے درمیان Aspec_Ration اور Compactness، اس کا مطلب ہے کہ ہم صرف استعمال کرنے کا انتخاب کرسکتے ہیں۔ Aspec_Ration یا صرف Compactness، ان دونوں کے بجائے (چونکہ وہ تقریبا برابر ہوں گے۔ پیشن گو ایک دوسرے کا) کے لیے بھی ایسا ہی ہے۔ Eccentricity اور Compactness ایک -0.98 تعلق، کے لیے Area اور Perimeter ایک 0.94 ارتباط، اور کچھ دوسرے کالم۔

ڈیٹا پر پری پروسیسنگ

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

فیچر کالم ہمارے ہوں گے۔ X ڈیٹا اور کلاس کالم، ہمارا y ہدف ڈیٹا:

y = df['Class']
X = df.drop(columns=['Class'], axis=1)

زمرہ کی خصوصیات کو عددی خصوصیات میں تبدیل کرنا

ہمارے بارے میں Class کالم - اس کی اقدار نمبر نہیں ہیں، اس کا مطلب ہے کہ ہمیں انہیں تبدیل کرنے کی بھی ضرورت ہے۔ اس تبدیلی کو کرنے کے بہت سے طریقے ہیں؛ یہاں، ہم استعمال کریں گے replace() طریقہ اور تبدیل کریں Çerçevelik کرنے کے لئے 0 اور Ürgüp Sivrisi کرنے کے لئے 1.

y = y.replace('Çerçevelik', 0).replace('Ürgüp Sivrisi', 1)

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

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

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

اسکیلنگ کے بارے میں سوچنے سے پتہ چلتا ہے کہ ہمیں پہلے تقسیم کرنے کی ضرورت ہے۔ X اور y ڈیٹا مزید ٹرین اور ٹیسٹ سیٹ میں اور پھر فٹ ٹریننگ سیٹ پر ایک سکیلر، اور تبدیل ٹرین اور ٹیسٹ سیٹ دونوں (بغیر ٹیسٹ سیٹ کا اثر اسکیلر پر ہوتا ہے جو ایسا کرتا ہے)۔ اس کے لیے ہم Scikit-Learns استعمال کریں گے۔ train_test_split() طریقہ:

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=.25, 
                                                    random_state=SEED)

مقرر test_size=.25 اس بات کو یقینی بنا رہا ہے کہ ہم 25% ڈیٹا ٹیسٹنگ اور 75% ٹریننگ کے لیے استعمال کر رہے ہیں۔ اسے چھوڑ دیا جا سکتا ہے، ایک بار جب یہ پہلے سے طے شدہ تقسیم ہو جائے، لیکن پائتھونک کوڈ لکھنے کا طریقہ مشورہ دیتا ہے کہ "واضح ہونا مضمر سے بہتر ہے"۔

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

X_train.shape, X_test.shape, y_train.shape, y_test.shape

یہ دکھاتا ہے:

((1875, 12), (625, 12), (1875,), (625,))

ہم دیکھ سکتے ہیں کہ تقسیم کے بعد، ہمارے پاس تربیت کے لیے 1875 اور جانچ کے لیے 625 ریکارڈ موجود ہیں۔

اسکیلنگ ڈیٹا

ایک بار جب ہمارے پاس ہماری ٹرین اور ٹیسٹ سیٹ تیار ہو جائیں، تو ہم Scikit-Learn کے ساتھ ڈیٹا کو سکیل کرنے کے لیے آگے بڑھ سکتے ہیں۔ StandardScaler آبجیکٹ (یا لائبریری کے ذریعہ فراہم کردہ دیگر اسکیلرز)۔ رساو سے بچنے کے لیے، اسکیلر کو پر لگایا جاتا ہے۔ X_train اس کے بعد ڈیٹا اور ٹرین کی اقدار کا استعمال ٹرین اور ٹیسٹ ڈیٹا دونوں کو پیمانے یا تبدیل کرنے کے لیے کیا جاتا ہے:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

چونکہ آپ عام طور پر کال کریں گے:

scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

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

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

column_names = df.columns[:12] 
X_train = pd.DataFrame(X_train, columns=column_names)

sns.boxplot(data=X_train, orient='h')

ہم آخر کار اپنے تمام باکس پلاٹ دیکھ سکتے ہیں! نوٹ کریں کہ ان سب کے پاس آؤٹ لیئرز ہیں، اور وہ خصوصیات جو معمول سے آگے کی تقسیم کو پیش کرتی ہیں (جن کے منحنی خطوط یا تو بائیں یا دائیں طرف مڑے ہوئے ہیں)، جیسے Solidity, Extent, Aspect_Ration، اور Compactedness، وہی ہیں جن میں اعلی ارتباطات تھے۔

IQR طریقہ سے آؤٹ لیرز کو ہٹانا

ہم پہلے ہی جان چکے ہیں کہ لاجسٹک ریگریشن آؤٹ لیرز سے متاثر ہو سکتی ہے۔ ان کے علاج کے طریقوں میں سے ایک طریقہ استعمال کرنا ہے جسے کہا جاتا ہے انٹرکوارٹائل رینج or آئی کیو آر. IQR طریقہ کار کا ابتدائی مرحلہ یہ ہے کہ ہم ٹرین کے ڈیٹا کو چار حصوں میں تقسیم کریں، جنہیں quartiles کہتے ہیں۔ پہلا چوتھائی، Q1، ڈیٹا کا 25٪ ہے، دوسرا، Q250% تک، تیسرا، Q375% تک، اور آخری، Q4، 100٪ تک۔ باکس پلاٹ کے خانوں کی تعریف IQR طریقہ سے کی گئی ہے اور یہ اس کی بصری نمائندگی ہیں۔

افقی باکس پلاٹ پر غور کرتے ہوئے، بائیں طرف عمودی لائن ڈیٹا کا 25% نشان لگاتی ہے، درمیان میں عمودی لائن، 50% ڈیٹا (یا میڈین)، اور دائیں طرف کی آخری عمودی لائن، ڈیٹا کا 75% . عمودی لکیروں کے ذریعہ بیان کردہ دونوں مربع جتنی زیادہ سائز میں ہیں - یا جتنی زیادہ درمیانی عمودی لائن درمیان میں ہے - اس کا مطلب ہے کہ ہمارا ڈیٹا عام تقسیم کے قریب ہے یا کم ترچھا ہے، جو ہمارے تجزیہ کے لیے مددگار ہے۔

IQR باکس کے علاوہ، اس کے دونوں طرف افقی لکیریں بھی ہیں۔ وہ لائنیں کم از کم اور زیادہ سے زیادہ تقسیم کی قدروں کو نشان زد کرتی ہیں جن کی وضاحت کی گئی ہے۔

$$
کم از کم = Q1 - 1.5*IQR
$$

اور

$$
زیادہ سے زیادہ = Q3 + 1.5*IQR
$$

IQR بالکل Q3 اور Q1 (یا Q3 – Q1) کے درمیان فرق ہے اور یہ ڈیٹا کا سب سے مرکزی نقطہ ہے۔ یہی وجہ ہے کہ جب IQR تلاش کرتے ہیں، تو ہم اعداد و شمار کی انتہاؤں، یا کم سے کم اور زیادہ سے زیادہ پوائنٹس میں آؤٹ لیرز کو فلٹر کرتے ہیں۔ باکس پلاٹ ہمیں جھانکتے ہیں کہ IQR طریقہ کار کا نتیجہ کیا ہوگا۔

ہم پانڈا استعمال کر سکتے ہیں۔ quantile() ہمارے quantiles تلاش کرنے کا طریقہ، اور iqr سے scipy.stats ہر کالم کے لیے انٹرکوارٹائل ڈیٹا رینج حاصل کرنے کے لیے پیکیج:

from scipy.stats import iqr

Q1 = X_train.quantile(q=.25)
Q3 = X_train.quantile(q=.75)

IQR = X_train.apply(iqr)

اب ہمارے پاس Q1، Q3، اور IQR ہے، ہم درمیانی قدروں کو فلٹر کر سکتے ہیں:

minimum = X_train < (Q1-1.5*IQR)
maximum = X_train > (Q3+1.5*IQR)


filter = ~(minimum | maximum).any(axis=1)


X_train = X_train[filter]

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

X_train.shape

اس کے نتائج:

(1714, 12)

ہم دیکھ سکتے ہیں کہ فلٹرنگ کے بعد قطاروں کی تعداد 1875 سے 1714 تک چلی گئی۔ اس کا مطلب ہے کہ 161 قطاروں میں آؤٹ لیرز یا 8.5% ڈیٹا شامل ہے۔

آؤٹ لیرز کو ہٹانے کے بعد، ہم ماڈل میں ڈیٹا شامل کرنے کے لیے تقریباً تیار ہیں۔ ماڈل فٹنگ کے لیے، ہم ٹرین کا ڈیٹا استعمال کریں گے۔ X_train فلٹر کیا گیا ہے، لیکن کیا ہوگا؟ y_train?

y_train.shape

یہ نتائج:

(1875,)

محسوس کرو اسے y_train اب بھی 1875 قطاریں ہیں۔ ہمیں کی تعداد سے ملنے کی ضرورت ہے۔ y_train کی تعداد تک قطاریں X_train قطاریں اور نہ صرف من مانی۔ ہمیں کدو کے بیجوں کی y- اقدار کو ہٹانے کی ضرورت ہے جنہیں ہم نے ہٹا دیا ہے، جو ممکنہ طور پر بکھرے ہوئے ہیں۔ y_train سیٹ فلٹر شدہ X_train اسٹیل کے اصل انڈیکس ہیں اور انڈیکس میں خلا ہے جہاں ہم نے آؤٹ لیرز کو ہٹا دیا ہے! اس کے بعد ہم انڈیکس کا استعمال کر سکتے ہیں۔ X_train میں متعلقہ اقدار کو تلاش کرنے کے لیے ڈیٹا فریم y_train:

y_train = y_train.iloc[X_train.index]

ایسا کرنے کے بعد، ہم دیکھ سکتے ہیں y_train دوبارہ شکل:

y_train.shape

کون سے نتائج:

(1714,)

اب، y_train اس کی بھی 1714 قطاریں ہیں اور وہ ایک جیسی ہیں۔ X_train قطاریں ہم آخر کار اپنا لاجسٹک ریگریشن ماڈل بنانے کے لیے تیار ہیں!

لاجسٹک ریگریشن ماڈل کو نافذ کرنا

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

سب سے پہلے، ہم درآمد کرتے ہیں LogisticRegression کلاس بنائیں اور اسے فوری بنائیں، ایک تخلیق کریں۔ LogisticRegression اعتراض:

from sklearn.linear_model import LogisticRegression
logreg = LogisticRegression(random_state=SEED)

دوسرا، ہم اپنے ٹرین کے ڈیٹا کو فٹ کرتے ہیں۔ logreg کے ساتھ ماڈل fit() طریقہ، اور کے ساتھ ہمارے ٹیسٹ ڈیٹا کی پیشن گوئی predict() طریقہ، نتائج کو بطور ذخیرہ کرنا y_pred:

logreg.fit(X_train.values, y_train)
y_pred = logreg.predict(X_test)

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

X_train[:3]

اوپر کوڈ آؤٹ پٹ:

       Area          Perimeter     Major_Axis_Length    Minor_Axis_Length    Convex_Area   Equiv_Diameter       Eccentricity  Solidity      Extent        Roundness     Aspect_Ration        Compactness
0      -1.098308     -0.936518     -0.607941            -1.132551            -1.082768     -1.122359            0.458911      -1.078259     0.562847      -0.176041     0.236617             -0.360134
1      -0.501526     -0.468936     -0.387303            -0.376176            -0.507652     -0.475015            0.125764      0.258195      0.211703      0.094213      -0.122270            0.019480
2      0.012372      -0.209168     -0.354107            0.465095              0.003871      0.054384            -0.453911     0.432515      0.794735      0.647084      -0.617427            0.571137

اور پہلی 3 پیشین گوئیوں میں y_pred نتائج دیکھنے کے لیے:

y_pred[:3] 

اس کے نتائج:

array([0, 0, 0])

ان تین قطاروں کے لیے، ہماری پیشین گوئیاں یہ تھیں کہ وہ پہلی جماعت کے بیج ہیں، Çerçevelik.

ساتھ لاجسٹک رجعت، حتمی کلاس کی پیش گوئی کرنے کے بجائے، جیسے 0، ہم اس امکان کا بھی اندازہ لگا سکتے ہیں کہ قطار سے متعلق ہے۔ 0 کلاس اصل میں یہی ہوتا ہے جب لاجسٹک ریگریشن ڈیٹا کی درجہ بندی کرتا ہے، اور predict() طریقہ پھر اس پیشین گوئی کو "مشکل" کلاس واپس کرنے کے لیے ایک حد سے گزرتا ہے۔ کسی طبقے سے متعلق امکان کی پیشین گوئی کرنے کے لیے، predict_proba() استعمال کیا جاتا ہے:

y_pred_proba = logreg.predict_proba(X_test)

آئیے y امکانات کی پیشین گوئیوں کی پہلی 3 قدروں پر بھی ایک نظر ڈالتے ہیں:

y_pred_proba[:3] 

کون سے نتائج:

        # class 0   class 1   
array([[0.54726628, 0.45273372],
       [0.56324527, 0.43675473],
       [0.86233349, 0.13766651]])

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

اس بارے میں مزید معلومات موجود ہیں کہ کس طرح پیش گوئی کی گئی پیداوار کی گئی تھی۔ یہ اصل میں نہیں تھا 0، لیکن کلاس کا 55٪ موقع 0، اور کلاس کا 45٪ موقع 1. اس سے پتہ چلتا ہے کہ پہلے تین کیسے ہیں۔ X_test ڈیٹا پوائنٹس، کلاس سے متعلق 0، 86% امکان کے ساتھ صرف تیسرے ڈیٹا پوائنٹ کے بارے میں واقعی واضح ہیں - اور پہلے دو ڈیٹا پوائنٹس کے لیے اتنا زیادہ نہیں۔

جب ML طریقوں کا استعمال کرتے ہوئے نتائج کو مواصلت کرتے ہیں - عام طور پر ایک نرم طبقے کو واپس کرنا بہتر ہے، اور اس سے وابستہ امکان "اعتماد" اس درجہ بندی کے.

جب ہم ماڈل کی گہرائی میں جائیں گے تو ہم اس کے بارے میں مزید بات کریں گے۔ اس وقت، ہم اگلے مرحلے پر آگے بڑھ سکتے ہیں۔

درجہ بندی کی رپورٹس کے ساتھ ماڈل کا اندازہ لگانا

تیسرا مرحلہ یہ دیکھنا ہے کہ ماڈل ٹیسٹ ڈیٹا پر کیسے کارکردگی کا مظاہرہ کرتا ہے۔ ہم Scikit-Learn درآمد کر سکتے ہیں۔ classification_report() اور ہمارے پاس y_test اور y_pred دلائل کے طور پر. اس کے بعد، ہم اس کا جواب پرنٹ کر سکتے ہیں۔

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

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

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

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

$$
recall = frac{text{true positive}}{text{true positive} + text{false negative}}
$$

3. F1 سکور: متوازن غذا ہے۔ ہارمونک مطلب درستگی اور یاد کی. سب سے کم قیمت 0 ہے اور سب سے زیادہ 1 ہے۔ کب f1-score 1 کے برابر ہے، اس کا مطلب ہے کہ تمام کلاسوں کی درست پیشین گوئی کی گئی تھی - یہ حقیقی ڈیٹا کے ساتھ حاصل کرنا بہت مشکل اسکور ہے:

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

4. درستگی: بیان کرتا ہے کہ ہمارے درجہ بندی کرنے والے نے کتنی پیشین گوئیاں درست کیں۔ سب سے کم درستگی کی قدر 0 ہے اور سب سے زیادہ 1۔ اس قدر کو عام طور پر 100 سے ضرب دیا جاتا ہے تاکہ فیصد حاصل کیا جا سکے۔

$$
درستگی = frac{متن{صحیح پیشین گوئیوں کی تعداد}}متن{پیش گوئیوں کی کل تعداد}}
$$

from sklearn.metrics import classification_report
cr = classification_report(y_test, y_pred)
print(cr)

پھر ہم درجہ بندی کی رپورٹ کے آؤٹ پٹ کو دیکھ سکتے ہیں:

				precision    recall  f1-score   support

           0       0.83      0.91      0.87       316
           1       0.90      0.81      0.85       309

    accuracy                           0.86       625
   macro avg       0.86      0.86      0.86       625
weighted avg       0.86      0.86      0.86       625

یہ ہمارا نتیجہ ہے۔ محسوس کرو اسے precision, recall, f1-score، اور accuracy میٹرکس سب بہت زیادہ ہیں، 80% سے اوپر، جو کہ مثالی ہے - لیکن وہ نتائج غالباً اعلی ارتباط سے متاثر ہوئے تھے، اور طویل عرصے تک برقرار نہیں رہیں گے۔

ماڈل کی درستگی 86% ہے، یعنی اس کی درجہ بندی 14% وقت میں غلط ہوتی ہے۔ ہمارے پاس وہ مجموعی معلومات ہیں، لیکن یہ جاننا دلچسپ ہوگا کہ کیا کلاس کی درجہ بندی کے حوالے سے 14% غلطیاں ہوتی ہیں 0 یا کلاس 1. اس بات کی نشاندہی کرنے کے لیے کہ کون سی کلاسز کو غلط طور پر شناخت کیا گیا ہے، اور کس فریکوئنسی میں - ہم حساب کر سکتے ہیں اور a کنفیوژن میٹرکس ہمارے ماڈل کی پیشین گوئیوں کا۔

کنفیوژن میٹرکس کے ساتھ ماڈل کا اندازہ لگانا

آئیے حساب لگائیں اور پھر کنفیوژن میٹرکس کو پلاٹ کریں۔ ایسا کرنے کے بعد، ہم اس کے ہر حصے کو سمجھ سکتے ہیں۔ کنفیوژن میٹرکس کی منصوبہ بندی کرنے کے لیے، ہم Scikit-Learn استعمال کریں گے۔ confusion_matrix()، جسے ہم سے درآمد کریں گے۔ metrics ماڈیول.

سیبورن کا استعمال کرتے ہوئے کنفیوژن میٹرکس کو تصور کرنا آسان ہے۔ heatmap(). لہذا، اسے پیدا کرنے کے بعد، ہم اپنے کنفیوژن میٹرکس کو ہیٹ میپ کی دلیل کے طور پر پاس کریں گے:

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d')

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

کنفیوژن میٹرکس پلاٹ کو دیکھ کر، ہم دیکھ سکتے ہیں کہ ہمارے پاس ہے۔ 287 اقدار جو تھے 0 اور اس طرح کی پیشن گوئی کی 0 - یا حقیقی مثبت کلاس کے لیے 0 (Cerçevelik بیج)۔ ہمارے پاس بھی ہے 250 کلاس کے لئے حقیقی مثبت 1 (Ürgüp Sivrisi بیج)۔ حقیقی مثبتات ہمیشہ میٹرکس اخترن میں واقع ہوتے ہیں جو اوپری بائیں سے نیچے دائیں طرف جاتا ہے۔

ہم بھی ہیں 29 اقدار جو ہونی چاہئیں 0، لیکن اس طرح کی پیش گوئی کی گئی ہے۔ 1 (غلط مثبت) اور 59 اقدار جو تھے 1 اور اس طرح کی پیشن گوئی کی 0 (جھوٹے منفی)۔ ان نمبروں کے ساتھ، ہم سمجھ سکتے ہیں کہ ماڈل جو غلطی سب سے زیادہ کرتا ہے وہ یہ ہے کہ یہ غلط منفی کی پیش گوئی کرتا ہے۔ لہذا، یہ زیادہ تر Ürgüp Sivrisi بیج کو Çerçevelik بیج کے طور پر درجہ بندی کر سکتا ہے۔

اس قسم کی غلطی کی وضاحت 81% کلاس کی واپسی سے بھی ہوتی ہے۔ 1. نوٹ کریں کہ میٹرکس منسلک ہیں۔ اور یاد کرنے میں فرق Ürgüp Sivrisi کلاس کے 100 کم نمونے رکھنے سے آ رہا ہے۔ یہ دوسرے طبقے کے مقابلے میں صرف چند نمونے کم ہونے کے مضمرات میں سے ایک ہے۔ یاد کو مزید بہتر بنانے کے لیے، آپ یا تو کلاس وزن کے ساتھ تجربہ کر سکتے ہیں یا مزید Ürgüp Sivrisi نمونے استعمال کر سکتے ہیں۔

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

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

لاجسٹک ریگریشن واقعی کیسے کام کرتا ہے اس کی گہرائی میں جانا

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

$$
y = b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n
$$

جس میں بی₀ ریگریشن انٹرسیپٹ تھا، بی¹ گتانک اور x¹ ڈیٹا.

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

مشاہدہ کریں کہ جب لکیری ریگریشن لائن چلتی رہتی ہے اور مسلسل لامحدود قدروں سے بنی ہوتی ہے، لاجسٹک ریگریشن وکر کو درمیان میں تقسیم کیا جا سکتا ہے اور 0 اور 1 قدروں میں اس کی انتہا ہوتی ہے۔ اس "S" شکل کی وجہ سے یہ ڈیٹا کی درجہ بندی کرتا ہے - وہ پوائنٹس جو قریب ہیں یا سب سے اونچی انتہا پر گرتے ہیں کلاس 1 سے تعلق رکھتے ہیں، جب کہ پوائنٹس جو نچلے کواڈرینٹ میں ہیں یا 0 کے قریب ہیں، ان کا تعلق کلاس 0 سے ہے۔ "S" 0 اور 1 کے درمیان ہے، 0.5 - یہ لاجسٹک ریگریشن پوائنٹس کی حد ہے۔

ہم لاجسٹک اور لکیری رجعت کے درمیان بصری فرق کو پہلے ہی سمجھ چکے ہیں، لیکن فارمولے کا کیا ہوگا؟ لاجسٹک ریگریشن کا فارمولا درج ذیل ہے:

$$
y = b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n
$$

اسے یوں بھی لکھا جا سکتا ہے:

$$
y_{prob} = frac{1}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

یا اس طرح بھی لکھا جائے:

$$
y_{prob} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

اوپر دی گئی مساوات میں، ہمارے پاس اس کی قدر کے بجائے ان پٹ کا امکان ہے۔ اس کے عدد کے طور پر 1 ہے لہذا اس کے نتیجے میں 0 اور 1 کے درمیان ایک قدر ہو سکتی ہے، اور 1 جمع اس کے ڈینومینیٹر میں ایک قدر ہو سکتی ہے، تاکہ اس کی قدر 1 ہو اور کچھ - اس کا مطلب ہے کہ پورے کسر کا نتیجہ 1 سے بڑا نہیں ہو سکتا .

اور اس کی قیمت کیا ہے جو کہ ڈینومینیٹر میں ہے؟ یہ ہے e, قدرتی لوگارتھم کی بنیاد (تقریباً 2.718282)، لکیری رجعت کی طاقت پر اٹھایا گیا:

$$
e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

اسے لکھنے کا دوسرا طریقہ یہ ہوگا:

$$
ln بائیں( frac{p}{1-p} دائیں) = {(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

اس آخری مساوات میں، ln قدرتی لوگارتھم ہے (بیس ای) اور p امکان ہے، لہذا نتیجہ کے امکان کا لاگرتھم لکیری رجعت کے نتیجے کے برابر ہے۔

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

لاجسٹک ریگریشن اخذ کرنے کا پورا عمل درج ذیل ہے:

$$
p{X} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

$$
p(1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}) = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

$$
p + p*e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)} = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

p
=

e

(

b
0

+

b
1

*

x
1

+

b
2

*

x
2

+

b
3

*

x
3

+
...
+

b
n

*

x
n

)

-
p
*

e

(

b
0

+

b
1

*

x
1

+

b
2

*

x
2

+

b
3

*

x
3

+
...
+

b
n

*

x
n

)

$$
frac{p}{1-p} = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

$$
ln بائیں( frac{p}{1-p} دائیں) = (b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)
$$

اس کا مطلب ہے کہ لاجسٹک ریگریشن ماڈل میں بھی گتانک اور ایک انٹرسیپٹ ویلیو ہے۔ کیونکہ یہ ایک لکیری رجعت کا استعمال کرتا ہے اور اس میں قدرتی لاگرتھم (e).

ہم اپنے ماڈل کی گتانکوں اور مداخلت کی قدروں کو دیکھ سکتے ہیں، اسی طرح جیسے ہم نے لکیری رجعت کے لیے کیا، استعمال کرتے ہوئے coef_ اور intercept_ خصوصیات:

logreg.coef_

جو 12 خصوصیات میں سے ہر ایک کے گتانک دکھاتا ہے:

array([[ 1.43726172, -1.03136968,  0.24099522, -0.61180768,  1.36538261,
        -1.45321951, -1.22826034,  0.98766966,  0.0438686 , -0.78687889,
         1.9601197 , -1.77226097]])

logreg.intercept_

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

array([0.08735782])

گتانک اور مداخلتی اقدار کے ساتھ، ہم اپنے ڈیٹا کی پیشین گوئی کے امکانات کا حساب لگا سکتے ہیں۔ آئیے پہلے حاصل کریں۔ X_test دوبارہ اقدار، مثال کے طور پر:

X_test[:1]

یہ کی پہلی قطار لوٹاتا ہے۔ X_test NumPy صف کے طور پر:

array([[-1.09830823, -0.93651823, -0.60794138, -1.13255059, -1.0827684 ,
        -1.12235877,  0.45891056, -1.07825898,  0.56284738, -0.17604099,
         0.23661678, -0.36013424]])

ابتدائی مساوات کے بعد:

$$
p{X} = frac{e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}{1 + e^{(b_0 + b_1 * x_1 + b_2 * x_2 + b_3 * x_3 + ldots + b_n * x_n)}}
$$

ازگر میں، ہمارے پاس ہے:

import math

lin_reg = logreg.intercept_[0] + 
((logreg.coef_[0][0]* X_test[:1][0][0])+ 
(logreg.coef_[0][1]* X_test[:1][0][1])+ 
(logreg.coef_[0][2]* X_test[:1][0][2])+ 
(logreg.coef_[0][3]* X_test[:1][0][3])+ 
(logreg.coef_[0][4]* X_test[:1][0][4])+ 
(logreg.coef_[0][5]* X_test[:1][0][5])+ 
(logreg.coef_[0][6]* X_test[:1][0][6])+ 
(logreg.coef_[0][7]* X_test[:1][0][7])+ 
(logreg.coef_[0][8]* X_test[:1][0][8])+ 
(logreg.coef_[0][9]* X_test[:1][0][9])+ 
(logreg.coef_[0][10]* X_test[:1][0][10])+ 
(logreg.coef_[0][11]* X_test[:1][0][11]))

px = math.exp(lin_reg)/(1 +(math.exp(lin_reg)))
px

اس کے نتائج:

0.45273372469369133

اگر ہم دوبارہ دیکھیں predict_proba پہلے کا نتیجہ X_test لائن، ہمارے پاس ہے:

logreg.predict_proba(X_test[:1])

اس کا مطلب ہے کہ اصل لاجسٹک ریگریشن مساوات ہمیں کلاس کے حوالے سے ان پٹ کا امکان فراہم کرتی ہے۔ 1یہ معلوم کرنے کے لیے کہ کون سا امکان کلاس کے لیے ہے۔ 0، ہم آسانی سے کر سکتے ہیں:

1 - px

نوٹ کریں کہ دونوں px اور 1-px سے ملتے جلتے ہیں predict_proba نتائج اس طرح لاجسٹک ریگریشن کا حساب لگایا جاتا ہے اور کیوں رجعت اس کے نام کا حصہ ہے۔ لیکن اصطلاح کا کیا ہوگا؟ لاجسٹک?

مدت لاجسٹک سے آتا ہے لاگ ان کریں، جو ایک فنکشن ہے جو ہم پہلے ہی دیکھ چکے ہیں:

$$
ln بائیں ( frac{p}{1-p} دائیں)
$$

ہم نے صرف اس کے ساتھ حساب کیا ہے۔ px اور 1-px. یہ لاگٹ ہے، جسے بھی کہا جاتا ہے۔ لاگ ان مشکلات چونکہ یہ مشکلات کے لوگارتھم کے برابر ہے جہاں p ایک امکان ہے.

نتیجہ

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

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

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

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

میں آپ کو L1 اور L2 کا مطالعہ کرنے کا بھی مشورہ دوں گا۔ ریگولرائزیشنز، وہ ماڈل کی پیچیدگی کو برقرار رکھتے ہوئے اعلی ڈیٹا کو "جرمانہ" کرنے کا ایک طریقہ ہیں تاکہ یہ معمول کے قریب تر ہو جائے، تاکہ الگورتھم بہتر نتیجہ حاصل کر سکے۔ ہم نے جو Scikit-Learn نفاذ استعمال کیا ہے، اس میں پہلے سے ہی L2 ریگولرائزیشن بذریعہ ڈیفالٹ ہے۔ دیکھنے کے لئے ایک اور چیز مختلف ہے۔ محلول، جیسے lbgs، جو لاجسٹک ریگریشن الگورتھم کی کارکردگی کو بہتر بناتا ہے۔

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

• مشاہدات آزاد ہیں؛
• وضاحتی متغیرات میں کوئی کثیر الجہتی نہیں ہے۔
• کوئی انتہائی outliers نہیں ہیں؛
• وضاحتی متغیرات اور جوابی متغیر کے لاگٹ کے درمیان ایک خطی تعلق ہے؛
• نمونے کا سائز کافی بڑا ہے۔

نوٹس کریں کہ ان میں سے کتنے مفروضے پہلے ہی ہمارے ڈیٹا کے تجزیہ اور علاج میں شامل تھے۔

مجھے امید ہے کہ آپ یہ دریافت کرتے رہیں گے کہ لاجسٹک ریگریشن اپنے تمام مختلف طریقوں میں کیا پیش کرتا ہے!