[Français] scikit-learn 0.18 Guide de l'utilisateur 3.1. Validation croisée: évaluer les performances de l'estimateur

google traduit http://scikit-learn.org/0.18/modules/cross_validation.html [scikit-learn 0.18 Guide de l'utilisateur 3. Sélection et évaluation du modèle](http://qiita.com/nazoking@github/items/267f2371757516f8c168#3-%E3%83%A2%E3%83%87%E3%83] À partir de% AB% E3% 81% AE% E9% 81% B8% E6% 8A% 9E% E3% 81% A8% E8% A9% 95% E4% BE% A1)


3.1. Validation croisée: évaluer les performances de l'estimateur

Apprendre les paramètres du prédicteur et tester avec les mêmes données est une erreur méthodologique. Les étiquettes des échantillons connus sont parfaitement renvoyées, mais aucune prédiction utile ne peut être faite pour des données inconnues. Cette situation est appelée ** overfit **. Pour éviter cela, il est courant d'effectuer des expériences d'apprentissage automatique (supervisées) qui conservent certaines des données disponibles sous forme de ** ensembles de tests ** X_test, y_test. Veuillez noter que le mot «expérience» ne signifie pas uniquement une utilisation académique. L'apprentissage automatique commence généralement de manière expérimentale, même dans des contextes commerciaux. scikit-learn utilise la fonction d'assistance train_test_split pour entraîner et tester l'ensemble Vous pouvez calculer rapidement la division aléatoire de. Chargez l'ensemble de données d'iris pour entraîner un SVM linéaire:

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

Pour tester (évaluer) le classificateur, vous pouvez échantillonner l'ensemble d'apprentissage tout en conservant 40% des données.

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

Lors de l'ajustement de divers paramètres («hyperparamètres»), tels que la valeur de «C» qui doit être réglée manuellement sur le SVM, suradapter à l'ensemble de test pour affiner les paramètres afin d'optimiser l'estimation. Je vais. De cette manière, la connaissance de l'ensemble de test «fuit» dans le modèle, rendant les performances prédictives moins polyvalentes dans les mesures d'évaluation. Pour résoudre ce problème, une autre partie de l'ensemble de données peut être le soi-disant «ensemble de validation». Vous pouvez vous entraîner sur l'ensemble d'entraînement, puis évaluer sur l'ensemble de validation et effectuer une évaluation finale sur l'ensemble de test lorsque l'expérience semble réussie. Cependant, si la division des données disponibles en trois ensembles réduit considérablement le nombre d'échantillons disponibles pour l'apprentissage du modèle, les résultats peuvent dépendre d'une sélection aléatoire particulière de paires (apprentissage, validation). Il y a du sexe. La solution à ce problème est une procédure appelée Cross-Validation, Cross-Validation (https://en.wikipedia.org/wiki/Cross-validation_(statistics)) (CV en abrégé). L'ensemble de test doit encore être réservé pour l'évaluation finale, mais l'ensemble de validation n'est plus nécessaire lors de l'exécution du CV. Dans une approche de base appelée CV k fois, l'ensemble d'apprentissage est divisé en k petits ensembles (d'autres approches sont décrites ci-dessous, mais suivent généralement les mêmes principes). Pour chacune des k divisions

La métrique de performance rapportée par le test croisé du facteur k est la moyenne des valeurs calculées dans la boucle. Bien que cette approche soit coûteuse en calcul, elle ne gaspille pas trop de données (comme elle le fait lors de la correction d'un ensemble de test arbitraire) et présente de grands avantages tels que la rétro-inférence avec un très petit nombre d'échantillons.

3.1.1. Calcul des paramètres à validation croisée

La manière la plus simple d'utiliser la validation croisée est d'utiliser l'estimateur et l'ensemble de données cross_val_score Pour appeler une fonction d'assistance. L'exemple suivant montre comment estimer la précision d'une SVM linéaire sur un ensemble de données d'iris en fractionnant les données, en ajustant le modèle et en calculant le score cinq fois de suite (avec des fractionnements différents à chaque fois).

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

Par conséquent, le score moyen et l'intervalle de confiance à 95% du score sont

>>>
>>> print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))
Accuracy: 0.98 (+/- 0.03)

Par défaut, le score calculé pour chaque itération CV est la méthode du score estimé. Vous pouvez modifier cela à l'aide des paramètres de notation:

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

Pour plus d'informations, consultez Paramètres de notation: définition des règles d'évaluation du modèle (http://qiita.com/nazoking@github/items/958426da6448d74279c7). Pour l'ensemble de données d'iris, les échantillons sont équilibrés dans la classe cible, de sorte que la précision et les scores F1 sont à peu près les mêmes. Si l'argument cv est un entier, cross_val_score prend par défaut la valeur [KFold](http: //scikit-learn.org/0.18/modules/generated/sklearn.model_selection.KFold.html#sklearn.model_selection.KFold) ou StratifiedKFold Utilisez .model_selection.StratifiedKFold.html # sklearn.model_selection.StratifiedKFold). Ce dernier est utilisé lorsque l'estimateur est dérivé de ClassifierMixin. Vous pouvez également utiliser d'autres stratégies de validation croisée en passant un itérateur pour la validation croisée.

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

** Conversion de données par données en attente **

Tout comme il est important de tester les attentes pour les données réservées à la formation, au prétraitement (standardisation, sélection de fonctionnalités, etc.) et similaires transformation de données data_transforms.html # data-transforms) doit également être appris à partir de l'ensemble d'apprentissage et appliqué aux données en attente pour la prédiction:

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

Pipeline facilite la création d'estimateurs synthétiques pour la validation croisée. disponible.

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

Voir Pipeline and Feature Union: Combining Estimators (http://scikit-learn.org/0.18/modules/pipeline.html#combining-estimators).

3.1.1.1. Obtention de prévisions par validation croisée

La fonction cross_val_predict est cross_val_score (http://scikit. Il a la même interface que /0.18/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score), mais renvoie le résultat prédit lui-même. Vous ne pouvez utiliser que des stratégies de test croisé qui affectent tous les éléments à un ensemble de test une seule fois (sinon vous obtiendrez une exception). Le classificateur peut également être évalué à l'aide de ces prédictions.

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

Le résultat de ce calcul est [cross_val_score](http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score] car les éléments sont regroupés de différentes manières. Veuillez noter que les résultats obtenus avec) peuvent différer légèrement. Les itérateurs de validation croisée disponibles sont présentés dans la section suivante.

--Exemple

3.1.2. Itérateur de validation croisée

Les sections suivantes présentent des utilitaires qui génèrent des index pour le partitionnement des ensembles de données selon diverses stratégies de validation croisée.

3.1.3. Itérateur de validation croisée pour des données indépendantes et également distribuées

En supposant que certaines données sont distribuées de manière indépendante (iid), on suppose que tous les échantillons proviennent du même processus de génération et que le processus de génération n'a pas la mémoire des échantillons précédemment générés. .. Dans de tels cas, les données à variables croisées suivantes peuvent être utilisées.

Mise en garde

Les données i.i.d. sont une hypothèse courante dans la théorie de l'apprentissage automatique et sont rarement valables dans la pratique. Si vous savez que l'échantillon a été généré à l'aide d'un processus dépendant du temps, il est plus sûr d'utiliser la méthode de validation croisée de reconnaissance de séries chronologiques <time_series_cv>. Il est plus sûr d'utiliser la validation croisée de groupe <group_cv> si vous savez que le processus de génération a une structure de groupe (différents sujets, expériences, appareils de mesure).

3.1.3.1. Vérification du croisement K-Split

KFold place tous les échantillons dans les mêmes $ k $ morceaux appelés plis. Divisez en groupes de tailles (si possible) (si $ k = n $, c'est la même chose que la stratégie Leave One Out). La fonction prédictive est entraînée en utilisant le pli $ k-1 $, et le pli restant est utilisé pour les tests. Exemple de validation d'intersection en deux parties dans un jeu de données avec quatre échantillons:

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

Chaque pli se compose de deux tableaux. Le premier est pour l'ensemble d'apprentissage et le second pour l'ensemble de test. Par conséquent, vous pouvez utiliser l'index numpy pour créer des ensembles d'entraînement / de test.

>>> 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 (ou LOO) est une simple validation croisée. Chaque ensemble d'apprentissage est créé par tous les échantillons sauf un, et l'ensemble de test est un échantillon exclu. Par conséquent, pour n échantillons, il existe n ensembles d'apprentissage différents et n ensembles de tests différents. Cette procédure de validation croisée ne supprime qu'un seul échantillon de l'ensemble d'apprentissage, de sorte qu'aucune donnée n'est gaspillée.

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

Les utilisateurs potentiels de LOO pour la sélection du modèle doivent tenir compte de certains avertissements connus. Par rapport à la validation croisée fractionnée $ k $, les échantillons $ n $ construisent des modèles $ n $ au lieu de $ k $ modèles. De plus, chacun est entraîné sur $ n-1 $ échantillons au lieu de $ (k-1) n / k $. Dans les deux méthodes, LOO est plus coûteuse en calcul que la vérification d'intersection de k fois, en supposant que $ k $ n'est pas trop grand et $ k <n $. Du point de vue de l'exactitude, les LOO entraînent souvent une variance élevée en tant qu'erreur de test de l'estimateur. Intuitivement, des échantillons $ n-1 $ sur $ n $ sont utilisés pour construire chaque modèle, de sorte que les modèles construits à partir de fold sont pratiquement identiques les uns aux autres et à partir de l'ensemble d'entraînement complet. C'est le même que le modèle construit. Cependant, si la courbe d'entraînement est raide par rapport à la taille d'entraînement en question, une validation croisée en 5 ou 10 parties peut surestimer l'erreur de généralisation. En règle générale, la plupart des auteurs et des preuves empiriques suggèrent que la validation croisée à 5 ou 10 segments est préférée à la LOO.

--Référence: - http://www.faqs.org/faqs/ai-faq/neural-nets/part3/section-12.html; --T. Hastie, R. Tibshirani, J. Friedman, Elements of Statistical Learning, Springer 2009

3.1.3.3. Leave P Out(LPO)

LeavePOut est très similaire à LeaveOneOut. Il s'agit de créer tous les ensembles d'entraînement / de test possibles en supprimant les échantillons $ p $ de l'ensemble complet. Pour n échantillons, cela générera une paire $ {n \ choose p} $ entraînement-test. Contrairement à LeaveOneOut et KFold, les ensembles de tests sont dupliqués à $ p> 1 $. Exemple d'absence de 2 pour un ensemble de données avec 4 échantillons:

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

3.1.3.4. Vérification mutuelle de remplacement aléatoire alias Shuffle & Split

ShuffleSplit L'itérateur a un nombre défini par l'utilisateur de fractionnements de jeu de données d'entraînement / test indépendants. Produire. Mélangez d'abord l'échantillon, puis divisez-le en paires de kits d'apprentissage et de test. Vous pouvez contrôler la reproductibilité des résultats en amorçant explicitement le générateur de nombres pseudo-aléatoires random_state. L'exemple d'utilisation est présenté ci-dessous.

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

Pour cette raison, ShuffleSplit est une excellente alternative à la validation croisée de KFold, vous donnant plus de contrôle sur le nombre d'échantillons et d'itérations pour chaque entraînement / test.

3.1.4. Itérateur de validation mutuelle avec hiérarchie basée sur l'étiquette de classe

Certains problèmes de classification peuvent montrer un déséquilibre important dans la distribution des classes cibles: par exemple, il peut y avoir plusieurs fois plus d'échantillons négatifs que d'échantillons positifs. Dans de tels cas, StratifiedKFold et [StratifiedShuffleSplit](http: // scikit- La fréquence relative des classes est presque préservée aux multiples de chaque apprentissage et validation à l'aide de l'échantillonnage stratifié implémenté dans learn.org/0.18/modules/generated/sklearn.model_selection.StratifiedShuffleSplit.html#sklearn.model_selection.StratifiedShuffleSplit) Il est recommandé de le faire.

3.1.4.1. Division K en couches

StratifiedKFold est une variation de la division k qui renvoie un pli stratifié. Chaque ensemble contient approximativement le même pourcentage de l'ensemble complet et des échantillons de chaque classe cible. Exemple de validation croisée par trisection stratifiée pour un ensemble de données de 10 échantillons provenant de deux classes légèrement déséquilibrées:

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

3.1.5. Itérateur de validation mutuelle pour les données groupées

L'hypothèse i.i.d. est violée si le processus de génération de base produit un groupe d'échantillons dépendants. Le regroupement de ces données est spécifique au domaine. Un exemple est lorsque des données médicales sont collectées auprès de plusieurs patients et que plusieurs échantillons sont prélevés sur chaque patient. Ces données sont probablement des groupes individuels. Dans cet exemple, l'ID patient de chaque échantillon est un identifiant de groupe. Dans ce cas, j'aimerais savoir si un modèle formé dans un ensemble particulier de groupes peut également être appliqué à d'autres groupes. Pour mesurer cela, vous devez vous assurer que les échantillons de validation proviennent d'un groupe qui n'est jamais utilisé pour la formation. Vous pouvez le faire en utilisant le séparateur de validation croisée suivant. L'identificateur de regroupement d'échantillon est spécifié par le paramètre groups.

3.1.5.1. Division du groupe k

GroupKFold est une variante de la division k qui empêche le même groupe d'apparaître à la fois dans l'ensemble de test et dans l'ensemble d'apprentissage. est. Par exemple, si les données sont obtenues à partir de différents sujets avec plusieurs échantillons par sujet et que le modèle est suffisamment flexible pour tirer des leçons de caractéristiques très individuelles, il ne peut pas être généralisé à de nouveaux sujets. GroupKFold permet de détecter un tel surpeuplement. Supposons que vous ayez trois groupes, chacun associé à un nombre de 1 à 3.

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

Chaque sujet est à un stade de test différent et le même sujet n'est pas à la fois dans le test et la formation. Notez qu'ils ne seront pas exactement de la même taille en raison de déséquilibres de données.

3.1.5.2. Leave One Group Out

LeaveOneGroupOut (http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.LeaveOneGroupOut.html#sklearn.model_selection.LeaveOneGroupOut) contient des échantillons en fonction d'un tableau de numéros de groupe fourni par un tiers. C'est une méthode de validation croisée. Ces informations de groupe peuvent être utilisées pour coder toute partition de validation croisée prédéfinie spécifique au domaine. Par conséquent, chaque ensemble d'apprentissage comprend tous les échantillons à l'exception de ceux associés à un groupe particulier. Par exemple, pour plusieurs expériences, LeaveOneGroupOut peut être utilisé pour créer des validations croisées basées sur différentes expériences. Créez un ensemble de formation en utilisant des échantillons de toutes les expériences sauf une.

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

Une autre application courante consiste à utiliser les informations de temps. Par exemple, un groupe peut être l'année de collecte des échantillons et peut être contre-validé pour les divisions basées sur le temps.

3.1.5.3. Leave P Groups Out

LeavePGroupsOut est LeaveOneGroupOut (http://scikit-learn.org) /modules/generated/sklearn.model_selection.LeaveOneGroupOut.html#sklearn.model_selection.LeaveOneGroupOut), mais supprime l'échantillon associé au groupe $ P $ pour chaque ensemble d'entraînement / de test. Exemple d'abandon de 2 groupes:

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

3.1.5.4. Fractionnement aléatoire des groupes

GroupShuffleSplit L'itérateur est ShuffleSplit /0.18/modules/generated/sklearn.model_selection.ShuffleSplit.html#sklearn.model_selection.ShuffleSplit) et [LeavePGroupsOut](http://scikit-learn.org/0.18/modules/PGenerated/sklearn.model_selection.html_selection.html Agit comme une combinaison de sklearn.model_selection.LeavePGroupsOut), produisant une séquence aléatoire de partitions avec un sous-ensemble des groupes détenus pour chaque division. L'exemple d'utilisation est présenté ci-dessous.

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

Cette classe est utile si vous avez besoin du comportement de LeavePGroupsOut, mais elle a un grand nombre de groupes et il est très coûteux de générer toutes les partitions possibles contenant des groupes $ P $. Dans de tels scénarios, GroupShuffleSplit fournit un échantillon aléatoire (remplacement) des fractionnements de formation / test générés par LeavePGroupsOut.

3.1.6. Ensembles de pliage / de validation prédéfinis

Pour certains ensembles de données, il existe déjà des divisions de formation et de validation de données prédéfinies ou des divisions de validation croisée. Vous pouvez utiliser ces plis avec PredefinedSplit. Par exemple, utilisez-le lors de la recherche d'hyper paramètres. Par exemple, si vous utilisez un ensemble de validation, définissez test_fold sur 0 pour tous les échantillons qui font partie de l'ensemble de validation et -1 pour tous les autres échantillons.

3.1.7. Vérification mutuelle des données de séries chronologiques

Les données chronologiques sont caractérisées par des corrélations entre des observations proches dans le temps (autocorrélation). Cependant, les techniques classiques de validation croisée telles que KFold et ShuffleSplit supposent que les échantillons sont distribués indépendamment et uniformément, créant une corrélation irrationnelle entre les instances d'entraînement et de test (estimation d'erreur de généralisation). mal). Par conséquent, il est très important d'évaluer un modèle de données chronologiques pour des observations «futures», telles que celles utilisées pour entraîner le modèle. Pour y parvenir, il existe une solution fournie par TimeSeries Split (http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.TimeSeriesSplit.html#sklearn.model_selection.TimeSeriesSplit).

3.1.7.1. Division des séries chronologiques

TimeSeriesSplit est une variante de k-fold qui renvoie les k premiers plis sous la forme d'un ensemble de colonnes et les $ k + 1 $ ème plis en tant qu'ensemble de test. Notez que contrairement aux méthodes standard de validation croisée, les ensembles d'entraînement successifs sont un sur-ensemble de ce qui les précède. Il ajoute également toutes les données excédentaires à la première partition d'apprentissage qui est toujours utilisée pour entraîner le modèle. Cette classe peut être utilisée pour contre-valider des échantillons de données de séries chronologiques observés à intervalles de temps réguliers. Exemple de validation croisée de séries chronologiques en 3 parties pour un ensemble de données à 6 échantillons:

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

3.1.8. Précautions relatives à la lecture aléatoire

Si l'ordre des données n'est pas arbitraire (par exemple, des échantillons consécutifs avec la même étiquette de classe), il peut être essentiel de les mélanger d'abord pour obtenir des résultats de validation croisée significatifs. Cependant, l'inverse peut être vrai si les échantillons ne sont pas distribués indépendamment et uniformément. Par exemple, si les échantillons correspondent à des articles d'actualité et sont triés par heure de publication, le brassage des données peut conduire à des modèles sur-ajustés et à des scores de validation exagérés. C'est parce qu'il a été testé sur des échantillons artificiellement similaires (proches dans le temps). Certains itérateurs de validation mutuelle tels que KFold ont un index de données avant le fractionnement. Il existe des options intégrées pour la lecture aléatoire.

3.1.9. Validation croisée et sélection du modèle

L'itérateur de validation croisée peut également être utilisé pour sélectionner directement les hyperparamètres optimaux pour le modèle à l'aide de la recherche de grille. C'est le sujet de la section suivante. Réglage des hyperparamètres de l'estimateur.


[scikit-learn 0.18 Guide de l'utilisateur 3. Sélection et évaluation du modèle](http://qiita.com/nazoking@github/items/267f2371757516f8c168#3-%E3%83%A2%E3%83%87%E3%83] À partir de% AB% E3% 81% AE% E9% 81% B8% E6% 8A% 9E% E3% 81% A8% E8% A9% 95% E4% BE% A1)

© 2010 --2016, développeurs scikit-learn (licence BSD).

Recommended Posts

[Français] scikit-learn 0.18 Guide de l'utilisateur 3.1. Validation croisée: évaluer les performances de l'estimateur
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.2. Réglage des hyper paramètres de l'estimateur
[Français] scikit-learn 0.18 Guide de l'utilisateur Table des matières
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.3. Évaluation du modèle: quantifier la qualité de la prédiction
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.5. Courbe de vérification: tracez le score pour évaluer le modèle
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.8. Convertir la cible de prédiction (y)
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.7. Détection des nouveautés et des valeurs aberrantes
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.5. Projection aléatoire
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.11. Méthode Ensemble
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.15. Régression isotonique
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.2 Extraction de fonctionnalités
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.16. Étalonnage des probabilités
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.13 Sélection des fonctionnalités
[Français] scikit-learn 0.18 Guide de l'utilisateur 3.4. Persistance du modèle
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.8. Estimation de la densité
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.3. Prétraitement des données
Évaluer les performances d'un modèle de régression simple à l'aide de la validation d'intersection LeaveOneOut
[Français] scikit-learn 0.18 Guide de l'utilisateur 4.1. Union des pipelines et des fonctionnalités: combinaison d'estimateurs
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.4. Support Vector Machine
[Français] scikit-learn 0.18 Guide de l'utilisateur 2.5. Décomposer les signaux en composants (problème de décomposition de la matrice)
[Français] scikit-learn 0.18 Guide de l'utilisateur 1.12. Algorithme multi-classes et algorithme multi-étiquettes
Essayez d'évaluer les performances du modèle d'apprentissage automatique / de régression
Essayez d'évaluer les performances du modèle d'apprentissage automatique / de classification
Évaluer la précision du modèle d'apprentissage par test croisé de scikit learn
Traduction japonaise du manuel e2fsprogs
[Français] Table des matières du didacticiel scikit-learn 0.18
Traduction japonaise du manuel man-db
Traduction japonaise du manuel util-linux
Traduction japonaise du manuel iproute2
Guide de l'utilisateur Pandas "fusionner et joindre et concaténer" (document officiel traduction japonaise)
[Français] Tutoriel scikit-learn 0.18 Choisir le bon modèle
Traduction japonaise: PEP 20 - Le Zen de Python