python - stratified - sklearn metrics

¿Cómo se calcula scikit-learn cross_val_predict score de precisión?

Question

¿ cross_val_predict (ver doc , v0.18) con el método k- fold, como se muestra en el siguiente código, calcula la precisión de cada pliegue y promedia el cross_val_predict o no?

cv = KFold(len(labels), n_folds=20)
clf = SVC()
ypred = cross_val_predict(clf, td, labels, cv=cv)
accuracy = accuracy_score(labels, ypred)
print accuracy

Answer 1

Como puede ver en el código de cross_val_predict en github , la función calcula para cada fold las predicciones y las concatena. Las predicciones se basan en el modelo aprendido de otros pliegues.

Aquí hay una combinación de su código y el ejemplo provisto en el código

from sklearn import datasets, linear_model
from sklearn.model_selection import cross_val_predict, KFold
from sklearn.metrics import accuracy_score

diabetes = datasets.load_diabetes()
X = diabetes.data[:400]
y = diabetes.target[:400]
cv = KFold(n_splits=20)
lasso = linear_model.Lasso()
y_pred = cross_val_predict(lasso, X, y, cv=cv)
accuracy = accuracy_score(y_pred.astype(int), y.astype(int))

print(accuracy)
# >>> 0.0075

Finalmente, para responder a su pregunta: "No, la precisión no se promedia para cada pliegue".

Answer 2

¡No, no lo hace!

De acuerdo con la página de documentación de validación cruzada , cross_val_predict no devuelve ningún puntaje, sino solo las etiquetas basadas en una determinada estrategia que se describe aquí:

La función cross_val_predict tiene una interfaz similar a cross_val_score, pero devuelve, para cada elemento de la entrada, la predicción que se obtuvo para ese elemento cuando estaba en el conjunto de prueba . Solo se pueden usar las estrategias de validación cruzada que asignan todos los elementos a un conjunto de prueba exactamente una vez (de lo contrario, se genera una excepción).

Y, por lo tanto, al llamar a accuracy_score(labels, ypred) , solo está calculando las puntuaciones de precisión de las etiquetas predichas por la estrategia particular mencionada anteriormente en comparación con las etiquetas verdaderas. Esto nuevamente se especifica en la misma página de documentación:

Estas predicciones se pueden usar para evaluar el clasificador:

predicted = cross_val_predict(clf, iris.data, iris.target, cv=10) 
metrics.accuracy_score(iris.target, predicted)

Tenga en cuenta que el resultado de este cálculo puede ser ligeramente diferente de los obtenidos usando cross_val_score ya que los elementos se agrupan de diferentes maneras.

Si necesita puntajes de precisión de pliegues diferentes, debe intentar:

>>> scores = cross_val_score(clf, X, y, cv=cv)
>>> scores                                              
array([ 0.96...,  1.  ...,  0.96...,  0.96...,  1.        ])

y luego, para la precisión media de todos los pliegues, use scores.mean() :

>>> print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))
Accuracy: 0.98 (+/- 0.03)

Editar:

Para calcular el Cohen Kappa coefficient y la matriz de confusión, asumí que se refiere al coeficiente kappa y la matriz de confusión entre las etiquetas verdaderas y las etiquetas predichas de cada pliegue:

from sklearn.model_selection import KFold
from sklearn.svm.classes import SVC
from sklearn.metrics.classification import cohen_kappa_score
from sklearn.metrics import confusion_matrix

cv = KFold(len(labels), n_folds=20)
clf = SVC()
for train_index, test_index in cv.split(X):
    clf.fit(X[train_index], labels[train_index])
    ypred = clf.predict(X[test_index])
    kappa_score = cohen_kappa_score(labels[test_index], ypred)
    confusion_matrix = confusion_matrix(labels[test_index], ypred)

Editar 2:

¿ cross_val_predict devuelve cross_val_predict ?

KFold divide los datos en k partes y luego para i = 1..k iteraciones hace esto: toma todas las partes excepto la i parte como datos de entrenamiento, ajusta el modelo con ellas y luego predice las etiquetas para la i parte (datos de prueba) ) En cada iteración, la etiqueta de la i-ésima parte de los datos se predice. Al final, cross_val_predict fusiona todas las etiquetas parcialmente predichas y las devuelve como un todo.

Este código muestra este proceso paso a paso:

X = np.array([[0], [1], [2], [3], [4], [5]])
labels = np.array([''a'', ''a'', ''a'', ''b'', ''b'', ''b''])

cv = KFold(len(labels), n_folds=3)
clf = SVC()
ypred_all = np.chararray((labels.shape))
i = 1
for train_index, test_index in cv.split(X):
    print("iteration", i, ":")
    print("train indices:", train_index)
    print("train data:", X[train_index])
    print("test indices:", test_index)
    print("test data:", X[test_index])
    clf.fit(X[train_index], labels[train_index])
    ypred = clf.predict(X[test_index])
    print("predicted labels for data of indices", test_index, "are:", ypred)
    ypred_all[test_index] = ypred
    print("merged predicted labels:", ypred_all)
    i = i+1
    print("=====================================")
y_cross_val_predict = cross_val_predict(clf, X, labels, cv=cv)
print("predicted labels by cross_val_predict:", y_cross_val_predict)

El resultado es:

iteration 1 :
train indices: [2 3 4 5]
train data: [[2] [3] [4] [5]]
test indices: [0 1]
test data: [[0] [1]]
predicted labels for data of indices [0 1] are: [''b'' ''b'']
merged predicted labels: [''b'' ''b'' '''' '''' '''' '''']
=====================================
iteration 2 :
train indices: [0 1 4 5]
train data: [[0] [1] [4] [5]]
test indices: [2 3]
test data: [[2] [3]]
predicted labels for data of indices [2 3] are: [''a'' ''b'']
merged predicted labels: [''b'' ''b'' ''a'' ''b'' '''' '''']
=====================================
iteration 3 :
train indices: [0 1 2 3]
train data: [[0] [1] [2] [3]]
test indices: [4 5]
test data: [[4] [5]]
predicted labels for data of indices [4 5] are: [''a'' ''a'']
merged predicted labels: [''b'' ''b'' ''a'' ''b'' ''a'' ''a'']
=====================================
predicted labels by cross_val_predict: [''b'' ''b'' ''a'' ''b'' ''a'' ''a'']