Kan scikit-learn-transformatorer returnera pandas DataFrames?

Ja. Anropa set_output(transform="pandas") på en transformer eller en hel pipeline så behåller resultatet sina kolumnnamn istället för att returnera en ren NumPy-array, vilket gör ColumnTransformer-utdata mycket enklare att inspektera.

Scikit-Learn Tutorial: Hur man installerar & Scikit-Learn Exempel

⚡ Smart sammanfattning

Scikit-learn är öppen källkod Python bibliotek som täcker förbehandling, klassificering, regression, klustring och modellval bakom ett enda konsekvent estimatorgränssnitt, vilket håller ett komplett arbetsflöde för maskininlärning kort, läsbart och reproducerbart från rådata till poängsatta förutsägelser.

🔘 Installation: Både Conda och pip fungerar, och den nuvarande stabila utgåvan innehåller redan alla transformatorer som används här.
☑️ Bearbetad datamängd: UCI:s vuxenfolkräkningsfil med 32 561 rader driver varje exempel i den här genomgången.
✅ Rörledningar: make_column_transformer skalar de numeriska kolumnerna och kodar de kategoriska i ett enda objekt med ett hot.
🧪 Inställning: GridSearchCV sveper ett fullständigt parameternät, medan RandomizedSearchCV samplar det och slutför det mycket snabbare.
🛠️ Tre modeller: Logistisk regressionspoäng 0.850891, XGBoost 0.873157 och MLPClassifier-nätverket 0.821253.
⚠️ Förklaring: LIME visar vilka funktioner som drev en enskild förutsägelse mot sin klass, inklusive de felaktiga.

Läs mer

Vad är Scikit-learn?

Scikit lära är en öppen källkod Python bibliotek för maskininlärningDen stöder väletablerade algoritmer som KNN, gradient boosting, random forest och SVM, och den är byggd ovanpå numpy och SciPy. Scikit-learn används flitigt i Kaggle-tävlingar såväl som i framstående teknikföretag. Det omfattar förbehandling, dimensionalitetsreduktion, klassificering, regression, klustring och modellval.

Scikit-learn har några av de bästa dokumentationerna av alla öppna källkodsbibliotek. Det tillhandahåller till och med ett interaktivt kalkylatordiagram, Att välja rätt kalkylator, som guidar dig från storleken på din datauppsättning till en kortlista med algoritmer som är värda att prova.

Figuren nedan illustrerar hur Scikit-learn fungerar.

Scikit-learn är inte svårt att använda och ger utmärkta resultat. Det tränas dock på processorn: arbetet parallelliseras över kärnor med argumentet n_jobs snarare än på en GPU. Att köra en djupinlärningsalgoritm med det är möjligt men sällan optimalt, särskilt om du redan vet hur man använder det. TensorFlow.

Hur man laddar ner och installerar Scikit-learn

Nu i detta Python Scikit-learn handledning, du lär dig hur du laddar ner och installerar Scikit-learn:

Alternativ 1: AWS

Scikit-learn kan användas över AWS. En Docker-avbildning med scikit-learn förinstallerat sparar installationsarbetet helt.

För att installera utvecklarversionen, kör kommandot nedan inuti Jupyter:

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

Alternativ 2: Mac eller Windows använder Anaconda

För att lära dig mer om installationen av Anaconda, se hur man laddar ner och installerar TensorFlow.

När denna genomgång skrevs hade utvecklarna av scikit släppt en utvecklingsversion som åtgärdade problem som fanns i den dåvarande utgåvan, så stegen nedan använder den utvecklarversionen. På en ny maskin idag innehåller den nuvarande stabila utgåvan redan alla transformatorer som används här, och pip install -U scikit-learn är nog.

Hur man installerar scikit-learn med Conda Environment

Om du installerade scikit-learn med conda-miljön, följ stegen nedan för att uppdatera till version 0.20.

Steg 1) Aktivera tensorflow-miljön

source activate hello-tf

Steg 2) Ta bort scikit-learn med hjälp av conda-kommandot

conda remove scikit-learn

Steg 3) Installera utvecklarversionen

Installera utvecklarversionen av scikit-learn tillsammans med nödvändiga bibliotek.

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

OBS: Windows användarna behöver Microsoft Visuell C++ 14. Du kan få det här..

Scikit-Learn-exempel med maskininlärning

Denna Scikit-handledning är uppdelad i två delar:

Maskininlärning med scikit-learn
Hur du litar på din modell med LIME

Den första delen beskriver hur man bygger en pipeline, skapar en modell och finjusterar hyperparametrarna, medan den andra delen täcker modelltolkning.

Steg 1) Importera data

Under den här Scikit Learn-handledningen kommer du att använda datamängden för vuxna.

Filen läses direkt från UCI Machine Learning Repository i koden nedan, så ingen manuell nedladdning behövs. Om du är intresserad av beskrivande statistik är verktygen Dive och Overview värda att titta på. Se denna handledning för att lära dig mer om Dyk och Översikt.

Du importerar datamängden med pandas. Observera att du måste konvertera de kontinuerliga variablerna till flyttalformat.

Denna datauppsättning innehåller åtta kategoriska variabler, listade i CATE_FEATURES:

arbetsklass
utbildning
äktenskaplig
ockupation
relation
lopp
kön
hemland

Den innehåller också sex kontinuerliga variabler, listade i CONTI_FEATURES:

ålder
fnlwgt
utbildningsnummer
kapitalvinsten
kapitalförlust
timmar_vecka

Listorna fylls i för hand här så att du får en tydligare uppfattning om vilka kolumner som är i spel. Ett snabbare sätt att bygga en lista med kategoriska eller kontinuerliga kolumner är:

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

Här är koden för att importera data:

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

Att anropa describe() på ramen returnerar sammanfattningsstatistiken för de sex kontinuerliga kolumnerna:

	ålder	fnlwgt	utbildningsnummer	kapitalvinsten	kapitalförlust	timmar_vecka
räkna	32561.000000	3.256100e + 04	32561.000000	32561.000000	32561.000000	32561.000000
betyda	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
min	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

Du kan kontrollera antalet unika värden för funktionen native_country. Endast ett hushåll kommer från Nederländerna. Det hushållet ger ingen information och kommer att ge ett felmeddelande under träningen.

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

Du kan exkludera den här oinformativa raden från datasetet:

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

Därefter lagrar du positionen för de kontinuerliga funktionerna i en lista. Du kommer att behöva det i nästa steg för att bygga pipelinen.

Koden nedan loopar över alla kolumnnamn i CONTI_FEATURES, läser varje plats (det vill säga dess kolumnnummer) och lägger till den i en lista som heter 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]

Nästa block gör samma jobb för de kategoriska variablerna.

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

Titta nu på själva datamängden. Varje kategorisk funktion är en sträng, och en modell kan inte matas med ett strängvärde, så datamängden måste transformeras med dummyvariabler.

df_train.head(5)

Faktum är att du behöver en kolumn för varje grupp i varje funktion. Kör först koden nedan för att beräkna det totala antalet kolumner som behövs.

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

Hela datamängden innehåller 101 grupper, som visas ovan. Bara arbetsklassfunktionen har nio grupper. Du kan lista namnen på grupperna med koden nedan; unique() returnerar de distinkta värdena för varje kategorisk funktion.

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

Träningsdatasetet kommer därför att innehålla 101 + 6 kolumner: de en-hot-grupperna plus de sex kontinuerliga funktionerna.

Scikit-learn kan hantera konverteringen i två steg:

Konvertera strängen till ett ID. State-gov blir ID 1, Self-emp-not-inc blir ID 2 och så vidare. LabelEncoder gör detta åt dig.
Transponera varje ID till en ny kolumn. Datasetet har 101 grupp-ID:n, så det kommer att finnas 101 kolumner som fångar varje kategorisk funktionsgrupp. Scikit-learn tillhandahåller OneHotEncoder för denna operation.

Steg 2) Skapa tåget/testsetet

Nu när datamängden är klar, dela den 80/20: 80 procent för träningsmängden och 20 procent för testmängden.

Du kan använda train_test_split. Det första argumentet är dataframen för funktionerna och det andra är etiketten. Du anger storleken på testuppsättningen med 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)

Steg 3) Bygg pipeline

Pipelinen gör det enklare att mata modellen med konsekventa data. Tanken är att skicka rådata genom ett objekt som utför varje operation i ordning.

Med denna datauppsättning behöver du standardisera de kontinuerliga variablerna och konvertera de kategoriska. Alla operationer kan finnas inuti en pipeline: saknade värden kan ersättas med medelvärdet eller medianen, och nya variabler kan skapas.

Du har ett val: hårdkoda de två processerna, eller bygga en pipeline. Hårdkodning kan läcka testdata till den anpassade statistiken och skapa inkonsekvenser över tid, så pipeline är det bättre alternativet.

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

Pipelinen utför två operationer innan den matar den logistiska klassificeraren:

Standardisera variabeln: StandardScaler()
Konvertera de kategoriska funktionerna: OneHotEncoder(sparse=False)

Du utför båda stegen med make_column_transformer. När den här genomgången skrevs fanns inte funktionen i den släppta versionen av scikit-learn (0.19), vilket är anledningen till att utvecklarversionen användes; den har inkluderats i varje stabil utgåva sedan 0.20.

make_column_transformer är enkelt: du deklarerar vilka kolumner som ska transformeras och vilken transformation som ska tillämpas. För att standardisera de kontinuerliga funktioner som skickas:

conti_features, StandardScaler() inuti make_column_transformer
- conti_features: listan över kontinuerliga kolumner
- StandardScaler: standardiserar dessa kolumner

OneHotEncoder-objektet inuti make_column_transformer kodar etiketterna automatiskt.

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

Versionsnotering: två argument i blocket ovan har flyttats. Nuvarande versioner förväntar sig transformatorn först och kolumnerna sedan, och gles döptes om gles_utdata i scikit-learn 1.2 och borttagen i 1.4, så nyare kod läses OneHotEncoder(sparse_output=False).

Du kan testa om pipelinen fungerar med fit_transform. Utdata ska ha formen 26048, 107.

preprocess.fit_transform(X_train).shape

(26048, 107)

Datatransformatorn är klar. Du skapar pipelinen med make_pipeline, och när data har transformerats matar du in den logistiska regressionen.

model = make_pipeline(
    preprocess,
    LogisticRegression())

Att träna en modell med scikit-learn är då trivialt: anropa anpassning på pipelinen. Du kan skriva ut noggrannheten med poängmetoden.

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

logistic regression score: 0.850891

Slutligen kan du förutsäga klasserna med predict_proba, vilket returnerar sannolikheten för varje klass. Observera att de två sannolikheterna summerar till ett.

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

Steg 4) Använda vår pipeline i en rutnätssökning

Att finjustera hyperparametrarna, de värden som fixerar modellens struktur, kan vara mödosamt och utmattande.

Ett sätt att utvärdera modellen vore att ändra storleken på träningssetet och mäta prestationen, genom att upprepa övningen tio gånger för att se spridningen av poängen. Det är mycket manuellt arbete.

Istället tillhandahåller scikit-learn funktioner som utför parameterjustering och korsvalidering åt dig.

Korsvalidering

Korsvalidering innebär att träningsmängden delas upp n gånger i veck under träning och modellen utvärderas n gånger. Om cv sätts till 10 tränas och utvärderas modellen tio gånger. I varje omgång tränar klassificeraren på nio slumpmässigt valda veck och den tionde vecken behålls för utvärdering.

Rutnätssökning

Varje klassificerare har hyperparametrar att finjustera. Du kan prova värden ett i taget, eller ställa in ett parameternät. Dokumentationen i scikit-learn listar alla parametrar som den logistiska klassificeraren accepterar. För att hålla träningen snabb finjusterar det här exemplet endast C-parametern, som styr regularisering. Den måste vara positiv, och ett litet värde ger mer vikt åt regulariseraren.

Du använder GridSearchCV-objektet, som tar en ordlista med hyperparametrar för att finjustera. Lista varje hyperparameter följt av de värden du vill prova. För att finjustera C skriver du:

'logisticregression__C': [0.001, 0.01, 0.1, 1.0] — parameternamnet föregås av klassificeringsnamnet med gemener och två understreck.

Modellen kommer att prova fyra olika värden: 0.001, 0.01, 0.1 och 1. Den tränas med 10 veck, det vill säga cv=10.

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

Du kan nu träna modellen med hjälp av GridSearchCV med parametern grid och cv.

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

Produktion:

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)

Versionsnotering: d iid Argumentet som syns i denna utdata föråldrades i scikit-learn 0.22 och togs bort i 0.24, så det bör helt enkelt tas bort från GridSearchCV-anropet i aktuella versioner.

För att komma åt de bästa parametrarna använder du best_params_.

grid_clf.best_params_

Produktion:

{'logisticregression__C': 1.0}

Efter att ha tränat modellen med fyra olika regulariseringsvärden ger den optimala parametern:

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

bästa logistiska regression från rutnätssökning: 0.850891

För att komma åt de förutspådda sannolikheterna:

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-modell med scikit-learn

Prova nu en av de starkaste klassificeringsverktygen på marknaden. XGBoost är en gradientförstärkande förbättring av den slumpmässiga skogen. Dess teoretiska bakgrund ligger utanför ramen för detta arbete. Python Scikit-handledning, men kom ihåg att XGBoost har vunnit många Kaggle-tävlingar. På en genomsnittlig datamängd kan den prestera lika bra som en djupinlärningsalgoritm, eller bättre.

Klassificeraren är svår att träna eftersom den exponerar ett stort antal parametrar. Du kan naturligtvis använda GridSearchCV för att välja dem åt dig.

Ett bättre alternativ här är RandomizedSearchCV. GridSearchCV blir långsamt när rutnätet är stort, eftersom sökutrymmet växer med varje parameter som läggs till. RandomizedSearchCV samplar istället värdena för varje hyperparameter slumpmässigt vid varje iteration, så 1 000 iterationer utvärderar 1 000 kombinationer. Det fungerar annars ungefär som GridSearchCV.

Du måste importera xgboost. Om biblioteket inte är installerat, kör pip3 install xgboost, eller installera det inifrån en [server/ ... Jupyter anteckningsbok med:

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

Importera sedan klassificeraren och de två sökhjälpfunktionerna:

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

Nästa steg i denna Scikit Python handledningen går ut på att ange de parametrar som ska finjusteras. Den officiella XGBoost-dokumentationen listar dem alla. För detta ändamål Python I Sklearn-handledningen väljer du bara två hyperparametrar med två värden vardera, eftersom XGBoost tar lång tid att träna och varje extra rutnätspunkt ökar väntetiden.

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

Sedan konstruerar du en ny pipeline med XGBoost-klassificeraren och 600 estimatorer. n_estimators är i sig självt justerbart, och ett högt värde kan leda till överanpassning. Du kan prova andra värden, men var medveten om att det kan ta timmar. Alla andra parametrar behåller sin standardvärde.

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

Du kan förbättra korsvalideringen med korsvalideraren Stratified K-Folds. Endast tre veck används här för att snabba upp beräkningen, vilket i sin tur påverkar kvaliteten negativt; öka detta till 5 eller 10 på din egen maskin för bättre resultat. Modellen tränas över fyra iterationer.

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)

Den slumpmässiga sökningen är klar, så du kan träna modellen.

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

Som du kan se får XGBoost bättre resultat än den tidigare logistiska regressionen.

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)

Skapa DNN med MLPClassifier i scikit-learn

Slutligen kan du träna ett neuralt nätverk med scikit-learn. Metoden är densamma som för alla andra klassificerare, och estimatorn är MLPClassifier.

from sklearn.neural_network import MLPClassifier

Nätverket nedan definieras med:

Adam lösare
ReLU aktiveringsfunktion
Alfa = 0.0001
Batchstorlek på 150
Två dolda lager med 200 respektive 100 neuroner

model_dnn = make_pipeline(
    preprocess,
    MLPClassifier(solver='adam',
                  alpha=0.0001,
                  activation='relu',
                    batch_size=150,
                    hidden_layer_sizes=(200, 100),
                    random_state=1))

Du kan ändra antalet lager för att förbättra modellen.

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

DNN-regressionspoäng: 0.821253

LIME: Lita på din modell

Nu när du har en bra modell behöver du ett sätt att lita på den. Maskininlärningsalgoritmer, särskilt slumpmässiga skogar och neurala nätverk, är kända som black-box-modeller: de fungerar, men ingen kan förstå varför.

Tre forskare byggde ett verktyg som visar hur datorn når en förutsägelse. Deras artikel är "Varför skulle jag lita på dig?", och algoritmen de publicerade kallas Local Interpretable Model-Agnostic Explanations (LIME).

Ta ett exempel. Ibland vet man inte om en maskininlärningsprediktion kan litas på. En läkare kan inte acceptera en diagnos bara för att en dator har producerat den, och man måste veta om en modell är tillförlitlig innan man tar den i produktion.

Tänk dig att kunna se varför en klassificerare gjorde en förutsägelse, även för modeller så komplicerade som neurala nätverk, slumpmässiga skogar eller SVM:er med en godtycklig kärna. Det blir mycket lättare att lita på en förutsägelse när orsakerna bakom den är synliga, och lika lättare att avgöra när en modell inte ska vara tillförlitlig. LIME berättar vilka funktioner som styrde klassificerarens beslut.

Förberedelse av data

Det finns ett par saker du behöver ändra för att köra LIME med PythonInstallera först lime i terminalen med pip install lime.

Lime använder ett LimeTabularExplainer-objekt för att approximera modellen lokalt. Detta objekt kräver:

en datauppsättning i numpy format
Namnet på funktionerna: feature_names
Namnet på klasserna: klassnamn
Indexet för kolumnen med kategoriska funktioner: categorical_features
Namnet på gruppen för varje kategorisk funktion: kategoriska_namn

Skapa NumPy-tågsetet

Du kan kopiera och konvertera df_train från pandas till NumPy mycket enkelt.

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

Få klassnamnet

Etiketten är tillgänglig via unique(). Du bör se:

'<=50K'
'>50K'

# Get the class name
class_names = df_lime.label.unique()
class_names

array(['<=50K', '>50K'], dtype=object)

Indexera kolumnerna för kategoriska funktioner

Använd metoden du lärde dig tidigare för att få namnet på varje grupp. Du kodar etiketten med LabelEncoder och upprepar operationen på varje kategoriskt objekt.

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

Nu när datamängden är klar kan du bygga de olika datamängderna som visas i Scikit-inlärningsexemplen nedan. Data transformeras utanför pipelinen här för att undvika fel med LIME: träningsmängden som skickas till LimeTabularExplainer måste vara en NumPy-array utan strängar, och metoden ovan har redan producerat en.

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)

Du kan skapa pipelinen med de optimala parametrar som XGBoost hittat.

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

Du får en varning. Den förklarar att du inte behöver skapa en etikettkodare före pipelinen. Om du inte använder LIME fungerar metoden från den första delen av den här handledningen för maskininlärning med Scikit-learn. Annars behåller du den här metoden: skapa först en kodad datamängd och använd sedan en-hot-kodaren inuti pipelinen.

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)

Innan du använder LIME, skapa en NumPy-array som innehåller funktionerna i de felaktigt klassificerade raderna. Du kan använda den listan senare för att få en uppfattning om vad som missledde klassificeraren.

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)

Sedan skapar du en lambdafunktion som hämtar prediktionen från modellen för nya data. Du kommer att behöva den inom kort.

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

Du konverterar pandas dataframe till en 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)

Välj nu ett slumpmässigt hushåll från testmängden och se både förutsägelsen och hur datorn kom fram till den.

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

Du kan använda explainern med explain_instance för att undersöka resonemanget bakom modellen. Diagrammet som den renderar visas nedan.

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

Klassificeraren förutspådde detta hushåll korrekt: inkomsten är faktiskt över 50 000 kr.

Det första man bör notera är att klassificeraren inte är särskilt säker på sig själv. Den förutspår en inkomst över 50 000 med en sannolikhet på 64 %, och att 64 % drivs av kapitalvinst och civilstånd. Den blå färgen bidrar negativt till den positiva klassen och den orangea linjen positivt.

Klassificeraren är tveksam eftersom hushållets kapitalvinst är noll, medan kapitalvinst vanligtvis är en bra indikator på förmögenhet. Hushållet arbetar också färre än 40 timmar per vecka. Ålder, yrke och kön bidrar alla positivt.

Om civilståndet var singel skulle klassificeraren ha förutspått en inkomst under 50 000 kr (0.64 – 0.18 = 0.46).

Försök nu med ett annat hushåll, ett som klassificerades felaktigt. Förklaringstabellen för det följer koden.

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)

Klassificeraren förutspådde en inkomst under 50 000 kr, vilket är fel. Detta hushåll är ovanligt: det har varken en kapitalvinst eller en kapitalförlust, personen är skild, nära 60 år gammal och utbildad, det vill säga utbildningsnummer > 12. Klassificeraren följt det övergripande mönstret och placerade hushållet under 50 000 kr.

Lek med LIME själv så kommer du att märka många raka misstag från klassificeraren. GitHub-arkivet som tillhör biblioteksförfattaren innehåller extra dokumentation för bild- och textklassificering.

Scikit-learn-kommandoreferens

Nedan följer en lista med användbara kommandon som gäller för scikit-learn version 0.20 och senare.

uppgift	Funktion eller klass
Skapa tåg-/testdatasetet	train_test_split
Bygg en pipeline
Markera kolumnerna och tillämpa transformationen	make_column_transformator
Typ av transformation
Standardisera	Standardskalare
Min-max-skalning	MinMaxScaler
Normalisera	normaliserare
Imputera saknade värden	SimpleImputer
Konvertera kategorisk	OneHotEncoder
Anpassa och transformera data	fit_transform
Gör rörledningen	make_pipeline
Grundmodell
Logistisk återgång	Logistisk tillbakagång
XGBoost	XGBClassifier
Neuralt nät	MLPClassifierare
Rutnätssökning	GridSearchCV
Randomiserad sökning	RandomizedSearchCV

Vanliga frågor

Installera den nuvarande stabila utgåvan med pip install -U scikit-learn eller conda install -c conda-forge scikit-learn. Utvecklarversionen som användes i stegen ovan var endast nödvändig 2018, när make_column_transformer inte släpptes; den levereras nu i alla stabila versioner.

fit lär sig parametrar som kolumnmedelvärde och standardavvikelse. transform tillämpar dem på data. fit_transform gör båda i ett anrop, och den ska bara vidröra träningsmängden, aldrig den uteslutna testmängden.

Genom att montera en skalare eller kodare på den fullständiga datamängden kan teststatistik nå modellen. En pipeline anpassar varje transformator inuti varje korsvalideringsvikning, så att de utelämnade raderna förblir osynliga tills de poängsätts.

Den autokompletterar välbekanta former: ColumnTransformer-block, parameterrutnät och de dubbla understrecknamnen som GridSearchCV förväntar sig. RevVisa allt versionskänsligt, eftersom förslag ofta reproducerar äldre argumentnamn som sparse istället för sparse_output.

Inte helt. Automatiserade sökverktyg utforskar ett rutnät snabbare och renar svaga kandidater, men du väljer fortfarande sökutrymme, poängsättning och korsvalideringsschema. Dessa beslut är viktigare än själva sökalgoritmen.

Nej. Träningen körs på processorn och parallelliseras över kärnor via n_jobs. Ett experimentellt Array API-lager låter en begränsad uppsättning estimatorer acceptera GPU-arrayer, men TensorFlow och liknande ramverk förblir GPU-alternativet.

Ja. Anropa set_output(transform=”pandas”) på en transformer eller en hel pipeline och resultatet behåller sina kolumnnamn istället för att returnera en naken kod. numpy array, vilket gör ColumnTransformer-utdata mycket enklare att inspektera.

Skicka class_weight=”balanced” till de estimatorer som accepterar det, omprova med ett tillhörande bibliotek som imbalanced-learn, och poängsätt med precision, recall eller F1-måttet snarare än ren noggrannhet.

Scikit-Learn Tutorial: Hur man installerar & Scikit-Learn Exempel

Vad är Scikit-learn?

Hur man laddar ner och installerar Scikit-learn

Alternativ 1: AWS

Alternativ 2: Mac eller Windows använder Anaconda

Hur man installerar scikit-learn med Conda Environment

Steg 1) Aktivera tensorflow-miljön

Steg 2) Ta bort scikit-learn med hjälp av conda-kommandot

Steg 3) Installera utvecklarversionen

Scikit-Learn-exempel med maskininlärning

Steg 1) Importera data

Steg 2) Skapa tåget/testsetet

Steg 3) Bygg pipeline

Steg 4) Använda vår pipeline i en rutnätssökning

Korsvalidering

Rutnätssökning

XGBoost-modell med scikit-learn

Skapa DNN med MLPClassifier i scikit-learn

LIME: Lita på din modell

Förberedelse av data

Skapa NumPy-tågsetet

Få klassnamnet

Indexera kolumnerna för kategoriska funktioner

Scikit-learn-kommandoreferens

Vanliga frågor

Sammanfatta detta inlägg med:

Anmäl dig till nyhetsbrevet

Vad är Scikit-learn?

Hur man laddar ner och installerar Scikit-learn

Alternativ 1: AWS

Alternativ 2: Mac eller Windows använder Anaconda

Hur man installerar scikit-learn med Conda Environment

Steg 1) Aktivera tensorflow-miljön

Steg 2) Ta bort scikit-learn med hjälp av conda-kommandot

Steg 3) Installera utvecklarversionen

RELATERADE ARTIKLAR

Scikit-Learn-exempel med maskininlärning

Steg 1) Importera data

Steg 2) Skapa tåget/testsetet

Steg 3) Bygg pipeline

Steg 4) Använda vår pipeline i en rutnätssökning

Korsvalidering

Rutnätssökning

XGBoost-modell med scikit-learn

Skapa DNN med MLPClassifier i scikit-learn

LIME: Lita på din modell

Förberedelse av data

Skapa NumPy-tågsetet

Få klassnamnet

Indexera kolumnerna för kategoriska funktioner

Scikit-learn-kommandoreferens

Vanliga frågor

Sammanfatta detta inlägg med:

Anmäl dig till nyhetsbrevet