Scikit-Learn ट्यूटोरियल: Scikit-Learn कैसे स्थापित करें और उदाहरण
स्किकिट-लर्न क्या है?
Scikit सीखने एक खुला स्रोत है Python मशीन लर्निंग के लिए लाइब्रेरी। यह KNN, XGBoost, रैंडम फ़ॉरेस्ट और SVM जैसे अत्याधुनिक एल्गोरिदम का समर्थन करता है। यह NumPy के शीर्ष पर बनाया गया है। Scikit-learn का उपयोग कागल प्रतियोगिता के साथ-साथ प्रमुख तकनीकी कंपनियों में व्यापक रूप से किया जाता है। यह प्रीप्रोसेसिंग, डायमेंशनलिटी रिडक्शन (पैरामीटर चयन), वर्गीकरण, रिग्रेशन, क्लस्टरिंग और मॉडल चयन में मदद करता है।
Scikit-learn में सभी ओपन-सोर्स लाइब्रेरीज़ का सबसे अच्छा दस्तावेज़ीकरण है। यह आपको एक इंटरैक्टिव चार्ट प्रदान करता है https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html.
स्किकिट-लर्न का उपयोग करना बहुत मुश्किल नहीं है और यह बेहतरीन परिणाम देता है। हालाँकि, स्किकिट लर्न समानांतर संगणनाओं का समर्थन नहीं करता है। इसके साथ डीप लर्निंग एल्गोरिदम चलाना संभव है लेकिन यह एक इष्टतम समाधान नहीं है, खासकर यदि आप TensorFlow का उपयोग करना जानते हैं।
Scikit-learn को कैसे डाउनलोड और इंस्टॉल करें
अब इसमें Python Scikit-learn ट्यूटोरियल में, हम सीखेंगे कि Scikit-learn को कैसे डाउनलोड और इंस्टॉल किया जाए:
विकल्प 1: एडब्ल्यूएस
scikit-learn का उपयोग AWS पर किया जा सकता है। कृपया उल्लेख वह डॉकर छवि जिसमें scikit-learn पूर्वस्थापित है।
डेवलपर संस्करण का उपयोग करने के लिए कमांड का उपयोग करें Jupyter
import sys !{sys.executable} -m pip install git+git://github.com/scikit-learn/scikit-learn.git
विकल्प 2: मैक या Windows एनाकोंडा का उपयोग
एनाकोंडा स्थापना के बारे में जानने के लिए देखें https://www.guru99.com/download-install-tensorflow.html
हाल ही में, scikit के डेवलपर्स ने एक डेवलपमेंट वर्जन जारी किया है जो मौजूदा वर्जन के साथ आने वाली आम समस्याओं से निपटता है। हमें मौजूदा वर्जन के बजाय डेवलपर वर्जन का उपयोग करना अधिक सुविधाजनक लगा।
कॉन्डा एनवायरनमेंट के साथ scikit-learn कैसे स्थापित करें
यदि आपने scikit-learn को conda वातावरण के साथ स्थापित किया है, तो कृपया संस्करण 0.20 पर अपडेट करने के लिए चरण का पालन करें
चरण 1) टेंसरफ़्लो वातावरण सक्रिय करें
source activate hello-tf
चरण 2) कोंडा कमांड का उपयोग करके scikit lean को हटाएँ
conda remove scikit-learn
चरण 3) डेवलपर संस्करण स्थापित करें.
आवश्यक लाइब्रेरीज़ के साथ scikit learn डेवलपर संस्करण स्थापित करें।
conda install -c anaconda git pip install Cython pip install h5py pip install git+git://github.com/scikit-learn/scikit-learn.git
नोट: Windows उपयोगकर्ता को स्थापित करने की आवश्यकता होगी Microsoft दृश्य C++ 14. आप इसे यहां से प्राप्त कर सकते हैं यहाँ उत्पन्न करें
मशीन लर्निंग के साथ Scikit-Learn उदाहरण
यह Scikit ट्यूटोरियल दो भागों में विभाजित है:
- स्किकिट-लर्न के साथ मशीन लर्निंग
- LIME के साथ अपने मॉडल पर भरोसा कैसे करें
पहले भाग में पाइपलाइन बनाने, मॉडल बनाने और हाइपरपैरामीटर्स को ट्यून करने के बारे में विस्तार से बताया गया है, जबकि दूसरे भाग में मॉडल चयन के संबंध में अत्याधुनिक जानकारी दी गई है।
चरण 1) डेटा आयात करें
इस Scikit learn ट्यूटोरियल के दौरान, आप वयस्क डेटासेट का उपयोग करेंगे।
इस डेटासेट की पृष्ठभूमि के लिए देखें यदि आप वर्णनात्मक सांख्यिकी के बारे में अधिक जानने में रुचि रखते हैं, तो कृपया डाइव और अवलोकन टूल का उपयोग करें।
संदर्भ लें इस ट्यूटोरियल गोता और अवलोकन के बारे में अधिक जानें
आप डेटासेट को Pandas के साथ आयात करते हैं। ध्यान दें कि आपको निरंतर चर के प्रकार को फ़्लोट फ़ॉर्मेट में बदलने की आवश्यकता है।
इस डेटासेट में आठ श्रेणीबद्ध चर शामिल हैं:
श्रेणीबद्ध चर CATE_FEATURES में सूचीबद्ध हैं
- वर्कक्लास
- शिक्षा
- वैवाहिक
- व्यवसाय
- संबंध
- दौड़
- लिंग
- जन्मभूमि
इसके अलावा, छह निरंतर चर:
सतत चर CONTI_FEATURES में सूचीबद्ध हैं
- उम्र
- एफएनएलडब्ल्यूजीटी
- शिक्षा_संख्या
- पूंजी_लाभ
- पूंजी_हानि
- घंटे_सप्ताह
ध्यान दें कि हम सूची को हाथ से भरते हैं ताकि आपको बेहतर पता चल सके कि हम कौन से कॉलम का उपयोग कर रहे हैं। श्रेणीबद्ध या निरंतर की सूची बनाने का एक तेज़ तरीका यह है:
## List Categorical CATE_FEATURES = df_train.iloc[:,:-1].select_dtypes('object').columns print(CATE_FEATURES) ## List continuous CONTI_FEATURES = df_train._get_numeric_data() print(CONTI_FEATURES)
डेटा आयात करने के लिए कोड यहां दिया गया है:
# Import dataset import pandas as pd ## Define path data COLUMNS = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country', 'label'] ### Define continuous list CONTI_FEATURES = ['age', 'fnlwgt','capital_gain', 'education_num', 'capital_loss', 'hours_week'] ### Define categorical list CATE_FEATURES = ['workclass', 'education', 'marital', 'occupation', 'relationship', 'race', 'sex', 'native_country'] ## Prepare the data features = ['age','workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country'] PATH = "https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data" df_train = pd.read_csv(PATH, skipinitialspace=True, names = COLUMNS, index_col=False) df_train[CONTI_FEATURES] =df_train[CONTI_FEATURES].astype('float64') df_train.describe()
उम्र | एफएनएलडब्ल्यूजीटी | शिक्षा_संख्या | पूंजी_लाभ | पूंजी_हानि | घंटे_सप्ताह | |
---|---|---|---|---|---|---|
गणना | 32561.000000 | 3.256100e + 04 | 32561.000000 | 32561.000000 | 32561.000000 | 32561.000000 |
मतलब | 38.581647 | 1.897784e + 05 | 10.080679 | 1077.648844 | 87.303830 | 40.437456 |
एसटीडी | 13.640433 | 1.055500e + 05 | 2.572720 | 7385.292085 | 402.960219 | 12.347429 |
मिनट | 17.000000 | 1.228500e + 04 | 1.000000 | 0.000000 | 0.000000 | 1.000000 |
25% तक | 28.000000 | 1.178270e + 05 | 9.000000 | 0.000000 | 0.000000 | 40.000000 |
50% तक | 37.000000 | 1.783560e + 05 | 10.000000 | 0.000000 | 0.000000 | 40.000000 |
75% तक | 48.000000 | 2.370510e + 05 | 12.000000 | 0.000000 | 0.000000 | 45.000000 |
मैक्स | 90.000000 | 1.484705e + 06 | 16.000000 | 99999.000000 | 4356.000000 | 99.000000 |
आप native_country विशेषताओं के अद्वितीय मानों की गिनती की जाँच कर सकते हैं। आप देख सकते हैं कि केवल एक घर हॉलैंड-नीदरलैंड से आता है। यह घर हमें कोई जानकारी नहीं देगा, लेकिन प्रशिक्षण के दौरान एक त्रुटि के माध्यम से आएगा।
df_train.native_country.value_counts()
United-States 29170 Mexico 643 ? 583 Philippines 198 Germany 137 Canada 121 Puerto-Rico 114 El-Salvador 106 India 100 Cuba 95 England 90 Jamaica 81 South 80 China 75 Italy 73 Dominican-Republic 70 Vietnam 67 Guatemala 64 Japan 62 Poland 60 Columbia 59 Taiwan 51 Haiti 44 Iran 43 Portugal 37 Nicaragua 34 Peru 31 France 29 Greece 29 Ecuador 28 Ireland 24 Hong 20 Cambodia 19 Trinadad&Tobago 19 Thailand 18 Laos 18 Yugoslavia 16 Outlying-US(Guam-USVI-etc) 14 Honduras 13 Hungary 13 Scotland 12 Holand-Netherlands 1 Name: native_country, dtype: int64
आप इस गैर-सूचनात्मक पंक्ति को डेटासेट से बाहर कर सकते हैं
## Drop Netherland, because only one row df_train = df_train[df_train.native_country != "Holand-Netherlands"]
इसके बाद, आप निरंतर सुविधाओं की स्थिति को एक सूची में संग्रहीत करते हैं। पाइपलाइन बनाने के लिए आपको अगले चरण में इसकी आवश्यकता होगी।
नीचे दिया गया कोड CONTI_FEATURES में सभी कॉलम नामों पर लूप करेगा और उसका स्थान (यानी, उसकी संख्या) प्राप्त करेगा और फिर उसे conti_features नामक सूची में जोड़ देगा
## Get the column index of the categorical features conti_features = [] for i in CONTI_FEATURES: position = df_train.columns.get_loc(i) conti_features.append(position) print(conti_features)
[0, 2, 10, 4, 11, 12]
नीचे दिया गया कोड ऊपर बताए गए कोड जैसा ही काम करता है, लेकिन कैटेगरिकल वैरिएबल के लिए। नीचे दिया गया कोड वही दोहराता है जो आपने पहले किया था, सिवाय कैटेगरिकल फीचर्स के।
## Get the column index of the categorical features categorical_features = [] for i in CATE_FEATURES: position = df_train.columns.get_loc(i) categorical_features.append(position) print(categorical_features)
[1, 3, 5, 6, 7, 8, 9, 13]
आप डेटासेट पर एक नज़र डाल सकते हैं। ध्यान दें कि, प्रत्येक श्रेणीबद्ध विशेषता एक स्ट्रिंग है। आप मॉडल को स्ट्रिंग मान नहीं दे सकते। आपको डमी वैरिएबल का उपयोग करके डेटासेट को बदलना होगा।
df_train.head(5)
वास्तव में, आपको फ़ीचर में प्रत्येक समूह के लिए एक कॉलम बनाने की आवश्यकता है। सबसे पहले, आप आवश्यक कॉलम की कुल मात्रा की गणना करने के लिए नीचे दिए गए कोड को चला सकते हैं।
print(df_train[CATE_FEATURES].nunique(), 'There are',sum(df_train[CATE_FEATURES].nunique()), 'groups in the whole dataset')
workclass 9 education 16 marital 7 occupation 15 relationship 6 race 5 sex 2 native_country 41 dtype: int64 There are 101 groups in the whole dataset
पूरे डेटासेट में 101 समूह हैं जैसा कि ऊपर दिखाया गया है। उदाहरण के लिए, वर्कक्लास की विशेषताओं में नौ समूह हैं। आप निम्नलिखित कोड के साथ समूहों के नाम को देख सकते हैं
unique() श्रेणीबद्ध विशेषताओं के अद्वितीय मान लौटाता है।
for i in CATE_FEATURES: print(df_train[i].unique())
['State-gov' 'Self-emp-not-inc' 'Private' 'Federal-gov' 'Local-gov' '?' 'Self-emp-inc' 'Without-pay' 'Never-worked'] ['Bachelors' 'HS-grad' '11th' 'Masters' '9th' 'Some-college' 'Assoc-acdm' 'Assoc-voc' '7th-8th' 'Doctorate' 'Prof-school' '5th-6th' '10th' '1st-4th' 'Preschool' '12th'] ['Never-married' 'Married-civ-spouse' 'Divorced' 'Married-spouse-absent' 'Separated' 'Married-AF-spouse' 'Widowed'] ['Adm-clerical' 'Exec-managerial' 'Handlers-cleaners' 'Prof-specialty' 'Other-service' 'Sales' 'Craft-repair' 'Transport-moving' 'Farming-fishing' 'Machine-op-inspct' 'Tech-support' '?' 'Protective-serv' 'Armed-Forces' 'Priv-house-serv'] ['Not-in-family' 'Husband' 'Wife' 'Own-child' 'Unmarried' 'Other-relative'] ['White' 'Black' 'Asian-Pac-Islander' 'Amer-Indian-Eskimo' 'Other'] ['Male' 'Female'] ['United-States' 'Cuba' 'Jamaica' 'India' '?' 'Mexico' 'South' 'Puerto-Rico' 'Honduras' 'England' 'Canada' 'Germany' 'Iran' 'Philippines' 'Italy' 'Poland' 'Columbia' 'Cambodia' 'Thailand' 'Ecuador' 'Laos' 'Taiwan' 'Haiti' 'Portugal' 'Dominican-Republic' 'El-Salvador' 'France' 'Guatemala' 'China' 'Japan' 'Yugoslavia' 'Peru' 'Outlying-US(Guam-USVI-etc)' 'Scotland' 'Trinadad&Tobago' 'Greece' 'Nicaragua' 'Vietnam' 'Hong' 'Ireland' 'Hungary']
इसलिए, प्रशिक्षण डेटासेट में 101 + 7 कॉलम होंगे। अंतिम सात कॉलम निरंतर विशेषताएं हैं।
Scikit-learn रूपांतरण का काम संभाल सकता है। यह दो चरणों में किया जाता है:
- सबसे पहले, आपको स्ट्रिंग को ID में बदलना होगा। उदाहरण के लिए, State-gov में ID 1, Self-emp-not-inc ID 2 और इसी तरह आगे भी होगा। फ़ंक्शन LabelEncoder आपके लिए यह काम करता है
- प्रत्येक आईडी को एक नए कॉलम में ट्रांसपोज़ करें। जैसा कि पहले बताया गया है, डेटासेट में 101 ग्रुप की आईडी है। इसलिए सभी श्रेणीबद्ध विशेषताओं के समूहों को कैप्चर करने वाले 101 कॉलम होंगे। Scikit-learn में OneHotEncoder नामक एक फ़ंक्शन है जो यह ऑपरेशन करता है
चरण 2) ट्रेन/टेस्ट सेट बनाएं
अब चूंकि डेटासेट तैयार है, हम इसे 80/20 में विभाजित कर सकते हैं।
प्रशिक्षण सेट के लिए 80 प्रतिशत और परीक्षण सेट के लिए 20 प्रतिशत।
आप train_test_split का उपयोग कर सकते हैं। पहला तर्क डेटाफ़्रेम है जो सुविधाएँ हैं और दूसरा तर्क लेबल डेटाफ़्रेम है। आप test_size के साथ परीक्षण सेट का आकार निर्दिष्ट कर सकते हैं।
from sklearn.model_selection import train_test_split X_train, X_test, y_train, y_test = train_test_split(df_train[features], df_train.label, test_size = 0.2, random_state=0) X_train.head(5) print(X_train.shape, X_test.shape)
(26048, 14) (6512, 14)
चरण 3) पाइपलाइन का निर्माण करें
पाइपलाइन से मॉडल को सुसंगत डेटा प्रदान करना आसान हो जाता है।
इसके पीछे विचार यह है कि परिचालन करने के लिए कच्चे डेटा को 'पाइपलाइन' में डाला जाए।
उदाहरण के लिए, वर्तमान डेटासेट के साथ, आपको निरंतर चर को मानकीकृत करने और श्रेणीबद्ध डेटा को परिवर्तित करने की आवश्यकता है। ध्यान दें कि आप पाइपलाइन के अंदर कोई भी ऑपरेशन कर सकते हैं। उदाहरण के लिए, यदि आपके पास डेटासेट में 'NA' है, तो आप उन्हें माध्य या माध्यिका से बदल सकते हैं। आप नए चर भी बना सकते हैं।
आपके पास विकल्प है; दो प्रक्रियाओं को हार्ड कोड करें या पाइपलाइन बनाएं। पहला विकल्प डेटा लीक होने और समय के साथ असंगतता पैदा करने का कारण बन सकता है। पाइपलाइन का उपयोग करना एक बेहतर विकल्प है।
from sklearn.preprocessing import StandardScaler, OneHotEncoder, LabelEncoder from sklearn.compose import ColumnTransformer, make_column_transformer from sklearn.pipeline import make_pipeline from sklearn.linear_model import LogisticRegression
पाइपलाइन लॉजिस्टिक क्लासिफायर को फीड करने से पहले दो ऑपरेशन करेगी:
- चर को मानकीकृत करें: `StandardScaler()“
- श्रेणीबद्ध विशेषताओं को परिवर्तित करें: OneHotEncoder(sparse=False)
आप make_column_transformer का उपयोग करके दो चरण निष्पादित कर सकते हैं। यह फ़ंक्शन scikit-learn (0.19) के वर्तमान संस्करण में उपलब्ध नहीं है। वर्तमान संस्करण के साथ लेबल एनकोडर और पाइपलाइन में एक हॉट एनकोडर निष्पादित करना संभव नहीं है। यह एक कारण है कि हमने डेवलपर संस्करण का उपयोग करने का निर्णय लिया।
make_column_transformer का उपयोग करना आसान है। आपको यह परिभाषित करना होगा कि कौन से कॉलम में परिवर्तन लागू करना है और कौन सा परिवर्तन संचालित करना है। उदाहरण के लिए, निरंतर सुविधा को मानकीकृत करने के लिए, आप यह कर सकते हैं:
- conti_features, make_column_transformer के अंदर StandardScaler().
- conti_features: सतत चर के साथ सूची
- StandardScaler: चर को मानकीकृत करें
make_column_transformer के अंदर मौजूद ऑब्जेक्ट OneHotEncoder स्वचालित रूप से लेबल को एनकोड करता है।
preprocess = make_column_transformer( (conti_features, StandardScaler()), ### Need to be numeric not string to specify columns name (categorical_features, OneHotEncoder(sparse=False)) )
आप जाँच कर सकते हैं कि पाइपलाइन fit_transform के साथ काम करती है या नहीं। डेटासेट का आकार निम्न होना चाहिए: 26048, 107
preprocess.fit_transform(X_train).shape
(26048, 107)
डेटा ट्रांसफ़ॉर्मर उपयोग के लिए तैयार है। आप make_pipeline के साथ पाइपलाइन बना सकते हैं। एक बार डेटा ट्रांसफ़ॉर्म हो जाने के बाद, आप लॉजिस्टिक रिग्रेशन को फीड कर सकते हैं।
model = make_pipeline( preprocess, LogisticRegression())
scikit-learn के साथ मॉडल को प्रशिक्षित करना आसान है। आपको पाइपलाइन से पहले ऑब्जेक्ट फिट का उपयोग करने की आवश्यकता है, अर्थात, मॉडल। आप scikit-learn लाइब्रेरी से स्कोर ऑब्जेक्ट के साथ सटीकता प्रिंट कर सकते हैं
model.fit(X_train, y_train) print("logistic regression score: %f" % model.score(X_test, y_test))
logistic regression score: 0.850891
अंत में, आप पूर्वानुमान_proba के साथ कक्षाओं की भविष्यवाणी कर सकते हैं। यह प्रत्येक वर्ग के लिए संभावना लौटाता है। ध्यान दें कि इसका योग एक होता है।
model.predict_proba(X_test)
array([[0.83576663, 0.16423337], [0.94582765, 0.05417235], [0.64760587, 0.35239413], ..., [0.99639252, 0.00360748], [0.02072181, 0.97927819], [0.56781353, 0.43218647]])
चरण 4) ग्रिड सर्च में हमारी पाइपलाइन का उपयोग करना
हाइपरपैरामीटर (वे चर जो छिपी हुई इकाइयों की तरह नेटवर्क संरचना निर्धारित करते हैं) को ट्यून करना थकाऊ और थका देने वाला हो सकता है।
मॉडल का मूल्यांकन करने का एक तरीका प्रशिक्षण सेट का आकार बदलना और प्रदर्शन का मूल्यांकन करना हो सकता है।
स्कोर मेट्रिक्स देखने के लिए आप इस विधि को दस बार दोहरा सकते हैं। हालाँकि, यह बहुत ज़्यादा काम है।
इसके बजाय, scikit-learn पैरामीटर ट्यूनिंग और क्रॉस-वैलिडेशन करने के लिए एक फ़ंक्शन प्रदान करता है।
परिणाम का सत्यापन करना
क्रॉस-वैलिडेशन का मतलब है कि प्रशिक्षण के दौरान, प्रशिक्षण सेट को फोल्ड में n बार स्लिप किया जाता है और फिर मॉडल का n बार मूल्यांकन किया जाता है। उदाहरण के लिए, यदि cv को 10 पर सेट किया जाता है, तो प्रशिक्षण सेट को प्रशिक्षित किया जाता है और दस बार मूल्यांकन किया जाता है। प्रत्येक दौर में, क्लासिफायर मॉडल को प्रशिक्षित करने के लिए यादृच्छिक रूप से नौ फोल्ड चुनता है, और 10वां फोल्ड मूल्यांकन के लिए होता है।
ग्रिड खोज
प्रत्येक क्लासिफायर में ट्यून करने के लिए हाइपरपैरामीटर होते हैं। आप अलग-अलग मान आज़मा सकते हैं, या आप पैरामीटर ग्रिड सेट कर सकते हैं। यदि आप scikit-learn की आधिकारिक वेबसाइट पर जाते हैं, तो आप देख सकते हैं कि लॉजिस्टिक क्लासिफायर में ट्यून करने के लिए अलग-अलग पैरामीटर हैं। प्रशिक्षण को तेज़ बनाने के लिए, आप C पैरामीटर को ट्यून करना चुनते हैं। यह रेग्यूलेशन पैरामीटर को नियंत्रित करता है। यह सकारात्मक होना चाहिए। एक छोटा मान रेग्यूलाइज़र को अधिक वज़न देता है।
आप ऑब्जेक्ट GridSearchCV का उपयोग कर सकते हैं। आपको ट्यून करने के लिए हाइपरपैरामीटर युक्त एक शब्दकोश बनाने की आवश्यकता है।
आप हाइपरपैरामीटर को सूचीबद्ध करते हैं और उसके बाद वे मान लिखते हैं जिन्हें आप आज़माना चाहते हैं। उदाहरण के लिए, C पैरामीटर को ट्यून करने के लिए, आप निम्न का उपयोग करते हैं:
- 'लॉजिस्टिकरिग्रेशन__सी': [0.1, 1.0, 1.0]: पैरामीटर के पहले क्लासिफायर का नाम, लोअर केस में, और दो अंडरस्कोर होते हैं।
मॉडल चार अलग-अलग मानों का प्रयास करेगा: 0.001, 0.01, 0.1 और 1.
आप 10 फोल्ड का उपयोग करके मॉडल को प्रशिक्षित करते हैं: cv=10
from sklearn.model_selection import GridSearchCV # Construct the parameter grid param_grid = { 'logisticregression__C': [0.001, 0.01,0.1, 1.0], }
आप पैरामीटर gri और cv के साथ GridSearchCV का उपयोग करके मॉडल को प्रशिक्षित कर सकते हैं।
# Train the model grid_clf = GridSearchCV(model, param_grid, cv=10, iid=False) grid_clf.fit(X_train, y_train)
आउटपुट
GridSearchCV(cv=10, error_score='raise-deprecating', estimator=Pipeline(memory=None, steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None, transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,...ty='l2', random_state=None, solver='liblinear', tol=0.0001, verbose=0, warm_start=False))]), fit_params=None, iid=False, n_jobs=1, param_grid={'logisticregression__C': [0.001, 0.01, 0.1, 1.0]}, pre_dispatch='2*n_jobs', refit=True, return_train_score='warn', scoring=None, verbose=0)
सर्वोत्तम पैरामीटर तक पहुंचने के लिए, आप best_params_ का उपयोग करते हैं
grid_clf.best_params_
आउटपुट
{'logisticregression__C': 1.0}
चार अलग-अलग नियमन मूल्यों के साथ मॉडल को प्रशिक्षित करने के बाद, इष्टतम पैरामीटर है
print("best logistic regression from grid search: %f" % grid_clf.best_estimator_.score(X_test, y_test))
ग्रिड खोज से सर्वोत्तम लॉजिस्टिक प्रतिगमन: 0.850891
अनुमानित संभावनाओं तक पहुंचने के लिए:
grid_clf.best_estimator_.predict_proba(X_test)
array([[0.83576677, 0.16423323], [0.9458291 , 0.0541709 ], [0.64760416, 0.35239584], ..., [0.99639224, 0.00360776], [0.02072033, 0.97927967], [0.56782222, 0.43217778]])
scikit-learn के साथ XGBoost मॉडल
आइए बाजार में मौजूद सबसे बेहतरीन क्लासिफायर में से एक को प्रशिक्षित करने के लिए Scikit-learn उदाहरणों को आजमाएं। XGBoost रैंडम फ़ॉरेस्ट पर एक सुधार है। क्लासिफायर की सैद्धांतिक पृष्ठभूमि इस दायरे से बाहर है Python स्किकिट ट्यूटोरियल। ध्यान रखें कि, XGBoost ने बहुत सी कागल प्रतियोगिताएं जीती हैं। औसत डेटासेट आकार के साथ, यह डीप लर्निंग एल्गोरिदम जितना अच्छा या उससे भी बेहतर प्रदर्शन कर सकता है।
क्लासिफायर को प्रशिक्षित करना चुनौतीपूर्ण है क्योंकि इसमें ट्यून करने के लिए बहुत सारे पैरामीटर हैं। आप निश्चित रूप से अपने लिए पैरामीटर चुनने के लिए GridSearchCV का उपयोग कर सकते हैं।
इसके बजाय, आइए देखें कि इष्टतम पैरामीटर खोजने के लिए बेहतर तरीके का उपयोग कैसे करें। यदि आप कई मान पास करते हैं तो GridSearchCV को प्रशिक्षित करना थकाऊ और बहुत लंबा हो सकता है। खोज स्थान पैरामीटर की संख्या के साथ बढ़ता है। एक बेहतर समाधान RandomizedSearchCV का उपयोग करना है। इस विधि में प्रत्येक पुनरावृत्ति के बाद प्रत्येक हाइपरपैरामीटर के मानों को यादृच्छिक रूप से चुनना शामिल है। उदाहरण के लिए, यदि क्लासिफायर को 1000 पुनरावृत्तियों पर प्रशिक्षित किया जाता है, तो 1000 संयोजनों का मूल्यांकन किया जाता है। यह कमोबेश इस तरह काम करता है। GridSearchCV
आपको xgboost आयात करने की आवश्यकता है। यदि लाइब्रेरी स्थापित नहीं है, तो कृपया pip3 install xgboost या का उपयोग करें
use import sys !{sys.executable} -m pip install xgboost
In Jupyter वातावरण
अगला,
import xgboost from sklearn.model_selection import RandomizedSearchCV from sklearn.model_selection import StratifiedKFold
इस Scikit में अगला कदम Python ट्यूटोरियल में ट्यून करने के लिए पैरामीटर निर्दिष्ट करना शामिल है। ट्यून करने के लिए सभी पैरामीटर देखने के लिए आप आधिकारिक दस्तावेज़ देख सकते हैं। Python स्केलर्न ट्यूटोरियल में, आप केवल दो हाइपरपैरामीटर चुनते हैं, जिनमें से प्रत्येक में दो मान होते हैं। XGBoost को प्रशिक्षित करने में बहुत समय लगता है, ग्रिड में जितने अधिक हाइपरपैरामीटर होंगे, आपको उतना ही अधिक समय तक प्रतीक्षा करनी होगी।
params = { 'xgbclassifier__gamma': [0.5, 1], 'xgbclassifier__max_depth': [3, 4] }
आप XGBoost क्लासिफायर के साथ एक नई पाइपलाइन बनाते हैं। आप 600 अनुमानक परिभाषित करना चुनते हैं। ध्यान दें कि n_estimators एक पैरामीटर है जिसे आप ट्यून कर सकते हैं। एक उच्च मूल्य ओवरफिटिंग की ओर ले जा सकता है। आप खुद से अलग-अलग मान आज़मा सकते हैं लेकिन ध्यान रखें कि इसमें घंटों लग सकते हैं। आप अन्य पैरामीटर के लिए डिफ़ॉल्ट मान का उपयोग करते हैं
model_xgb = make_pipeline( preprocess, xgboost.XGBClassifier( n_estimators=600, objective='binary:logistic', silent=True, nthread=1) )
आप स्ट्रेटिफाइड K-फोल्ड्स क्रॉस-वैलिडेटर के साथ क्रॉस-वैलिडेशन को बेहतर बना सकते हैं। आप यहाँ केवल तीन फोल्ड बनाते हैं जिससे गणना तेज़ होती है लेकिन गुणवत्ता कम होती है। परिणामों को बेहतर बनाने के लिए घर पर इस मान को 5 या 10 तक बढ़ाएँ।
आप मॉडल को चार पुनरावृत्तियों में प्रशिक्षित करना चुनते हैं।
skf = StratifiedKFold(n_splits=3, shuffle = True, random_state = 1001) random_search = RandomizedSearchCV(model_xgb, param_distributions=params, n_iter=4, scoring='accuracy', n_jobs=4, cv=skf.split(X_train, y_train), verbose=3, random_state=1001)
यादृच्छिक खोज उपयोग के लिए तैयार है, आप मॉडल को प्रशिक्षित कर सकते हैं
#grid_xgb = GridSearchCV(model_xgb, params, cv=10, iid=False) random_search.fit(X_train, y_train)
Fitting 3 folds for each of 4 candidates, totalling 12 fits [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8759645283888057, total= 1.0min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8729701715996775, total= 1.0min [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=0.5, score=0.8706519235199263, total= 1.0min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5 ............ [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8735460094437406, total= 1.3min [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8722791661868018, total= 57.7s [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8753886905447426, total= 1.0min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8697304768486523, total= 1.3min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=0.5, score=0.8740066797189912, total= 1.4min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1 .............. [CV] xgbclassifier__max_depth=3, xgbclassifier__gamma=1, score=0.8707671043538355, total= 1.0min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8729701715996775, total= 1.2min [Parallel(n_jobs=4)]: Done 10 out of 12 | elapsed: 3.6min remaining: 43.5s [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8736611770125533, total= 1.2min [CV] xgbclassifier__max_depth=4, xgbclassifier__gamma=1, score=0.8692697535130154, total= 1.2min
[Parallel(n_jobs=4)]: Done 12 out of 12 | elapsed: 3.6min finished /Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/sklearn/model_selection/_search.py:737: DeprecationWarning: The default of the `iid` parameter will change from True to False in version 0.22 and will be removed in 0.24. This will change numeric results when test-set sizes are unequal. DeprecationWarning)
RandomizedSearchCV(cv=<generator object _BaseKFold.split at 0x1101eb830>, error_score='raise-deprecating', estimator=Pipeline(memory=None, steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None, transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,... reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None, silent=True, subsample=1))]), fit_params=None, iid='warn', n_iter=4, n_jobs=4, param_distributions={'xgbclassifier__gamma': [0.5, 1], 'xgbclassifier__max_depth': [3, 4]}, pre_dispatch='2*n_jobs', random_state=1001, refit=True, return_train_score='warn', scoring='accuracy', verbose=3)
जैसा कि आप देख सकते हैं, XGBoost का स्कोर पिछले लॉजिस्टिक्स रिग्रेशन से बेहतर है।
print("Best parameter", random_search.best_params_) print("best logistic regression from grid search: %f" % random_search.best_estimator_.score(X_test, y_test))
Best parameter {'xgbclassifier__max_depth': 3, 'xgbclassifier__gamma': 0.5} best logistic regression from grid search: 0.873157
random_search.best_estimator_.predict(X_test)
array(['<=50K', '<=50K', '<=50K', ..., '<=50K', '>50K', '<=50K'], dtype=object)
scikit-learn में MLPClassifier के साथ DNN बनाएं
अंत में, आप scikit-learn के साथ डीप लर्निंग एल्गोरिदम को प्रशिक्षित कर सकते हैं। यह विधि अन्य क्लासिफायर के समान ही है। क्लासिफायर MLPClassifier पर उपलब्ध है।
from sklearn.neural_network import MLPClassifier
आप निम्नलिखित गहन शिक्षण एल्गोरिदम परिभाषित करते हैं:
- एडम सॉल्वर
- Relu सक्रियण फ़ंक्शन
- अल्फा = 0.0001
- बैच का आकार 150
- क्रमशः 100 और 50 न्यूरॉन्स वाली दो छिपी हुई परतें
model_dnn = make_pipeline( preprocess, MLPClassifier(solver='adam', alpha=0.0001, activation='relu', batch_size=150, hidden_layer_sizes=(200, 100), random_state=1))
आप मॉडल को बेहतर बनाने के लिए परतों की संख्या बदल सकते हैं
model_dnn.fit(X_train, y_train) print("DNN regression score: %f" % model_dnn.score(X_test, y_test))
DNN प्रतिगमन स्कोर: 0.821253
लाइम: अपने मॉडल पर भरोसा करें
अब जब आपके पास एक अच्छा मॉडल है, तो आपको उस पर भरोसा करने के लिए एक उपकरण की आवश्यकता है। मशीन लर्निंग एल्गोरिदम, खास तौर पर रैंडम फ़ॉरेस्ट और न्यूरल नेटवर्क, ब्लैक-बॉक्स एल्गोरिदम के तौर पर जाने जाते हैं। दूसरे शब्दों में कहें तो यह काम तो करता है लेकिन कोई नहीं जानता कि क्यों।
तीन शोधकर्ताओं ने एक बेहतरीन उपकरण बनाया है, जिससे यह पता लगाया जा सकता है कि कंप्यूटर किस तरह भविष्यवाणी करता है। इस शोध पत्र का नाम है 'मुझे आप पर भरोसा क्यों करना चाहिए?'
उन्होंने एक एल्गोरिथ्म विकसित किया जिसका नाम है स्थानीय व्याख्या योग्य मॉडल-अज्ञेय स्पष्टीकरण (LIME).
एक उदाहरण लें:
कभी-कभी आप यह नहीं जानते कि आप मशीन-लर्निंग की भविष्यवाणी पर भरोसा कर सकते हैं या नहीं:
उदाहरण के लिए, एक डॉक्टर किसी निदान पर सिर्फ़ इसलिए भरोसा नहीं कर सकता क्योंकि कंप्यूटर ने ऐसा कहा है। आपको यह भी जानना होगा कि उत्पादन में डालने से पहले आप मॉडल पर भरोसा कर सकते हैं या नहीं।
कल्पना कीजिए कि हम समझ सकते हैं कि कोई भी क्लासिफायर किसी भी कर्नेल के साथ न्यूरल नेटवर्क, रैंडम फॉरेस्ट या एसवीएम जैसे अविश्वसनीय रूप से जटिल मॉडल की भविष्यवाणी क्यों कर रहा है
अगर हम इसके पीछे के कारणों को समझ सकें तो किसी भविष्यवाणी पर भरोसा करना ज़्यादा आसान हो जाएगा। डॉक्टर के उदाहरण से, अगर मॉडल ने उसे बताया कि कौन से लक्षण ज़रूरी हैं तो आप उस पर भरोसा करेंगे, यह पता लगाना भी आसान है कि आपको मॉडल पर भरोसा करना चाहिए या नहीं।
लाइम आपको बता सकता है कि कौन सी विशेषताएं क्लासिफायर के निर्णयों को प्रभावित करती हैं
डेटा तैयारी
LIME चलाने के लिए आपको कुछ चीज़ें बदलने की ज़रूरत है अजगरसबसे पहले, आपको टर्मिनल में लाइम इंस्टॉल करना होगा। आप pip install lime का उपयोग कर सकते हैं
लाइम स्थानीय रूप से मॉडल का अनुमान लगाने के लिए LimeTabularExplainer ऑब्जेक्ट का उपयोग करता है। इस ऑब्जेक्ट के लिए निम्न की आवश्यकता होती है:
- numpy प्रारूप में एक डेटासेट
- सुविधाओं का नाम: feature_names
- कक्षाओं का नाम: class_names
- श्रेणीबद्ध विशेषताओं के स्तंभ का सूचकांक: categorical_features
- प्रत्येक श्रेणीबद्ध विशेषता के लिए समूह का नाम: categorical_names
numpy ट्रेन सेट बनाएँ
आप df_train को pandas से कॉपी करके परिवर्तित कर सकते हैं numpy बहुत आसानी से
df_train.head(5) # Create numpy data df_lime = df_train df_lime.head(3)
कक्षा का नाम प्राप्त करें लेबल को unique() ऑब्जेक्ट के साथ एक्सेस किया जा सकता है। आपको यह देखना चाहिए:
- '<=50K'
- '>50 हजार'
# Get the class name class_names = df_lime.label.unique() class_names
array(['<=50K', '>50K'], dtype=object)
श्रेणीगत विशेषताओं के स्तंभ का सूचकांक
आप समूह का नाम प्राप्त करने के लिए पहले सीखी गई विधि का उपयोग कर सकते हैं। आप लेबल को लेबलएनकोडर के साथ एनकोड करते हैं। आप सभी श्रेणीबद्ध विशेषताओं पर ऑपरेशन दोहराते हैं।
## import sklearn.preprocessing as preprocessing categorical_names = {} for feature in CATE_FEATURES: le = preprocessing.LabelEncoder() le.fit(df_lime[feature]) df_lime[feature] = le.transform(df_lime[feature]) categorical_names[feature] = le.classes_ print(categorical_names)
{'workclass': array(['?', 'Federal-gov', 'Local-gov', 'Never-worked', 'Private', 'Self-emp-inc', 'Self-emp-not-inc', 'State-gov', 'Without-pay'], dtype=object), 'education': array(['10th', '11th', '12th', '1st-4th', '5th-6th', '7th-8th', '9th', 'Assoc-acdm', 'Assoc-voc', 'Bachelors', 'Doctorate', 'HS-grad', 'Masters', 'Preschool', 'Prof-school', 'Some-college'], dtype=object), 'marital': array(['Divorced', 'Married-AF-spouse', 'Married-civ-spouse', 'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'], dtype=object), 'occupation': array(['?', 'Adm-clerical', 'Armed-Forces', 'Craft-repair', 'Exec-managerial', 'Farming-fishing', 'Handlers-cleaners', 'Machine-op-inspct', 'Other-service', 'Priv-house-serv', 'Prof-specialty', 'Protective-serv', 'Sales', 'Tech-support', 'Transport-moving'], dtype=object), 'relationship': array(['Husband', 'Not-in-family', 'Other-relative', 'Own-child', 'Unmarried', 'Wife'], dtype=object), 'race': array(['Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other', 'White'], dtype=object), 'sex': array(['Female', 'Male'], dtype=object), 'native_country': array(['?', 'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba', 'Dominican-Republic', 'Ecuador', 'El-Salvador', 'England', 'France', 'Germany', 'Greece', 'Guatemala', 'Haiti', 'Honduras', 'Hong', 'Hungary', 'India', 'Iran', 'Ireland', 'Italy', 'Jamaica', 'Japan', 'Laos', 'Mexico', 'Nicaragua', 'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland', 'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan', 'Thailand', 'Trinadad&Tobago', 'United-States', 'Vietnam', 'Yugoslavia'], dtype=object)} df_lime.dtypes
age float64 workclass int64 fnlwgt float64 education int64 education_num float64 marital int64 occupation int64 relationship int64 race int64 sex int64 capital_gain float64 capital_loss float64 hours_week float64 native_country int64 label object dtype: object
अब जब डेटासेट तैयार हो गया है, तो आप नीचे दिए गए Scikit learn उदाहरणों में दिखाए अनुसार अलग-अलग डेटासेट बना सकते हैं। LIME के साथ त्रुटियों से बचने के लिए आप वास्तव में पाइपलाइन के बाहर डेटा को रूपांतरित करते हैं। LimeTabularExplainer में प्रशिक्षण सेट स्ट्रिंग के बिना एक numpy सरणी होना चाहिए। उपरोक्त विधि के साथ, आपके पास पहले से ही परिवर्तित एक प्रशिक्षण डेटासेट है।
from sklearn.model_selection import train_test_split X_train_lime, X_test_lime, y_train_lime, y_test_lime = train_test_split(df_lime[features], df_lime.label, test_size = 0.2, random_state=0) X_train_lime.head(5)
आप XGBoost से इष्टतम मापदंडों के साथ पाइपलाइन बना सकते हैं
model_xgb = make_pipeline( preprocess, xgboost.XGBClassifier(max_depth = 3, gamma = 0.5, n_estimators=600, objective='binary:logistic', silent=True, nthread=1)) model_xgb.fit(X_train_lime, y_train_lime)
/Users/Thomas/anaconda3/envs/hello-tf/lib/python3.6/site-packages/sklearn/preprocessing/_encoders.py:351: FutureWarning: The handling of integer data will change in version 0.22. Currently, the categories are determined based on the range [0, max(values)], while in the future they will be determined based on the unique values. If you want the future behavior and silence this warning, you can specify "categories='auto'."In case you used a LabelEncoder before this OneHotEncoder to convert the categories to integers, then you can now use the OneHotEncoder directly. warnings.warn(msg, FutureWarning)
Pipeline(memory=None, steps=[('columntransformer', ColumnTransformer(n_jobs=1, remainder='drop', transformer_weights=None, transformers=[('standardscaler', StandardScaler(copy=True, with_mean=True, with_std=True), [0, 2, 10, 4, 11, 12]), ('onehotencoder', OneHotEncoder(categorical_features=None, categories=None,... reg_alpha=0, reg_lambda=1, scale_pos_weight=1, seed=None, silent=True, subsample=1))])
आपको एक चेतावनी मिलती है। चेतावनी बताती है कि आपको पाइपलाइन से पहले लेबल एनकोडर बनाने की आवश्यकता नहीं है। यदि आप LIME का उपयोग नहीं करना चाहते हैं, तो आप Scikit-learn ट्यूटोरियल के साथ मशीन लर्निंग के पहले भाग से विधि का उपयोग कर सकते हैं। अन्यथा, आप इस विधि का उपयोग कर सकते हैं, पहले एक एनकोडेड डेटासेट बनाएं, पाइपलाइन के भीतर हॉट वन एनकोडर सेट करें।
print("best logistic regression from grid search: %f" % model_xgb.score(X_test_lime, y_test_lime))
best logistic regression from grid search: 0.873157
model_xgb.predict_proba(X_test_lime)
array([[7.9646105e-01, 2.0353897e-01], [9.5173013e-01, 4.8269872e-02], [7.9344827e-01, 2.0655173e-01], ..., [9.9031430e-01, 9.6856682e-03], [6.4581633e-04, 9.9935418e-01], [9.7104281e-01, 2.8957171e-02]], dtype=float32)
LIME का उपयोग करने से पहले, आइए गलत वर्गीकरण की विशेषताओं के साथ एक numpy array बनाएँ। आप बाद में उस सूची का उपयोग करके यह अंदाजा लगा सकते हैं कि क्लासिफायर को क्या गुमराह कर रहा है।
temp = pd.concat([X_test_lime, y_test_lime], axis= 1) temp['predicted'] = model_xgb.predict(X_test_lime) temp['wrong']= temp['label'] != temp['predicted'] temp = temp.query('wrong==True').drop('wrong', axis=1) temp= temp.sort_values(by=['label']) temp.shape
(826, 16)
आप नए डेटा के साथ मॉडल से पूर्वानुमान प्राप्त करने के लिए एक लैम्ब्डा फ़ंक्शन बनाते हैं। आपको जल्द ही इसकी आवश्यकता होगी।
predict_fn = lambda x: model_xgb.predict_proba(x).astype(float) X_test_lime.dtypes
age float64 workclass int64 fnlwgt float64 education int64 education_num float64 marital int64 occupation int64 relationship int64 race int64 sex int64 capital_gain float64 capital_loss float64 hours_week float64 native_country int64 dtype: object
predict_fn(X_test_lime)
array([[7.96461046e-01, 2.03538969e-01], [9.51730132e-01, 4.82698716e-02], [7.93448269e-01, 2.06551731e-01], ..., [9.90314305e-01, 9.68566816e-03], [6.45816326e-04, 9.99354184e-01], [9.71042812e-01, 2.89571714e-02]])
आप पांडा डेटाफ्रेम को numpy array में परिवर्तित करते हैं
X_train_lime = X_train_lime.values X_test_lime = X_test_lime.values X_test_lime
array([[4.00000e+01, 5.00000e+00, 1.93524e+05, ..., 0.00000e+00, 4.00000e+01, 3.80000e+01], [2.70000e+01, 4.00000e+00, 2.16481e+05, ..., 0.00000e+00, 4.00000e+01, 3.80000e+01], [2.50000e+01, 4.00000e+00, 2.56263e+05, ..., 0.00000e+00, 4.00000e+01, 3.80000e+01], ..., [2.80000e+01, 6.00000e+00, 2.11032e+05, ..., 0.00000e+00, 4.00000e+01, 2.50000e+01], [4.40000e+01, 4.00000e+00, 1.67005e+05, ..., 0.00000e+00, 6.00000e+01, 3.80000e+01], [5.30000e+01, 4.00000e+00, 2.57940e+05, ..., 0.00000e+00, 4.00000e+01, 3.80000e+01]])
model_xgb.predict_proba(X_test_lime)
array([[7.9646105e-01, 2.0353897e-01], [9.5173013e-01, 4.8269872e-02], [7.9344827e-01, 2.0655173e-01], ..., [9.9031430e-01, 9.6856682e-03], [6.4581633e-04, 9.9935418e-01], [9.7104281e-01, 2.8957171e-02]], dtype=float32)
print(features, class_names, categorical_features, categorical_names)
['age', 'workclass', 'fnlwgt', 'education', 'education_num', 'marital', 'occupation', 'relationship', 'race', 'sex', 'capital_gain', 'capital_loss', 'hours_week', 'native_country'] ['<=50K' '>50K'] [1, 3, 5, 6, 7, 8, 9, 13] {'workclass': array(['?', 'Federal-gov', 'Local-gov', 'Never-worked', 'Private', 'Self-emp-inc', 'Self-emp-not-inc', 'State-gov', 'Without-pay'], dtype=object), 'education': array(['10th', '11th', '12th', '1st-4th', '5th-6th', '7th-8th', '9th', 'Assoc-acdm', 'Assoc-voc', 'Bachelors', 'Doctorate', 'HS-grad', 'Masters', 'Preschool', 'Prof-school', 'Some-college'], dtype=object), 'marital': array(['Divorced', 'Married-AF-spouse', 'Married-civ-spouse', 'Married-spouse-absent', 'Never-married', 'Separated', 'Widowed'], dtype=object), 'occupation': array(['?', 'Adm-clerical', 'Armed-Forces', 'Craft-repair', 'Exec-managerial', 'Farming-fishing', 'Handlers-cleaners', 'Machine-op-inspct', 'Other-service', 'Priv-house-serv', 'Prof-specialty', 'Protective-serv', 'Sales', 'Tech-support', 'Transport-moving'], dtype=object), 'relationship': array(['Husband', 'Not-in-family', 'Other-relative', 'Own-child', 'Unmarried', 'Wife'], dtype=object), 'race': array(['Amer-Indian-Eskimo', 'Asian-Pac-Islander', 'Black', 'Other', 'White'], dtype=object), 'sex': array(['Female', 'Male'], dtype=object), 'native_country': array(['?', 'Cambodia', 'Canada', 'China', 'Columbia', 'Cuba', 'Dominican-Republic', 'Ecuador', 'El-Salvador', 'England', 'France', 'Germany', 'Greece', 'Guatemala', 'Haiti', 'Honduras', 'Hong', 'Hungary', 'India', 'Iran', 'Ireland', 'Italy', 'Jamaica', 'Japan', 'Laos', 'Mexico', 'Nicaragua', 'Outlying-US(Guam-USVI-etc)', 'Peru', 'Philippines', 'Poland', 'Portugal', 'Puerto-Rico', 'Scotland', 'South', 'Taiwan', 'Thailand', 'Trinadad&Tobago', 'United-States', 'Vietnam', 'Yugoslavia'], dtype=object)}
import lime import lime.lime_tabular ### Train should be label encoded not one hot encoded explainer = lime.lime_tabular.LimeTabularExplainer(X_train_lime , feature_names = features, class_names=class_names, categorical_features=categorical_features, categorical_names=categorical_names, kernel_width=3)
आइए परीक्षण सेट से एक यादृच्छिक घर चुनें और मॉडल की भविष्यवाणी देखें तथा देखें कि कंप्यूटर ने अपना चुनाव किस प्रकार किया।
import numpy as np np.random.seed(1) i = 100 print(y_test_lime.iloc[i]) >50K
X_test_lime[i]
array([4.20000e+01, 4.00000e+00, 1.76286e+05, 7.00000e+00, 1.20000e+01, 2.00000e+00, 4.00000e+00, 0.00000e+00, 4.00000e+00, 1.00000e+00, 0.00000e+00, 0.00000e+00, 4.00000e+01, 3.80000e+01])
मॉडल के पीछे के स्पष्टीकरण की जांच करने के लिए आप explain_instance के साथ explainer का उपयोग कर सकते हैं
exp = explainer.explain_instance(X_test_lime[i], predict_fn, num_features=6) exp.show_in_notebook(show_all=False)
हम देख सकते हैं कि वर्गीकरणकर्ता ने घर के बारे में सही भविष्यवाणी की है। आय वास्तव में 50 हजार से अधिक है।
पहली बात जो हम कह सकते हैं वह यह है कि क्लासिफायर पूर्वानुमानित संभावनाओं के बारे में निश्चित नहीं है। मशीन भविष्यवाणी करती है कि घर की आय 50k से अधिक है, जिसकी संभावना 64% है। यह 64% पूंजीगत लाभ और वैवाहिक लाभ से बना है। नीला रंग सकारात्मक वर्ग में नकारात्मक रूप से योगदान देता है और नारंगी रेखा सकारात्मक रूप से।
क्लासिफायर भ्रमित है क्योंकि इस परिवार का पूंजीगत लाभ शून्य है, जबकि पूंजीगत लाभ आमतौर पर धन का एक अच्छा भविष्यवक्ता होता है। इसके अलावा, परिवार प्रति सप्ताह 40 घंटे से कम काम करता है। आयु, व्यवसाय और लिंग क्लासिफायर में सकारात्मक योगदान देते हैं।
यदि वैवाहिक स्थिति एकल होती, तो वर्गीकरणकर्ता 50 हजार से कम आय की भविष्यवाणी करता (0.64-0.18 = 0.46)
हम किसी अन्य घराने के साथ प्रयास कर सकते हैं जिसे गलत तरीके से वर्गीकृत किया गया है
temp.head(3) temp.iloc[1,:-2]
age 58 workclass 4 fnlwgt 68624 education 11 education_num 9 marital 2 occupation 4 relationship 0 race 4 sex 1 capital_gain 0 capital_loss 0 hours_week 45 native_country 38 Name: 20931, dtype: object
i = 1 print('This observation is', temp.iloc[i,-2:])
This observation is label <=50K predicted >50K Name: 20931, dtype: object
exp = explainer.explain_instance(temp.iloc[1,:-2], predict_fn, num_features=6) exp.show_in_notebook(show_all=False)
क्लासिफायर ने 50k से कम आय की भविष्यवाणी की थी जबकि यह असत्य है। यह घराना अजीब लगता है। इसमें न तो पूंजीगत लाभ है और न ही पूंजीगत हानि। वह तलाकशुदा है और 60 साल का है, और यह एक शिक्षित व्यक्ति है, यानी, education_num > 12। समग्र पैटर्न के अनुसार, इस घराने को, जैसा कि क्लासिफायर द्वारा समझाया गया है, 50k से कम आय प्राप्त करनी चाहिए।
आप LIME के साथ खेलने की कोशिश करें। आपको क्लासिफायर में बड़ी गलतियाँ नज़र आएंगी।
आप लाइब्रेरी के मालिक के GitHub की जाँच कर सकते हैं। वे छवि और पाठ वर्गीकरण के लिए अतिरिक्त दस्तावेज़ प्रदान करते हैं।
सारांश
नीचे scikit learn संस्करण >=0.20 के साथ कुछ उपयोगी कमांड की सूची दी गई है
प्रशिक्षण/परीक्षण डेटासेट बनाएं | प्रशिक्षुओं का विभाजन |
पाइपलाइन का निर्माण करें | |
कॉलम का चयन करें और परिवर्तन लागू करें | मेककॉलमट्रांसफॉर्मर |
परिवर्तन का प्रकार | |
मानकीकरण करना | स्टैंडर्डस्केलर |
न्यूनतम अधिकतम | मिनमैक्सस्केलर |
सामान्य | नॉर्मलाइज़र |
लुप्त मान आरोपित करें | इंपुटर |
श्रेणीबद्ध रूपांतरित करें | वनहॉटएनकोडर |
डेटा को फिट और रूपांतरित करें | फिट_ट्रांसफॉर्म |
पाइपलाइन बनाओ | पाइपलाइन बनाएं |
मूल मॉडल | |
रसद प्रतिगमन | रसद प्रतिगमन |
एक्सजीबूस्ट | XGBक्लासिफायर |
तंत्रिका जाल | एमएलपीक्लासिफायर |
ग्रिड खोज | ग्रिडसर्चसीवी |
यादृच्छिक खोज | रैंडमाइज्डसर्चCV |