Scikit-Learni õpetus: kuidas installida ja Scikit-Learn näiteid

Mis on Scikit-learn?

Scikit-õppida on avatud lähtekoodiga Python masinõppe raamatukogu. See toetab tipptasemel algoritme, nagu KNN, XGBoost, juhuslik mets ja SVM. See on ehitatud NumPy peale. Scikit-learni kasutatakse laialdaselt nii Kaggle'i konkurentsis kui ka silmapaistvates tehnoloogiaettevõtetes. See aitab eeltöötlusel, mõõtmete vähendamisel (parameetrite valikul), klassifitseerimisel, regressioonil, rühmitamisel ja mudelivalikul.

Scikit-learn sisaldab kõigi avatud lähtekoodiga teekide parimat dokumentatsiooni. See pakub teile interaktiivset diagrammi aadressil https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html.

Kuidas Scikit Learn töötab
Kuidas Scikit Learn töötab

Scikit-learni kasutamine pole eriti keeruline ja annab suurepäraseid tulemusi. Scikit learning ei toeta aga paralleelarvutusi. Sellega on võimalik käivitada sügav õppimisalgoritm, kuid see pole optimaalne lahendus, eriti kui tead, kuidas TensorFlow'd kasutada.

Kuidas Scikit-learn alla laadida ja installida

Nüüd selles Python Scikit-learni õpetus, õpime, kuidas Scikit-learn alla laadida ja installida:

Võimalus 1: AWS

scikit-learni saab kasutada AWS-i kaudu. Palun viitama Dockeri kujutis, millele on eelinstallitud scikit-learn.

Arendaja versiooni kasutamiseks kasutage käsku in Jupyter

import sys
!{sys.executable} -m pip install git+git://github.com/scikit-learn/scikit-learn.git

Võimalus 2: Mac või Windows kasutades Anacondat

Lisateavet Anaconda paigaldamise kohta leiate siit https://www.guru99.com/download-install-tensorflow.html

Hiljuti on scikiti arendajad välja andnud arendusversiooni, mis lahendab praeguse versiooni levinud probleemi. Leidsime, et praeguse versiooni asemel on mugavam kasutada arendaja versiooni.

Kuidas installida scikit-learn Conda keskkonnaga

Kui installisite scikit-learni koos conda keskkonnaga, järgige versioonile 0.20 värskendamiseks juhiseid

Step 1) Aktiveerige tensorflow keskkond

source activate hello-tf

Step 2) Eemaldage scikit lean käsuga conda

conda remove scikit-learn

Step 3) Installige arendaja versioon.
Installige scikit learning arendajaversioon koos vajalike raamatukogudega.

conda install -c anaconda git
pip install Cython
pip install h5py
pip install git+git://github.com/scikit-learn/scikit-learn.git

MÄRKUS: Windows kasutaja peab installima Microsoft Visuaalne C++ 14. Saate seda saada siin

Scikit-Learni näide masinõppega

See Scikiti õpetus on jagatud kaheks osaks:

  1. Masinõpe koos scikit-learniga
  2. Kuidas usaldada oma mudelit LIME'i

Esimeses osas kirjeldatakse, kuidas luua torujuhe, luua mudel ja häälestada hüperparameetreid, samas kui teine ​​​​osa pakub mudelivaliku tipptasemel teavet.

Samm 1) Importige andmed

Selle Scikiti õppimise õpetuse ajal kasutate täiskasvanute andmekogumit.

Selle andmestiku tausta saamiseks vaadake teavet. Kui soovite kirjeldava statistika kohta rohkem teada saada, kasutage sukeldumise ja ülevaate tööriistu.

Viitama see õpetus Lisateavet sukeldumise ja ülevaate kohta

Impordite andmestiku Pandadega. Pange tähele, et peate teisendama pidevate muutujate tüübid ujuvvormingusse.

See andmekogum sisaldab kaheksat kategoorilist muutujat:

Kategoorilised muutujad on loetletud jaotises CATE_FEATURES

  • tööklass
  • haridus
  • abielu-
  • okupatsioon
  • suhe
  • rass
  • sugu
  • kodumaa

lisaks kuus pidevat muutujat:

Pidevad muutujad on loetletud jaotises CONTI_FEATURES

  • vanus
  • fnlwgt
  • hariduse_nr
  • kapitalikasum
  • kapitali_kahjum
  • tundi_nädal

Pange tähele, et täidame loendi käsitsi, et saaksite paremini aru, milliseid veerge me kasutame. Kiirem viis kategooriliste või pidevate loendite koostamiseks on kasutada järgmist:

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

Siin on kood andmete importimiseks:

# 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()
vanus fnlwgt hariduse_nr kapitalikasum kapitali_kahjum tundi_nädal
loe 32561.000000 3.256100e + 04 32561.000000 32561.000000 32561.000000 32561.000000
keskmine 38.581647 1.897784e + 05 10.080679 1077.648844 87.303830 40.437456
std 13.640433 1.055500e + 05 2.572720 7385.292085 402.960219 12.347429
minutit 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
max 90.000000 1.484705e + 06 16.000000 99999.000000 4356.000000 99.000000

Saate kontrollida native_country funktsioonide kordumatute väärtuste arvu. Näete, et ainult üks majapidamine on pärit Hollandist-Hollandist. See majapidamine ei too meile mingit infot, küll aga koolituse käigus tekkinud vea kaudu.

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

Saate selle mitteinformatiivse rea andmekogumist välja jätta

## Drop Netherland, because only one row
df_train = df_train[df_train.native_country != "Holand-Netherlands"]

Järgmisena salvestate pidevate funktsioonide asukoha loendisse. Te vajate seda torujuhtme ehitamiseks järgmises etapis.

Allolev kood liigub üle kõigi veergude nimed jaotises CONTI_FEATURES ja saab selle asukoha (st selle numbri) ja lisab selle seejärel loendisse nimega 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]

Allolev kood teeb sama tööd nagu ülal, kuid kategoorilise muutuja jaoks. Allolev kood kordab seda, mida olete varem teinud, välja arvatud kategoorilised funktsioonid.

## 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]

Saate heita pilgu andmestikule. Pange tähele, et iga kategooriline tunnus on string. Stringiväärtusega mudelit ei saa toita. Peate andmestiku muutma näiva muutuja abil.

df_train.head(5)

Tegelikult peate iga funktsiooni rühma jaoks looma ühe veeru. Esiteks saate vajalike veergude koguhulga arvutamiseks käivitada alloleva koodi.

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

Kogu andmestik sisaldab 101 rühma, nagu ülal näidatud. Näiteks tööklassi funktsioonidel on üheksa rühma. Rühmade nimesid saate visualiseerida järgmiste koodidega

Unikaalne() tagastab kategooriliste tunnuste kordumatud väärtused.

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']

Seetõttu sisaldab koolitusandmekogum 101 + 7 veergu. Viimased seitse veergu on pidevad funktsioonid.

Scikit-learn võib teisendamise eest hoolitseda. Seda tehakse kahes etapis:

  • Esiteks peate stringi teisendama ID-ks. Näiteks riigivalitsusel on ID 1, Self-emp-not-inc ID 2 ja nii edasi. Funktsioon LabelEncoder teeb seda teie eest
  • Transponeerige iga ID uude veergu. Nagu varem mainitud, on andmestikul 101 rühma ID. Seetõttu on 101 veergu, mis kajastavad kõiki kategooriate funktsioonide rühmi. Scikit-learnil on funktsioon nimega OneHotEncoder, mis seda toimingut teostab

2. samm) Looge rongi/katsekomplekt

Nüüd, kui andmestik on valmis, saame selle jagada 80/20.

80 protsenti treeningkomplektile ja 20 protsenti testikomplektile.

Võite kasutada train_test_split. Esimene argument on andmeraam on funktsioonid ja teine ​​argument on sildi andmeraam. Testikomplekti suuruse saate määrata test_size abil.

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. samm) Ehitage torujuhe

Konveieri abil on lihtsam mudelit järjepidevate andmetega varustada.

Idee on panna toorandmed toimingute tegemiseks "konveierisse".

Näiteks praeguse andmestikuga peate standardiseerima pidevad muutujad ja teisendama kategoorilised andmed. Pange tähele, et torujuhtme sees saate teha mis tahes toiminguid. Näiteks kui teil on andmekogumis NA-d, saate need asendada keskmise või mediaaniga. Samuti saate luua uusi muutujaid.

Sul on valik; kaks protsessi kõvasti kodeerida või luua konveier. Esimene valik võib põhjustada andmete lekke ja aja jooksul ebakõlasid. Parem variant on torujuhtme kasutamine.

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

Torujuhe teeb enne logistilise klassifikaatori etteandmist kaks toimingut:

  1. Standardiseeri muutuja: "StandardScaler()"
  2. Teisenda kategoorilised funktsioonid: OneHotEncoder(sparse=False)

Saate teha kaks sammu kasutades make_column_transformer. See funktsioon pole scikit-learni praeguses versioonis (0.19) saadaval. Praeguse versiooniga ei ole võimalik kasutada sildikooderit ja üht kuumkooderit torujuhtmes. See on üks põhjus, miks otsustasime kasutada arendajaversiooni.

make_column_transformerit on lihtne kasutada. Peate määratlema, millised veerud teisendust rakendada ja millist teisendust kasutada. Näiteks pideva funktsiooni standardiseerimiseks saate teha järgmist.

  • conti_features, StandardScaler() make_column_transformeris.
    • conti_features: pidev muutujaga loend
    • StandardScaler: standardiseeri muutuja

Make_column_transformeris olev objekt OneHotEncoder kodeerib sildi automaatselt.

preprocess = make_column_transformer(
    (conti_features, StandardScaler()),
    ### Need to be numeric not string to specify columns name 
    (categorical_features, OneHotEncoder(sparse=False))
)

Saate testida, kas konveier töötab funktsiooniga fit_transform. Andmekogul peab olema järgmine kuju: 26048, 107

preprocess.fit_transform(X_train).shape
(26048, 107)

Andmetrafo on kasutamiseks valmis. Konveieri saate luua käsuga make_pipeline. Kui andmed on teisendatud, saate sisestada logistilise regressiooni.

model = make_pipeline(
    preprocess,
    LogisticRegression())

Modelli koolitamine scikit-learniga on triviaalne. Peate kasutama objekti sobivust, millele eelneb konveier, st mudelit. Saate täpsuse trükkida scikit-learni teegi skooriobjektiga

model.fit(X_train, y_train)
print("logistic regression score: %f" % model.score(X_test, y_test))
logistic regression score: 0.850891

Lõpuks saate klasse ennustada ennustamise_proba abil. See tagastab iga klassi tõenäosuse. Pange tähele, et selle summa on üks.

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. samm) Meie torujuhtme kasutamine ruudustikuotsingus

Hüperparameetri häälestamine (muutujad, mis määravad võrgu struktuuri, näiteks peidetud üksused) võib olla tüütu ja kurnav.

Üks võimalus mudeli hindamiseks võiks olla treeningkomplekti suuruse muutmine ja soorituste hindamine.

Saate seda meetodit korrata kümme korda, et näha skoori mõõdikuid. Siiski on see liiga palju tööd.

Selle asemel pakub scikit-learn funktsiooni parameetrite häälestamiseks ja ristvalideerimiseks.

Ristvalideerimine

Ristvalideerimine tähendab, et treeningu ajal libisetakse treeningkomplekti n korda voltides ja seejärel hinnatakse mudelit n aja jooksul. Näiteks kui cv väärtuseks on seatud 10, treenitakse treeningkomplekti ja see hindab kümme korda. Igas voorus valib klassifikaator modelli treenimiseks juhuslikult üheksa volti ja 10. voltimine on mõeldud hindamiseks.

Võrgu otsing

Igal klassifikaatoril on häälestamiseks hüperparameetrid. Võite proovida erinevaid väärtusi või määrata parameetrite ruudustiku. Kui lähete scikit-learni ametlikule veebisaidile, näete, et logistilisel klassifikaatoril on häälestamiseks erinevad parameetrid. Treenimise kiirendamiseks valite parameetri C häälestamise. See juhib reguleerimisparameetrit. See peaks olema positiivne. Väike väärtus annab regulaatorile suurema kaalu.

Võite kasutada objekti GridSearchCV. Peate häälestamiseks looma hüperparameetreid sisaldava sõnastiku.

Loetlete hüperparameetrid, millele järgneb väärtused, mida soovite proovida. Näiteks parameetri C häälestamiseks kasutate:

  • 'logisticregression__C': [0.1, 1.0, 1.0]: parameetrile eelneb klassifikaatori nimi (väiketähtedega) ja kaks alljoont.

Mudel proovib nelja erinevat väärtust: 0.001, 0.01, 0.1 ja 1.

Treenite mudelit 10 volti kasutades: cv=10

from sklearn.model_selection import GridSearchCV
# Construct the parameter grid
param_grid = {
    'logisticregression__C': [0.001, 0.01,0.1, 1.0],
    }

Mudelit saab treenida GridSearchCV abil parameetritega gri ja cv.

# Train the model
grid_clf = GridSearchCV(model,
                        param_grid,
                        cv=10,
                        iid=False)
grid_clf.fit(X_train, y_train)

OUTPUT

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)

Parimatele parameetritele juurdepääsu saamiseks kasutate best_params_

grid_clf.best_params_

OUTPUT

{'logisticregression__C': 1.0}

Pärast mudeli treenimist nelja erineva regulaarsusväärtusega on optimaalne parameeter

print("best logistic regression from grid search: %f" % grid_clf.best_estimator_.score(X_test, y_test))

parim logistiline regressioon võrguotsingust: 0.850891

Prognoositud tõenäosustele juurdepääsemiseks toimige järgmiselt.

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

XGBoost mudel koos scikit-learniga

Proovime Scikit-learni näiteid, et koolitada üht parimat klassifikaatorit turul. XGBoost on juhusliku metsaga võrreldes parem. Klassifikaatori teoreetiline taust selle ulatusest välja Python Scikiti õpetus. Pidage meeles, et XGBoost on võitnud palju kaggle võistlusi. Andmestiku keskmise suurusega võib see toimida sama hästi kui sügav õppimisalgoritm või isegi paremini.

Klassifikaatorit on keeruline treenida, kuna sellel on palju häälestavaid parameetreid. Loomulikult saate parameetri valimiseks kasutada GridSearchCV-d.

Selle asemel vaatame, kuidas kasutada paremat viisi optimaalsete parameetrite leidmiseks. GridSearchCV võib olla tüütu ja väga pikk treenimine, kui läbite palju väärtusi. Otsinguruum kasvab koos parameetrite arvuga. Eelistatav lahendus on kasutada RandomizedSearchCV-d. See meetod seisneb iga hüperparameetri väärtuste juhuslikus valimises pärast iga iteratsiooni. Näiteks kui klassifikaatorit treenitakse üle 1000 iteratsiooni, siis hinnatakse 1000 kombinatsiooni. See töötab enam-vähem nagu. GridSearchCV

Peate importima xgboosti. Kui teek pole installitud, kasutage pip3 install xgboost või

use import sys
!{sys.executable} -m pip install xgboost

In Jupyter keskkond

Järgmine,

import xgboost
from sklearn.model_selection import RandomizedSearchCV
from sklearn.model_selection import StratifiedKFold

Järgmine samm selles Scikitis Python õpetus sisaldab häälestatavate parameetrite määramist. Kõigi häälestatavate parameetrite nägemiseks võite vaadata ametlikku dokumentatsiooni. Selle huvides Python Sklearni õpetus, valite ainult kaks hüperparameetrit, millest igaühel on kaks väärtust. XGBoostil kulub treenimiseks palju aega, mida rohkem on ruudustikus hüperparameetreid, seda kauem on vaja oodata.

params = {
        'xgbclassifier__gamma': [0.5, 1],
        'xgbclassifier__max_depth': [3, 4]
        }

Ehitate XGBoosti klassifikaatoriga uue torujuhtme. Saate määrata 600 hindajat. Pange tähele, et n_estimators on parameeter, mida saate häälestada. Kõrge väärtus võib põhjustada ülepaigutamist. Võite ise proovida erinevaid väärtusi, kuid pidage meeles, et see võib võtta tunde. Teiste parameetrite jaoks kasutate vaikeväärtust

model_xgb = make_pipeline(
    preprocess,
    xgboost.XGBClassifier(
                          n_estimators=600,
                          objective='binary:logistic',
                          silent=True,
                          nthread=1)
)

Ristvalideerimist saate parandada Stratified K-Foldsi ristvalidaatoriga. Arvutamise kiirendamiseks, kuid kvaliteedi langetamiseks konstrueerite siin ainult kolm volti. Tulemuste parandamiseks suurendage seda väärtust kodus 5-ni või 10-ni.

Saate mudelit koolitada nelja iteratsiooni jooksul.

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)

Juhuslik otsing on kasutamiseks valmis, saate modelli koolitada

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

Nagu näete, on XGBoostil parem skoor kui eelmisel logistilisel regressioonil.

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)

Looge scikit-learnis MLPClassifieriga DNN

Lõpuks saate scikit-learni abil treenida süvaõppe algoritmi. Meetod on sama, mis teisel klassifikaatoril. Klassifikaator on saadaval MLPClassifieris.

from sklearn.neural_network import MLPClassifier

Määrate järgmise süvaõppe algoritmi:

  • Aadama lahendaja
  • Relu aktiveerimise funktsioon
  • Alfa = 0.0001
  • partii suurus 150
  • Kaks peidetud kihti vastavalt 100 ja 50 neuroniga
model_dnn = make_pipeline(
    preprocess,
    MLPClassifier(solver='adam',
                  alpha=0.0001,
                  activation='relu',
                    batch_size=150,
                    hidden_layer_sizes=(200, 100),
                    random_state=1))

Mudeli täiustamiseks saate muuta kihtide arvu

model_dnn.fit(X_train, y_train)
  print("DNN regression score: %f" % model_dnn.score(X_test, y_test))

DNN-i regressiooniskoor: 0.821253

LIME: usaldage oma mudelit

Nüüd, kui teil on hea mudel, vajate selle usaldamiseks tööriista. Masinõpe Algoritm, eriti juhuslik mets ja närvivõrk, on teadaolevalt musta kasti algoritm. Öelge teisiti, see töötab, kuid keegi ei tea, miks.

Kolm teadlast on välja töötanud suurepärase tööriista, et näha, kuidas arvuti ennustab. Leht kannab nime Miks ma peaksin sind usaldama?

Nad töötasid välja algoritmi nimega Kohalikud tõlgendatavad mudeli-agnostilised seletused (LIME).

Võtke näide:

mõnikord te ei tea, kas masinõppe ennustust saab usaldada:

Näiteks arst ei saa usaldada diagnoosi ainult sellepärast, et arvuti nii ütles. Samuti peate enne tootmisse laskmist teadma, kas saate mudelit usaldada.

Kujutage ette, et saame aru, miks mis tahes klassifikaator ennustab isegi uskumatult keerulisi mudeleid, nagu närvivõrgud, juhuslikud metsad või svms mis tahes tuumaga

muutub ennustuse usaldamiseks kättesaadavamaks, kui suudame mõista selle põhjuseid. Näites arstiga, kui modell ütles talle, millised sümptomid on olulised, siis usaldaksite teda, on ka lihtsam aru saada, kas te ei peaks modelli usaldama.

Lime võib teile öelda, millised omadused mõjutavad klassifikaatori otsuseid

Andmete ettevalmistamine

Need on mõned asjad, mida peate LIME'i käitamiseks muutma püüton. Kõigepealt peate terminali installima lubi. Võite kasutada pip install lime

Lime kasutab mudeli kohalikuks lähendamiseks objekti LimeTabularExplainer. See objekt nõuab:

  • numpy-vormingus andmekogum
  • Funktsioonide nimi: funktsioonide_nimed
  • Klasside nimed: klassi_nimed
  • Kategooriliste tunnuste veeru indeks: categorical_features
  • Iga kategooria tunnuse rühma nimi: kategooria_nimed

Looge tuim rongikomplekt

Saate kopeerida ja teisendada df_train pandadest failiks tuim väga lihtsalt

df_train.head(5)
# Create numpy data
df_lime = df_train
df_lime.head(3)

Hankige klassi nimi Silt on juurdepääsetav objektiga unikaalne(). Peaksite nägema:

  • '<=50 XNUMX'
  • '>50 XNUMX'
# Get the class name
class_names = df_lime.label.unique()
class_names
array(['<=50K', '>50K'], dtype=object)

kategooria tunnuste veeru indeks

Grupi nime saamiseks võite kasutada meetodit, mille olete varem kasutanud. Te kodeerite sildi LabelEncoderiga. Kordate toimingut kõigi kategooriliste tunnustega.

## 
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

Nüüd, kui andmestik on valmis, saate koostada erineva andmekogumi, nagu on näidatud allolevates Scikiti õppe näidetes. Tegelikult muudate andmed väljaspool konveierit, et vältida LIME-i vigu. LimeTabularExplaineri treeningkomplekt peaks olema ilma stringita numpy massiiv. Ülaltoodud meetodiga on treeninguandmekogum juba teisendatud.

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)

Saate teha optimaalsete parameetritega torujuhtme XGBoostist

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

Saate hoiatuse. Hoiatuses selgitatakse, et enne konveieri ei pea looma sildikooderit. Kui te LIME-i kasutada ei soovi, võite kasutada Scikit-learniga masinõppe õpetuse esimeses osas toodud meetodit. Vastasel juhul võite selle meetodi juurde jääda, esmalt luua kodeeritud andmestiku ja määrata konveieri sees hot one kodeerija.

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)

Enne LIME-i tegevuses kasutamist looge vale klassifikatsiooni tunnustega numpy massiiv. Saate seda loendit hiljem kasutada, et saada aimu, mis klassifikaatorit eksitab.

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)

Loote lambda-funktsiooni, et tuua ennustus mudelist uute andmetega. Teil on seda varsti vaja.

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

Teisendate pandade andmeraami numpy massiiviks

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)

Valime testkomplektist juhusliku majapidamise ja vaatame mudeli ennustust ja seda, kuidas arvuti oma valiku tegi.

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

Mudeli taga oleva seletuse kontrollimiseks saate kasutada selgitust koos selgituse_näidisega

exp = explainer.explain_instance(X_test_lime[i], predict_fn, num_features=6)
exp.show_in_notebook(show_all=False)

Andmete ettevalmistamine

Näeme, et klassifikaator ennustas majapidamist õigesti. Sissetulek on tõepoolest üle 50 tuhande.

Esimene asi, mida saame öelda, on see, et klassifikaator ei ole prognoositud tõenäosuste suhtes nii kindel. Masin ennustab, et leibkonna sissetulek on üle 50 64 64% tõenäosusega. See XNUMX% koosneb kapitalikasumist ja abielust. Sinine värv mõjutab negatiivselt positiivset klassi ja oranž joon positiivselt.

Klassifikaator on segaduses, kuna selle leibkonna kapitalikasum on null, samas kui kapitali juurdekasv on tavaliselt hea jõukuse ennustaja. Pealegi töötab majapidamine alla 40 tunni nädalas. Vanus, amet ja sugu mõjutavad klassifikaatorit positiivselt.

Kui perekonnaseis oleks vallaline, oleks klassifikaator prognoosinud sissetulekut alla 50 0.64 (0.18-0.46 = XNUMX)

Võime proovida mõne teise majapidamisega, mis on valesti klassifitseeritud

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)

Andmete ettevalmistamine

Klassifikaator ennustas sissetulekut alla 50 60, kuigi see ei vasta tõele. See majapidamine tundub veider. Sellel puudub kapitalikasum ega kapitalikahjum. Ta on lahutatud ja 12-aastane ning tegemist on haritud rahvaga, st hariduse_arv > 50. Üldise mustri järgi peaks see leibkond saama sissetulekut alla XNUMX XNUMX, nagu klassifikaator seletab.

Üritad LEEMIGA ringi mängida. Märkad klassifikaatorist jämedaid vigu.

Saate vaadata raamatukogu omaniku GitHubi. Need pakuvad lisadokumentatsiooni piltide ja tekstide klassifitseerimiseks.

kokkuvõte

Allpool on nimekiri kasulikest käskudest, mille scikit learning versioon >=0.20

rongi/katse andmestiku loomine praktikandid lahku
Ehitage torujuhe
valige veerg ja rakendage teisendus tee kolonntrafo
transformatsiooni tüüp
standardima StandardScaler
min max MinMaxScaler
Normaliseerida Normalisaator
Arvuta puuduv väärtus arvama
Teisenda kategooriliseks OneHotEncoder
Andmete sobitamine ja teisendamine sobi_teisendus
Tehke torujuhe make_pipeline
Põhimudel
logistiline regressioon Logistiline regressioon
XGBoost XGB klassifikaator
Närvivõrk MLPC klassifikaator
Võrgu otsing GridSearchCV
Juhuslik otsing Juhuslik otsing CV