🎼 🚢 🚴🏻 एनरॉन डेटासेट का उपयोग कर धोखाधड़ी की पहचान करें। भाग 2, सबसे अच्छा मॉडल ढूंढना ⛸️ 😽 👨🏿‍🔧

मैं आपको एनरॉन डेटासेट के डेटा के आधार पर संदिग्ध धोखाधड़ी की खोज पर लेख का दूसरा भाग पेश करता हूं। यदि आपने पहला भाग नहीं पढ़ा है, तो आप अपने आप को यहाँ से परिचित कर सकते हैं ।

अब हम एक मॉडल के निर्माण, अनुकूलन और चुनने की प्रक्रिया के बारे में बात करेंगे जो जवाब देगा: क्या यह धोखाधड़ी के एक व्यक्ति पर संदेह करने योग्य है?

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

परिणाम कई से परिचित था:

X_train और y_train - प्रशिक्षण के लिए उपयोग किया जाने वाला नमूना (111 रिकॉर्ड);
X_test और y_test - एक नमूना जिस पर हमारे मॉडल की भविष्यवाणियों की शुद्धता की जांच की जाएगी (28 प्रविष्टियां)।

मॉडलों का बोलना ... सही ढंग से यह अनुमान लगाने के लिए कि क्या यह किसी व्यक्ति पर संदेह करने के लायक है, कुछ संकेतों के आधार पर उसकी गतिविधियों को चिह्नित करता है, हम वर्गीकरण का उपयोग करेंगे। इस खंड में समस्याओं को हल करने के लिए उपयोग किए जाने वाले मुख्य प्रकार के मॉडल Sklearn से लिए जा सकते हैं:

नैवे बेस (भोले बेयस क्लासिफायरियर);
एसवीएम (संदर्भ वेक्टर मशीन);
K- निकटतम पड़ोसी (निकटतम पड़ोसियों को खोजने की विधि);
यादृच्छिक वन (यादृच्छिक वन);
तंत्रिका नेटवर्क।

एक ऐसी तस्वीर भी है जो उनकी प्रयोज्यता को अच्छी तरह दर्शाती है:

उनमें से एक डिसीजन ट्री (निर्णय वृक्ष) है, जो कई लोगों के लिए परिचित है, लेकिन, शायद, यह रैंडम फ़ॉरेस्ट के साथ इस पद्धति का उपयोग करने के लिए एक कार्य में कोई मतलब नहीं है, जो निर्णय पेड़ों का एक समूह है। इसलिए, इसे लॉजिस्टिक रिग्रेशन के साथ बदलें, जो एक क्लासिफायरियर के रूप में कार्य कर सकता है और अपेक्षित विकल्पों (0 या 1) में से एक का उत्पादन कर सकता है।

शुरुआत

हम सभी निर्दिष्ट क्लासिफायर को डिफ़ॉल्ट मानों के साथ आरंभ करते हैं:

from sklearn.naive_bayes import GaussianNB from sklearn.linear_model import LogisticRegression from sklearn.neighbors import KNeighborsClassifier from sklearn.svm import SVC from sklearn.neural_network import MLPClassifier from sklearn.ensemble import RandomForestClassifier random_state = 42 gnb = GaussianNB() svc = SVC() knn = KNeighborsClassifier() log = LogisticRegression(random_state=random_state) rfc = RandomForestClassifier(random_state=random_state) mlp = MLPClassifier(random_state=random_state)

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

 classifiers = [gnb, svc, knn, log, rfc, mlp] for clf in classifiers: clf.fit(X_train, y_train)

मॉडलों को प्रशिक्षित करने के बाद, यह उनकी भविष्यवाणी की गुणवत्ता के पहले परीक्षण का समय था। इसके अलावा, हम सीबॉर्न का उपयोग करके अपने परिणामों की कल्पना करते हैं:

 from sklearn.metrics import accuracy_score def calculate_accuracy(X, y): result = pd.DataFrame(columns=['classifier', 'accuracy']) for clf in classifiers: predicted = clf.predict(X_test) accuracy = round(100.0 * accuracy_score(y_test, predicted), 2) classifier = clf.__class__.__name__ classifier = classifier.replace('Classifier', '') result = result.append({'classifier': classifier, 'accuracy': accuracy}, ignore_index=True) print('Accuracy is {accuracy}% for {classifier_name}'.format(accuracy=accuracy, classifier_name=classifier)) result = result.sort_values(['classifier'], ascending=True) plt.subplots(figsize=(10, 7)) sns.barplot(x="classifier", y='accuracy', palette=cmap, data=result)

आइए एक नज़र डालते हैं कि कक्षा के छात्रों की सटीकता के सामान्य विचार पर:

 calculate_accuracy(X_train, y_train)

पहली नज़र में, यह बहुत अच्छा लग रहा है, परीक्षण के नमूने पर भविष्यवाणियों की सटीकता लगभग 90% है। ऐसा लगता है कि कार्य शानदार है!

वास्तव में, सब कुछ इतना रसीला नहीं है।

उच्च सटीकता सही भविष्यवाणियों की गारंटी नहीं है। हमारे परीक्षण के नमूने में 28 रिकॉर्ड हैं, जिनमें से 4 संदिग्ध से संबंधित हैं, और 24 जो संदेह से परे हैं। कल्पना कीजिए कि हमने किसी प्रकार के एल्गोरिथ्म का निर्माण किया है:

 def QuaziAlgo(features): return 0

फिर उन्होंने प्रवेश द्वार पर उसे हमारा परीक्षण नमूना दिया, और उन्होंने पाया कि सभी 28 लोग निर्दोष हैं। इस मामले में एल्गोरिथ्म की सटीकता क्या होगी?

$सटीकता = \ frac {P} {N} = \ frac {24} {28} \ लगभग 0.857$

दिलचस्प है, KNeighbors एक ही भविष्यवाणी सटीकता है ...

लेकिन फिर भी, खुद की चापलूसी करने से पहले, आइए भविष्यवाणी के परिणामों के लिए एक उलझन मैट्रिक्स का निर्माण करें:

 from sklearn.metrics import confusion_matrix def make_confussion_matrices(X, y): matrices = {} result = pd.DataFrame(columns=['classifier', 'recall']) for clf in classifiers: classifier = clf.__class__.__name__ classifier = classifier.replace('Classifier', '') predicted = clf.predict(X_test) print(f'{predicted}-{classifier}') matrix = confusion_matrix(y_test,predicted,labels=[1,0]) matrices[classifier] = matrix.T return matrices

हम प्रत्येक क्लासिफायर के लिए त्रुटि मैट्रेस की गणना करते हैं और, इसके साथ, देखें कि उन्होंने क्या भविष्यवाणी की थी:

 matrices = make_confussion_matrices(X_train,y_train)

यहां तक कि सहपाठियों के काम के परिणाम का एक पाठात्मक प्रतिनिधित्व यह समझने के लिए पर्याप्त है कि कुछ स्पष्ट रूप से गलत हो गया।

निकटतम पड़ोसियों की विधि ने परीक्षण के नमूने में एक भी संदिग्ध का खुलासा नहीं किया। दो सवाल उठते हैं:

KNeighbors क्लासिफायर के इस व्यवहार का कारण क्या है?
यदि हम उनका उपयोग नहीं करते हैं, तो त्रुटि त्रुटियों का निर्माण क्यों करते हैं, लेकिन सिर्फ भविष्यवाणी के परिणामों को देखें?

गहराई से देखें

दूसरे प्रश्न के साथ शुरू करते हैं। आइए, वर्गीकरण त्रुटि होने पर समझने के लिए अपनी त्रुटि मैट्रिक्स की कल्पना करें और ग्राफ़िकल प्रारूप में डेटा प्रस्तुत करें:

 import itertools from collections import Iterable def draw_confussion_matrices(row,col,matrices,figsize = (16,12)): fig, (axes) = plt.subplots(row,col, sharex='col', sharey='row',figsize=figsize ) if any(isinstance(i, Iterable) for i in axes): axes = list(itertools.chain.from_iterable(axes)) idx = 0 for name,matrix in matrices.items(): df_cm = pd.DataFrame( matrix, index=['True','False'], columns=['True','False'], ) ax = axes[idx] fig.subplots_adjust(wspace=0.1) sns.heatmap(df_cm, annot=True,cmap=cmap,cbar=False ,fmt="d",ax=ax,linewidths=1) ax.set_title(name) idx += 1

हम उन्हें 2 पंक्तियों और 3 कॉलमों में प्रदर्शित करते हैं:

 draw_confussion_matrices(2,3,matrices)

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

उदाहरण के लिए, हम देखते हैं कि 85.71% की भविष्यवाणी सटीकता के साथ KNeighbors निर्णय मामलों की वास्तविक स्थिति के साथ मेल खाता है जब 24 लोग, जो संदेह से बाहर थे, को क्लासिफायरियर द्वारा समान सूची में शामिल किया गया था। लेकिन संदिग्धों की सूची में से 4 लोगों को भी इस सूची में शामिल किया गया था। अगर इस क्लासिफायर ने फैसले किए, तो शायद कोई भी अदालत से बच सकता था।

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

मैट्रिक्स

सामान्य शब्दों में, यह निम्नलिखित चित्र द्वारा चित्रित किया जा सकता है:

और इस मामले में टीपी, टीएन, एफपी और कुछ प्रकार के एफएन क्या हैं?

$TP \ - \ true positive \ solution \\ TN \ - \ true negative \ solution \\ FP \ - \ false सकारात्मक \ solution \\ FN \ - \ false \ negative \ solution$

दूसरे शब्दों में, हम यह सुनिश्चित करने का प्रयास करते हैं कि क्लासिफायर के जवाब और मामलों की वास्तविक स्थिति मेल खाती है। यही है, यह सुनिश्चित करने के लिए कि सभी संख्याओं को टीपी और टीएन (सच्चे समाधान) के बीच वितरित किया जाता है और एफएन और एफपी (झूठे समाधान) में नहीं आते हैं।

हमेशा सब कुछ इतना नाटकीय और अस्पष्ट नहीं होता है

उदाहरण के लिए, कैंसर के निदान के साथ विहित मामले में, एफपी एफएन के लिए बेहतर है, क्योंकि कैंसर पर झूठे फैसले के मामले में, रोगी को दवा दी जाएगी और उसका इलाज किया जाएगा। हां, यह उनके स्वास्थ्य और वॉलेट को प्रभावित करेगा, लेकिन फिर भी इसे एफएन से कम खतरनाक माना जाता है और मिस्ड काल जिसमें कैंसर को छोटे तरीकों से हराया जा सकता है।
हमारे मामले में संदिग्धों के बारे में क्या? एफएन शायद एफपी जितना खराब नहीं है। लेकिन उस पर और बाद में ...

और जब से हम संक्षिप्तीकरण के बारे में बात कर रहे हैं, यह सटीकता (परिशुद्धता) और पूर्णता (रिकॉल) के मैट्रिक्स को याद करने का समय है।

यदि आप औपचारिक रिकॉर्ड से विदा होते हैं, तो सटीक रूप में व्यक्त किया जा सकता है:

दूसरे शब्दों में, एक खाते को रखा जाता है कि क्लासिफायरियर से कितनी सकारात्मक प्रतिक्रियाएं प्राप्त होती हैं। अधिक से अधिक सटीकता, झूठी हिट की संख्या कम (सटीकता 1 है अगर एफपी नहीं थे)।

रिकॉल को आम तौर पर प्रस्तुत किया जाता है:

याद रखें कि क्लासिफायर की क्षमता "अनुमान" के रूप में संभव के रूप में कई सकारात्मक जवाबों की विशेषता है। पूर्णता जितनी अधिक होगी, FN उतना ही कम होगा।

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

हम अपने वर्ग के लिए सटीक गणना करते हैं:

 from sklearn.metrics import precision_score def calculate_precision(X, y): result = pd.DataFrame(columns=['classifier', 'precision']) for clf in classifiers: predicted = clf.predict(X_test) precision = precision_score(y_test, predicted, average='macro') classifier = clf.__class__.__name__ classifier = classifier.replace('Classifier', '') result = result.append({'classifier': classifier, 'precision': precision}, ignore_index=True) print('Precision is {precision} for {classifier_name}'.format(precision=round(precision,2), classifier_name=classifier)) result = result.sort_values(['classifier'], ascending=True) plt.subplots(figsize=(10, 7)) sns.barplot(x="classifier", y='precision', palette=cmap, data=result) calculate_precision(X_train, y_train)

जैसा कि आकृति से निम्नानुसार है, यह उम्मीद के मुताबिक निकला: KNeighbors सटीकता सबसे कम निकला, क्योंकि टीपी मूल्य सबसे कम है।

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

हाइपर पैरामीटर चयन

हमने मेट्रिक के बाद पाया कि चयनित स्थितियों में सबसे अच्छा सूट करता है (हम एफपी की संख्या कम करते हैं), हम पहले सवाल पर लौट सकते हैं: केनिघोर्स क्लासिफायर के इस व्यवहार का कारण क्या है?

इसका कारण डिफ़ॉल्ट सेटिंग्स में है जिसके साथ यह मॉडल बनाया गया था। और, सबसे अधिक संभावना है, कई लोग इस चरण को प्राप्त कर सकते हैं: डिफ़ॉल्ट मापदंडों पर ट्रेन क्यों? विशेष चयन उपकरण हैं, उदाहरण के लिए, अक्सर उपयोग किए जाने वाले GridSearchCV।
हाँ, यह है, और इसका सहारा लेने का समय आ गया है,

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

 classifiers.remove(gnb)

ठीक ट्यूनिंग

हम प्रत्येक क्लासिफायरिफायर के मापदंडों को ग्रिड से परिभाषित करते हैं:

 parameters = {'SVC':{'kernel':('linear', 'rbf','poly'), 'C':[i for i in range(1,11)],'random_state': (random_state,)}, 'KNeighbors':{'algorithm':('ball_tree', 'kd_tree'), 'n_neighbors':[i for i in range(2,20)]}, 'LogisticRegression':{'penalty':('l1', 'l2'), 'C':[i for i in range(1,11)],'random_state': (random_state,)}, 'RandomForest':{'n_estimators':[i for i in range(10,101,10)],'random_state': (random_state,)}, 'MLP':{'activation':('relu','logistic'),'solver':('sgd','lbfgs'),'max_iter':(500,1000), 'hidden_layer_sizes':[(7,),(7,7)],'random_state': (random_state,)}}

इसके अतिरिक्त, मैं MLP में परतों / न्यूरॉन्स की संख्या पर ध्यान देना चाहता था।
यह उन्हें सभी संभावित मूल्यों की विस्तृत खोज के द्वारा निर्धारित करने का निर्णय लिया गया था, लेकिन अभी भी सूत्र पर आधारित है :

$N_h = \ frac {N_s} {(\ Alpha * (N_i + N_o))} = \ frac {117} {(2 * (7 + 1))} \ लगभग 7$

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

हम अनुकूलन को आगे बढ़ाएंगे और हमारे क्लासिफायर को उनके उन्नत संस्करण से बदलेंगे:

 from sklearn.model_selection import GridSearchCV warnings.filterwarnings('ignore') for idx,clf in enumerate(classifiers): classifier = clf.__class__.__name__ classifier = classifier.replace('Classifier', '') params = parameters.get(classifier) if not params: continue new_clf = clf.__class__() gs = GridSearchCV(new_clf, params, cv=5) result =gs.fit(X_train, y_train) print(f'The best params for {classifier} are {result.best_params_}') classifiers[idx] = result.best_estimator_

हमने मूल्यांकन के लिए एक मीट्रिक चुना है और GridSearchCV का प्रदर्शन करने के बाद, हम अंतिम रेखा खींचने के लिए तैयार हैं।

संक्षेप में देना

त्रुटि मैट्रिक्स v.2

 matrices = make_confussion_matrices(X_train,y_train) draw_confussion_matrices(1,2,first_row,figsize = (10.5,6)) draw_confussion_matrices(1,3,second_row,figsize = (16,6))

जैसा कि मैट्रिक्स से देखा जा सकता है, एमएलपी ने गिरावट दिखाई और माना कि परीक्षण नमूने में कोई संदिग्ध नहीं थे। रैंडम फ़ॉरेस्ट ने सटीकता प्राप्त की और झूठी नकारात्मक और सच्चे सकारात्मक के मापदंडों को सही किया। और KNeighbors ने भविष्यवाणी में सुधार दिखाया। दूसरों के लिए पूर्वानुमान नहीं बदला है।

सटीकता v.2

अब, हमारे किसी भी वर्तमान क्लासिफायर के पास फाल्स पॉजिटिव की गलतियाँ नहीं हैं, जो अच्छी खबर है। लेकिन, यदि हम संख्याओं की भाषा में सब कुछ व्यक्त करते हैं, तो हमें निम्नलिखित चित्र मिलते हैं:

 calculate_precision(X_train, y_train)

उच्चतम परिशुद्धता स्कोर वाले 3 क्लासिफायर की पहचान की गई। और त्रुटि मैट्रिक्स के आधार पर उनके समान मूल्य हैं। किस वर्ग का चयन करना है?

कौन बेहतर है?

यह मुझे लगता है कि यह एक कठिन सवाल है, जिसके लिए कोई सार्वभौमिक जवाब नहीं है। हालाँकि, इस मामले में मेरा दृष्टिकोण कुछ इस तरह होगा:

1. क्लासिफायर संभव के रूप में अपने तकनीकी कार्यान्वयन में सरल होना चाहिए। तब उसे फिर से पैर रखने का जोखिम कम होगा (शायद एमएलपी के साथ ऐसा ही हुआ)। इसलिए, यह रैंडम फ़ॉरेस्ट नहीं है, क्योंकि यह एल्गोरिथ्म 30 पेड़ों का एक पहनावा है और परिणामस्वरूप, उन पर निर्भर करता है। पायथन ज़ेन के विचारों में से एक के साथ व्यंजन: सरल जटिल से बेहतर है।

2. एल्गोरिथ्म सहज होने पर बुरा नहीं था। यही है, KNeighbors संभावित बहुआयामी स्थान के साथ SVMs से अधिक माना जाता है।
बदले में जो एक और बयान के समान है: स्पष्ट रूप से निहित से बेहतर है।

इसलिए, 3 पड़ोसियों के साथ KNeighbors, मेरी राय में, सबसे अच्छा उम्मीदवार है।

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

एनरॉन डेटासेट का उपयोग कर धोखाधड़ी की पहचान करें। भाग 2, सबसे अच्छा मॉडल ढूंढना