Scikit-Learn Tutorial: Kuinka asentaa ja Scikit-Learn esimerkkejä

Mitä Scikit-learn on?

Scikit opittava on avoimen lähdekoodin Python kirjasto koneoppimista varten. Se tukee huippuluokan algoritmeja, kuten KNN, XGBoost, satunnainen metsä ja SVM. Se on rakennettu NumPyn päälle. Scikit-learnia käytetään laajasti Kaggle-kilpailussa sekä merkittävissä teknologiayrityksissä. Se auttaa esikäsittelyssä, ulottuvuuden vähentämisessä (parametrien valinta), luokittelussa, regressiossa, klusteroinnissa ja mallin valinnassa.

Scikit-learnillä on paras dokumentaatio kaikista avoimen lähdekoodin kirjastoista. Se tarjoaa sinulle interaktiivisen kaavion osoitteessa https://scikit-learn.org/stable/tutorial/machine_learning_map/index.html.

Kuinka Scikit Learn toimii
Kuinka Scikit Learn toimii

Scikit-learn ei ole kovin vaikea käyttää ja tarjoaa erinomaisia ​​tuloksia. Scikit learning ei kuitenkaan tue rinnakkaisia ​​laskelmia. Sillä on mahdollista ajaa syväoppimisalgoritmia, mutta se ei ole optimaalinen ratkaisu, varsinkin jos osaat käyttää TensorFlow'ta.

Kuinka ladata ja asentaa Scikit-learn

Nyt tässä Python Scikit-learn opetusohjelma, opimme lataamaan ja asentamaan Scikit-learn:

Vaihtoehto 1: AWS

scikit-learnia voidaan käyttää AWS:n yli. Ole kiltti katso Docker-kuva, johon on esiasennettu scikit-learn.

Jos haluat käyttää kehittäjäversiota, käytä komentoa in Jupyter

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

Vaihtoehto 2: Mac tai Windows käyttämällä Anacondaa

Katso lisätietoja Anacondan asennuksesta https://www.guru99.com/download-install-tensorflow.html

Äskettäin scikitin kehittäjät ovat julkaisseet kehitysversion, joka ratkaisee nykyisen version yleisiä ongelmia. Mielestämme on helpompi käyttää kehittäjäversiota nykyisen version sijaan.

Kuinka asentaa scikit-learn Conda Environmentin avulla

Jos asensit scikit-learnin conda-ympäristön kanssa, päivitä versioon 0.20 noudattamalla vaiheita

Vaihe 1) Aktivoi tensorflow-ympäristö

source activate hello-tf

Vaihe 2) Poista scikit lean komennolla conda

conda remove scikit-learn

Vaihe 3) Asenna kehittäjäversio.
Asenna scikit learning -kehittäjäversio ja tarvittavat kirjastot.

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

HUOMAUTUS: Windows käyttäjän on asennettava Microsoft Visuaalinen C++ 14. Saat sen osoitteesta tätä

Scikit-Learn-esimerkki koneoppimisen kanssa

Tämä Scikit-opetusohjelma on jaettu kahteen osaan:

  1. Koneoppiminen scikit-learnillä
  2. Kuinka luottaa malliisi LIME:n kanssa

Ensimmäisessä osassa kerrotaan liukuhihnan rakentamisesta, mallin luomisesta ja hyperparametrien virittämisestä, kun taas toisessa osassa tarjotaan mallin valinnan kannalta uusinta tekniikkaa.

Vaihe 1) Tuo tiedot

Tämän Scikit-oppimisohjelman aikana käytät aikuisten tietojoukkoa.

Jos haluat tietää lisää kuvaavista tilastoista, ole hyvä ja käytä Sukellus- ja Yleiskatsaus -työkaluja.

Katso tämä opetusohjelma lisätietoja sukelluksesta ja yleiskatsauksesta

Tuot tietojoukon Pandasin avulla. Huomaa, että sinun on muunnettava jatkuvien muuttujien tyyppi float-muotoon.

Tämä tietojoukko sisältää kahdeksan kategorista muuttujaa:

Kategoriset muuttujat on lueteltu kohdassa CATE_FEATURES

  • työluokka
  • koulutus
  • avio-
  • ammatti
  • yhteys
  • rotu
  • sukupuoli
  • Kotimaa

lisäksi kuusi jatkuvaa muuttujaa:

Jatkuvat muuttujat on lueteltu kohdassa CONTI_FEATURES

  • ikä
  • fnlwgt
  • koulutus_nm
  • myyntivoitto
  • pääoma_tappio
  • tuntia_viikko

Huomaa, että täytämme luettelon käsin, jotta sinulla on parempi käsitys käyttämistämme sarakkeista. Nopeampi tapa luoda luettelo kategorisista tai jatkuvista on käyttää:

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

Tässä on koodi tietojen tuontia varten:

# 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()
ikä fnlwgt koulutus_nm myyntivoitto pääoma_tappio tuntia_viikko
laskea 32561.000000 3.256100e + 04 32561.000000 32561.000000 32561.000000 32561.000000
tarkoittaa 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
minuuttia 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

Voit tarkistaa native_country-ominaisuuksien yksilöllisten arvojen määrän. Näet, että vain yksi kotitalous tulee Holand-Hollannista. Tämä kotitalous ei tuo meille mitään tietoa, mutta tulee koulutuksen aikana tapahtuneen virheen kautta.

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

Voit jättää tämän epätietoisen rivin pois tietojoukosta

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

Seuraavaksi tallennat jatkuvien ominaisuuksien sijainnin luetteloon. Tarvitset sitä seuraavassa vaiheessa putkilinjan rakentamiseen.

Alla oleva koodi kiertää kaikkien sarakkeiden nimet kohteessa CONTI_FEATURES ja saa sen sijainnin (eli numeron) ja liittää sen sitten luetteloon nimeltä 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]

Alla oleva koodi tekee saman työn kuin yllä, mutta kategoriselle muuttujalle. Alla oleva koodi toistaa sen, mitä olet tehnyt aiemmin, paitsi kategorisilla ominaisuuksilla.

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

Voit katsoa tietojoukkoa. Huomaa, että jokainen kategorinen ominaisuus on merkkijono. Et voi syöttää mallia merkkijonoarvolla. Sinun on muutettava tietojoukko valemuuttujan avulla.

df_train.head(5)

Itse asiassa sinun on luotava yksi sarake kullekin ominaisuuden ryhmälle. Ensin voit suorittaa alla olevan koodin laskeaksesi tarvittavien sarakkeiden kokonaismäärän.

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

Koko tietojoukko sisältää 101 ryhmää, kuten yllä on esitetty. Esimerkiksi työluokan ominaisuuksilla on yhdeksän ryhmää. Voit visualisoida ryhmien nimet seuraavilla koodeilla

ainutlaatuinen() palauttaa kategoristen ominaisuuksien ainutlaatuiset arvot.

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

Siksi harjoitustietojoukko sisältää 101 + 7 saraketta. Viimeiset seitsemän saraketta ovat jatkuvia ominaisuuksia.

Scikit-learn voi huolehtia muuntamisesta. Se tehdään kahdessa vaiheessa:

  • Ensin sinun on muunnettava merkkijono ID:ksi. Esimerkiksi State-govilla on tunnus 1, Self-emp-not-inc ID 2 ja niin edelleen. LabelEncoder-toiminto tekee tämän puolestasi
  • Siirrä jokainen tunnus uuteen sarakkeeseen. Kuten aiemmin mainittiin, tietojoukossa on 101 ryhmän tunnus. Siksi siellä on 101 saraketta, jotka kaappaavat kaikki kategorioiden ominaisuuksien ryhmät. Scikit-learnissä on OneHotEncoder-niminen toiminto, joka suorittaa tämän toiminnon

Vaihe 2) Luo juna/testisarja

Nyt kun tietojoukko on valmis, voimme jakaa sen 80/20.

80 prosenttia harjoitussarjasta ja 20 prosenttia testisarjasta.

Voit käyttää train_test_split. Ensimmäinen argumentti on, että datakehys on ominaisuuksia ja toinen argumentti on etiketin datakehys. Voit määrittää testijoukon koon komennolla 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)

Vaihe 3) Rakenna putki

Liukulinja helpottaa mallin syöttämistä johdonmukaisilla tiedoilla.

Ideana on laittaa raakadata "putkiin" toimintojen suorittamista varten.

Esimerkiksi nykyisellä tietojoukolla sinun on standardoitava jatkuvat muuttujat ja muunnettava kategoriset tiedot. Huomaa, että voit suorittaa minkä tahansa toimenpiteen putkilinjan sisällä. Jos sinulla on esimerkiksi 'NA't' tietojoukossa, voit korvata ne keskiarvolla tai mediaanilla. Voit myös luoda uusia muuttujia.

Sinulla on valinta; koodaa kaksi prosessia tai luo liukuhihna. Ensimmäinen valinta voi johtaa tietovuotoon ja aiheuttaa epäjohdonmukaisuuksia ajan myötä. Parempi vaihtoehto on käyttää putkistoa.

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

Putkilinja suorittaa kaksi toimintoa ennen logistisen luokittelijan syöttämistä:

  1. Standardoi muuttuja: "StandardScaler()"
  2. Muunna kategoriset ominaisuudet: OneHotEncoder(sparse=False)

Voit suorittaa kaksi vaihetta käyttämällä make_column_transformer-toimintoa. Tämä toiminto ei ole käytettävissä scikit-learnin (0.19) nykyisessä versiossa. Nykyisellä versiolla ei ole mahdollista suorittaa etikettienkooderia ja yhtä hot-enkooderia valmisteilla. Se on yksi syy, miksi päätimme käyttää kehittäjäversiota.

make_column_transformer on helppokäyttöinen. Sinun on määritettävä, mitkä sarakkeet muunnosa käytetään ja mitä muunnoksia käytetään. Voit esimerkiksi standardoida jatkuvan ominaisuuden seuraavasti:

  • conti_features, StandardScaler() sisällä make_column_transformer.
    • conti_features: luettelo jatkuvalla muuttujalla
    • StandardScaler: standardoi muuttuja

Make_column_transformerin sisällä oleva OneHotEncoder-objekti koodaa tunnisteen automaattisesti.

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

Voit testata, toimiiko liukuhihna fit_transform-toiminnolla. Tietojoukon tulee olla seuraavanlainen: 26048, 107

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

Datamuuntaja on käyttövalmis. Voit luoda liukuhihnan komennolla make_pipeline. Kun tiedot on muunnettu, voit syöttää logistisen regression.

model = make_pipeline(
    preprocess,
    LogisticRegression())

Mallin kouluttaminen scikit-learnillä on triviaalia. Sinun on käytettävä objektisovitusta, jota edeltää liukuhihna, eli malli. Voit tulostaa tarkkuuden scikit-learn-kirjaston partituuriobjektilla

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

Lopuksi voit ennustaa luokat komennolla ennustaa_proba. Se palauttaa kunkin luokan todennäköisyyden. Huomaa, että se on yksi.

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

Vaihe 4) Liukulinjamme käyttäminen ruudukkohaussa

Hyperparametrin (muuttujat, jotka määrittävät verkon rakenteen, kuten piilotetut yksiköt) säätäminen voi olla työlästä ja uuvuttavaa.

Yksi tapa arvioida mallia voisi olla muuttaa harjoitussarjan kokoa ja arvioida suorituksia.

Voit toistaa tämän menetelmän kymmenen kertaa nähdäksesi tulostiedot. Se on kuitenkin liikaa työtä.

Sen sijaan scikit-learn tarjoaa toiminnon parametrien virittämiseen ja ristiinvalidointiin.

Ristiinvalidointi

Ristiinvalidointi tarkoittaa sitä, että harjoitussarjaa liu'utetaan koulutuksen aikana n monta kertaa laskoksissa ja sitten arvioidaan mallin n ajan. Jos esimerkiksi cv on asetettu arvoon 10, harjoitussarjaa harjoitellaan ja se arvioi kymmenen kertaa. Jokaisella kierroksella luokittelija valitsee satunnaisesti yhdeksän laskosta mallin harjoittamiseksi, ja 10. taitto on tarkoitettu arvioitavaksi.

Verkkohaku

Jokaisella luokittimella on säädettävät hyperparametrit. Voit kokeilla erilaisia ​​arvoja tai määrittää parametriruudukon. Jos siirryt scikit-learnin viralliselle verkkosivustolle, voit nähdä, että logistisella luokittimella on eri parametreja viritettävänä. Voit nopeuttaa harjoittelua säätämällä C-parametria. Se ohjaa säännöstelyparametria. Sen pitäisi olla positiivista. Pieni arvo antaa lisää painoarvoa säätimelle.

Voit käyttää objektia GridSearchCV. Sinun on luotava sanakirja, joka sisältää säädettävät hyperparametrit.

Listat hyperparametrit ja arvot, joita haluat kokeilla. Esimerkiksi C-parametrin virittämiseen käytät:

  • 'logisticregression__C': [0.1, 1.0, 1.0]: Parametria edeltää luokittelijan nimi pienillä kirjaimilla ja kaksi alaviivaa.

Malli yrittää neljää eri arvoa: 0.001, 0.01, 0.1 ja 1.

Harjoittele mallia 10 taitolla: cv=10

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

Voit harjoitella mallia GridSearchCV:llä parametreilla gri ja cv.

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

LÄHTÖ

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)

Saadaksesi parhaat parametrit, käytä best_params_

grid_clf.best_params_

LÄHTÖ

{'logisticregression__C': 1.0}

Kun mallia on harjoiteltu neljällä eri regularisointiarvolla, optimaalinen parametri on

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

paras logistinen regressio ruudukkohausta: 0.850891

Pääset ennustettuihin todennäköisyyksiin seuraavasti:

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-malli scikit-learnillä

Kokeillaan Scikit-learn-esimerkkejä kouluttaaksemme yhden markkinoiden parhaista luokittelijoista. XGBoost on parannus satunnaiseen metsään. Luokittelijan teoreettinen tausta ei kuulu tähän Python Scikit opetusohjelma. Muista, että XGBoost on voittanut paljon kaggle-kilpailuja. Keskimääräisellä tietojoukon koolla se voi toimia yhtä hyvin kuin syväoppimisalgoritmi tai jopa paremmin.

Luokitin on haastava harjoitella, koska sillä on paljon viritettävää parametria. Voit tietysti käyttää GridSearchCV:tä valitaksesi parametrin puolestasi.

Sen sijaan katsotaan kuinka käyttää parempaa tapaa löytää optimaaliset parametrit. GridSearchCV voi olla työlästä ja erittäin pitkä harjoitus, jos ohitat useita arvoja. Hakutila kasvaa parametrien määrän mukana. Suositeltava ratkaisu on käyttää RandomizedSearchCV:tä. Tämä menetelmä koostuu kunkin hyperparametrin arvojen valitsemisesta jokaisen iteraation jälkeen satunnaisesti. Esimerkiksi jos luokittelijaa koulutetaan yli 1000 iteraatiota, niin 1000 yhdistelmää arvioidaan. Toimii enemmän tai vähemmän kuin. GridSearchCV

Sinun on tuotava xgboost. Jos kirjastoa ei ole asennettu, käytä pip3 install xgboost tai

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

In Jupyter ympäristö

Seuraavaksi

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

Seuraava askel tässä Scikitissä Python opetusohjelma sisältää virittävien parametrien määrittämisen. Voit katsoa kaikki viritettävät parametrit virallisesta dokumentaatiosta. Sen vuoksi Python Sklearn-opetusohjelma, valitset vain kaksi hyperparametria, joissa kummassakin on kaksi arvoa. XGBoostin harjoitteleminen vie paljon aikaa, mitä enemmän hyperparametreja ruudukossa on, sitä pidempään sinun on odotettava.

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

Rakennat uuden putkilinjan XGBoost-luokittimella. Voit määrittää 600 arvioijaa. Huomaa, että n_estimators on parametri, jota voit säätää. Korkea arvo voi johtaa ylisovitukseen. Voit kokeilla itse erilaisia ​​arvoja, mutta muista, että se voi kestää tunteja. Käytät oletusarvoa muille parametreille

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

Voit parantaa ristiinvalidointia Stratified K-Folds -ristivalidaattorilla. Rakennat tähän vain kolme taitosta nopeuttaaksesi laskentaa, mutta heikentääksesi laatua. Nosta tämä arvo 5:een tai 10:een kotona parantaaksesi tuloksia.

Voit harjoitella mallia neljällä iteraatiolla.

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)

Satunnaistettu haku on käyttövalmis, voit kouluttaa mallia

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

Kuten näet, XGBoostilla on parempi pistemäärä kuin edellisellä logistiikkaregressiolla.

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)

Luo DNN MLPClassifierilla scikit-learnissä

Lopuksi voit kouluttaa syvän oppimisalgoritmin scikit-learnillä. Menetelmä on sama kuin muussa luokittimessa. Luokitin on saatavilla MLPClassifierista.

from sklearn.neural_network import MLPClassifier

Määrität seuraavan syvän oppimisalgoritmin:

  • Adam ratkaisija
  • Relu aktivointitoiminto
  • Alfa = 0.0001
  • eräkoko 150
  • Kaksi piilotettua kerrosta, joissa on 100 ja 50 neuronia
model_dnn = make_pipeline(
    preprocess,
    MLPClassifier(solver='adam',
                  alpha=0.0001,
                  activation='relu',
                    batch_size=150,
                    hidden_layer_sizes=(200, 100),
                    random_state=1))

Voit muuttaa tasojen määrää mallin parantamiseksi

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

DNN-regressiopisteet: 0.821253

LIME: Luota malliisi

Nyt kun sinulla on hyvä malli, tarvitset työkalun, jolla voit luottaa siihen. Koneen oppiminen Algoritmi, erityisesti satunnainen metsä ja hermoverkko, tiedetään olevan black-box-algoritmeja. Sano toisin, se toimii, mutta kukaan ei tiedä miksi.

Kolme tutkijaa on keksinyt loistavan työkalun nähdäkseen, kuinka tietokone tekee ennusteen. Lehden nimi on Miksi minun pitäisi luottaa sinuun?

He kehittivät algoritmin nimeltä Paikalliset tulkittavat malli-agnostiset selitykset (LIME).

Ota esimerkki:

joskus et tiedä, voitko luottaa koneoppimisen ennusteeseen:

Lääkäri ei esimerkiksi voi luottaa diagnoosiin vain siksi, että tietokone sanoi niin. Sinun on myös tiedettävä, voitko luottaa malliin ennen sen käyttöönottoa.

Kuvittele, että voimme ymmärtää, miksi mikä tahansa luokitin ennustaa jopa uskomattoman monimutkaisia ​​malleja, kuten hermoverkkoja, satunnaisia ​​metsiä tai svms-malleja millä tahansa ytimellä

ennusteeseen on helpompi luottaa, jos ymmärrämme sen taustalla olevat syyt. Lääkärin esimerkistä, jos malli kertoisi hänelle, mitkä oireet ovat olennaisia, luottaisit siihen, on myös helpompi selvittää, eikö malliin pitäisi luottaa.

Lime voi kertoa, mitkä ominaisuudet vaikuttavat luokittelijan päätöksiin

Tietojen valmistelu

Nämä ovat muutamia asioita, jotka sinun on muutettava, jotta voit käyttää LIMEä pytonkäärme. Ensinnäkin sinun on asennettava kalkki terminaaliin. Voit käyttää pip install limeä

Lime käyttää LimeTabularExplainer-objektia likimääräiseen malliin paikallisesti. Tämä objekti vaatii:

  • tietojoukko numpy-muodossa
  • Ominaisuuksien nimet: ominaisuuden_nimet
  • Luokkien nimet: luokan_nimet
  • Kategoristen ominaisuuksien sarakkeen indeksi: categorical_features
  • Ryhmän nimi jokaiselle kategoriselle ominaisuudelle: categorical_names

Luo numpy junasarja

Voit kopioida ja muuntaa df_trainin pandasta muotoon numpy tosi helposti

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

Hanki luokan nimi Tunniste on käytettävissä objektilla ainutlaatuinen(). Sinun pitäisi nähdä:

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

kategoristen ominaisuuksien sarakkeen indeksi

Voit käyttää menetelmää, jota nojasit aiemmin saadaksesi ryhmän nimen. Koodaat tarran LabelEncoderilla. Toistat operaation kaikille kategorisille piirteille.

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

Nyt kun tietojoukko on valmis, voit rakentaa eri tietojoukon alla olevien Scikit learning -esimerkkien mukaisesti. Muutat tiedot liukuhihnan ulkopuolelle välttääksesi virheet LIME:n kanssa. LimeTabularExplainerin harjoitusjoukon tulee olla numpy-taulukko ilman merkkijonoa. Yllä olevalla menetelmällä harjoitustietojoukko on jo muunnettu.

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)

Voit tehdä liukuhihnan optimaalisilla parametreilla XGBoostista

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

Saat varoituksen. Varoitus selittää, että sinun ei tarvitse luoda tarraenkooderia ennen liukuhihnaa. Jos et halua käyttää LIMEä, voit käyttää menetelmää koneoppimisen ja Scikit-learn -opetusohjelman ensimmäisestä osasta. Muussa tapauksessa voit jatkaa tätä menetelmää, luoda ensin koodatun tietojoukon ja asettaa hot one -enkooderin prosessissa.

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)

Ennen kuin käytät LIMEä toiminnassa, luodaan numpy array, jossa on väärän luokituksen ominaisuudet. Voit käyttää tätä luetteloa myöhemmin saadaksesi käsityksen siitä, mikä luokittelijaa johtaa harhaan.

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)

Luot lambda-funktion hakemaan ennusteen mallista uusilla tiedoilla. Tarvitset sitä pian.

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

Muunnat panda-tietokehyksen numpy-taulukoksi

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)

Valitaan testijoukosta satunnainen kotitalous ja nähdään malliennuste ja kuinka tietokone teki valintansa.

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

Voit tarkistaa mallin taustalla olevan selityksen selittäjällä selityksen_instance kanssa

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

Tietojen valmistelu

Näemme, että luokittelija ennusti kotitalouden oikein. Tulot ovat tosiaan yli 50k.

Ensimmäinen asia, jonka voimme sanoa, on, että luokitin ei ole niin varma ennustetuista todennäköisyyksistä. Kone ennustaa kotitalouden tulot yli 50k 64% todennäköisyydellä. Tämä 64 % koostuu pääomavoitosta ja avioliitosta. Sininen väri vaikuttaa negatiivisesti positiiviseen luokkaan ja oranssi viiva positiivisesti.

Luokitin on hämmentynyt, koska tämän kotitalouden myyntivoitto on nolla, kun taas myyntivoitto on yleensä hyvä varallisuuden ennustaja. Lisäksi kotitalous työskentelee alle 40 tuntia viikossa. Ikä, ammatti ja sukupuoli vaikuttavat luokittelijaan myönteisesti.

Jos siviilisääty olisi ollut sinkku, luokittelija olisi ennustanut alle 50 tk:n tulot (0.64-0.18 = 0.46)

Voimme yrittää toisella taloudella, joka on luokiteltu väärin

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)

Tietojen valmistelu

Luokittaja ennusti alle 50 60 tuloa, vaikka se ei pidä paikkaansa. Tämä kotitalous näyttää oudolta. Sillä ei ole myyntivoittoa eikä pääomatappiota. Hän on eronnut ja on 12-vuotias, ja kyseessä on koulutettu kansa, eli koulutusluku > 50. Kokonaismallin mukaan tämän kotitalouden pitäisi, kuten luokittelija selittää, saada alle XNUMX tk tuloja.

Yrität leikkiä LIME:llä. Huomaat luokittelijasta karkeita virheitä.

Voit tarkistaa kirjaston omistajan GitHubista. Ne tarjoavat lisädokumentaatiota kuvien ja tekstien luokitteluun.

Yhteenveto

Alla on luettelo hyödyllisistä komennoista, joiden scikit learning versio on >=0.20

luo juna-/testitietojoukko harjoittelijat erosivat
Rakenna putki
valitse sarake ja ota muunnos käyttöön tee kolonnimuuntaja
muunnostyyppi
standardoida StandardScaler
min max MinMaxScaler
normalisoitua Normalizer
Laske puuttuva arvo laskea
Muunna kategorisiksi OneHotEncoder
Sovita ja muunna tiedot sovita_muunnos
Tee putkisto make_pipeline
Perus malli
logistinen regressio Logistinen regressio
XGBoost XGB-luokitus
Hermoverkko MLPC-luokitus
Verkkohaku GridSearchCV
Satunnaistettu haku Satunnaistettu haku CV