[Français] scikit-learn 0.18 Tutorial Tutoriel d'apprentissage statistique pour le traitement des données scientifiques Sélection du modèle: sélection de l'estimateur et de ses paramètres

traduction google de http://scikit-learn.org/stable/tutorial/statistical_inference/model_selection.html Table des matières du didacticiel scikit-learn 0.18 Tableau du didacticiel d'apprentissage statistique pour le traitement des données scientifiques Page précédente du tutoriel

Sélection du modèle: sélection de l'estimateur et de ses paramètres

Score, score à validation croisée

Comme nous l'avons vu, tous les estimateurs exposent une méthode de «score» qui peut déterminer la qualité d'ajustement (ou de prédiction) des nouvelles données. Plus c'est grand, mieux c'est.

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

Pour obtenir une meilleure mesure de la précision prédictive (qui peut être utilisée comme proxy pour l'ajustement du modèle), nous pouvons continuellement diviser les données dans les plis que nous utilisons pour la formation et les tests.

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

C'est ce qu'on appelle la validation croisée de KFold.

Générateur de validation croisée

scikit-learn a une collection de classes qui peuvent être utilisées pour générer une liste d'index de formation / test pour les stratégies de validation croisée courantes. Ils acceptent les ensembles de données d'entrée fractionnés et exposent une méthode «fractionnée» qui génère un index train / testset pour chaque itération de la stratégie de validation croisée sélectionnée. Cet exemple montre un exemple d'utilisation de la méthode split.

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

La validation croisée est facile à faire.

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

Le score de validation croisée peut être calculé directement à l'aide de l'assistant cross_val_score. Étant donné un objet de validation croisée et une estimation pour l'ensemble de données d'entrée, cross_val_score divise de manière itérative les données en un ensemble d'apprentissage et un ensemble de test, entraîne l'estimation à l'aide de l'ensemble d'apprentissage et est basé sur l'ensemble de test pour chaque itération de l'agrégation de validation croisée. Pour calculer le score. Par défaut, la méthode «score» de l'estimateur est utilisée pour calculer les scores individuels. Pour plus d'informations sur les méthodes de notation disponibles, consultez Modules métriques (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 signifie que les calculs sont distribués sur tous les processeurs de l'ordinateur. Vous pouvez également fournir l'argument scoring pour spécifier une méthode de notation différente.

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

Générateur de vérification mutuelle

• KFold (n_splits, shuffle, random_state)
• Séparez K, entraînez-vous avec K-1 et testez avec le reste.
• StratifiedKFold (n_iter, test_size, train_size, random_state)
• Identique au pli K, mais préserve la distribution des classes au sein du pli.
• GroupKFold (n_splits, shuffle, random_state)
• Assurez-vous que le même groupe n'est pas à la fois dans l'ensemble de test et dans l'ensemble d'apprentissage.
• ShuffleSplit (n_iter, test_size, train_size, random_state) --Générer des exposants de formation / test basés sur un remplacement aléatoire.
• StratifiedShuffleSplit
• Identique au fractionnement aléatoire, mais conserve la distribution des classes dans chaque itération.
• GroupShuffleSplit
• Assurez-vous que le même groupe n'est pas à la fois dans l'ensemble de test et dans l'ensemble d'apprentissage.
• LeaveOneGroupOut ()
• Prenez un tableau de groupe pour regrouper les valeurs observées.
• LeavePGroupsOut (p)
• Laisser le groupe P tel quel.
• LeaveOneOut () -Laisser une observation.
• LeavePOut(p)
• Laisser la valeur observée de P telle quelle.
• PredefinedSplit --Générer des formations / tests basés sur des divisions prédéfinies.

Exercice

Tracez le score de validation croisée de l'estimation SVC en utilisant le noyau linéaire en fonction du paramètre «C» dans l'ensemble de données numériques (en utilisant une grille logarithmique de points de 1 à 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)

[Répondez ici: Validation croisée avec l'exercice Digits Dataset](http://scikit-learn.org/stable/auto_examples/exercises/plot_cv_digits.html#sphx-glr-auto-examples-exercises-plot-cv-digits- py)

Recherche de grille et estimateur à validation croisée

Recherche de grille

scikit-learn fournit un objet dans lequel les données données calculent le score lors de l'ajustement de l'estimateur sur la grille de paramètres et sélectionnent le paramètre qui maximise le score de validation croisée. Cet objet effectue des estimations lors de la construction et expose l'API de l'estimateur.

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

>>> #Les performances de prédiction de l'ensemble de test ne sont pas aussi bonnes que celles de l'ensemble d'entraînement
>>> clf.score(X_digits[1000:], y_digits[1000:])      
0.943...

Par défaut, GridSearchCV (http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV) utilise la validation mutuelle 3x. Cependant, au lieu de l'analyse de régression, s'il est détecté qu'une classification a été réussie, utilisez un triplet stratifié.

Validation mutuelle imbriquée

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

Deux boucles de validation croisée s'exécutent en parallèle, une avec l'estimateur GridSearchCV pour définir le gamma et l'autre avec cross_val_score pour mesurer les performances prédictives de l'évaluateur. Le score obtenu est une estimation non biaisée du score prévu pour les nouvelles données.

avertissement

Les objets ne peuvent pas être imbriqués dans des calculs parallèles («n_jobs» est différent de 1).

Estimateur à validation croisée

La validation mutuelle de la définition des paramètres peut être effectuée efficacement pour chaque algorithme. En effet, pour certains estimateurs, scikit-learn définit automatiquement les paramètres par validation croisée "Cross Validation: Evaluate Estimator Performance. /cross_validation.html#cross-validation) »Publiez l'estimateur.

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

Ces estimateurs sont appelés comme s'ils avaient un «CV» ajouté à leur nom.

Exercice

Dans le jeu de données sur le diabète, trouvez le paramètre de régularisation optimal «alpha».

** Bonus: ** Dans quelle mesure pouvez-vous faire confiance au choix alpha?

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

[Réponse ici: Exercice d'authentification mutuelle de l'ensemble de données diabétiques](http://scikit-learn.org/stable/auto_examples/exercises/plot_cv_diabetes.html#sphx-glr-auto-examples-exercises-plot-cv-diabetes -py)

Page suivante

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