पायथन के स्किकिट-लर्न के साथ एसवीएम और कर्नेल एसवीएम को लागू करना

परिचय

यह गाइड सपोर्ट वेक्टर मशीन (एसवीएम) के बारे में तीन गाइड का पहला भाग है। इस श्रृंखला में, हम जाली बैंक नोटों के उपयोग के मामले पर काम करेंगे, सरल एसवीएम के बारे में जानेंगे, फिर एसवीएम हाइपरपैरामीटर के बारे में और अंत में, एक अवधारणा सीखेंगे जिसे कर्नेल ट्रिक और अन्य प्रकार के एसवीएम का अन्वेषण करें।

यदि आप सभी गाइड पढ़ना चाहते हैं या यह देखना चाहते हैं कि कौन सी गाइड आपको सबसे ज्यादा पसंद है, तो प्रत्येक गाइड में शामिल विषयों की तालिका नीचे दी गई है:

1. पायथन के स्किकिट-लर्न के साथ एसवीएम और कर्नेल एसवीएम को लागू करना

• उदाहरण का प्रयोग करें: बैंक नोट भूल जाओ
• एसवीएम की पृष्ठभूमि
• सरल (रैखिक) एसवीएम मॉडल
  • डेटासेट के बारे में
  • डेटासेट आयात करना
  • डेटासट की खोज
• एसवीएम को स्किकिट-लर्न के साथ लागू करना
  • डेटा को ट्रेन/टेस्ट सेट में विभाजित करना
  • मॉडल को प्रशिक्षित करना
  • पूर्वानुमान करना
  • मॉडल का मूल्यांकन
  • व्याख्या परिणाम

2. एसवीएम हाइपरपैरामीटर को समझना (जल्द आ रहा है!)

• सी हाइपरपैरामीटर
• गामा हाइपरपैरामीटर

3. पायथन के स्किकिट-लर्न के साथ अन्य एसवीएम स्वादों को लागू करना (जल्द आ रहा है!)

• एसवीएम का सामान्य विचार (एक पुनर्कथन)
• कर्नेल (ट्रिक) एसवीएम
• स्किकिट-लर्न के साथ नॉन-लीनियर कर्नेल एसवीएम को लागू करना
• पुस्तकालयों का आयात करना
  • डेटासेट आयात करना
  • डेटा को सुविधाओं (X) और लक्ष्य (y) में विभाजित करना
  • डेटा को ट्रेन/टेस्ट सेट में विभाजित करना
  • एल्गोरिथम प्रशिक्षण
• बहुपद कर्नेल
  • पूर्वानुमान करना
  • एल्गोरिथ्म का मूल्यांकन
• गाऊसी कर्नेल
  • भविष्यवाणी और मूल्यांकन
• सिग्मॉइड कर्नेल
  • भविष्यवाणी और मूल्यांकन
• गैर रेखीय कर्नेल प्रदर्शनों की तुलना

केस का प्रयोग करें: जाली बैंक नोट

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

लेकिन क्या होता है जब प्रत्येक नोट को देखने वाला कोई व्यक्ति नहीं होता है? क्या कोई ऐसा तरीका है जिससे स्वतः ही पता चल जाता है कि बैंक नोट जाली हैं या असली?

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

चूंकि छवियों का उपयोग किया जा रहा है, उन्हें संकुचित किया जा सकता है, ग्रेस्केल में घटाया जा सकता है, और उनके माप निकाले या परिमाणित किए जा सकते हैं। इस तरह, तुलना प्रत्येक छवि के पिक्सेल के बजाय छवियों के मापन के बीच होगी।

अब तक, हमने बैंक नोटों को संसाधित करने और उनकी तुलना करने का एक तरीका खोज लिया है, लेकिन उन्हें असली या जाली में कैसे वर्गीकृत किया जाएगा? हम उस वर्गीकरण को करने के लिए मशीन लर्निंग का उपयोग कर सकते हैं। एक वर्गीकरण एल्गोरिदम कहा जाता है समर्थन वेक्टर यंत्र, मुख्य रूप से इसके संक्षिप्त रूप से जाना जाता है: SVM.

एसवीएम की पृष्ठभूमि

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

उपरोक्त छवि में हमारे बीच में एक रेखा है, जिसके कुछ बिंदु बाईं ओर हैं, और अन्य उस रेखा के दाईं ओर हैं। ध्यान दें कि बिंदुओं के दोनों समूह पूरी तरह से अलग हैं, बीच में या रेखा के करीब भी कोई बिंदु नहीं हैं। समान बिंदुओं और उन्हें विभाजित करने वाली रेखा के बीच एक मार्जिन लगता है, उस मार्जिन को कहा जाता है जुदाई मार्जिन. पृथक्करण मार्जिन का कार्य समान बिंदुओं और उन्हें विभाजित करने वाली रेखा के बीच की जगह को बड़ा बनाना है। एसवीएम ऐसा कुछ बिंदुओं का उपयोग करके करता है और लाइन के मार्जिन के निर्णय का समर्थन करने के लिए अपने लंबवत वैक्टरों की गणना करता है। वो हैं वैक्टर का समर्थन करें जो एल्गोरिथम के नाम का हिस्सा हैं। हम उनके बारे में बाद में और समझेंगे। और जो सीधी लाइन हम बीच में देखते है वो मेथड से पाई जाती है अधिकतम रेखा और बिंदुओं के बीच का वह स्थान, या जो पृथक्करण मार्जिन को अधिकतम करता है। वे विधियाँ के क्षेत्र से उत्पन्न होती हैं अनुकूलन सिद्धांत.

उदाहरण में हमने अभी देखा है, बिंदुओं के दोनों समूहों को आसानी से अलग किया जा सकता है, क्योंकि प्रत्येक व्यक्तिगत बिंदु अपने समान बिंदुओं के साथ-साथ है, और दो समूह एक दूसरे से दूर हैं।

लेकिन क्या होता है अगर एक सीधी रेखा का उपयोग करके डेटा को अलग करने का कोई तरीका नहीं है? यदि जगह के बाहर गन्दे बिंदु हैं, या यदि वक्र की आवश्यकता है?

उस समस्या को हल करने के लिए, SVM को बाद में 1990 के दशक में डेटा को वर्गीकृत करने में सक्षम होने के लिए परिष्कृत किया गया था, जिसमें ऐसे बिंदु थे जो इसकी केंद्रीय प्रवृत्ति से दूर थे, जैसे कि आउटलेयर, या अधिक जटिल समस्याएं जिनमें दो से अधिक आयाम थे और रैखिक रूप से अलग नहीं थे .

दिलचस्प बात यह है कि केवल हाल के वर्षों में एसवीएम को व्यापक रूप से अपनाया गया है, मुख्य रूप से कभी-कभी 90% से अधिक सही उत्तर प्राप्त करने की उनकी क्षमता के कारण या शुद्धता, कठिन समस्याओं के लिए।

एसवीएम को अन्य मशीन लर्निंग एल्गोरिदम की तुलना में एक अनोखे तरीके से लागू किया जाता है, एक बार जब वे सीखने की सांख्यिकीय व्याख्याओं पर आधारित होते हैं, या सांख्यिकी सीखने के सिद्धांत.

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

सरल (रैखिक) एसवीएम मॉडल

डेटासेट के बारे में

परिचय में दिए गए उदाहरण के बाद, हम एक ऐसे डेटासेट का उपयोग करेंगे जिसमें वास्तविक और जाली बैंक नोटों की छवियों का माप हो।

दो नोटों को देखते समय, हमारी आंखें आमतौर पर उन्हें बाएं से दाएं स्कैन करती हैं और जांचती हैं कि समानताएं या असमानताएं कहां हो सकती हैं। हम एक हरे रंग के बिंदु से पहले आने वाले एक काले बिंदु, या एक चित्रण के ऊपर एक चमकदार निशान की तलाश करते हैं। इसका अर्थ है कि एक क्रम है जिसमें हम नोटों को देखते हैं। अगर हमें पता होता कि हरे और काले बिंदु हैं, लेकिन अगर हरे रंग से पहले हरे रंग का बिंदु नहीं आ रहा था, या अगर हरे रंग से पहले काला आ रहा था, तो नोटों के बीच भेदभाव करना कठिन होगा।

हमने अभी जो वर्णन किया है, उसके समान एक विधि है जिसे बैंक नोट छवियों पर लागू किया जा सकता है। सामान्य शब्दों में, इस विधि में छवि के पिक्सेल को सिग्नल में अनुवाद करना शामिल है, फिर उस क्रम को ध्यान में रखते हुए छवि में प्रत्येक अलग सिग्नल को छोटी तरंगों में बदलकर, या तरंगिकाओं. वेवलेट प्राप्त करने के बाद, उस क्रम को जानने का एक तरीका है जिसमें कुछ सिग्नल दूसरे से पहले होता है, या पहर, लेकिन वास्तव में क्या संकेत नहीं। यह जानने के लिए, छवि की आवृत्तियों को प्राप्त करने की आवश्यकता होती है। वे एक विधि द्वारा प्राप्त किए जाते हैं जो प्रत्येक सिग्नल का अपघटन करता है, जिसे कहा जाता है फूरियर विधि.

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

यह विधि जिसमें तरंगिकाओं, उनकी आवृत्तियों को खोजना और फिर दोनों को फिट करना शामिल है, कहलाती है तरंगिका रूपांतरण. तरंगिका परिवर्तन में गुणांक होते हैं, और उन गुणांकों का उपयोग हमारे पास डेटासेट में माप प्राप्त करने के लिए किया जाता था।

डेटासेट आयात करना

इस खंड में हम जिस बैंक नोट्स डेटासेट का उपयोग करने जा रहे हैं, वह वही है जिसका उपयोग वर्गीकरण अनुभाग में किया गया था निर्णय वृक्ष ट्यूटोरियल.

आइए डेटा को पांडा में आयात करें 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 तरंगिका रूपांतरित छवि की। तिरछापन एक सतत मूल्य है जो वितरण की विषमता को इंगित करता है। यदि माध्य के बाईं ओर अधिक मान हैं, तो वितरण है नकारात्मक रूप से तिरछा, यदि माध्य के दाईं ओर अधिक मान हैं, तो वितरण है सकारात्मक रूप से तिरछा, और यदि माध्य, बहुलक और माध्यिका समान हैं, तो वितरण है सममित. एक वितरण जितना अधिक सममित होता है, वह सामान्य वितरण के उतना ही करीब होता है, साथ ही इसके मूल्यों को अधिक अच्छी तरह से वितरित किया जाता है। वर्तमान संदर्भ में, यह उन गुणांकों का तिरछापन है जो तरंगिका परिवर्तन से उत्पन्न होते हैं। अधिक सममित, गुणांक हम जितने करीब होंगेvariance, skewness, curtosis, entropyवास्तविक छवि का अनुवाद करने के लिए फिर से।

• curtosis तरंगिका रूपांतरित छवि का (या कर्टोसिस)। ककुदता एक सतत मूल्य है, जो तिरछापन की तरह, वितरण के आकार का भी वर्णन करता है। कर्टोसिस गुणांक (के) के आधार पर, एक वितरण - जब सामान्य वितरण की तुलना में कम या ज्यादा फ्लैट हो सकता है - या इसके चरम या पूंछ में अधिक या कम डेटा हो सकता है। जब वितरण अधिक फैला हुआ और चापलूसी वाला होता है, तो इसे कहा जाता है प्लैटीकुर्टिक; जब यह कम फैलता है और बीच में अधिक केंद्रित होता है, मेसोकर्टिक; और जब वितरण लगभग पूरी तरह से मध्य में केंद्रित होता है, तो इसे कहा जाता है लेप्टोकुर्टिक. यह वैसा ही मामला है जैसा विचरण और तिरछापन पिछले मामलों में होता है, वितरण जितना अधिक मेसोकर्टिक होता है, वास्तविक छवि का अनुवाद करने के लिए गुणांक उतने ही करीब होते हैं।

• 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)

RSI 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

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

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

आइए प्रत्येक फीचर के वितरण के साथ शुरू करें, और को छोड़कर प्रत्येक डेटा कॉलम के हिस्टोग्राम को प्लॉट करें 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();

ध्यान दें कि सभी ग्राफ़ में वास्तविक और जाली दोनों डेटा बिंदु स्पष्ट रूप से एक दूसरे से अलग नहीं होते हैं, इसका मतलब है कि कक्षाओं का किसी प्रकार का सुपरपोजिशन है। चूंकि एक एसवीएम मॉडल कक्षाओं के बीच अलग करने के लिए एक रेखा का उपयोग करता है, क्या ग्राफ में उन समूहों में से कोई भी केवल एक पंक्ति का उपयोग करके अलग किया जा सकता है? यह नामुमकिन सा लगता है। यह सबसे वास्तविक डेटा जैसा दिखता है। अलगाव के जितना करीब हम पहुंच सकते हैं, वह संयोजन में है skewness और varianceया, entropy और variance भूखंड। यह शायद की वजह से है variance वितरण आकार वाला डेटा जो सामान्य के करीब है।

लेकिन उन सभी ग्राफ़ को क्रम से देखना थोड़ा कठिन हो सकता है। हमारे पास सीबॉर्न का उपयोग करके सभी वितरण और स्कैटर प्लॉट ग्राफ़ को एक साथ देखने का विकल्प है pairplot().

हमारे द्वारा किए गए लूप के पिछले दोनों को केवल इस पंक्ति द्वारा प्रतिस्थापित किया जा सकता है:

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

जोड़ी प्लॉट को देखकर ऐसा लगता है कि, वास्तव में, curtosis और variance सुविधाओं का सबसे आसान संयोजन होगा, इसलिए विभिन्न वर्गों को एक रेखा से अलग किया जा सकता है, या रैखिक रूप से वियोज्य.

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

इस मामले के लिए, आगे के प्रीप्रोसेसिंग के बिना डेटा का उपयोग करते हैं, और बाद में, हम एक कदम पीछे जा सकते हैं, डेटा प्रीप्रोसेसिंग में जोड़ सकते हैं और परिणामों की तुलना कर सकते हैं।

एसवीएम को स्किकिट-लर्न के साथ लागू करना

एसवीएम कैसे काम करता है, इस सिद्धांत में और अधिक जाने से पहले, हम डेटा और स्किकिट-लर्न के साथ अपना पहला बेसलाइन मॉडल बना सकते हैं। समर्थन वेक्टर वर्गीकारक or एसवीसी वर्ग.

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

डेटा को ट्रेन/टेस्ट सेट में विभाजित करना

पिछले सत्र में, हमने डेटा को समझा और उसका अन्वेषण किया। अब, हम अपने डेटा को दो सरणियों में विभाजित कर सकते हैं - एक चार विशेषताओं के लिए, और दूसरी पाँचवीं या लक्ष्य विशेषता के लिए। चूँकि हम तरंगिका गुणांकों के आधार पर वर्ग की भविष्यवाणी करना चाहते हैं, हमारा y हो जाएगा class कॉलम और हमारा X होगा variance, skewness, curtosis, तथा entropy कॉलम।

लक्ष्य और सुविधाओं को अलग करने के लिए, हम केवल विशेषता दे सकते हैं class करने के लिए स्तंभ y, बाद में शेष स्तंभों को विशेषता देने के लिए इसे डेटाफ़्रेम से छोड़ दें X साथ में .drop() तरीका:

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

एक बार डेटा को विशेषताओं और लेबल में विभाजित करने के बाद, हम इसे ट्रेन और टेस्ट सेट में विभाजित कर सकते हैं। यह हाथ से किया जा सकता है, लेकिन model_selection स्किकिट-लर्न की लाइब्रेरी में शामिल है train_test_split() विधि जो हमें डेटा को ट्रेन और टेस्ट सेट में बेतरतीब ढंग से विभाजित करने की अनुमति देती है।

इसका उपयोग करने के लिए, हम पुस्तकालय आयात कर सकते हैं, कॉल कर सकते हैं train_test_split() विधि, पास X और y डेटा, और एक परिभाषित करें 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 पुस्तकालय के साथ समर्थन वेक्टर वर्गीकारक कक्षा, या SVC वर्ग.

वर्ग को आयात करने के बाद, हम इसका एक उदाहरण बना सकते हैं - चूंकि हम एक साधारण एसवीएम मॉडल बना रहे हैं, हम अपने डेटा को रैखिक रूप से अलग करने की कोशिश कर रहे हैं, इसलिए हम अपने डेटा को विभाजित करने के लिए एक रेखा खींच सकते हैं - जो कि एक का उपयोग करने के समान है रैखिक प्रकार्य - परिभाषित करके 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 डेटा, परिणाम एक में संग्रहीत हैं y_pred चर। तो सरल रैखिक एसवीएम मॉडल के साथ भविष्यवाणी की गई प्रत्येक कक्षा अब अंदर है y_pred चर।

यह भविष्यवाणी कोड है:

y_pred = svc.predict(X_test)

यह देखते हुए कि हमारे पास भविष्यवाणियां हैं, अब हम उनकी तुलना वास्तविक परिणामों से कर सकते हैं।

मॉडल का मूल्यांकन

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

1. असमंजस का जाल: जब हमें यह जानने की आवश्यकता होती है कि हमें कितने नमूने सही या गलत मिले प्रत्येक वर्ग. वे मान जो सही थे और सही भविष्यवाणी की गई थी, कहलाते हैं सच्ची सकारात्मकता, जिनकी भविष्यवाणी सकारात्मक के रूप में की गई थी लेकिन सकारात्मक नहीं थी, उन्हें कहा जाता है झूठी सकारात्मक. एक ही नामकरण सच नकारात्मक और झूठे नकारात्मक नकारात्मक मूल्यों के लिए प्रयोग किया जाता है;

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

$$
सटीक = frac {पाठ {सही सकारात्मक}} {पाठ {सच्चे सकारात्मक} + पाठ {गलत सकारात्मक}}
$$

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

$$
याद = frac {पाठ {सही सकारात्मक}} {पाठ {सच्चे सकारात्मक} + पाठ {गलत नकारात्मक}}
$$

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

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

हम पहले से ही भ्रम मैट्रिक्स, सटीक, रिकॉल और F1 स्कोर उपायों से परिचित हो चुके हैं। उनकी गणना करने के लिए, हम स्किकिट-लर्न का आयात कर सकते हैं 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 के लिए 0.99 का f0 स्कोर है। उन मापों को 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% होने पर ओवरफिट लगता है। इस परिदृश्य में क्या किया जा सकता है?

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

आप इस गाइड का दूसरा भाग देख सकते हैं (जल्द आ रहा है!) यह देखने के लिए कि क्रॉस सत्यापन कैसे लागू किया जाए और हाइपरपैरामीटर ट्यूनिंग कैसे करें।

निष्कर्ष

इस लेख में हमने सरल रैखिक कर्नेल एसवीएम का अध्ययन किया। हमने एसवीएम एल्गोरिद्म के पीछे का अंतर्ज्ञान प्राप्त किया, एक वास्तविक डेटासेट का उपयोग किया, डेटा का पता लगाया, और देखा कि कैसे इस डेटा को एसवीएम के साथ पायथन के स्किकिट-लर्न लाइब्रेरी के साथ लागू करके उपयोग किया जा सकता है।

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

मैं यह भी सुझाव दूंगा कि आप एसवीएम मॉडल के पीछे वास्तविक गणित का पता लगाएं। यद्यपि एसवीएम एल्गोरिदम का उपयोग करने के लिए आपको इसकी आवश्यकता नहीं होगी, फिर भी यह जानना बहुत आसान है कि पर्दे के पीछे वास्तव में क्या चल रहा है, जबकि आपका एल्गोरिदम निर्णय सीमाओं को ढूंढ रहा है।

• एसईओ संचालित सामग्री और पीआर वितरण। आज ही प्रवर्धित हो जाओ।
• प्लेटोब्लॉकचैन। Web3 मेटावर्स इंटेलिजेंस। ज्ञान प्रवर्धित। यहां पहुंचें।
• मिंटिंग द फ्यूचर डब्ल्यू एड्रिएन एशले। यहां पहुंचें।
• स्रोत: https://stackabuse.com/implementing-svm-and-kernel-svm-with-pythons-scikit-learn/