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)