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)
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.
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).
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
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.
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).
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]
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.
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.
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]
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.
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]
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.
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.
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).
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]
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.
cv = some_integer (http://scikit-learn.org/0.18/modules/generated/sklearn.model_selection.cross_val_score.html#sklearn.model_selection.cross_val_score), recherche de grille, (couches) T) Validation croisée de la division K, etc. Notez que train_test_split renvoie toujours un fractionnement aléatoire.random_state est None. Cela signifie que la lecture aléatoire sera différente à chaque fois que KFold (..., shuffle = True) est utilisé. Cependant, GridSearchCV utilise le même mélange pour chaque ensemble de paramètres validés en un seul appel à la méthode fit.
--Utilisez une valeur fixe pour random_state pour rendre le résultat reproductible (sur la même plateforme).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