[PYTHON] [Übersetzung] scikit-learn 0.18 Tutorial Statistisches Lernen Tutorial für die wissenschaftliche Datenverarbeitung Modellauswahl: Auswahl des Schätzers und seiner Parameter

Google-Übersetzung von http://scikit-learn.org/stable/tutorial/statistical_inference/model_selection.html scikit-learn 0.18 Tutorial Inhaltsverzeichnis Tutorial-Tabelle zum statistischen Lernen für die wissenschaftliche Datenverarbeitung Vorherige Tutorial-Seite

Modellauswahl: Auswahl des Schätzers und seiner Parameter

Punktzahl, kreuzvalidierte Punktzahl

Wie wir gesehen haben, legen alle Schätzer eine "Score" -Methode offen, mit der die Anpassungs- (oder Vorhersage-) Qualität neuer Daten bestimmt werden kann. Größer ist besser.

>>> from sklearn import datasets, svm
>>> digits = datasets.load_digits()
>>> X_digits = digits.data
>>> y_digits = digits.target
>>> svc = svm.SVC(C=1, kernel='linear')
>>> svc.fit(X_digits[:-100], y_digits[:-100]).score(X_digits[-100:], y_digits[-100:])
0.97999999999999998

Um ein besseres Maß für die Vorhersagegenauigkeit zu erhalten (das als Proxy für die Modellanpassung verwendet werden kann), können wir die Daten kontinuierlich in die Falten aufteilen, die wir für Training und Test verwenden.

>>> import numpy as np
>>> X_folds = np.array_split(X_digits, 3)
>>> y_folds = np.array_split(y_digits, 3)
>>> scores = list()
>>> for k in range(3):
...     # We use 'list' to copy, in order to 'pop' later on
...     X_train = list(X_folds)
...     X_test  = X_train.pop(k)
...     X_train = np.concatenate(X_train)
...     y_train = list(y_folds)
...     y_test  = y_train.pop(k)
...     y_train = np.concatenate(y_train)
...     scores.append(svc.fit(X_train, y_train).score(X_test, y_test))
>>> print(scores)
[0.93489148580968284, 0.95659432387312182, 0.93989983305509184]

Dies wird als Kreuzvalidierung von [KFold] bezeichnet (http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.KFold.html#sklearn.model_selection.KFold).

Kreuzvalidierungsgenerator

scikit-learn verfügt über eine Sammlung von Klassen, mit denen eine Liste von Trainings- / Testindizes für gängige Kreuzvalidierungsstrategien erstellt werden kann. Sie akzeptieren geteilte Eingabedatensätze und legen eine geteilte Methode offen, die für jede Iteration der ausgewählten Kreuzvalidierungsstrategie einen Zug- / Testsatzindex generiert. Dieses Beispiel zeigt ein Beispiel für die Verwendung der Split-Methode.

>>> from sklearn.model_selection import KFold, cross_val_score
>>> X = ["a", "a", "b", "c", "c", "c"]
>>> k_fold = KFold(n_splits=3)
>>> for train_indices, test_indices in k_fold.split(X):
...      print('Train: %s | test: %s' % (train_indices, test_indices))
Train: [2 3 4 5] | test: [0 1]
Train: [0 1 4 5] | test: [2 3]
Train: [0 1 2 3] | test: [4 5]

Eine Kreuzvalidierung ist einfach durchzuführen.

>>> kfold = KFold(n_splits=3)
>>> [svc.fit(X_digits[train], y_digits[train]).score(X_digits[test], y_digits[test])
...          for train, test in k_fold.split(X_digits)]
[0.93489148580968284, 0.95659432387312182, 0.93989983305509184]

Die Kreuzvalidierungsbewertung kann direkt mit dem Helfer cross_val_score berechnet werden. Bei einem Kreuzvalidierungsobjekt und einer Schätzung für den Eingabedatensatz unterteilt cross_val_score die Daten iterativ in einen Trainingssatz und einen Testsatz, trainiert die Schätzung unter Verwendung des Trainingssatzes und basiert auf dem Testsatz für jede Iteration der Kreuzvalidierungsaggregation. Um die Punktzahl zu berechnen. Standardmäßig wird die "Score" -Methode des Schätzers verwendet, um einzelne Scores zu berechnen. Weitere Informationen zu den verfügbaren Bewertungsmethoden finden Sie unter Metrikmodule (http://scikit-learn.org/stable/modules/metrics.html#metrics).

>>> cross_val_score(svc, X_digits, y_digits, cv=k_fold, n_jobs=-1)
array([ 0.93489149,  0.95659432,  0.93989983])

n_jobs = -1 bedeutet, dass Berechnungen auf allen CPUs im Computer ausgelöst werden. Alternativ können Sie das Argument "Scoring" angeben, um eine andere Bewertungsmethode anzugeben.

>>> cross_val_score(svc, X_digits, y_digits, cv=k_fold,
...                 scoring='precision_macro')
array([ 0.93969761,  0.95911415,  0.94041254])

Generator für gegenseitige Überprüfung

• KFold (n_splits, shuffle, random_state)
• K teilen, mit K-1 trainieren und mit dem Rest testen.
• StratifiedKFold (n_iter, test_size, train_size, random_state)
• Gleich wie K-Fold, behält jedoch die Klassenverteilung innerhalb der Fold bei.
• GroupKFold (n_splits, shuffle, random_state)
• Stellen Sie sicher, dass sich nicht dieselbe Gruppe sowohl im Test- als auch im Trainingssatz befindet.
• ShuffleSplit (n_iter, test_size, train_size, random_state)
• Generieren Sie Trainings- / Testexponenten basierend auf zufälliger Substitution.
• StratifiedShuffleSplit
• Gleich wie Shuffle Split, behält jedoch die Verteilung der Klassen innerhalb jeder Iteration bei.
• GroupShuffleSplit
• Stellen Sie sicher, dass sich nicht dieselbe Gruppe sowohl im Test- als auch im Trainingssatz befindet.
• LeaveOneGroupOut ()
• Nehmen Sie ein Gruppenarray, um die beobachteten Werte zu gruppieren.
• LeavePGroupsOut (p)
• Lassen Sie die P-Gruppe wie sie ist.
• LeaveOneOut () -Lassen Sie eine Beobachtung.
• LeavePOut(p)
• Lassen Sie den beobachteten Wert von P unverändert.
• PredefinedSplit
• Generieren Sie Schulungen / Tests basierend auf vordefinierten Abteilungen.

Übung

Zeichnen Sie den Kreuzvalidierungswert der SVC-Schätzung unter Verwendung des linearen Kernels als Funktion des Parameters "C" im Ziffern-Datensatz (unter Verwendung eines logarithmischen Rasters von Punkten von 1 bis 10).

import numpy as np
from sklearn.model_selection import cross_val_score
from sklearn import datasets, svm

digits = datasets.load_digits()
X = digits.data
y = digits.target

svc = svm.SVC(kernel='linear')
C_s = np.logspace(-10, 0, 10)

[Antwort hier: Kreuzvalidierung mit Digits Dataset Exercise](http://scikit-learn.org/stable/auto_examples/exercises/plot_cv_digits.html#sphx-glr-auto-examples-exercises-plot-cv-digits- py)

Rastersuche und kreuzvalidierter Schätzer

Rastersuche

scikit-learn stellt ein Objekt bereit, bei dem die angegebenen Daten die Bewertung während der Anpassung des Schätzers an das Parameterraster berechnen und den Parameter auswählen, der die Kreuzvalidierungsbewertung maximiert. Dieses Objekt nimmt während der Erstellung Schätzungen vor und macht die API des Schätzers verfügbar.

>>> from sklearn.model_selection import GridSearchCV, cross_val_score
>>> Cs = np.logspace(-6, -1, 10)
>>> clf = GridSearchCV(estimator=svc, param_grid=dict(C=Cs),
...                    n_jobs=-1)
>>> clf.fit(X_digits[:1000], y_digits[:1000])        
GridSearchCV(cv=None,...
>>> clf.best_score_                                  
0.925...
>>> clf.best_estimator_.C                            
0.0077...

>>> #Die Vorhersageleistung des Testsatzes ist nicht so gut wie die des Trainingssatzes
>>> clf.score(X_digits[1000:], y_digits[1000:])      
0.943...

Standardmäßig verwendet GridSearchCV (http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV) die dreifache gegenseitige Validierung. Verwenden Sie jedoch anstelle der Regressionsanalyse das geschichtete Tripel, wenn festgestellt wird, dass eine Klassifizierung bestanden wurde.

Verschachtelte gegenseitige Validierung

>>> cross_val_score(clf, X_digits, y_digits)
...                                               
array([ 0.938...,  0.963...,  0.944...])

Zwei Kreuzvalidierungsschleifen werden parallel ausgeführt, eine mit dem GridSearchCV-Schätzer zum Festlegen des Gammas und eine mit dem cross_val_score zum Messen der Vorhersageleistung des Evaluators. Die erhaltene Punktzahl ist eine unvoreingenommene Schätzung der vorhergesagten Punktzahl für die neuen Daten.

Warnung

Objekte können nicht in parallelen Berechnungen verschachtelt werden (n_jobs ist anders als 1).

Kreuzvalidierter Schätzer

Die gegenseitige Validierung zum Einstellen von Parametern kann für jeden Algorithmus effizient durchgeführt werden. Dies liegt daran, dass scikit-learn für bestimmte Schätzer die Parameter automatisch durch Kreuzvalidierung festlegt "Kreuzvalidierung: Bewertung der Schätzerleistung. /cross_validation.html#cross-validation) ”Veröffentlichen Sie den Schätzer.

>>> from sklearn import linear_model, datasets
>>> lasso = linear_model.LassoCV()
>>> diabetes = datasets.load_diabetes()
>>> X_diabetes = diabetes.data
>>> y_diabetes = diabetes.target
>>> lasso.fit(X_diabetes, y_diabetes)
LassoCV(alphas=None, copy_X=True, cv=None, eps=0.001, fit_intercept=True,
    max_iter=1000, n_alphas=100, n_jobs=1, normalize=False, positive=False,
    precompute='auto', random_state=None, selection='cyclic', tol=0.0001,
    verbose=False)
>>> # The estimator chose automatically its lambda:
>>> lasso.alpha_ 
0.01229...

Diese Schätzer werden so aufgerufen, als hätten sie "CV" zu ihrem Namen hinzugefügt.

Übung

Finden Sie im Diabetes-Datensatz den optimalen Regularisierungsparameter "alpha".

** Bonus: ** Wie glaubwürdig können Sie der Alpha-Wahl vertrauen?

from sklearn import datasets
from sklearn.linear_model import LassoCV
from sklearn.linear_model import Lasso
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score

diabetes = datasets.load_diabetes()

[Antwort hier: Gegenseitige Authentifizierung von Diabetiker-Datensatzübungen](http://scikit-learn.org/stable/auto_examples/exercises/plot_cv_diabetes.html#sphx-glr-auto-examples-exercises-plot-cv-diabetes -py)

Nächste Seite

© 2010 - 2016, Entwickler von Scikit-Learn (BSD-Lizenz)