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?
$\begingroup$
$\endgroup$
1
-
$\begingroup$ Just use list indexing? If it's in an image form, then we have to manually code them up $\endgroup$– AdityaMar 2, 2018 at 0:35
Add a comment
|
9 Answers
$\begingroup$
$\endgroup$
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[0][0]
FP = cm[0][1]
FN = cm[1][0]
TN = cm[1][1]
$\begingroup$
$\endgroup$
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[0][0])
print('False positive = ', cm[0][1])
print('False negative = ', cm[1][0])
print('True negative = ', cm[1][1])
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[0][0], cm[0][1], cm[1][0], cm[1][1])
TP, FP, FN, TN = get_confusion_matrix_values(x_test, x_pred)
$\begingroup$
$\endgroup$
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]
$\begingroup$
$\endgroup$
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
$\begingroup$
$\endgroup$
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
$\begingroup$
$\endgroup$
tn, fp, fn, tp = confusion_matrix(x_test,x_predictions,labels).ravel()
$\begingroup$
$\endgroup$
@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, ...)
$\begingroup$
$\endgroup$
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[0][0], c[0][1], c[1][0],c[1][1]
answered Oct 26, 2020 at 8:39
$\begingroup$
$\endgroup$
Classification Task: Anamoly detection; (y=1 -> anamoly, y=0 -> not an anamoly)
𝑡𝑝 is the number of true positives: the ground truth label says it’s an anomaly and our algorithm correctly classified it as an anomaly.
𝑡𝑛 is the number of true negatives: the ground truth label says it’s not an anomaly and our algorithm correctly classified it as not an anomaly.
𝑓𝑝 is the number of false positives: the ground truth label says it’s not an anomaly, but our algorithm incorrectly classified it as an anomaly.
𝑓𝑛 is the number of false negatives: the ground truth label says it’s an anomaly, but our algorithm incorrectly classified it as not being.
Here is a vectorized implementation.
def perf_measure(y_actual, y_pred):
tp = np.sum((y_actual==1) & (y_pred==1))
tn = np.sum((y_actual==0) & (y_pred==0))
fp = np.sum((y_actual==0) & (y_pred==1))
fn = np.sum((y_actual==1) & (y_pred==0))
return(tp, tn, fp, fn)
