google übersetzte http://scikit-learn.org/0.18/modules/cross_validation.html [scikit-learn 0.18 Benutzerhandbuch 3. Modellauswahl und -bewertung](http://qiita.com/nazoking@github/items/267f2371757516f8c168#3-%E3%83%A2%E3%83%87%E3%83] Von% AB% E3% 81% AE% E9% 81% B8% E6% 8A% 9E% E3% 81% A8% E8% A9% 95% E4% BE% A1)
Das Erlernen der Parameter der Vorhersagefunktion und das Testen mit denselben Daten ist ein methodischer Fehler. Die Etiketten bekannter Proben werden perfekt zurückgegeben, für unbekannte Daten können jedoch keine nützlichen Vorhersagen getroffen werden. Diese Situation wird als ** Überanpassung ** bezeichnet. Um dies zu vermeiden, ist es üblich, (überwachte) Experimente zum maschinellen Lernen durchzuführen, bei denen einige der verfügbaren Daten als ** Testsätze ** X_test, y_test gespeichert werden. Bitte beachten Sie, dass das Wort "Experiment" nicht nur akademische Verwendung bedeutet. Maschinelles Lernen beginnt normalerweise experimentell, auch in kommerziellen Umgebungen.
scikit-learn verwendet die Hilfsfunktion train_test_split, um das Set zu trainieren und zu testen Sie können die zufällige Division von schnell berechnen. Laden Sie den Iris-Datensatz, um eine lineare SVM zu trainieren:
>>> import numpy as np
>>> from sklearn.model_selection import train_test_split
>>> from sklearn import datasets
>>> from sklearn import svm
>>> iris = datasets.load_iris()
>>> iris.data.shape, iris.target.shape
((150, 4), (150,))
Um den Klassifikator zu testen (auszuwerten), können Sie den Trainingssatz testen, während 40% der Daten erhalten bleiben.
>>>
>>> X_train, X_test, y_train, y_test = train_test_split(
... iris.data, iris.target, test_size=0.4, random_state=0)
>>> X_train.shape, y_train.shape
((90, 4), (90,))
>>> X_test.shape, y_test.shape
((60, 4), (60,))
>>> clf = svm.SVC(kernel='linear', C=1).fit(X_train, y_train)
>>> clf.score(X_test, y_test)
0.96...
Wenn Sie verschiedene Einstellungen („Hyperparameter“) anpassen, z. B. den Wert von C, der manuell in der SVM eingestellt werden muss, passen Sie den Testsatz an, um die Parameter zu optimieren und die Schätzung zu optimieren. Ich werde. Auf diese Weise "leckt" das Wissen über den Testsatz in das Modell, wodurch die Vorhersageleistung in Bezug auf Bewertungsmetriken weniger vielseitig ist. Um dieses Problem zu lösen, kann ein weiterer Teil des Datensatzes der sogenannte "Validierungssatz" sein. Sie können auf dem Trainingssatz trainieren, dann auf dem Validierungssatz bewerten und eine abschließende Bewertung auf dem Testsatz vornehmen, wenn das Experiment erfolgreich zu sein scheint.
Wenn jedoch die Aufteilung der verfügbaren Daten in drei Sätze die Anzahl der für das Training des Modells verfügbaren Stichproben erheblich verringert, können die Ergebnisse von einer bestimmten zufälligen Auswahl von (Trainings-, Validierungs-) Paaren abhängen. Es gibt Sex.
Die Lösung für dieses Problem ist ein Verfahren namens Cross-Validation, Cross-Validation (https://en.wikipedia.org/wiki/Cross-validation_(statistics)) (kurz CV). Der Testsatz muss noch für die endgültige Bewertung reserviert werden, aber der Validierungssatz wird beim Ausführen des Lebenslaufs nicht mehr benötigt. In einem grundlegenden Ansatz, der als k-facher Lebenslauf bezeichnet wird, wird der Trainingssatz in k kleine Sätze unterteilt (andere Ansätze werden unten beschrieben, folgen jedoch im Allgemeinen denselben Prinzipien). Für jede der k Abteilungen
Die vom k-fachen Kreuztest angegebene Leistungsmetrik ist der Durchschnitt der in der Schleife berechneten Werte. Obwohl dieser Ansatz rechenintensiv ist, verschwendet er nicht zu viele Daten (wie beim Fixieren eines beliebigen Testsatzes) und bietet große Vorteile wie die Rückinferenz mit einer sehr kleinen Anzahl von Stichproben.
Die Kreuzvalidierung lässt sich am einfachsten mit dem Schätzer und dem Datensatz cross_val_score verwenden. ) Um eine Hilfsfunktion aufzurufen. Das folgende Beispiel zeigt, wie die Genauigkeit einer linearen SVM in einem Iris-Datensatz geschätzt wird, indem die Daten aufgeteilt, das Modell angepasst und die Punktzahl fünfmal hintereinander berechnet werden (jeweils mit unterschiedlichen Teilungen).
>>> from sklearn.model_selection import cross_val_score
>>> clf = svm.SVC(kernel='linear', C=1)
>>> scores = cross_val_score(clf, iris.data, iris.target, cv=5)
>>> scores
array([ 0.96..., 1. ..., 0.96..., 0.96..., 1. ])
Daher sind die durchschnittliche Punktzahl und das 95% -Konfidenzintervall der Punktzahl
>>>
>>> print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))
Accuracy: 0.98 (+/- 0.03)
Standardmäßig ist die für jede CV-Iteration berechnete Punktzahl die geschätzte Punktemethode. Sie können dies mithilfe der Bewertungsparameter ändern:
>>>
>>> from sklearn import metrics
>>> scores = cross_val_score(
... clf, iris.data, iris.target, cv=5, scoring='f1_macro')
>>> scores
array([ 0.96..., 1. ..., 0.96..., 0.96..., 1. ])
Weitere Informationen finden Sie unter Bewertungsparameter: Definieren von Modellbewertungsregeln (http://qiita.com/nazoking@github/items/958426da6448d74279c7). Für den Iris-Datensatz sind die Stichproben über die Zielklasse verteilt, sodass Genauigkeit und F1-Werte ungefähr gleich sind. Wenn das cv-Argument eine Ganzzahl ist, lautet cross_val_score standardmäßig [KFold](http: //scikit-learn.org/0.18/modules/generated/sklearn.model_selection.KFold.html#sklearn.model_selection.KFold) oder StratifiedKFold Verwenden Sie .model_selection.StratifiedKFold.html # sklearn.model_selection.StratifiedKFold). Letzteres wird verwendet, wenn der Schätzer von [ClassifierMixin] abgeleitet ist (http://scikit-learn.org/0.18/modules/generated/sklearn.base.ClassifierMixin.html#sklearn.base.ClassifierMixin). Sie können auch andere Kreuzvalidierungsstrategien verwenden, indem Sie einen Iterator zur Kreuzvalidierung übergeben.
>>> from sklearn.model_selection import ShuffleSplit
>>> n_samples = iris.data.shape[0]
>>> cv = ShuffleSplit(n_splits=3, test_size=0.3, random_state=0)
>>> cross_val_score(clf, iris.data, iris.target, cv=cv)
...
array([ 0.97..., 0.97..., 1. ])
** Datenkonvertierung durch ausstehende Daten **
Ebenso wichtig ist es, die Erwartungen an Daten zu testen, die für Schulungen, Vorverarbeitung (Standardisierung, Funktionsauswahl usw.) und ähnliche [Datentransformation] reserviert sind (http://scikit-learn.org/0.18/). data_transforms.html # data-transforms) muss ebenfalls aus dem Trainingssatz gelernt und zur Vorhersage auf die ausstehenden Daten angewendet werden:
>>>
>>> from sklearn import preprocessing
>>> X_train, X_test, y_train, y_test = train_test_split(
... iris.data, iris.target, test_size=0.4, random_state=0)
>>> scaler = preprocessing.StandardScaler().fit(X_train)
>>> X_train_transformed = scaler.transform(X_train)
>>> clf = svm.SVC(C=1).fit(X_train_transformed, y_train)
>>> X_test_transformed = scaler.transform(X_test)
>>> clf.score(X_test_transformed, y_test)
0.9333...
Mit Pipeline können auf einfache Weise synthetische Schätzer für die Kreuzvalidierung erstellt werden. verfügbar.
>>>
>>> from sklearn.pipeline import make_pipeline
>>> clf = make_pipeline(preprocessing.StandardScaler(), svm.SVC(C=1))
>>> cross_val_score(clf, iris.data, iris.target, cv=cv)
...
array([ 0.97..., 0.93..., 0.95...])
Siehe Pipeline- und Feature-Union: Kombinieren von Schätzern (http://scikit-learn.org/0.18/modules/pipeline.html#combining-estimators).
Die Funktion cross_val_predict lautet cross_val_score. Es hat dieselbe Schnittstelle wie /0.18/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score), gibt jedoch das vorhergesagte Ergebnis selbst zurück. Es können nur Cross-Test-Strategien verwendet werden, bei denen alle Elemente nur einmal einem Testsatz zugewiesen werden (andernfalls tritt eine Ausnahme auf). Der Klassifikator kann auch unter Verwendung dieser Vorhersagen bewertet werden.
>>>
>>> from sklearn.model_selection import cross_val_predict
>>> predicted = cross_val_predict(clf, iris.data, iris.target, cv=10)
>>> metrics.accuracy_score(iris.target, predicted)
0.966...
Das Ergebnis dieser Berechnung ist [cross_val_score](http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score], da die Elemente auf unterschiedliche Weise gruppiert sind. Bitte beachten Sie, dass die mit) erzielten Ergebnisse geringfügig abweichen können. Die verfügbaren Kreuzvalidierungsiteratoren werden im nächsten Abschnitt vorgestellt.
--Beispiel
In den folgenden Abschnitten werden Dienstprogramme gezeigt, die Indizes für die Partitionierung von Datasets gemäß verschiedenen Kreuzvalidierungsstrategien generieren.
Unter der Annahme, dass einige Daten unabhängig, identisch verteilt (iid) sind, wird angenommen, dass alle Stichproben aus demselben Generierungsprozess stammen und dass der Generierungsprozess nicht über den Speicher zuvor generierter Stichproben verfügt. .. In solchen Fällen können die folgenden variablenübergreifenden Daten verwendet werden.
Hinweis
i.i.d.-Daten sind eine verbreitete Annahme in der Theorie des maschinellen Lernens und gelten in der Praxis nur selten. Es ist sicherer, die Kreuzvalidierungsmethode <time_series_cv> für die Zeitreihenerkennung zu verwenden, wenn Sie wissen, dass die Stichprobe mithilfe eines zeitabhängigen Prozesses generiert wurde. Die gruppenweise Kreuzvalidierung <group_cv> ist sicherer, wenn Sie wissen, dass der Generierungsprozess eine Gruppenstruktur aufweist (verschiedene Themen, Experimente, Messgeräte).
KFold legt alle Samples in die gleichen $ k $ -Stücke, die als Folds bezeichnet werden. Teilen Sie es in Gruppen von Größen ein (wenn möglich) (wenn $ k = n $, entspricht dies der Strategie „Auslassen“). Die Vorhersagefunktion wird unter Verwendung der $ k-1 $ -Falte trainiert, und die verbleibende Falte wird zum Testen verwendet. Beispiel für eine zweiteilige Kreuzungsvalidierung in einem Datensatz mit vier Stichproben:
>>> import numpy as np
>>> from sklearn.model_selection import KFold
>>> X = ["a", "b", "c", "d"]
>>> kf = KFold(n_splits=2)
>>> for train, test in kf.split(X):
... print("%s %s" % (train, test))
[2 3] [0 1]
[0 1] [2 3]
Jede Falte besteht aus zwei Arrays. Der erste ist für den Trainingssatz und der zweite ist für den Testsatz. Daher können Sie den Numpy-Index verwenden, um Trainings- / Testsätze zu erstellen.
>>> X = np.array([[0., 0.], [1., 1.], [-1., -1.], [2., 2.]])
>>> y = np.array([0, 1, 0, 1])
>>> X_train, X_test, y_train, y_test = X[train], X[test], y[train], y[test]
3.1.3.2. Leave One Out（LOO）
LeaveOneOut (oder LOO) ist eine einfache Kreuzvalidierung. Jeder Trainingssatz wird von allen bis auf eine Stichprobe erstellt, und der Testsatz ist eine Stichprobe ausgeschlossen. Daher gibt es für n Proben n verschiedene Trainingssätze und n verschiedene Testsätze. Durch dieses Kreuzvalidierungsverfahren wird nur eine Probe aus dem Trainingssatz entfernt, sodass keine Daten verschwendet werden.
>>> from sklearn.model_selection import LeaveOneOut
>>> X = [1, 2, 3, 4]
>>> loo = LeaveOneOut()
>>> for train, test in loo.split(X):
... print("%s %s" % (train, test))
[1 2 3] [0]
[0 2 3] [1]
[0 1 3] [2]
[0 1 2] [3]
Potenzielle Benutzer von LOO für die Modellauswahl sollten einige bekannte Warnungen berücksichtigen. Im Vergleich zur geteilten Kreuzvalidierung von $ k $ bilden $ n $ Samples $ n $ Modelle anstelle von $ k $ Modellen. Zusätzlich wird jedes auf $ n-1 $ Samples anstelle von $ (k-1) n / k $ trainiert. Bei beiden Methoden ist LOO rechenintensiver als die Überprüfung der k-fachen Schnittmenge, vorausgesetzt, $ k $ ist nicht zu groß und $ k <n $. Unter dem Gesichtspunkt der Genauigkeit führen LOOs häufig zu einer hohen Varianz als Schätzertestfehler. Intuitiv werden $ n-1 $ von $ n $ Samples verwendet, um jedes Modell zu erstellen, sodass die aus Falz erstellten Modelle praktisch miteinander und aus dem gesamten Trainingssatz identisch sind. Es ist das gleiche wie das gebaute Modell. Wenn die Trainingskurve jedoch in Bezug auf die betreffende Trainingsgröße steil ist, kann die Kreuzvalidierung von 5 oder 10 Abteilungen den Generalisierungsfehler überschätzen. In der Regel legen die meisten Autoren und empirischen Daten nahe, dass eine Kreuzvalidierung mit 5 oder 10 Segmenten gegenüber LOO bevorzugt wird.
--Referenz: - http://www.faqs.org/faqs/ai-faq/neural-nets/part3/section-12.html;
3.1.3.3. Leave P Out（LPO）
LeavePOut ist LeaveOneOut sehr ähnlich. Hiermit werden alle möglichen Trainings- / Testsätze erstellt, indem $ p $ Samples aus dem vollständigen Satz entfernt werden. Für n Beispiele wird ein $ {n \ select p} $ Training-Test-Paar generiert. Im Gegensatz zu LeaveOneOut und KFold werden Testsätze mit $ p> 1 $ dupliziert. Leave-2-Out-Beispiel für einen Datensatz mit 4 Beispielen:
>>> from sklearn.model_selection import LeavePOut
>>> X = np.ones(4)
>>> lpo = LeavePOut(p=2)
>>> for train, test in lpo.split(X):
... print("%s %s" % (train, test))
[2 3] [0 1]
[1 3] [0 2]
[1 2] [0 3]
[0 3] [1 2]
[0 2] [1 3]
[0 1] [2 3]
ShuffleSplit Iterator bietet eine benutzerdefinierte Anzahl unabhängiger Trainings- / Testdatensatzaufteilungen. Generieren. Mische die Probe zuerst und teile sie dann in Trainings- und Testsatzpaare auf.
Sie können die Reproduzierbarkeit der Ergebnisse steuern, indem Sie den Pseudozufallszahlengenerator random_state explizit festlegen.
Das Verwendungsbeispiel ist unten dargestellt.
>>> from sklearn.model_selection import ShuffleSplit
>>> X = np.arange(5)
>>> ss = ShuffleSplit(n_splits=3, test_size=0.25,
... random_state=0)
>>> for train_index, test_index in ss.split(X):
... print("%s %s" % (train_index, test_index))
...
[1 3 4] [2 0]
[1 4 3] [0 2]
[4 0 2] [1 3]
Aus diesem Grund ist ShuffleSplit eine großartige Alternative zur Kreuzvalidierung von KFold und bietet Ihnen mehr Kontrolle über die Anzahl der Proben und Iterationen für jedes Training / Test.
Einige Klassifizierungsprobleme können ein großes Ungleichgewicht in der Verteilung der Zielklassen aufweisen: Beispielsweise kann es mehrmals mehr negative als positive Stichproben geben. In solchen Fällen StratifiedKFold und [StratifiedShuffleSplit](http: // scikit- Die relative Klassenhäufigkeit bleibt in Vielfachen jedes Trainings und jeder Validierung nahezu erhalten, wobei geschichtete Stichproben verwendet werden, die in learn.org/0.18/modules/generated/sklearn.model_selection.StratifiedShuffleSplit.html#sklearn.model_selection.StratifiedShuffleSplit implementiert sind. Es wird empfohlen, dies zu tun.
StratifiedKFold ist eine Variation von k-split, die eine geschichtete Falte zurückgibt. Jeder Satz enthält ungefähr den gleichen Prozentsatz des gesamten Satzes und der Stichprobe für jede Zielklasse. Beispiel für eine geschichtete 3-Split-Kreuzvalidierung für einen 10-Stichproben-Datensatz aus 2 leicht unausgeglichenen Klassen:
>>> from sklearn.model_selection import StratifiedKFold
>>> X = np.ones(10)
>>> y = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
>>> skf = StratifiedKFold(n_splits=3)
>>> for train, test in skf.split(X, y):
... print("%s %s" % (train, test))
[2 3 6 7 8 9] [0 1 4 5]
[0 1 3 4 5 8 9] [2 6 7]
[0 1 2 4 5 6 7] [3 8 9]
Die i.i.d.-Annahme wird verletzt, wenn der grundlegende Erzeugungsprozess eine Gruppe abhängiger Proben erzeugt.
Die Gruppierung solcher Daten ist domänenspezifisch. Ein Beispiel ist, wenn medizinische Daten von mehreren Patienten gesammelt werden und von jedem Patienten mehrere Proben entnommen werden. Bei solchen Daten handelt es sich wahrscheinlich um einzelne Gruppen. In diesem Beispiel ist die Patienten-ID für jede Probe eine Gruppenkennung.
In diesem Fall möchte ich wissen, ob ein Modell, das in einer bestimmten Gruppe von Gruppen trainiert wurde, auch auf andere Gruppen angewendet werden kann. Um dies zu messen, müssen Sie sicherstellen, dass die Validierungsmuster aus einer Gruppe stammen, die niemals für Schulungen verwendet wird.
Sie können dies mit dem folgenden Kreuzvalidierungs-Splitter tun. Die Beispielgruppierungskennung wird durch den Parameter groups angegeben.
GroupKFold ist eine Variation der k-Aufteilung, die verhindert, dass dieselbe Gruppe sowohl im Testsatz als auch im Trainingssatz erscheint. ist. Wenn die Daten beispielsweise von verschiedenen Probanden mit mehreren Stichproben pro Proband stammen und das Modell flexibel genug ist, um aus sehr individuellen Merkmalen zu lernen, kann es nicht auf neue Probanden verallgemeinert werden. GroupKFold ermöglicht es, eine solche Überfüllung zu erkennen. Angenommen, Sie haben drei Gruppen, die jeweils einer Zahl von 1 bis 3 zugeordnet sind.
>>> from sklearn.model_selection import GroupKFold
>>> X = [0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 8.8, 9, 10]
>>> y = ["a", "b", "b", "b", "c", "c", "c", "d", "d", "d"]
>>> groups = [1, 1, 1, 2, 2, 2, 3, 3, 3, 3]
>>> gkf = GroupKFold(n_splits=3)
>>> for train, test in gkf.split(X, y, groups=groups):
... print("%s %s" % (train, test))
[0 1 2 3 4 5] [6 7 8 9]
[0 1 2 6 7 8 9] [3 4 5]
[3 4 5 6 7 8 9] [0 1 2]
Jedes Subjekt befindet sich in einer anderen Testphase und dasselbe Subjekt befindet sich nicht sowohl im Test als auch im Training. Beachten Sie, dass sie aufgrund von Datenungleichgewichten nicht exakt dieselbe Größe haben.
3.1.5.2. Leave One Group Out
LeaveOneGroupOut enthält Stichproben gemäß einer Reihe von Gruppennummern, die von Dritten bereitgestellt wurden. Es ist eine Kreuzvalidierungsmethode. Diese Gruppeninformationen können verwendet werden, um jede domänenspezifische vordefinierte Kreuzvalidierungspartition zu codieren. Daher besteht jeder Trainingssatz aus allen Stichproben mit Ausnahme derjenigen, die einer bestimmten Gruppe zugeordnet sind. Beispielsweise kann LeaveOneGroupOut für mehrere Experimente verwendet werden, um Kreuzvalidierungen basierend auf verschiedenen Experimenten zu erstellen. Erstellen Sie ein Trainingsset mit Beispielen aus allen bis auf ein Experiment.
>>> from sklearn.model_selection import LeaveOneGroupOut
>>> X = [1, 5, 10, 50, 60, 70, 80]
>>> y = [0, 1, 1, 2, 2, 2, 2]
>>> groups = [1, 1, 2, 2, 3, 3, 3]
>>> logo = LeaveOneGroupOut()
>>> for train, test in logo.split(X, y, groups=groups):
... print("%s %s" % (train, test))
[2 3 4 5 6] [0 1]
[0 1 4 5 6] [2 3]
[0 1 2 3] [4 5 6]
Eine andere häufige Anwendung ist die Verwendung von Zeitinformationen. Beispielsweise kann eine Gruppe das Jahr der Probenentnahme sein und für zeitbasierte Unterteilungen kreuzvalidiert werden.
3.1.5.3. Leave P Groups Out
LeavePGroupsOut ist LeaveOneGroupOut /modules/generated/sklearn.model_selection.LeaveOneGroupOut.html#sklearn.model_selection.LeaveOneGroupOut), entfernt jedoch die der $ P $ -Gruppe zugeordnete Stichprobe für jeden Trainings- / Testsatz. Beispiel für Leave-2-Group Out:
>>> from sklearn.model_selection import LeavePGroupsOut
>>> X = np.arange(6)
>>> y = [1, 1, 1, 2, 2, 2]
>>> groups = [1, 1, 2, 2, 3, 3]
>>> lpgo = LeavePGroupsOut(n_groups=2)
>>> for train, test in lpgo.split(X, y, groups=groups):
... print("%s %s" % (train, test))
[4 5] [0 1 2 3]
[2 3] [0 1 4 5]
[0 1] [2 3 4 5]
GroupShuffleSplit Der Iterator ist ShuffleSplit /0.18/modules/generated/sklearn.model_selection.ShuffleSplit.html#sklearn.model_selection.ShuffleSplit) und LeavePGroupsOut Dient als Kombination von sklearn.model_selection.LeavePGroupsOut) und erzeugt eine zufällige Folge von Partitionen mit einer Teilmenge der Gruppen, die für jeden Split gehalten werden. Das Verwendungsbeispiel ist unten dargestellt.
>>> from sklearn.model_selection import GroupShuffleSplit
>>> X = [0.1, 0.2, 2.2, 2.4, 2.3, 4.55, 5.8, 0.001]
>>> y = ["a", "b", "b", "b", "c", "c", "c", "a"]
>>> groups = [1, 1, 2, 2, 3, 3, 4, 4]
>>> gss = GroupShuffleSplit(n_splits=4, test_size=0.5, random_state=0)
>>> for train, test in gss.split(X, y, groups=groups):
... print("%s %s" % (train, test))
...
[0 1 2 3] [4 5 6 7]
[2 3 6 7] [0 1 4 5]
[2 3 4 5] [0 1 6 7]
[4 5 6 7] [0 1 2 3]
Diese Klasse ist nützlich, wenn Sie das Verhalten von LeavePGroupsOut benötigen, sie hat jedoch eine große Anzahl von Gruppen und es ist sehr teuer, alle möglichen Partitionen mit $ P $ -Gruppen zu generieren. In solchen Szenarien bietet GroupShuffleSplit eine Zufallsstichprobe (Ersatz) der von LeavePGroupsOut generierten Trainings- / Testaufteilungen.
Für einige Datensätze gibt es bereits vordefinierte Datentrainings- und Validierungsaufteilungen oder einige Kreuzvalidierungsaufteilungen. Sie können diese Falten mit PredefinedSplit verwenden. Verwenden Sie es beispielsweise bei der Suche nach Hyperparametern. Wenn Sie beispielsweise einen Validierungssatz verwenden, setzen Sie "test_fold" für alle Proben, die Teil des Validierungssatzes sind, auf 0 und für alle anderen Proben auf -1.
Zeitreihendaten sind durch Korrelationen zwischen zeitnahen Beobachtungen gekennzeichnet (Autokorrelation). Klassische Kreuzvalidierungstechniken wie KFold und ShuffleSplit setzen jedoch voraus, dass die Stichproben unabhängig und gleichmäßig verteilt sind, wodurch eine irrationale Korrelation zwischen Trainings- und Testinstanzen entsteht (Generalisierungsfehlerschätzung). Schlecht). Daher ist es sehr wichtig, ein Modell von Zeitreihendaten für "zukünftige" Beobachtungen auszuwerten, wie sie zum Trainieren des Modells verwendet werden. Um dies zu erreichen, wird von TimeSeries Split eine Lösung bereitgestellt (http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.TimeSeriesSplit.html#sklearn.model_selection.TimeSeriesSplit).
TimeSeriesSplit ist eine Variante von k-fold, die die ersten k-Folds als Spaltensatz und die $ k + 1 $ -ten Falten als Testsatz zurückgibt. Beachten Sie, dass im Gegensatz zu Standardmethoden zur Kreuzvalidierung aufeinanderfolgende Trainingssätze eine Obermenge dessen sind, was vor ihnen liegt. Außerdem werden alle überschüssigen Daten zur ersten Trainingspartition hinzugefügt, die immer zum Trainieren des Modells verwendet wird. Diese Klasse kann zur Kreuzvalidierung von Zeitreihendatenproben verwendet werden, die in regelmäßigen Zeitintervallen beobachtet werden. Beispiel für eine Kreuzvalidierung von 3-Split-Zeitreihen für einen Datensatz mit 6 Stichproben:
>>> from sklearn.model_selection import TimeSeriesSplit
>>> X = np.array([[1, 2], [3, 4], [1, 2], [3, 4], [1, 2], [3, 4]])
>>> y = np.array([1, 2, 3, 4, 5, 6])
>>> tscv = TimeSeriesSplit(n_splits=3)
>>> print(tscv)
TimeSeriesSplit(n_splits=3)
>>> for train, test in tscv.split(X):
... print("%s %s" % (train, test))
[0 1 2] [3]
[0 1 2 3] [4]
[0 1 2 3 4] [5]
Wenn die Reihenfolge der Daten nicht willkürlich ist (z. B. wenn Stichproben mit derselben Klassenbezeichnung zusammenhängend sind), muss sie möglicherweise zuerst gemischt werden, um aussagekräftige Kreuzvalidierungsergebnisse zu erhalten. Das Gegenteil kann jedoch der Fall sein, wenn die Proben nicht unabhängig und gleichmäßig verteilt sind. Wenn die Stichproben beispielsweise Nachrichtenartikeln entsprechen und nach Veröffentlichungszeit sortiert sind, kann das Mischen der Daten zu überpassenden Modellen und überhöhten Validierungswerten führen. Das liegt daran, dass es an künstlich ähnlichen (zeitnahen) Proben getestet wurde. Einige Iteratoren für die gegenseitige Validierung wie KFold haben vor dem Teilen einen Datenindex. Es gibt integrierte Optionen zum Mischen.
cv = some_integer (http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score), Rastersuche, (geschichtet) T) Kreuzvalidierung der K-Division usw. Beachten Sie, dass train_test_split immer noch eine zufällige Aufteilung zurückgibt.random_state ist None. Dies bedeutet, dass der Shuffle jedes Mal anders ist, wenn "KFold (..., shuffle = True)" verwendet wird. "GridSearchCV" verwendet jedoch für jeden Parametersatz, der in einem einzigen Aufruf der "fit" -Methode validiert wurde, dieselbe Zufallswiedergabe.
--Verwenden Sie einen festen Wert für random_state, um das Ergebnis wiederholbar zu machen (auf derselben Plattform).Der Kreuzvalidierungsiterator kann auch verwendet werden, um mithilfe der Rastersuche direkt die optimalen Hyperparameter für das Modell auszuwählen. Dies ist das Thema im nächsten Abschnitt. Optimieren der Hyperparameter des Schätzers.
[scikit-learn 0.18 Benutzerhandbuch 3. Modellauswahl und -bewertung](http://qiita.com/nazoking@github/items/267f2371757516f8c168#3-%E3%83%A2%E3%83%87%E3%83] % AB% E3% 81% AE% E9% 81% B8% E6% 8A% 9E% E3% 81% A8% E8% A9% 95% E4% BE% A1)
© 2010 - 2016, Entwickler von Scikit-Learn (BSD-Lizenz).
Recommended Posts