Wie man die a k-falten Kreuzvalidierung in Scikit mit Naive Bayes Klassifikator und NLTK

Question

Ich habe ein kleines Korpus und ich möchte die Genauigkeit der naiven Bayes Klassifikator mit 10-fach-Kreuzvalidierung zu berechnen, wie es geht.

Answer 1

Ihre Optionen sind, entweder dies selbst einzurichten oder etwas wie NLTK-Trainer seit NLTK doesn't directly support cross-validation for machine learning algorithms zu verwenden.

Ich würde wahrscheinlich empfehlen, nur ein anderes Modul, um dies für Sie tun, aber wenn Sie wirklich Ihren eigenen Code schreiben möchten, könnten Sie etwas wie folgt tun.

Angenommen, Sie wollen 10fach, würden Sie haben Ihre Ausbildung für jede Kombination von Untergruppen in 10 Subsets Zug auf 9/10, Test auf dem verbleibenden 1/10, und tun dies auf partitionieren (10).

Ihre Trainingssatz ist in einer Liste training, eine einfache Möglichkeit, dies sein,

wie folgt

num_folds = 10 
subset_size = len(training)/num_folds 
for i in range(num_folds): 
    testing_this_round = training[i*subset_size:][:subset_size] 
    training_this_round = training[:i*subset_size] + training[(i+1)*subset_size:] 
    # train using training_this_round 
    # evaluate against testing_this_round 
    # save accuracy 

# find mean accuracy over all rounds 

Answer 2

ich verwendet habe, beide Bibliotheken und NLTK für Kreuzvalidierung für naivebayes sklearn würde zu erreichen genannt Unter der Annahme:

import nltk 
from sklearn import cross_validation 
training_set = nltk.classify.apply_features(extract_features, documents) 
cv = cross_validation.KFold(len(training_set), n_folds=10, indices=True, shuffle=False, random_state=None, k=None) 

for traincv, testcv in cv: 
    classifier = nltk.NaiveBayesClassifier.train(training_set[traincv[0]:traincv[len(traincv)-1]]) 
    print 'accuracy:', nltk.classify.util.accuracy(classifier, training_set[testcv[0]:testcv[len(testcv)-1]]) 

und am Ende berechnet ich die durchschnittliche Genauigkeit

Answer 3

die zweite Antwort Modifiziert:

cv = cross_validation.KFold(len(training_set), n_folds=10, shuffle=True, random_state=None) 

Answer 4

von Jared's answer inspiriert, hier ist eine Version mit einem Generator:

def k_fold_generator(X, y, k_fold): 
    subset_size = len(X)/k_fold # Cast to int if using Python 3 
    for k in range(k_fold): 
     X_train = X[:k * subset_size] + X[(k + 1) * subset_size:] 
     X_valid = X[k * subset_size:][:subset_size] 
     y_train = y[:k * subset_size] + y[(k + 1) * subset_size:] 
     y_valid = y[k * subset_size:][:subset_size] 

     yield X_train, y_train, X_valid, y_valid 

Ich gehe davon aus, dass Ihre Daten gesetzt X N Datenpunkte (= 4 im Beispiel) hat und D-Funktionen (= 2 im Beispiel). Die zugehörigen N-Etiketten sind in y gespeichert.

X = [[ 1, 2], [3, 4], [5, 6], [7, 8]] 
y = [0, 0, 1, 1] 
k_fold = 2 

for X_train, y_train, X_valid, y_valid in k_fold_generator(X, y, k_fold): 
    # Train using X_train and y_train 
    # Evaluate using X_valid and y_valid 

Answer 5

Eigentlich sind keine langen Schleifeniterationen erforderlich, die in der am häufigsten aufgewerteten Antwort enthalten sind. Auch die Wahl des Klassifikators ist irrelevant (es kann jeder Klassifikator sein).

Scikit bietet cross_val_score, die alle Schleifen unter der Haube macht.