Scikit-aprender: Cómo obtener Verdadero Positivo, Verdadero Negativo, Falso Positivo y Falso Negativo

Para el caso multi-clase, todo lo que necesita se puede encontrar en la matriz de confusión. Por ejemplo, si su matriz de confusión se ve así:

Entonces lo que estás buscando, por clase, se puede encontrar así:

Usando pandas / numpy, puede hacer esto para todas las clases a la vez de la siguiente manera:

FP = confusion_matrix.sum(axis=0) - np.diag(confusion_matrix)  
FN = confusion_matrix.sum(axis=1) - np.diag(confusion_matrix)
TP = np.diag(confusion_matrix)
TN = confusion_matrix.values.sum() - (FP + FN + TP)

# Sensitivity, hit rate, recall, or true positive rate
TPR = TP/(TP+FN)
# Specificity or true negative rate
TNR = TN/(TN+FP) 
# Precision or positive predictive value
PPV = TP/(TP+FP)
# Negative predictive value
NPV = TN/(TN+FN)
# Fall out or false positive rate
FPR = FP/(FP+TN)
# False negative rate
FNR = FN/(TP+FN)
# False discovery rate
FDR = FP/(TP+FP)

# Overall accuracy
ACC = (TP+TN)/(TP+FP+FN+TN)

Puede obtener todos los parámetros de la matriz de confusión. La estructura de la matriz de confusión(que es la matriz 2X2) es la siguiente

TP|FP
FN|TN

So

TP = cm[0][0]
FP = cm[0][1]
FN = cm[1][0]
TN = cm[1][1]

Más detalles en https://en.wikipedia.org/wiki/Confusion_matrix

De acuerdo con la documentación de scikit-learn,

Http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html#sklearn.metrics.confusion_matrix

Por definición, una matriz de confusión C es tal que C [i, j] es igual al número de observaciones conocidas por estar en el grupo i pero predichas por estar en el grupo j.

Así, en la clasificación binaria, el recuento de negativos verdaderos es C [0,0], negativos falsos es C [1,0], positivos verdaderos es C [1,1] y falsos positivos es C[0,1].

CM = confusion_matrix(y_true, y_pred)

TN = CM[0][0]
FN = CM[1][0]
TP = CM[1][1]
FP = CM[0][1]

En la biblioteca 'metrics' de scikit-learn hay un método confusion_matrix que le da la salida deseada.

Puede utilizar cualquier clasificador que desee. Aquí usé los rodilleros como ejemplo.

from sklearn import metrics, neighbors

clf = neighbors.KNeighborsClassifier()

X_test = ...
y_test = ...

expected = y_test
predicted = clf.predict(X_test)

conf_matrix = metrics.confusion_matrix(expected, predicted)

>>> print conf_matrix
>>>  [[1403   87]
     [  56 3159]]

Los documentos: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html#sklearn.metrics.confusion_matrix

Puedes probar sklearn.metrics.classification_report de la siguiente manera:

import sklearn
y_true = [1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]
y_pred = [1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0]

print sklearn.metrics.classification_report(y_true, y_pred)

Salida:

         precision    recall  f1-score   support

      0       0.80      0.57      0.67         7
      1       0.50      0.75      0.60         4

      avg / total       0.69      0.64      0.64        11

Creo que ambas respuestas no son totalmente correctas. Por ejemplo, supongamos que tenemos los siguientes arrays;
y_actual = [1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]

Y_predic = [1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0]

Si calculamos los valores FP, FN, TP y TN manualmente, deben ser los siguientes:

PF: 3 FN: 1 TP: 3 TN: 4

Sin embargo, si usamos la primera respuesta, los resultados se dan de la siguiente manera:

PF: 1 FN: 3 TP: 3 TN: 4

No son correctos, porque en la primera respuesta, el Falso positivo debe ser donde real es 0, pero el predicho es 1, no lo contrario. También es lo mismo para el Falso Negativo.

Y, si usamos la segunda respuesta, los resultados se calculan de la siguiente manera:

PF: 3 FN: 1 TP: 4 TN: 3

Los números Verdaderos Positivos y Verdaderos Negativos no son correctos, deben ser opuestos.

¿Estoy en lo correcto con mis cálculos? Por favor, hágamelo saber si me estoy perdiendo algo.

Si tiene más de una clase en su clasificador, es posible que desee usar pandas-ml en esa parte. La matriz de confusión de pandas-ml proporciona información más detallada. compruebe que

Escribí una versión que funciona usando solo numpy. Espero que te ayude.

import numpy as np

def perf_metrics_2X2(yobs, yhat):
    """
    Returns the specificity, sensitivity, positive predictive value, and 
    negative predictive value 
    of a 2X2 table.

    where:
    0 = negative case
    1 = positive case

    Parameters
    ----------
    yobs :  array of positive and negative ``observed`` cases
    yhat : array of positive and negative ``predicted`` cases

    Returns
    -------
    sensitivity  = TP / (TP+FN)
    specificity  = TN / (TN+FP)
    pos_pred_val = TP/ (TP+FP)
    neg_pred_val = TN/ (TN+FN)

    Author: Julio Cardenas-Rodriguez
    """
    TP = np.sum(  yobs[yobs==1] == yhat[yobs==1] )
    TN = np.sum(  yobs[yobs==0] == yhat[yobs==0] )
    FP = np.sum(  yobs[yobs==1] == yhat[yobs==0] )
    FN = np.sum(  yobs[yobs==0] == yhat[yobs==1] )

    sensitivity  = TP / (TP+FN)
    specificity  = TN / (TN+FP)
    pos_pred_val = TP/ (TP+FP)
    neg_pred_val = TN/ (TN+FN)

    return sensitivity, specificity, pos_pred_val, neg_pred_val

Aquí hay una solución al código de error de invoketheshell (que actualmente aparece como la respuesta aceptada):

def performance_measure(y_actual, y_hat):
    TP = 0
    FP = 0
    TN = 0
    FN = 0

    for i in range(len(y_hat)): 
        if y_actual[i] == y_hat[i]==1:
            TP += 1
        if y_hat[i] == 1 and y_actual[i] == 0:
            FP += 1
        if y_hat[i] == y_actual[i] == 0:
            TN +=1
        if y_hat[i] == 0 and y_actual[i] == 1:
            FN +=1

    return(TP, FP, TN, FN)