python - Cómo utilizar la validación cruzada de un k-fold en scikit con el clasificador de bayes y NLTK ingenuo

scikit-learn bayesian

Question

Tengo un pequeño corpus y quiero calcular la precisión del ingenuo clasificador de Bayes usando una validación cruzada de 10 veces, ¿cómo puedo hacerlo?

Answer 1

En realidad, no hay necesidad de un ciclo largo de iteraciones que se proporcionan en la respuesta más votada. Además, la elección del clasificador es irrelevante (puede ser cualquier clasificador).

cross_val_score proporciona cross_val_score , que realiza todos los bucles bajo el capó.

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

Answer 2

He usado ambas bibliotecas y NLTK para naivebayes sklearn para la validación cruzada de la siguiente manera:

from sklearn.cross_validation import KFold, cross_val_score
k_fold = KFold(len(y), n_folds=10, shuffle=True, random_state=0)
clf = <any classifier>
print cross_val_score(clf, X, y, cv=k_fold, n_jobs=1)

Y al final calculé la precisión media.

Answer 3

Inspirado en la respuesta de Jared , aquí hay una versión que usa un generador:

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

Supongo que su conjunto de datos X tiene N puntos de datos (= 4 en el ejemplo) y características D (= 2 en el ejemplo). Las etiquetas N asociadas se almacenan en 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 4

Modificó la segunda respuesta:

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

Answer 5

Sus opciones son configurar esto usted mismo o usar algo como NLTK-Trainer ya que NLTK no admite directamente la validación cruzada para los algoritmos de aprendizaje automático .

Probablemente recomiendo usar otro módulo para hacer esto por usted, pero si realmente desea escribir su propio código, podría hacer algo como lo siguiente.

Suponiendo que quiere 10 veces , tendría que dividir su conjunto de entrenamiento en 10 subconjuntos, entrenar el 9/10 , probar el 1/10 restante, y hacer esto para cada combinación de subconjuntos ( 10 ).

Suponiendo que su conjunto de entrenamiento está en una lista llamada training , una forma simple de lograr esto sería,

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