Was ich getan habe

Klassifizieren Sie handgeschriebene numerische Bilddaten mit SVM
Bewerten Sie die Modellbewertung mit Cross Validation
Ändern Sie den Hyperparameter C und sehen Sie, wie sich die Punktzahl ändert
Ändern Sie den Hyperparameter Gamma und sehen Sie, wie sich die Punktzahl ändert

Die Quelle ist hier.

Bibliotheken und Daten importieren

Importieren Sie die Cross-Test-Bibliothek "cross_validation". Daten verwenden handgeschriebene Ziffern.

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn import svm, datasets, cross_validation
digits = datasets.load_digits()
X_digits = digits.data
y_digits = digits.target

Kreuztestmethode und Parametereinstellung

Die folgenden Methoden stehen für Kreuztests zur Verfügung. --kFold (n, k): Teilen Sie n Probendaten in k Stapel auf. Verwenden Sie eine Charge zum Testen und die verbleibende (k-1) Charge zum Training. Ändern Sie den für den Test verwendeten Datensatz und wiederholen Sie den Test k-mal. --StratifiedKFold (y, k): Teilen Sie Daten in k Teile auf, während Sie das Verhältnis der Beschriftungen im geteilten Datensatz beibehalten. --LeaveOneOut (n): Entspricht dem Fall von kFold mit k = n. Wenn die Anzahl der Datenproben gering ist. --LeaveOneLabelOut (Labels): Teilen Sie die Daten nach einem bestimmten Label auf. Zum Beispiel beim Umgang mit Jahresdaten, bei der Durchführung von Tests durch Aufteilung in Jahresdaten.

Dieses Mal werde ich die einfachste KFold verwenden. Die Anzahl der Abteilungen betrug 4. Wie ich später in KFold bemerkt habe, scheint die Datenreihenfolge automatisch sortiert zu werden, wenn Sie die Variable 'shuffle = true' definieren.

np.random.seed(0) #Zufällige Starteinstellung, es muss nicht 0 sein
indices = np.random.permutation(len(X_digits))
X_digits = X_digits[indices] #Sortieren Sie die Reihenfolge der Daten nach dem Zufallsprinzip
y_digits = y_digits[indices]
n_fold = 4 #Anzahl der Kreuztests
k_fold = cross_validation.KFold(n=len(X_digits),n_folds = n_fold)
# k_fold = cross_validation.KFold(n=len(X_digits),n_folds = n_fold, shuffle=true)
#In diesem Fall sind die ersten vier Zeilen nicht erforderlich.

Experimentieren Sie, indem Sie die Variable C von SVM ändern

Ändern Sie den Hyperparameter C, um zu sehen, wie sich der Bewertungswert des Modells ändert. C ist ein Parameter, der bestimmt, wie viele Fehlalarme toleriert werden. Der SVM-Kernel war ein Gaußscher Kernel. Referenz: Vorheriger Artikel "Erkennen handgeschriebener Zahlen mit SVM"

C_list = np.logspace(-8, 2, 11) # C
score = np.zeros((len(C_list),3))
tmp_train, tmp_test = list(), list()
# score_train, score_test = list(), list()
i = 0
for C in C_list:
    svc = svm.SVC(C=C, kernel='rbf', gamma=0.001)
    for train, test in k_fold:
        svc.fit(X_digits[train], y_digits[train])
        tmp_train.append(svc.score(X_digits[train],y_digits[train]))
        tmp_test.append(svc.score(X_digits[test],y_digits[test]))
        score[i,0] = C
        score[i,1] = sum(tmp_train) / len(tmp_train)
        score[i,2] = sum(tmp_test) / len(tmp_test)
        del tmp_train[:]
        del tmp_test[:]
    i = i + 1

Es ist einfacher zu schreiben, wenn Sie sich nur den Bewertungswert des Tests ansehen. Sie können auch die Anzahl der in der Variablen n_jobs verwendeten CPUs angeben. -1 verwendet alle CPUs. cross_validation.cross_val_score(svc, X_digits, y_digits, cv=k_fold, n_jobs=-1) Der Auswertungswert wird vom Array ausgegeben. array([ 0.98888889, 0.99109131, 0.99331849, 0.9844098 ])

Visualisieren Sie die Ergebnisse in einem Diagramm

Zeichnen Sie mit C als horizontaler Achse den Bewertungswert während des Trainings und den Bewertungswert während des Tests. Wenn C klein ist, verbessert sich die Genauigkeit nicht, wahrscheinlich weil eine fehlerhafte Beurteilung zu viel erlaubt ist.

xmin, xmax = score[:,0].min(), score[:,0].max()
ymin, ymax = score[:,1:2].min()-0.1, score[:,1:2].max()+0.1
plt.semilogx(score[:,0], score[:,1], c = "r", label = "train")
plt.semilogx(score[:,0], score[:,2], c = "b", label = "test")
plt.axis([xmin,xmax,ymin,ymax])
plt.legend(loc='upper left')
plt.xlabel('C')
plt.ylabel('score')
plt.show

Experimentieren Sie, indem Sie die SVM-Variable Gamma ändern

Fixieren Sie dann C auf 100 und ändern Sie das Gamma für dasselbe Experiment. Je größer das Gamma ist, desto komplexer sind die Klassifizierungsgrenzen.

g_list = np.logspace(-8, 2, 11) # C
score = np.zeros((len(g_list),3))
tmp_train, tmp_test = list(), list()
i = 0
for gamma in g_list:
    svc = svm.SVC(C=100, gamma=gamma, kernel='rbf')
    for train, test in k_fold:
        svc.fit(X_digits[train], y_digits[train])
        tmp_train.append(svc.score(X_digits[train],y_digits[train]))
        tmp_test.append(svc.score(X_digits[test],y_digits[test]))
        score[i,0] = gamma
        score[i,1] = sum(tmp_train) / len(tmp_train)
        score[i,2] = sum(tmp_test) / len(tmp_test)
        del tmp_train[:]
        del tmp_test[:]
    i = i + 1

Hier sind die Ergebnisse. Wenn das Gamma erhöht wird, nehmen sowohl die Genauigkeit während des Trainings als auch die Genauigkeit während des Testens zu, aber ab etwa 0,001 ändert sich die Genauigkeit während des Trainings nicht, aber die Genauigkeit während des Tests nimmt ab. Es scheint, dass Überlernen aufgrund zu hoher Komplexität auftritt. Es stellt sich heraus, dass das Einstellen von Variablen wichtig ist.