Qu'est-ce que la recherche de grille?

scikit learn a une fonction appelée recherche de grille. Une fonctionnalité intéressante qui optimise automatiquement les hyper paramètres du modèle d'apprentissage automatique. Par exemple, pour SVM, C, noyau, gamma, etc. Du Guide de l'utilisateur Scikit-learn, voici la référence cette fois.

Ce que j'ai fait

--Classez les chiffres manuscrits (0-9) du jeu de données par SVM -Optimiser les hyperparamètres avec des tests croisés avec GridSearchCV --Utilisez f1 pour la fonction d'évaluation du modèle au moment de l'optimisation.

Préparation des données

Importez des chiffres manuscrits.

from sklearn import datasets
from sklearn.cross_validation import train_test_split
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import classification_report
from sklearn.svm import SVC

digits = datasets.load_digits()
n_samples = len(digits.images) #Nombre d'échantillons 1797
X = digits.images.reshape((n_samples, -1)) #Conversion d'un tableau 8x8 en vecteur 64 dimensions
y = digits.target #Étiquette de réponse correcte

train_test_split divise l'ensemble de données en deux, un pour la formation et un pour le test.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
print(X.shape)
>>> (1797, 64)
print(X_train.shape)
>>> (898, 64)
print(X_test.shape)
>>> (899, 64)

Définition des paramètres que vous souhaitez optimiser

Ensuite, définissez les paramètres que vous souhaitez optimiser dans une liste. Ajout de noyaux poly et sigmoïdes en plus des exemples.

tuned_parameters = [
    {'C': [1, 10, 100, 1000], 'kernel': ['linear']},
    {'C': [1, 10, 100, 1000], 'kernel': ['rbf'], 'gamma': [0.001, 0.0001]},
    {'C': [1, 10, 100, 1000], 'kernel': ['poly'], 'degree': [2, 3, 4], 'gamma': [0.001, 0.0001]},
    {'C': [1, 10, 100, 1000], 'kernel': ['sigmoid'], 'gamma': [0.001, 0.0001]}
    ]

Effectuer l'optimisation

Optimisez les paramètres définis ci-dessus en utilisant GridSearchCV. Il existe quatre variables spécifiées: le modèle à utiliser, le jeu de paramètres à optimiser, le nombre de tests croisés et la valeur d'évaluation du modèle. La valeur d'évaluation était «f1». Vous pouvez également utiliser «précision» ou «rappel». Pour plus d'informations, cliquez ici (http://scikit-learn.org/stable/modules/model_evaluation.html#scoring-parameter).

score = 'f1'
clf = GridSearchCV(
    SVC(), #Identifiant
    tuned_parameters, #Jeu de paramètres que vous souhaitez optimiser
    cv=5, #Nombre de tests croisés
    scoring='%s_weighted' % score ) #Spécification de la fonction d'évaluation du modèle

Effectuez des optimisations en utilisant uniquement des ensembles de données d'entraînement. Le jeu de paramètres etc. s'affiche.

clf.fit(X_train, y_train) 
>>> GridSearchCV(cv=5, error_score='raise',
>>>       estimator=SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
>>>  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
>>>  max_iter=-1, probability=False, random_state=None, shrinking=True,
>>>  tol=0.001, verbose=False),
>>>       fit_params={}, iid=True, n_jobs=1,
>>>       param_grid=[{'kernel': ['linear'], 'C': [1, 10, 100, 1000]}, {'kernel': ['rbf'], 'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001]}, {'kernel': ['poly'], 'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001], 'degree': [2, 3, 4]}, {'kernel': ['sigmoid'], 'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001]}],
       pre_dispatch='2*n_jobs', refit=True, scoring='f1_weighted',
       verbose=0)

Voir les résultats

Vous pouvez vérifier le score de chaque essai avec clf.grid_scores_.

clf.grid_scores_
>>> [mean: 0.97311, std: 0.00741, params: {'kernel': 'linear', 'C': 1},
>>> mean: 0.97311, std: 0.00741, params: {'kernel': 'linear', 'C': 10},
>>> mean: 0.97311, std: 0.00741, params: {'kernel': 'linear', 'C': 100}, 
>>> ...
>>>  mean: 0.96741, std: 0.00457, params: {'kernel': 'sigmoid', 'C': 1000, 'gamma': 0.0001}]

Vous pouvez vérifier les paramètres optimisés avec clf.best_params_.

clf.best_params_
{'C': 10, 'gamma': 0.001, 'kernel': 'rbf'}

Le score de chaque essai est affiché sous forme de texte et la précision des paramètres optimisés est affichée dans un tableau.

print("# Tuning hyper-parameters for %s" % score)
print()
print("Best parameters set found on development set: %s" % clf.best_params_)
print()

#Affichage des résultats d'essai pour chaque paramètre
print("Grid scores on development set:")
print()
for params, mean_score, scores in clf.grid_scores_:
    print("%0.3f (+/-%0.03f) for %r"
          % (mean_score, scores.std() * 2, params))
print()

#Afficher la précision de la classification dans l'ensemble de données de test
print("The scores are computed on the full evaluation set.")
print()
y_true, y_pred = y_test, clf.predict(X_test)
print(classification_report(y_true, y_pred))

Ce sera sorti comme ça.

# Tuning hyper-parameters for f1

Best parameters set found on development set: {'kernel': 'rbf', 'C': 10, 'gamma': 0.001}

Grid scores on development set:

0.973 (+/-0.015) for {'kernel': 'linear', 'C': 1}
0.973 (+/-0.015) for {'kernel': 'linear', 'C': 10}
0.973 (+/-0.015) for {'kernel': 'linear', 'C': 100}

 [Omis parce que c'est long]

0.967 (+/-0.009) for {'kernel': 'sigmoid', 'C': 1000, 'gamma': 0.0001}

The scores are computed on the full evaluation set.

             precision    recall  f1-score   support

          0       1.00      1.00      1.00        89
          1       0.97      1.00      0.98        90
          2       0.99      0.98      0.98        92
          3       1.00      0.99      0.99        93
          4       1.00      1.00      1.00        76
          5       0.99      0.98      0.99       108
          6       0.99      1.00      0.99        89
          7       0.99      1.00      0.99        78
          8       1.00      0.98      0.99        92
          9       0.99      0.99      0.99        92

avg / total       0.99      0.99      0.99       899