[PYTHON] Validation croisée avec scikit-learn

J'ai essayé scikit-learnCross Validation et Grid Search.

Cross Validation

Des détails peuvent être trouvés dans Wikipedia. La validation croisée est l'une des méthodes permettant de vérifier la validité du modèle. En général, les données de développement sont divisées en données de formation et données de vérification. Cependant, si cela est fait tel quel, les données d'apprentissage seront réduites et les performances de généralisation peuvent être réduites en fonction de la manière dont les données d'apprentissage sont sélectionnées. C'est le test de résistance de ce qui est écrit sur Wikipedia. En général, ce n'est pas une validation croisée.

C'est le test croisé de division K décrit ici. Dans le test croisé de division K, les données de développement sont divisées en K pièces, K-1 pièces sont utilisées pour la formation et le reste est utilisé pour la vérification afin de calculer la validité du modèle. En conséquence, les données d'apprentissage qui peuvent être utilisées augmentent et, en même temps, les performances de généralisation peuvent être améliorées en modifiant les données d'apprentissage.

J'ai écrit comment le faire concrètement avec scikit-learn. Les données utilisées pour la formation provenaient de Kaggle Data Science London.

SVM

Tout d'abord, le code lors de la simple classification avec la machine à vecteurs de support

# -*- coding: utf-8 -*-

import os
import sys
from sklearn import svm
import numpy as np
import csv

if __name__ == "__main__":
    train_feature_file = np.genfromtxt(open("../data/train.csv", "rb"), delimiter=",", dtype=float)
    train_label_file = np.genfromtxt(open("../data/trainLabels.csv", "rb"), delimiter=",", dtype=float)

    train_features = []
    train_labels = []
    for train_feature, train_label in zip(train_feature_file, train_label_file):
        train_features.append(train_feature)
        train_labels.append(train_label)

    train_features = np.array(train_features)
    train_labels = np.array(train_labels)

    clf = svm.SVC(C=100, cache_size=200, class_weight=None, coef0=0.0, degree=3,gamma=0.001, kernel="rbf", max_iter=-1, probability=False,random_state=None, shrinking=True, tol=0.001, verbose=False)

    clf.fit(train_features, train_labels)

    test_feature_file = np.genfromtxt(open("../data/test.csv", "rb"), delimiter=",", dtype=float)

    test_features = []
    print "Id,Solution"
    i = 1
    for test_feature in test_feature_file:
        print str(i) + "," + str(int(clf.predict(test_feature)[0]))
        i += 1

Vérifions ce modèle avec la validation croisée.

def get_score(clf, train_features, train_labels):
    X_train, X_test, y_train, y_test = cross_validation.train_test_split(train_features, train_labels, test_size=0.4, random_state=0)

    clf.fit(X_train, y_train)
    print clf.score(X_test, y_test) 

cross_validation.train_test_split est une fonction qui divise les données de développement afin qu'un certain pourcentage devienne des données de vérification. Dans ce cas, puisque test_size = 0.4 est spécifié, 40% des données seront utilisées pour la vérification. fit est fait avec 60% de données d'entraînement, et le score est vérifié avec les 40% de données restantes et le taux de réponse correct est donné. C'est la légitimité de ce modèle dans ces données de test. Bien sûr, plus c'est élevé, mieux c'est Il est impossible de lire ici si les performances de généralisation sont élevées ou non. Par conséquent, il est possible d'effectuer K vérifications en effectuant une division K. En faisant la moyenne de ces scores, la validité du modèle, y compris les performances de généralisation, peut être exprimée.

def get_accuracy(clf, train_features, train_labels):
    scores = cross_validation.cross_val_score(clf, train_features, train_labels, cv=10)
    print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))

Vous pouvez obtenir tous les scores pour ces validations avec cross_validation_cross_val_score. cv peut spécifier le nombre de K divisions. Cette fois, les données de développement seront divisées en 10 pièces et vérifiées 10 fois. scores renverra une liste de 10 scores. La moyenne de ceci est donnée en tant que précision. Avec cela, l'exactitude du modèle, y compris les performances de généralisation, peut être obtenue, mais il est nécessaire d'ajuster manuellement les paramètres du modèle. Il est très difficile d'ajuster à la main et de calculer la précision, de sorte que ce réglage peut être automatisé dans une certaine mesure par un algorithme appelé Grid Search.

Grid Search

Grid Search est une méthode pour rechercher l'ensemble optimal de paramètres de manière empirique en spécifiant la plage de paramètres. Pour le faire en Python, écrivez comme suit.

def grid_search(train_features, train_labels):
    param_grid = [
        {'C': [1, 10, 100, 1000], 'kernel': ['linear']},
        {'C': [1, 10, 100, 1000], 'gamma': [0.001, 0.0001], 'kernel': ['rbf']},
    ]
    
    clf = GridSearchCV(svm.SVC(C=1), param_grid, n_jobs=-1)
    clf.fit(train_features, train_labels)
    print clf.best_estimator_

Cette plage peut être spécifiée en la spécifiant dans param_grid. Vous pouvez spécifier le nombre de processus qui effectuent des calculs en parallèle dans n_jobs. Si -1 est spécifié, le nombre de cœurs est sélectionné par défaut. Effectuez une recherche de grille sur les données d'entraînement données. Cela prendra un certain temps, mais vous pouvez choisir les paramètres du modèle qui donnent le score le plus élevé pour ces données d'entraînement. Ces données d'entraînement peuvent être utilisées pour des données de test réelles.