Jak używać sprawdzania krzyżowego k-krotnego w scikicie z klasyfikatorem naive bayes i NLTK

Question

Mam mały korpus i chcę obliczyć dokładność naiwnego klasyfikatora Bayesa przy użyciu 10-krotnego sprawdzania poprawności krzyżowej, jak to zrobić.

Answer 1

Dostępne opcje to ustawienie samodzielnie lub użycie czegoś podobnego do NLTK-Trainer od NLTK doesn't directly support cross-validation for machine learning algorithms.

Polecam prawdopodobnie użycie innego modułu, aby to zrobić, ale jeśli naprawdę chcesz napisać własny kod, możesz zrobić coś takiego.

Przypuśćmy chcesz 10-krotnie, to musiałby podzielić trening ustawić w 10 podzbiorów, pociągu na 9/10, test na pozostałej 1/10, i zrobić to dla każdej kombinacji podzbiorów (10).

Zakładając, że zestaw szkoleniowy znajduje się w wykazie o nazwie training, prosta droga do osiągnięcia tego celu byłoby,

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

Używałem obu bibliotek i NLTK dla naivebayes sklearn do oceny krzyżowej w następujący sposób:

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

i na koniec i oblicza średnią dokładność

Answer 3

zmodyfikował drugą odpowiedź:

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

Answer 4

Zainspirowany od Jared's answer, tutaj jest wersją pomocą generatora:

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 

jestem przy założeniu, że dane ustawienie X ma punktów danych N (= 4 w przykładzie) i funkcje D (= 2 w przykładzie). Powiązane etykiety N są przechowywane w y.

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

W rzeczywistości nie ma potrzeby wykonywania długich pętli, które są przewidziane w odpowiedzi najbardziej przeczącej. Również wybór klasyfikatora jest nieistotny (może to być dowolny klasyfikator).

Scikit zapewnia cross_val_score, który wykonuje wszystkie pętle pod maską.