[PYTHON] Kreuzvalidierung mit Scikit-Learn

Ich habe scikit-learnCross Validation und Grid Search ausprobiert.

Cross Validation

Details finden Sie in Wikipedia. Die Kreuzvalidierung ist eine der Methoden zur Überprüfung der Gültigkeit des Modells. Im Allgemeinen werden Entwicklungsdaten in Trainingsdaten und Verifizierungsdaten unterteilt. Wenn dies jedoch so gemacht wird, wie es ist, werden die Trainingsdaten reduziert und die Generalisierungsleistung kann abhängig von der Auswahl der Trainingsdaten verringert werden. Dies ist der Hold-out-Test für das, was auf Wikipedia geschrieben steht. Im Allgemeinen ist dies keine Kreuzvalidierung.

Dies ist der hier beschriebene K-Divisions-Kreuztest. Im K-Division-Kreuztest werden die Entwicklungsdaten in K-Teile unterteilt, K-1-Teile werden für das Training verwendet und der verbleibende Teil wird zur Überprüfung verwendet, um die Gültigkeit des Modells zu berechnen. Infolgedessen erhöhen sich die Trainingsdaten, die verwendet werden können, und gleichzeitig kann die Generalisierungsleistung durch Ändern der Trainingsdaten verbessert werden.

Ich habe konkret geschrieben, wie man es mit Scikit-Learn macht. Die für das Training verwendeten Daten stammen von Kaggles Data Science London.

SVM

Zunächst der Code beim einfachen Klassifizieren mit der Support-Vektor-Maschine

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

Lassen Sie uns dieses Modell mit Cross Validation überprüfen.

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 ist eine Funktion, die Entwicklungsdaten so aufteilt, dass ein bestimmter Prozentsatz zu Verifizierungsdaten wird. In diesem Fall werden 40% der Daten zur Überprüfung verwendet, da "test_size = 0.4" angegeben ist. "fit" wird mit 60% Trainingsdaten durchgeführt, und die Punktzahl wird mit den verbleibenden 40% Daten überprüft und die richtige Antwortrate angegeben. Dies ist die Legitimität dieses Modells in diesen Testdaten. Je höher dies ist, desto besser Ob die Generalisierungsleistung hoch ist oder nicht, kann hier nicht abgelesen werden. Daher ist es möglich, K-Überprüfungen durchzuführen, indem eine K-Division durchgeführt wird. Durch Mittelung dieser Bewertungen kann die Gültigkeit des Modells einschließlich der Generalisierungsleistung ausgedrückt werden.

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

Sie können alle Bewertungen für diese Validierungen mit cross_validation_cross_val_score erhalten. cv kann die Anzahl der K Unterteilungen angeben. Dieses Mal werden die Entwicklungsdaten in 10 Teile aufgeteilt und 10 Mal überprüft. Ergebnisse geben eine Liste mit 10 Ergebnissen zurück. Der Durchschnitt hierfür wird als Genauigkeit angegeben. Damit kann die Korrektheit des Modells einschließlich der Generalisierungsleistung erhalten werden, es ist jedoch erforderlich, die Modellparameter manuell abzustimmen. Es ist sehr mühsam, die Einstellung von Hand vorzunehmen und die Genauigkeit zu berechnen, sodass diese Optimierung bis zu einem gewissen Grad durch einen Algorithmus namens Grid Search automatisiert werden kann.

Grid Search

Die Rastersuche ist eine Methode zur empirischen Suche nach dem optimalen Parametersatz durch Angabe des Parameterbereichs. Schreiben Sie dazu in Python wie folgt.

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_

Dieser Bereich kann durch Angabe in param_grid angegeben werden. In n_jobs können Sie die Anzahl der Prozesse angeben, die parallel Berechnungen durchführen. Wenn -1 angegeben ist, ist standardmäßig die Anzahl der Kerne ausgewählt. Führen Sie eine Rastersuche für die angegebenen Trainingsdaten durch. Es wird einige Zeit dauern, aber Sie können die Modellparameter auswählen, die die höchste Punktzahl für diese Trainingsdaten ergeben. Diese Trainingsdaten können für tatsächliche Testdaten verwendet werden.