Scikit-lernen: So erhalten Sie True Positive, True Negative, False Positive und False Negative

Question

Ich bin neu im maschinellen Lernen und in scikit-learn.

Mein Problem:

(Bitte korrigieren Sie jede Art von missconception)

Ich habe einen Datensatz, der ein BIG JSON ist, rufe ich sie und speichern sie in einer trainList variabel.

Ich pre-Prozess es um damit arbeiten zu können.

Sobald ich das getan haben, ich die Klassifizierung beginnen:

1. I kfold Kreuzvalidierungsmethode verwenden, um die mittlere Genauigkeit zu erhalten, und ich trainiere einen Klassifikator.
2. Ich mache die Voraussagen und ich erhalte die Genauigkeit und Verwirrung Matrix dieser Falte.
3. Danach möchte ich die True Positive (TP), True Negative (TN), False Positive (FP) und False Negative (FN) -Werte erhalten. Ich würde diese Parameter verwenden, um die Sensitivität und die Spezifität zu erhalten, und ich würde ihnen und der Summe der TPs einen HTML geben, um ein Diagramm mit den TPs jedes Etiketts zu zeigen.

Code:

Die Variablen, die ich für den Moment haben:

trainList #It is a list with all the data of my dataset in JSON form 
labelList #It is a list with all the labels of my data 

Der größte Teil des Verfahrens:

#I transform the data from JSON form to a numerical one 
X=vec.fit_transform(trainList) 

#I scale the matrix (don't know why but without it, it makes an error) 
X=preprocessing.scale(X.toarray()) 

#I generate a KFold in order to make cross validation 
kf = KFold(len(X), n_folds=10, indices=True, shuffle=True, random_state=1) 

#I start the cross validation 
for train_indices, test_indices in kf: 
    X_train=[X[ii] for ii in train_indices] 
    X_test=[X[ii] for ii in test_indices] 
    y_train=[listaLabels[ii] for ii in train_indices] 
    y_test=[listaLabels[ii] for ii in test_indices] 

    #I train the classifier 
    trained=qda.fit(X_train,y_train) 

    #I make the predictions 
    predicted=qda.predict(X_test) 

    #I obtain the accuracy of this fold 
    ac=accuracy_score(predicted,y_test) 

    #I obtain the confusion matrix 
    cm=confusion_matrix(y_test, predicted) 

    #I should calculate the TP,TN, FP and FN 
    #I don't know how to continue 

Answer 1

Wenn Sie zwei Listen, die die vorhergesagten und tatsächlichen haben Werte; wie es scheint, die Sie tun können Sie sie an eine Funktion, die TP, FP, TN, FN mit etwas wie folgt berechnen wird:

def perf_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]!=y_hat[i]: 
      FP += 1 
     if y_actual[i]==y_hat[i]==0: 
      TN += 1 
     if y_hat[i]==0 and y_actual[i]!=y_hat[i]: 
      FN += 1 

return(TP, FP, TN, FN) 

Von hier denke ich, Sie in der Lage sein werden die Preise für Sie von Interesse zu berechnen, und andere Leistungsmaßstab wie Spezifität und Empfindlichkeit.

Answer 2

Sie können alle Parameter erhalten aus die Konfusionsmatrix. Die Struktur der Konfusionsmatrix (die Matrix 2X2) ist wie folgt

TP|FP 
FN|TN 

So

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

Weitere Details unter https://en.wikipedia.org/wiki/Confusion_matrix

Answer 3

Ich denke, dass beide Antworten nicht vollständig korrekt sind.Angenommen, wir haben die folgenden 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]

Wenn wir die FP, FN, TP und TN Werte manuell zu berechnen, sollten sie sich wie folgt:

FP: 3 FN: 1 TP: 3 TN: 4

Wenn wir jedoch die erste Antwort verwenden, werden die Ergebnisse wie folgt angegeben:

FP: 1 FN: 3 TP: 3 TN: 4

Sie sind nicht korrekt, denn in der ersten Antwort False Positive sein sollte tatsächliche wobei 0, aber die vorhergesagten 1, nicht das Gegenteil . Es ist auch dasselbe für falsches Negativ.

Und wenn wir die zweite Antwort verwenden, werden die Ergebnisse wie folgt berechnet:

FP: 3 FN: 1 TP: 4 TN: 3

Wahre Positive und Wahre Negative Zahlen sind nicht korrekt, sie sollten entgegengesetzt sein.

Bin ich richtig mit meinen Berechnungen? Bitte lassen Sie mich wissen, wenn ich etwas vermisse.

Answer 4

Nach Scikit-Learn Dokumentation

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

per Definition eine Konfusionsmatrix C so ist, dass C [i, j], das die Anzahl der Beobachtungen gleich ist bekannt, in der Gruppe zu sein, i, aber vorhergesagt in Gruppe j sein.

Somit ist in der binären Klassifikation die Anzahl der wahren negativen Werte C [0,0], falsche negative Werte C [1,0], wahre positive Werte C [1,1] und falsche positive Werte 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] 

Answer 5

Wenn Sie mehr als eine Klasse in Ihrem Klassifikator haben, möchten Sie möglicherweise pandas-ml in diesem Teil verwenden. Confusion Matrix von Pandas-ml geben detailliertere Informationen. check that

Answer 6

Für die Multi-Class-Fall alles, was Sie können, müssen aus der Konfusionsmatrix gefunden werden.Zum Beispiel sieht, wenn Ihr Konfusionsmatrix wie folgt aus:

Dann, was Sie suchen, pro Klasse, kann wie folgt gefunden werden:

Mit Pandas/numpy

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) 

Answer 7

im scikit-Learn ‚Metriken‘ Bibliothek gibt es eine confusio:, Sie dies für alle Klassen auf einmal wie so tun können, n_matrix-Methode, die Ihnen die gewünschte Ausgabe liefert.

Sie können einen beliebigen Klassifizierer verwenden. Hier habe ich die KNeighbors als Beispiel benutzt.

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

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

Answer 8

Hier ist ein Update des fehlerhaften Code invoketheshell (die derzeit als die akzeptierten Antwort erscheint):

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) 

Answer 9

Ich schrieb eine Version, die mit nur numpy funktioniert. Ich hoffe es hilft dir.

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