Comment écrire une matrice de confusion en Python?

Scikit-Learn offre un confusion_matrix fonction

from sklearn.metrics import confusion_matrix
y_actu = [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]
confusion_matrix(y_actu, y_pred)

de sortie d'un tableau Numpy

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

Mais vous pouvez également créer une matrice de confusion en utilisant les Pandas:

import pandas as pd
y_actu = pd.Series([2, 0, 2, 2, 0, 1, 1, 2, 2, 0, 1, 2], name='Actual')
y_pred = pd.Series([0, 0, 2, 1, 0, 2, 1, 0, 2, 0, 2, 2], name='Predicted')
df_confusion = pd.crosstab(y_actu, y_pred)

Vous obtiendrez une (bien marqués) les Pandas DataFrame:

Predicted  0  1  2
Actual
0          3  0  0
1          0  1  2
2          2  1  3

Si vous ajoutez margins=True comme

df_confusion = pd.crosstab(y_actu, y_pred, rownames=['Actual'], colnames=['Predicted'], margins=True)

vous aurez également la somme de chaque ligne et colonne:

Predicted  0  1  2  All
Actual
0          3  0  0    3
1          0  1  2    3
2          2  1  3    6
All        5  2  5   12

Vous pouvez également obtenir un normalisée de la confusion de la matrice à l'aide de:

df_conf_norm = df_confusion / df_confusion.sum(axis=1)

Predicted         0         1         2
Actual
0          1.000000  0.000000  0.000000
1          0.000000  0.333333  0.333333
2          0.666667  0.333333  0.500000

Vous pouvez tracer cette confusion_matrix à l'aide de

import matplotlib.pyplot as plt
def plot_confusion_matrix(df_confusion, title='Confusion matrix', cmap=plt.cm.gray_r):
    plt.matshow(df_confusion, cmap=cmap) # imshow
    #plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(df_confusion.columns))
    plt.xticks(tick_marks, df_confusion.columns, rotation=45)
    plt.yticks(tick_marks, df_confusion.index)
    #plt.tight_layout()
    plt.ylabel(df_confusion.index.name)
    plt.xlabel(df_confusion.columns.name)

plot_confusion_matrix(df_confusion)

Ou un terrain normalisé de la confusion de la matrice à l'aide de:

plot_confusion_matrix(df_conf_norm)  

Vous pourriez également être intéressé par ce projet https://github.com/pandas-ml/pandas-ml et son Pip paquet https://pypi.python.org/pypi/pandas_ml

Avec ce forfait, la confusion de la matrice peut être joli imprimé, de l'intrigue.
Vous pouvez binariser une matrice de confusion, obtenir des statistiques de catégories telles que les TP, TN, FP, FN, ACC, TPR, FPR, FNR, TNR (SPC), LR+, LR-, DOR, de TVC, RAD, POUR la VAN et quelques statistiques globales

In [1]: from pandas_ml import ConfusionMatrix
In [2]: y_actu = [2, 0, 2, 2, 0, 1, 1, 2, 2, 0, 1, 2]
In [3]: y_pred = [0, 0, 2, 1, 0, 2, 1, 0, 2, 0, 2, 2]
In [4]: cm = ConfusionMatrix(y_actu, y_pred)
In [5]: cm.print_stats()
Confusion Matrix:
Predicted  0  1  2  __all__
Actual
0          3  0  0        3
1          0  1  2        3
2          2  1  3        6
__all__    5  2  5       12
Overall Statistics:
Accuracy: 0.583333333333
95% CI: (0.27666968568210581, 0.84834777019156982)
No Information Rate: ToDo
P-Value [Acc > NIR]: 0.189264302376
Kappa: 0.354838709677
Mcnemar's Test P-Value: ToDo
Class Statistics:
Classes                                        0          1          2
Population                                    12         12         12
P: Condition positive                          3          3          6
N: Condition negative                          9          9          6
Test outcome positive                          5          2          5
Test outcome negative                          7         10          7
TP: True Positive                              3          1          3
TN: True Negative                              7          8          4
FP: False Positive                             2          1          2
FN: False Negative                             0          2          3
TPR: (Sensitivity, hit rate, recall)           1  0.3333333        0.5
TNR=SPC: (Specificity)                 0.7777778  0.8888889  0.6666667
PPV: Pos Pred Value (Precision)              0.6        0.5        0.6
NPV: Neg Pred Value                            1        0.8  0.5714286
FPR: False-out                         0.2222222  0.1111111  0.3333333
FDR: False Discovery Rate                    0.4        0.5        0.4
FNR: Miss Rate                                 0  0.6666667        0.5
ACC: Accuracy                          0.8333333       0.75  0.5833333
F1 score                                    0.75        0.4  0.5454545
MCC: Matthews correlation coefficient  0.6831301  0.2581989  0.1690309
Informedness                           0.7777778  0.2222222  0.1666667
Markedness                                   0.6        0.3  0.1714286
Prevalence                                  0.25       0.25        0.5
LR+: Positive likelihood ratio               4.5          3        1.5
LR-: Negative likelihood ratio                 0       0.75       0.75
DOR: Diagnostic odds ratio                   inf          4          2
FOR: False omission rate                       0        0.2  0.4285714

J'ai remarqué qu'une nouvelle bibliothèque Python sur la Confusion de la Matrice nommé PyCM est: peut-être vous pouvez avoir un coup d'oeil.

Près d'une décennie s'est écoulée, mais les solutions (sans sklearn) à ce poste sont alambiquées et inutilement long. Le calcul d'une matrice de confusion peut être fait proprement en Python en quelques lignes. Par exemple:

import numpy as np
def compute_confusion_matrix(true, pred):
'''Computes a confusion matrix using numpy for two np.arrays
true and pred.
Results are identical (and similar in computation time) to: 
"from sklearn.metrics import confusion_matrix"
However, this function avoids the dependency on sklearn.'''
K = len(np.unique(true)) # Number of classes 
result = np.zeros((K, K))
for i in range(len(true)):
result[true[i]][pred[i]] += 1
return result

Cette fonction crée de la confusion des matrices pour n'importe quel nombre de classes.

def create_conf_matrix(expected, predicted, n_classes):
m = [[0] * n_classes for i in range(n_classes)]
for pred, exp in zip(predicted, expected):
m[pred][exp] += 1
return m
def calc_accuracy(conf_matrix):
t = sum(sum(l) for l in conf_matrix)
return sum(conf_matrix[i][i] for i in range(len(conf_matrix))) / t

Contrairement à votre fonction ci-dessus, vous devez extraire le prédit de classes avant l'appel de la fonction, basée sur vos résultats de la classification, c'est à dire qqch. comme

[1 if p < .5 else 2 for p in classifications]

Voici une confusion de la matrice de classe qui prend en charge d'impression, etc:

http://nltk.googlecode.com/svn/trunk/doc/api/nltk.metrics.confusionmatrix-pysrc.html

Mise à jour

Depuis la rédaction de ce post, j'ai mis à jour ma bibliothèque de la mise en œuvre d'inclure quelques autres fonctionnalités intéressantes. Comme avec le code ci-dessous, pas de tiers dépendances sont nécessaires. La classe peut également sortie une belle tabulation tableau, semblable à beaucoup d'couramment utilisé des logiciels statistiques. Voir ce Gist.

Exemple d'utilisation de la ci-dessus Gist

# Example Usage
actual      = ["A", "B", "C", "C", "B", "C", "C", "B", "A", "A", "B", "A", "B", "C", "A", "B", "C"]
predicted   = ["A", "B", "B", "C", "A", "C", "A", "B", "C", "A", "B", "B", "B", "C", "A", "A", "C"]
# Initialize Performance Class
performance = Performance(actual, predicted)
# Print Confusion Matrix
performance.tabulate()

Voici un exemple de sortie:

===================================
Aᴬ      Bᴬ      Cᴬ
Aᴾ      3       2       1
Bᴾ      1       4       1
Cᴾ      1       0       4
Note: classᴾ = Predicted, classᴬ = Actual
===================================

En plus de comptages bruts, nous pouvons sortie normalisée de la confusion de la matrice (c'est à dire avec des proportions)

# Print Normalized Confusion Matrix
performance.tabulate(normalized = True)
===================================
Aᴬ      Bᴬ      Cᴬ
Aᴾ      17.65%  11.76%  5.88%
Bᴾ      5.88%   23.53%  5.88%
Cᴾ      5.88%   0.00%   23.53%
Note: classᴾ = Predicted, classᴬ = Actual
===================================

---

Un Simple Multiclass Mise En Œuvre

Un multi-classe de la confusion de la matrice peut être calculée incroyablement simplement avec de la vanille Python dans environ O(N) fois. Tout ce que nous devons faire est de jumeler les classes uniques trouvés dans la actual vecteur dans un 2-dimensions de la liste. À partir de là, il nous suffit de parcourir la zippée actual et predicted de vecteurs et de remplir les comtes.

# A Simple Confusion Matrix Implementation
def confusionmatrix(actual, predicted, normalize = False):
"""
Generate a confusion matrix for multiple classification
@params:
actual      - a list of integers or strings for known classes
predicted   - a list of integers or strings for predicted classes
normalize   - optional boolean for matrix normalization
@return:
matrix      - a 2-dimensional list of pairwise counts
"""
unique = sorted(set(actual))
matrix = [[0 for _ in unique] for _ in unique]
imap   = {key: i for i, key in enumerate(unique)}
# Generate Confusion Matrix
for p, a in zip(predicted, actual):
matrix[imap[p]][imap[a]] += 1
# Matrix Normalization
if normalize:
sigma = sum([sum(matrix[imap[i]]) for i in unique])
matrix = [row for row in map(lambda i: list(map(lambda j: j / sigma, i)), matrix)]
return matrix

Utilisation

# Input Below Should Return: [[2, 1, 0], [0, 2, 1], [1, 2, 1]]
cm = confusionmatrix(
[1, 1, 2, 0, 1, 1, 2, 0, 0, 1], # actual
[0, 1, 1, 0, 2, 1, 2, 2, 0, 2]  # predicted
)
# And The Output
print(cm)
[[2, 1, 0], [0, 2, 1], [1, 2, 1]]

Remarque: la actual classes sont le long des colonnes et la predicted classes sont le long de la lignes de.

# Actual
# 0  1  2
#  #  #   
[[2, 1, 0], # 0
[0, 2, 1], # 1  Predicted
[1, 2, 1]] # 2

Les Noms de classe Peuvent être des Chaînes de caractères ou des nombres Entiers

# Input Below Should Return: [[2, 1, 0], [0, 2, 1], [1, 2, 1]]
cm = confusionmatrix(
["B", "B", "C", "A", "B", "B", "C", "A", "A", "B"], # actual
["A", "B", "B", "A", "C", "B", "C", "C", "A", "C"]  # predicted
)
# And The Output
print(cm)
[[2, 1, 0], [0, 2, 1], [1, 2, 1]]

Vous Pouvez Également Retourner La Matrice Avec Les Proportions (Normalisation)

# Input Below Should Return: [[0.2, 0.1, 0.0], [0.0, 0.2, 0.1], [0.1, 0.2, 0.1]]
cm = confusionmatrix(
["B", "B", "C", "A", "B", "B", "C", "A", "A", "B"], # actual
["A", "B", "B", "A", "C", "B", "C", "C", "A", "C"], # predicted
normalize = True
)
# And The Output
print(cm)
[[0.2, 0.1, 0.0], [0.0, 0.2, 0.1], [0.1, 0.2, 0.1]]

L'extraction de Statistiques à Partir d'une Classification Multiple de la Confusion de la Matrice

Une fois que vous avez la matrice, vous pouvez calculer un tas de statistiques pour évaluer votre classificateur. Cela dit, l'extraction de la valeur d'une confusion configuration de la matrice de classement multiple peut être un peu mal à la tête. Voici une fonction qui renvoie la matrice de confusion et de statistiques par classe:

# Not Required, But Nice For Legibility
from collections import OrderedDict
# A Simple Confusion Matrix Implementation
def confusionmatrix(actual, predicted, normalize = False):
"""
Generate a confusion matrix for multiple classification
@params:
actual      - a list of integers or strings for known classes
predicted   - a list of integers or strings for predicted classes
@return:
matrix      - a 2-dimensional list of pairwise counts
statistics  - a dictionary of statistics for each class
"""
unique = sorted(set(actual))
matrix = [[0 for _ in unique] for _ in unique]
imap   = {key: i for i, key in enumerate(unique)}
# Generate Confusion Matrix
for p, a in zip(predicted, actual):
matrix[imap[p]][imap[a]] += 1
# Get Confusion Matrix Sum
sigma = sum([sum(matrix[imap[i]]) for i in unique])
# Scaffold Statistics Data Structure
statistics = OrderedDict(((i, {"counts" : OrderedDict(), "stats" : OrderedDict()}) for i in unique))
# Iterate Through Classes & Compute Statistics
for i in unique:
loc = matrix[imap[i]][imap[i]]
row = sum(matrix[imap[i]][:])
col = sum([row[imap[i]] for row in matrix])
# Get TP/TN/FP/FN
tp  = loc
fp  = row - loc
fn  = col - loc
tn  = sigma - row - col + loc
# Populate Counts Dictionary
statistics[i]["counts"]["tp"]   = tp
statistics[i]["counts"]["fp"]   = fp
statistics[i]["counts"]["tn"]   = tn
statistics[i]["counts"]["fn"]   = fn
statistics[i]["counts"]["pos"]  = tp + fn
statistics[i]["counts"]["neg"]  = tn + fp
statistics[i]["counts"]["n"]    = tp + tn + fp + fn
# Populate Statistics Dictionary
statistics[i]["stats"]["sensitivity"]   = tp / (tp + fn) if tp > 0 else 0.0
statistics[i]["stats"]["specificity"]   = tn / (tn + fp) if tn > 0 else 0.0
statistics[i]["stats"]["precision"]     = tp / (tp + fp) if tp > 0 else 0.0
statistics[i]["stats"]["recall"]        = tp / (tp + fn) if tp > 0 else 0.0
statistics[i]["stats"]["tpr"]           = tp / (tp + fn) if tp > 0 else 0.0
statistics[i]["stats"]["tnr"]           = tn / (tn + fp) if tn > 0 else 0.0
statistics[i]["stats"]["fpr"]           = fp / (fp + tn) if fp > 0 else 0.0
statistics[i]["stats"]["fnr"]           = fn / (fn + tp) if fn > 0 else 0.0
statistics[i]["stats"]["accuracy"]      = (tp + tn) / (tp + tn + fp + fn) if (tp + tn) > 0 else 0.0
statistics[i]["stats"]["f1score"]       = (2 * tp) / ((2 * tp) + (fp + fn)) if tp > 0 else 0.0
statistics[i]["stats"]["fdr"]           = fp / (fp + tp) if fp > 0 else 0.0
statistics[i]["stats"]["for"]           = fn / (fn + tn) if fn > 0 else 0.0
statistics[i]["stats"]["ppv"]           = tp / (tp + fp) if tp > 0 else 0.0
statistics[i]["stats"]["npv"]           = tn / (tn + fn) if tn > 0 else 0.0
# Matrix Normalization
if normalize:
matrix = [row for row in map(lambda i: list(map(lambda j: j / sigma, i)), matrix)]
return matrix, statistics

Calculée De La Statistique

Ci-dessus, la matrice de confusion est utilisé pour calculer les statistiques pour chaque classe, qui sont retournés dans un OrderedDict avec la structure suivante:

OrderedDict(
[
('A', {
'stats' : OrderedDict([
('sensitivity', 0.6666666666666666), 
('specificity', 0.8571428571428571), 
('precision', 0.6666666666666666), 
('recall', 0.6666666666666666), 
('tpr', 0.6666666666666666), 
('tnr', 0.8571428571428571), 
('fpr', 0.14285714285714285), 
('fnr', 0.3333333333333333), 
('accuracy', 0.8), 
('f1score', 0.6666666666666666), 
('fdr', 0.3333333333333333), 
('for', 0.14285714285714285), 
('ppv', 0.6666666666666666), 
('npv', 0.8571428571428571)
]), 
'counts': OrderedDict([
('tp', 2), 
('fp', 1), 
('tn', 6), 
('fn', 1), 
('pos', 3), 
('neg', 7), 
('n', 10)
])
}), 
('B', {
'stats': OrderedDict([
('sensitivity', 0.4), 
('specificity', 0.8), 
('precision', 0.6666666666666666), 
('recall', 0.4), 
('tpr', 0.4), 
('tnr', 0.8), 
('fpr', 0.2), 
('fnr', 0.6), 
('accuracy', 0.6), 
('f1score', 0.5), 
('fdr', 0.3333333333333333), 
('for', 0.42857142857142855), 
('ppv', 0.6666666666666666), 
('npv', 0.5714285714285714)
]), 
'counts': OrderedDict([
('tp', 2), 
('fp', 1), 
('tn', 4), 
('fn', 3), 
('pos', 5), 
('neg', 5), 
('n', 10)
])
}), 
('C', {
'stats': OrderedDict([
('sensitivity', 0.5), 
('specificity', 0.625), 
('precision', 0.25), 
('recall', 0.5), 
('tpr', 0.5), 
('tnr', 0.625), (
'fpr', 0.375), (
'fnr', 0.5), 
('accuracy', 0.6), 
('f1score', 0.3333333333333333), 
('fdr', 0.75), 
('for', 0.16666666666666666), 
('ppv', 0.25), 
('npv', 0.8333333333333334)
]), 
'counts': OrderedDict([
('tp', 1), 
('fp', 3), 
('tn', 5), 
('fn', 1), 
('pos', 2), 
('neg', 8), 
('n', 10)
])
})
]
)

Dans un sens général, vous allez avoir besoin de changer votre probabilité de tableau. Au lieu d'avoir un seul numéro pour chaque instance et de la classification basée sur si oui ou non il est de plus de 0,5, vous allez avoir besoin d'une liste de scores (un pour chaque classe), puis prendre le plus grand des notes de la classe qui a été choisie (un.k.un. argmax).

Vous pouvez utiliser un dictionnaire pour tenir les probabilités pour chaque classification:

prob_arr = [{classification_id: probability}, ...]

Le choix d'une classification serait quelque chose comme:

for instance_scores in prob_arr :
predicted_classes = [cls for (cls, score) in instance_scores.iteritems() if score = max(instance_scores.values())]

Cette traite le cas où les deux classes ont les mêmes scores. Vous pouvez obtenir un score, en choisissant la première dans cette liste, mais la façon dont vous gérer cela dépend de ce que vous êtes le classement.

Une fois que vous avez votre liste de prédit de classes et d'une liste de prévu de classes, vous pouvez utiliser le code Torsten Marek's pour créer la confusion tableau et calculer l'exactitude.

Seulement avec numpy, nous pouvons le faire comme suit compte tenu de l'efficacité:

def confusion_matrix(pred, label, nc=None):
assert pred.size == label.size
if nc is None:
nc = len(unique(label))
logging.debug("Number of classes assumed to be {}".format(nc))
confusion = np.zeros([nc, nc])
# avoid the confusion with `0`
tran_pred = pred + 1
for i in xrange(nc):    # current class
mask = (label == i)
masked_pred = mask * tran_pred
cls, counts = unique(masked_pred, return_counts=True)
# discard the first item
cls = [cl - 1 for cl in cls][1:]
counts = counts[1:]
for cl, count in zip(cls, counts):
confusion[i, cl] = count
return confusion

Pour d'autres fonctionnalités comme l'intrigue, le moyen-reconnaissance de dette, voir mes dépôts.