पायथन में लॉजिस्टिक रिग्रेशन के लिए निश्चित गाइड

परिचय

कभी-कभी भ्रमित रेखीय प्रतिगमन नौसिखियों द्वारा - शब्द साझा करने के कारण प्रतीपगमन - रसद प्रतिगमन से बहुत अलग है रेखीय प्रतिगमन. जबकि रैखिक प्रतिगमन 2, 2.45, 6.77 या . जैसे मूल्यों की भविष्यवाणी करता है निरंतर मूल्य, यह एक प्रतीपगमन कलन विधि, रसद प्रतिगमन 0 या 1, 1 या 2 या 3 जैसे मानों की भविष्यवाणी करता है, जो हैं असतत मान, यह एक वर्गीकरण कलन विधि। हाँ, इसे कहते हैं प्रतीपगमन लेकिन ए है वर्गीकरण कलन विधि। उस पर और भी जानकारी कुछ क्षणों में।

इसलिए, यदि आपकी डेटा विज्ञान समस्या में निरंतर मूल्य शामिल हैं, तो आप आवेदन कर सकते हैं a प्रतीपगमन एल्गोरिथ्म (रैखिक प्रतिगमन उनमें से एक है)। अन्यथा, यदि इसमें इनपुट, असतत मूल्यों या वर्गों को वर्गीकृत करना शामिल है, तो आप आवेदन कर सकते हैं a वर्गीकरण एल्गोरिथ्म (लॉजिस्टिक रिग्रेशन उनमें से एक है)।

इस गाइड में, हम स्किकिट-लर्न लाइब्रेरी के साथ पायथन में लॉजिस्टिक रिग्रेशन करेंगे। हम यह भी बताएंगे कि शब्द क्यों "प्रतिगमन" नाम में मौजूद है और लॉजिस्टिक रिग्रेशन कैसे काम करता है।

ऐसा करने के लिए, हम पहले डेटा लोड करेंगे जिसे वर्गीकृत, विज़ुअलाइज़ किया जाएगा और पूर्व-संसाधित किया जाएगा। फिर, हम एक लॉजिस्टिक रिग्रेशन मॉडल बनाएंगे जो उस डेटा को समझेगा। फिर इस मॉडल का मूल्यांकन किया जाएगा, और नए इनपुट के आधार पर मूल्यों की भविष्यवाणी करने के लिए नियोजित किया जाएगा।

अभिप्रेरण

आप जिस कंपनी के लिए काम करते हैं, उसने तुर्की के एक कृषि फार्म के साथ साझेदारी की है। इस साझेदारी में कद्दू के बीज बेचना शामिल है। कद्दू के बीज मानव पोषण के लिए बहुत महत्वपूर्ण हैं। इनमें कार्बोहाइड्रेट, वसा, प्रोटीन, कैल्शियम, पोटेशियम, फास्फोरस, मैग्नीशियम, लोहा और जस्ता का अच्छा अनुपात होता है।

डेटा साइंस टीम में, आपका काम सिर्फ डेटा का उपयोग करके कद्दू के बीजों के प्रकारों के बीच अंतर बताना है - या वर्गीकृत बीज प्रकार के अनुसार डेटा।

तुर्की फार्म दो प्रकार के कद्दू के बीज के साथ काम करता है, एक को . कहा जाता है सेर्सेवेलिक और दूसरा ओर्गुप सिव्रीसिक.

कद्दू के बीजों को वर्गीकृत करने के लिए, आपकी टीम ने 2021 के पेपर का अनुसरण किया है "कद्दू के बीजों के वर्गीकरण में मशीन लर्निंग विधियों का उपयोग (कुकुर्बिता पेपो एल।) आनुवंशिक संसाधन और फसल विकास" कोकलू, सरिगिल, और ओज़्बेक से - इस पेपर में छवियों से बीज माप लेने और निकालने के लिए एक पद्धति है।

कागज में वर्णित प्रक्रिया को पूरा करने के बाद, निम्नलिखित माप निकाले गए:

• क्षेत्र - कद्दू के बीज की सीमाओं के भीतर पिक्सेल की संख्या
• परिधि - एक कद्दू के बीज के पिक्सल में परिधि
• प्रमुख अक्ष लंबाई - एक कद्दू के बीज के पिक्सल में परिधि भी
• लघु अक्ष लंबाई - कद्दू के बीज की छोटी धुरी की दूरी
• सनक - कद्दू के बीज की विलक्षणता
• उत्तल क्षेत्र - कद्दू के बीज द्वारा गठित क्षेत्र में सबसे छोटे उत्तल खोल के पिक्सल की संख्या
• सीमा - कद्दू के बीज क्षेत्र का बाउंडिंग बॉक्स पिक्सल का अनुपात
• समतुल्य व्यास - कद्दू के बीज के क्षेत्रफल के गुणन का वर्गमूल चार से विभाजित pi
• सघनता - समान परिधि वाले वृत्त के क्षेत्रफल के सापेक्ष कद्दू के बीज के क्षेत्रफल का अनुपात
• दृढ़ता - कद्दू के बीज की उत्तल और उत्तल स्थिति
• गोलाई - कद्दू के बीज की अंडाकारता इसके किनारों की विकृतियों पर विचार किए बिना
• अभिमुखता अनुपात - कद्दू के बीज का पहलू अनुपात

वे माप हैं जिनके साथ आपको काम करना है। माप के अलावा, वहाँ भी है वर्ग दो प्रकार के कद्दू के बीज के लिए लेबल।

बीजों का वर्गीकरण शुरू करने के लिए, आइए डेटा आयात करें और इसे देखना शुरू करें।

डेटासेट को समझना

डेटासेट डाउनलोड करने के बाद, हम इसे डेटाफ़्रेम संरचना में लोड कर सकते हैं 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 नमूने हैं सेर्सेवेलिक बीज और के 1200 नमूने ओर्गुप सिव्रीसिक बीज। ध्यान दें कि उनके बीच का अंतर 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 (सामान्य विज़ुअलाइज़ेशन इंजन/लाइब्रेरी जिसके ऊपर सीबॉर्न बनाया गया है) और इसके साथ आकार बदलें 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. उस स्थिति में, हम परिचय देंगे गोपनीय जानकारी का चोरी हो जाना, क्योंकि जल्द ही होने वाले परीक्षण सेट के मूल्यों ने स्केलिंग को प्रभावित किया होगा। डेटा रिसाव अपूरणीय परिणामों और एमएल मॉडल के भ्रामक उच्च प्रदर्शन का एक सामान्य कारण है।

स्केलिंग के बारे में सोचने से पता चलता है कि हमें पहले विभाजित होने की आवश्यकता है X और y डेटा आगे ट्रेन और परीक्षण सेट में और फिर करने के लिए फिट प्रशिक्षण सेट पर एक स्केलर, और करने के लिए परिणत दोनों ट्रेन और परीक्षण सेट (बिना कभी परीक्षण सेट के स्केलर को प्रभावित करता है जो ऐसा करता है)। इसके लिए हम Scikit-Learn's . का प्रयोग करेंगे 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% प्रशिक्षण के लिए उपयोग कर रहे हैं। इसे छोड़ा जा सकता है, एक बार यह डिफ़ॉल्ट विभाजन है, लेकिन pythonic कोड लिखने का तरीका सलाह देता है कि "स्पष्ट होना निहित से बेहतर है"।

डेटा को ट्रेन और टेस्ट सेट में विभाजित करने के बाद, यह देखना एक अच्छा अभ्यास है कि प्रत्येक सेट में कितने रिकॉर्ड हैं। यह के साथ किया जा सकता है shape विशेषता:

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

यह प्रदर्शित करता है:

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

हम देख सकते हैं कि विभाजन के बाद, हमारे पास प्रशिक्षण के लिए 1875 और परीक्षण के लिए 625 रिकॉर्ड हैं।

स्केलिंग डेटा

एक बार जब हम अपनी ट्रेन और परीक्षण सेट तैयार कर लेते हैं, तो हम स्किकिट-लर्न . के साथ डेटा को स्केल करने के लिए आगे बढ़ सकते हैं 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 पद्धति का प्रारंभिक चरण हमारे ट्रेन डेटा को चार भागों में विभाजित करना है, जिन्हें चतुर्थक कहा जाता है। प्रथम चतुर्थक, Q1, 25% डेटा की मात्रा, दूसरा, Q2, 50% तक, तीसरा, Q3, से 75%, और अंतिम एक, Q4, 100% तक। बॉक्सप्लॉट में बॉक्स को IQR विधि द्वारा परिभाषित किया गया है और यह इसका एक दृश्य प्रतिनिधित्व है।

एक क्षैतिज बॉक्सप्लॉट को ध्यान में रखते हुए, बाईं ओर लंबवत रेखा डेटा का 25%, बीच में लंबवत रेखा, डेटा का 50% (या औसत), और दाईं ओर अंतिम लंबवत रेखा, डेटा का 75% . आकार में जितना अधिक दोनों वर्ग लंबवत रेखाओं द्वारा परिभाषित होते हैं - या उतनी ही मध्य में लंबवत रेखा होती है - इसका मतलब है कि हमारा डेटा सामान्य वितरण के करीब है या कम तिरछा है, जो हमारे विश्लेषण के लिए सहायक है।

IQR बॉक्स के अलावा इसके दोनों तरफ क्षैतिज रेखाएं भी हैं। वे रेखाएँ द्वारा परिभाषित न्यूनतम और अधिकतम वितरण मानों को चिह्नित करती हैं

$$
न्यूनतम = Q1 - 1.5*IQR
$$

और

$$
अधिकतम = Q3 + 1.5*IQR
$$

IQR वास्तव में Q3 और Q1 (या Q3 - Q1) के बीच का अंतर है और यह डेटा का सबसे केंद्रीय बिंदु है। यही कारण है कि IQR को खोजते समय, हम आउटलेर्स को डेटा चरम में, या न्यूनतम और अधिकतम बिंदुओं में फ़िल्टर करना समाप्त कर देते हैं। बॉक्स प्लॉट हमें इस बात की एक झलक देते हैं कि IQR पद्धति का परिणाम क्या होगा।

हम पांडा का उपयोग कर सकते हैं quantile() हमारे मात्राओं को खोजने की विधि, और 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 DataFrame में संबंधित मानों की खोज करने के लिए y_train:

y_train = y_train.iloc[X_train.index]

ऐसा करने के बाद, हम देख सकते हैं y_train फिर से आकार दें:

y_train.shape

कौन सा आउटपुट:

(1714,)

अभी, y_train 1714 पंक्तियाँ भी हैं और वे समान हैं X_train पंक्तियाँ। हम अंत में अपना लॉजिस्टिक रिग्रेशन मॉडल बनाने के लिए तैयार हैं!

लॉजिस्टिक रिग्रेशन मॉडल को लागू करना

कठिन हिस्सा हो गया है! प्रीप्रोसेसिंग आमतौर पर मॉडल विकास की तुलना में अधिक कठिन होता है, जब स्किकिट-लर्न जैसे पुस्तकालयों का उपयोग करने की बात आती है, जिन्होंने एमएल मॉडल के आवेदन को केवल कुछ पंक्तियों में सुव्यवस्थित किया है।

सबसे पहले, हम आयात करते हैं 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% संभावना के साथ - और पहले दो डेटा बिंदुओं के लिए इतना नहीं।

एमएल विधियों का उपयोग करते हुए निष्कर्षों को संप्रेषित करते समय - आमतौर पर एक सॉफ्ट क्लास, और संबंधित संभावना को वापस करना सबसे अच्छा होता है "आत्मविश्वास" उस वर्गीकरण का।

हम इस बारे में अधिक बात करेंगे कि जब हम मॉडल में गहराई से जाते हैं तो इसकी गणना कैसे की जाती है। इस समय, हम अगले चरण पर आगे बढ़ सकते हैं।

वर्गीकरण रिपोर्ट के साथ मॉडल का मूल्यांकन

तीसरा चरण यह देखना है कि मॉडल परीक्षण डेटा पर कैसा प्रदर्शन करता है। हम स्किकिट-लर्न आयात कर सकते हैं classification_report() और हमारे पास y_test और y_pred तर्क के रूप में। उसके बाद, हम इसके रिस्पांस का प्रिंट आउट ले सकते हैं।

वर्गीकरण रिपोर्ट में सबसे अधिक उपयोग की जाने वाली वर्गीकरण मीट्रिक शामिल हैं, जैसे शुद्धता, याद, f1-स्कोर, तथा शुद्धता.

1. शुद्धता: यह समझने के लिए कि हमारे क्लासिफायरियर द्वारा कौन से सही भविष्यवाणी मूल्यों को सही माना गया। प्रेसिजन उन सच्चे सकारात्मक मूल्यों को किसी भी चीज़ से विभाजित करेगा जिसे सकारात्मक के रूप में भविष्यवाणी की गई थी:

$$
सटीक = फ़्रैक {पाठ {सच्चा सकारात्मक}} {पाठ {सच्चा सकारात्मक} + पाठ {गलत सकारात्मक}}
$$

2. वापस बुलाना: यह समझने के लिए कि हमारे क्लासिफायरियर द्वारा कितने सच्चे सकारात्मक की पहचान की गई थी। रिकॉल की गणना वास्तविक सकारात्मक को किसी भी चीज़ से विभाजित करके की जाती है जिसे सकारात्मक के रूप में भविष्यवाणी की जानी चाहिए थी:

$$
रिकॉल = फ़्रेक {पाठ {सच्चा सकारात्मक}} {पाठ {सच्चा सकारात्मक} + पाठ {गलत नकारात्मक}}
$$

3. एफ 1 का स्कोर: संतुलित है या अनुकूल माध्य सटीकता और याद की। निम्नतम मान 0 है और उच्चतम 1 है। कब f1-score 1 के बराबर है, इसका मतलब है कि सभी वर्गों की सही भविष्यवाणी की गई थी - यह वास्तविक डेटा के साथ प्राप्त करने के लिए एक बहुत ही कठिन स्कोर है:

$$
टेक्स्ट{f1-स्कोर} = 2* फ़्रेक{टेक्स्ट{सटीक} * टेक्स्ट{रिकॉल}}{टेक्स्ट{सटीक} + टेक्स्ट{रिकॉल}}
$$

4. शुद्धता: बताता है कि हमारे क्लासिफायरियर ने कितनी भविष्यवाणियां कीं। न्यूनतम सटीकता मान 0 है और उच्चतम 1 है। प्रतिशत प्राप्त करने के लिए उस मान को आमतौर पर 100 से गुणा किया जाता है:

$$
सटीकता = फ़्रेक {पाठ {सही भविष्यवाणियों की संख्या}} {पाठ {भविष्यवाणियों की कुल संख्या}}
$$

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 असमंजस का जाल हमारे मॉडल की भविष्यवाणियों के बारे में।

एक भ्रम मैट्रिक्स के साथ मॉडल का मूल्यांकन

आइए गणना करें और फिर भ्रम मैट्रिक्स को प्लॉट करें। ऐसा करने के बाद हम इसके प्रत्येक भाग को समझ सकते हैं। कन्फ्यूजन मैट्रिक्स को प्लॉट करने के लिए, हम स्किकिट-लर्न का उपयोग करेंगे 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 (सेर्सवेलिक बीज)। हमारे पास भी है 250 कक्षा के लिए सही सकारात्मक 1 (Ürgüp Sivrisi के बीज)। सच्चे सकारात्मक हमेशा मैट्रिक्स विकर्ण में स्थित होते हैं जो ऊपरी बाएं से निचले दाएं तक जाते हैं।

हम यह भी है 29 मूल्य जो होने चाहिए थे 0, लेकिन भविष्यवाणी के रूप में 1 (झूठी सकारात्मक) और 59 मूल्य जो थे 1 और के रूप में भविष्यवाणी की 0 (झूठे नकारात्मक) उन संख्याओं के साथ, हम समझ सकते हैं कि मॉडल जो त्रुटि सबसे अधिक करता है वह यह है कि यह झूठी नकारात्मक भविष्यवाणी करता है। तो, यह ज्यादातर एक rgüp Sivrisi बीज को erçevelik बीज के रूप में वर्गीकृत कर सकता है।

इस तरह की त्रुटि को कक्षा के 81% रिकॉल द्वारा भी समझाया गया है 1. ध्यान दें कि मेट्रिक्स जुड़े हुए हैं। और रिकॉल में अंतर उर्गुप सिवरीसी वर्ग के 100 कम नमूने होने से आ रहा है। यह अन्य वर्ग की तुलना में कुछ ही नमूने कम होने के निहितार्थों में से एक है। स्मरण शक्ति को और बेहतर बनाने के लिए, आप या तो वर्ग भारों के साथ प्रयोग कर सकते हैं या अधिक rgüp Sivrisi नमूनों का उपयोग कर सकते हैं।

अब तक, हमने अधिकांश डेटा विज्ञान पारंपरिक चरणों को निष्पादित किया है और लॉजिस्टिक रिग्रेशन मॉडल को ब्लैक बॉक्स के रूप में उपयोग किया है।

अब ब्लैक बॉक्स को खोलने और इसके अंदर देखने का समय है, यह समझने के लिए कि लॉजिस्टिक रिग्रेशन कैसे काम करता है।

लॉजिस्टिक रिग्रेशन वास्तव में कैसे काम करता है, इसकी गहराई में जाना

RSI प्रतीपगमन शब्द दुर्घटना से नहीं है, यह समझने के लिए कि लॉजिस्टिक रिग्रेशन क्या करता है, हम याद रख सकते हैं कि इसका भाई, रैखिक प्रतिगमन डेटा के लिए क्या करता है। रैखिक प्रतिगमन सूत्र निम्नलिखित था:

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

जिसमें बी₀ प्रतिगमन अवरोधन था, b¹ गुणांक और x¹ आँकड़े।

उस समीकरण के परिणामस्वरूप एक सीधी रेखा बन गई जिसका उपयोग नए मूल्यों की भविष्यवाणी करने के लिए किया गया था। परिचय को याद करते हुए, अब अंतर यह है कि हम नए मूल्यों की भविष्यवाणी नहीं करेंगे, बल्कि एक वर्ग की भविष्यवाणी करेंगे। तो उस सीधी रेखा को बदलने की जरूरत है। लॉजिस्टिक रिग्रेशन के साथ, हम एक गैर-रैखिकता का परिचय देते हैं और भविष्यवाणी अब एक रेखा के बजाय एक वक्र का उपयोग करके की जाती है:

ध्यान दें कि जब रैखिक प्रतिगमन रेखा चलती रहती है और निरंतर अनंत मूल्यों से बनी होती है, तो रसद प्रतिगमन वक्र को बीच में विभाजित किया जा सकता है और 0 और 1 मानों में चरम सीमा होती है। यही कारण है कि यह "एस" आकार डेटा को वर्गीकृत करता है - जो बिंदु उच्चतम छोर पर करीब या गिरते हैं, वे कक्षा 1 से संबंधित होते हैं, जबकि निचले चतुर्थांश में या 0 के करीब वाले बिंदु कक्षा 0 से संबंधित होते हैं। "एस" 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), रैखिक प्रतिगमन की शक्ति तक बढ़ा:

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

इसे लिखने का एक और तरीका होगा:

$$
एलएन लेफ्ट (फ्रैक{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 + बी_एन * एक्स_एन)}
$$

$$
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 + बी_एन * एक्स_एन)}
$$

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

)

$$
फ़्रैक{p}{1-p} = e^{(b_0 + b_1 * x_1 + b_2 *x_2 + b_3 * x_3 + ldots + b_n * x_n)}
$$

$$
एलएन लेफ्ट (फ्रैक{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 परिणाम। इस प्रकार लॉजिस्टिक रिग्रेशन की गणना की जाती है और क्यों प्रतीपगमन इसके नाम का हिस्सा है। लेकिन टर्म का क्या? तार्किक?

अवधि तार्किक से आता है logit, जो एक फ़ंक्शन है जिसे हम पहले ही देख चुके हैं:

$$
एलएन लेफ्ट (फ्रैक {पी} {1-पी} राइट)
$$

हमने अभी इसकी गणना की है px और 1-px. यह लॉगिट है, जिसे भी कहा जाता है लॉग-बाधाओं चूँकि यह ऑड्स के लघुगणक के बराबर है जहाँ p एक संभावना है।

निष्कर्ष

इस गाइड में, हमने सबसे मौलिक मशीन लर्निंग वर्गीकरण एल्गोरिदम में से एक का अध्ययन किया है, अर्थात रसद प्रतिगमन.

प्रारंभ में, हमने स्किकिट-लर्न की मशीन लर्निंग लाइब्रेरी के साथ एक ब्लैक बॉक्स के रूप में लॉजिस्टिक रिग्रेशन को लागू किया, और बाद में हमने इसे चरण दर चरण समझा कि यह स्पष्ट है कि रिग्रेशन और लॉजिस्टिक शब्द क्यों और कहां से आते हैं।

हमने डेटा की खोज और अध्ययन भी किया है, यह समझते हुए कि डेटा विज्ञान विश्लेषण के सबसे महत्वपूर्ण भागों में से एक है।

यहां से, मैं आपको इसके साथ खेलने की सलाह दूंगा मल्टीक्लास लॉजिस्टिक रिग्रेशन, दो से अधिक वर्गों के लिए लॉजिस्टिक प्रतिगमन - आप अन्य डेटासेट के लिए समान लॉजिस्टिक प्रतिगमन एल्गोरिदम लागू कर सकते हैं, जिसमें कई वर्ग हैं, और परिणामों की व्याख्या कर सकते हैं।

मैं आपको L1 और L2 का अध्ययन करने की भी सलाह दूंगा नियमितीकरण, वे उच्च डेटा को "दंडित" करने का एक तरीका हैं ताकि यह सामान्य के करीब हो जाए, मॉडल की जटिलता को बनाए रखता है, ताकि एल्गोरिथम बेहतर परिणाम प्राप्त कर सके। हमने जिस स्किकिट-लर्न कार्यान्वयन का उपयोग किया है, उसमें पहले से ही डिफ़ॉल्ट रूप से L2 नियमितीकरण है। देखने की एक और बात अलग है समाधानकर्ताओंइस तरह के रूप में, lbgs, जो लॉजिस्टिक रिग्रेशन एल्गोरिथम प्रदर्शन को अनुकूलित करता है।

पर एक नज़र डालना भी ज़रूरी है सांख्यिकीय लॉजिस्टिक रिग्रेशन के लिए दृष्टिकोण। यह है मान्यताओं डेटा के व्यवहार के बारे में, और अन्य आँकड़ों के बारे में जो संतोषजनक परिणामों की गारंटी के लिए होना चाहिए, जैसे:

• अवलोकन स्वतंत्र हैं;
• व्याख्यात्मक चरों के बीच कोई बहुसंरेखण नहीं है;
• कोई चरम बाहरी नहीं हैं;
• व्याख्यात्मक चर और प्रतिक्रिया चर के लॉगिट के बीच एक रैखिक संबंध है;
• नमूना आकार पर्याप्त रूप से बड़ा है।

ध्यान दें कि उनमें से कितनी धारणाएं हमारे विश्लेषण और डेटा के उपचार में पहले से ही शामिल थीं।

मुझे आशा है कि आप यह खोजते रहेंगे कि लॉजिस्टिक रिग्रेशन को इसके सभी विभिन्न तरीकों में क्या पेश करना है!