Comment créer une matrice de confusion et extraire les vrais et faux positifs et les vrais et faux négatifs en utilisant scikit learn en python ?

Exemples de comment créer une matrice de confusion et extraire les vrais et faux positifs et les vrais et faux négatifs en utilisant scikit learn en python:

Créer une matrice de confusion avec scikit-learn

Pour créer une matrice de confusion, une solution consiste à utiliser scikit-learn :

from sklearn.metrics import confusion_matrix

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

cm = confusion_matrix(y_true, y_pred, labels=[0, 1])

print(cm)

donne

[[1 1]
 [0 3]]

Obtenir tn, fp, fn, tp pour une classification binaire

tn, fp, fn, tp = confusion_matrix(list(y_true), list(y_pred), labels=[0, 1]).ravel()

print('True Positive', tp)
print('True Negative', tn)
print('False Positive', fp)
print('False Negative', fn)

donne

True Positive 3
True Negative 1
False Positive 1
False Negative 0

Calculer le score de précision

from sklearn.metrics import accuracy_score

accuracy_score(y_true, y_pred)

donne

0.8

même chose que de faire

acc = (tp+tn) / (tp+tn+fn+fp)

print(acc)

donne

0.8

Calculer les taux tp, tn, fp et fn

tot = cm.sum()

pareil que

tot = tn+tp+fp+fn

donne ici

5

et alors

print('True Positive Rate', tp/tot)
print('True Negative Rate', tn/tot)
print('False Positive Rate', fp/tot)
print('False Negative Rate', fn/tot)

donne

True Positive Rate 0.6
True Negative Rate 0.2
False Positive Rate 0.2
False Negative Rate 0.0

Obtenez tn, fp, fn, tp avec plus de deux catégories

from sklearn.metrics import confusion_matrix

y_true = [1,1,0,0,1,1,2,2]
y_pred = [1,1,1,0,2,1,2,2]

cm = confusion_matrix(y_true, y_pred, labels=[0, 1])
cm = confusion_matrix(y_true, y_pred)

print(cm)

donne

[[1 1 0]
 [0 3 1]
 [0 0 2]]

et

fp = cm.sum(axis=0) - np.diag(cm)  
fn = cm.sum(axis=1) - np.diag(cm)
tp = np.diag(cm)
tn = cm.sum() - (fp + fn + tp)

print(fp,fn,tp,tn)

donne

[0 1 1] [1 1 0] [1 3 2] [6 3 5]

Obtenir tp, tn, fp, fn pour une catégorie donnée

idx = 0
print(fp[idx], fn[idx], tp[idx], tn[idx])

donne

0 1 1 6

print(fp[idx], fn[idx], tp[idx], tn[idx])

Catégorie 1

idx = 1

donne

1 1 3 3

Catégorie 2

idx = 2

donne

1 0 2 5

Calculer le score de précision

from sklearn.metrics import accuracy_score

accuracy_score(y_true, y_pred)

donne

0.75

pareil que

acc = np.diag(cm).sum() / cm.sum()

Tracer une matrice de confusion avec matplotlib et seaborn

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sn
import pandas as pd

import seaborn as sns
import math

from mpl_toolkits.axes_grid1 import make_axes_locatable

import matplotlib as mpl

mpl.style.use('seaborn')

df_cm = pd.DataFrame(cm, 
    index = [i for i in range(cm.shape[0])],
    columns = [i for i in range(cm.shape[1])])

fig = plt.figure()

plt.clf()

ax = fig.add_subplot(111)
ax.set_aspect(1)

cmap = sns.cubehelix_palette(light=1, as_cmap=True)

res = sn.heatmap(df_cm, annot=True, fmt='.2f', cmap=cmap)

res.invert_yaxis()

#plt.yticks([0.5,1.5,2.5], [ '0', '1', '2'],va='center')

plt.title('Confusion Matrix')

plt.savefig('confusion_matrix_1.png', dpi=100, bbox_inches='tight' )

plt.show()

Normaliser la matrice de confusion

Ajoutez simplement

sum = cm.sum()
cm = cm * 100.0 / ( 1.0 * sum )

et remplacer

res = sn.heatmap(df_cm, annot=True, fmt='.2f', cmap=cmap)

par

res = sn.heatmap(df_cm, annot=True, vmin=0.0, vmax=100.0, fmt='.2f', cmap=cmap)

Références

• Scikit-learn: How to obtain True Positive, True Negative, False Positive and False Negative
• Confusion Matrix