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 ट्यूटोरियल दो भागों में विभाजित है:

  1. स्किकिट-लर्न के साथ मशीन लर्निंग
  2. 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

पाइपलाइन लॉजिस्टिक क्लासिफायर को फीड करने से पहले दो ऑपरेशन करेगी:

  1. चर को मानकीकृत करें: `StandardScaler()“
  2. श्रेणीबद्ध विशेषताओं को परिवर्तित करें: 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