# Confusion Matrix - Get Items FP/FN/TP/TN - Python

After run my python code:

print(confusion_matrix(x_test, x_pred))


I get this: [100 32 211 21]

My question is how can I get the following list:

• True positive = 100
• False positive = 32
• False negative = 211
• True negative = 21

Is this possible?

• Just use list indexing? If it's in an image form, then we have to manually code them up Mar 2 '18 at 0:35

Considering you have two lists y_actual and y_pred ( I assume you made a typo error on x_test and x_pred as in your code), you can pass the two lists to this function to parse them

def perf_measure(y_actual, y_pred):
TP = 0
FP = 0
TN = 0
FN = 0

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

return(TP, FP, TN, FN)


Alternatively, if confusion matrix is a 2x2 matrix (named cm), you can use

TP = cm
FP = cm
FN = cm
TN = cm


Create a method that does the printing for you:

def print_confusion_matrix(y_true, y_pred):
cm = confusion_matrix(y_true, y_pred)
print('True positive = ', cm)
print('False positive = ', cm)
print('False negative = ', cm)
print('True negative = ', cm)


And use it like this

print_confusion_matrix(x_test, x_pred)


Alternatively, if you want the values return and not only printed you can do it like this:

def get_confusion_matrix_values(y_true, y_pred):
cm = confusion_matrix(y_true, y_pred)
return(cm, cm, cm, cm)

TP, FP, FN, TN = get_confusion_matrix_values(x_test, x_pred)


In your case you can use

conf = confusion_matrix(x_test, x_pred)
TP = conf[0,0]
FP = conf[0,1]
TN = conf[1,0]
FN = conf[1,1]


I suggest PyCM lib for confusion matrix analysis.

Example :

>>> from pycm import *
>>> y_actu = [2, 0, 2, 2, 0, 1, 1, 2, 2, 0, 1, 2] # or y_actu = numpy.array([2, 0, 2, 2, 0, 1, 1, 2, 2, 0, 1, 2])
>>> y_pred = [0, 0, 2, 1, 0, 2, 1, 0, 2, 0, 2, 2] # or y_pred = numpy.array([0, 0, 2, 1, 0, 2, 1, 0, 2, 0, 2, 2])
>>> cm = ConfusionMatrix(actual_vector=y_actu, predict_vector=y_pred) # Create CM From Data
>>> cm.classes
[0, 1, 2]
>>> cm.table
{0: {0: 3, 1: 0, 2: 0}, 1: {0: 0, 1: 1, 2: 2}, 2: {0: 2, 1: 1, 2: 3}}
>>> print(cm)
Predict          0        1        2
Actual
0                3        0        0
1                0        1        2
2                2        1        3

Overall Statistics :

95% CI                                                           (0.30439,0.86228)
Bennett_S                                                        0.375
Chi-Squared                                                      6.6
Chi-Squared DF                                                   4
Conditional Entropy                                              0.95915
Cramer_V                                                         0.5244
Cross Entropy                                                    1.59352
Gwet_AC1                                                         0.38931
Joint Entropy                                                    2.45915
KL Divergence                                                    0.09352
Kappa                                                            0.35484
Kappa 95% CI                                                     (-0.07708,0.78675)
Kappa No Prevalence                                              0.16667
Kappa Standard Error                                             0.22036
Kappa Unbiased                                                   0.34426
Lambda A                                                         0.16667
Lambda B                                                         0.42857
Mutual Information                                               0.52421
Overall_ACC                                                      0.58333
Overall_RACC                                                     0.35417
Overall_RACCU                                                    0.36458
PPV_Macro                                                        0.56667
PPV_Micro                                                        0.58333
Phi-Squared                                                      0.55
Reference Entropy                                                1.5
Response Entropy                                                 1.48336
Scott_PI                                                         0.34426
Standard Error                                                   0.14232
Strength_Of_Agreement(Altman)                                    Fair
Strength_Of_Agreement(Cicchetti)                                 Poor
Strength_Of_Agreement(Fleiss)                                    Poor
Strength_Of_Agreement(Landis and Koch)                           Fair
TPR_Macro                                                        0.61111
TPR_Micro                                                        0.58333

Class Statistics :

Classes                                                          0                       1                       2
ACC(Accuracy)                                                    0.83333                 0.75                    0.58333
BM(Informedness or bookmaker informedness)                       0.77778                 0.22222                 0.16667
DOR(Diagnostic odds ratio)                                       None                    4.0                     2.0
ERR(Error rate)                                                  0.16667                 0.25                    0.41667
F0.5(F0.5 score)                                                 0.65217                 0.45455                 0.57692
F1(F1 score - harmonic mean of precision and sensitivity)        0.75                    0.4                     0.54545
F2(F2 score)                                                     0.88235                 0.35714                 0.51724
FDR(False discovery rate)                                        0.4                     0.5                     0.4
FN(False negative/miss/type 2 error)                             0                       2                       3
FNR(Miss rate or false negative rate)                            0.0                     0.66667                 0.5
FOR(False omission rate)                                         0.0                     0.2                     0.42857
FP(False positive/type 1 error/false alarm)                      2                       1                       2
FPR(Fall-out or false positive rate)                             0.22222                 0.11111                 0.33333
G(G-measure geometric mean of precision and sensitivity)         0.7746                  0.40825                 0.54772
LR+(Positive likelihood ratio)                                   4.5                     3.0                     1.5
LR-(Negative likelihood ratio)                                   0.0                     0.75                    0.75
MCC(Matthews correlation coefficient)                            0.68313                 0.2582                  0.16903
MK(Markedness)                                                   0.6                     0.3                     0.17143
N(Condition negative)                                            9                       9                       6
NPV(Negative predictive value)                                   1.0                     0.8                     0.57143
P(Condition positive)                                            3                       3                       6
POP(Population)                                                  12                      12                      12
PPV(Precision or positive predictive value)                      0.6                     0.5                     0.6
PRE(Prevalence)                                                  0.25                    0.25                    0.5
RACC(Random accuracy)                                            0.10417                 0.04167                 0.20833
RACCU(Random accuracy unbiased)                                  0.11111                 0.0434                  0.21007
TN(True negative/correct rejection)                              7                       8                       4
TNR(Specificity or true negative rate)                           0.77778                 0.88889                 0.66667
TON(Test outcome negative)                                       7                       10                      7
TOP(Test outcome positive)                                       5                       2                       5
TP(True positive/hit)                                            3                       1                       3
TPR(Sensitivity, recall, hit rate, or true positive rate)        1.0                     0.33333                 0.5

>>> cm.matrix()
Predict          0        1        2
Actual
0                3        0        0
1                0        1        2
2                2        1        3

>>> cm.normalized_matrix()
Predict          0              1              2
Actual
0                1.0            0.0            0.0
1                0.0            0.33333        0.66667
2                0.33333        0.16667        0.5


If you are using scikit-learn you can use it like this:

In the binary case, we can extract true positives, etc as follows:

tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()


where y_true is the actual values and y_pred is the predicted values

See more details in the documentation

tn, fp, fn, tp = confusion_matrix(x_test,x_predictions,labels).ravel()

@Srihari's answer works well but pays attention to the indention of the 'return'. Currently, it is written as follows:

def perf_measure(..., ...):
for i in range(...):
if():
...

return (FP, TN, ...)



This return: "SyntaxError: 'return' outside function ". The normal indement should be:

def perf_measure(..., ...):
for i in range(...):
if():
...

return (FP, TN, ...)

import sklearn
from sklearn.metrics import confusion_matrix
actual = [1, -1, 1, 1, -1, 1]
predicted = [1, 1, 1, -1, -1, 1]
confusion_matrix(actual, predicted)


output would be

array([[1, 1],
[1, 3]])


For TP (truly predicted as positive), TN, FP, FN

c = confusion_matrix(actual, predicted)
TN, FP, FN, TP =  confusion_matrix = c, c, c,c