混淆矩阵——矩阵可视化

余将董道而不豫兮

已于 2024-06-11 17:03:17 修改

阅读量1.6k

点赞数 23

分类专栏：漫漫 TensorFlow 修仙路文章标签：神经网络人工智能深度学习机器学习 python

于 2023-12-24 13:31:09 首次发布

本文链接：https://blog.csdn.net/kkkaiyu/article/details/135180884

版权

漫漫 TensorFlow 修仙路专栏收录该内容

6 篇文章 0 订阅

订阅专栏

相关文章

混淆矩阵——矩阵可视化
混淆矩阵——评估指标
关于本文中存在的错误已有细心网友指出，特此声明

import numpy as np
import seaborn as sns
import tensorflow as tf
from matplotlib import pyplot as plt
from sklearn.metrics import confusion_matrix

正例 and 负例

在二分类中

正例是指在分类问题中，被标记为目标类别的样本。在二分类问题中，正例（Positive）代表我们感兴趣的目标，而另一个类别定义为反例（Negative）

举个栗子🌰，我们要区分苹果🍎和凤梨🍐。我们想要的是苹果，在这种情况下，我们将苹果定义为正例，凤梨则为反例

当我们使用构建的模型对苹果和梨分类时

被分类的是🍎（正例），如果模型分类对了，那就是真正例（TP）
被分类的是🍎（正例），如果模型分类错了，那就是假正例（FP）
被分类的是🍐（反例），如果模型分类对了，那就是真反例（TN）
被分类的是🍐（反例），如果模型分类错了，那就是假正例（FN）

T/F表示是否被分类正确，P/N表示是正例 or 反例

在多分类中

还是大差不差，但在多分类中要看我们进行分类的对象了（👏👏此对象非彼对象！！！）

举个栗子🌰，我们要区分苹果🍎、凤梨🍐和橘子🍊

当对象为苹果🍎，也就是说我们想要的是苹果时，在这种情况下，苹果为正例，其他的（凤梨、橘子）则为反例
- 被分类的是🍎（正例），如果模型分类正确，那就是真正例（TP）
- 被分类的是🍎（正例），如果模型分类错误，那就是假正例（FP）
- 被分类的是🍐|🍊（反例），如果模型分类正确，那就是真反例（TN）
- 被分类的是🍐|🍊（反例），如果模型分类错误，那就是假正例（FN）
当对象为凤梨🍐，也就是说我们想要的是凤梨时，在这种情况下，凤梨为正例，其他的（苹果、橘子）则为反例
- 被分类的是🍐（正例），如果模型分类正确，那就是真正例（TP）
- 被分类的是🍐（正例），如果模型分类错误，那就是假正例（FP）
- 被分类的是🍎|🍊（反例），如果模型分类正确，那就是真反例（TN）
- 被分类的是🍎|🍊（反例），如果模型分类错误，那就是假正例（FN）
当对象为橘子🍊，也就是说我们想要的是橘子时，在这种情况下，橘子为正例，其他的（苹果、凤梨）则为反例
- 被分类的是🍊（正例），如果模型分类正确，那就是真正例（TP）
- 被分类的是🍊（正例），如果模型分类错误，那就是假正例（FP）
- 被分类的是🍎|🍐（反例），如果模型分类正确，那就是真反例（TN）
- 被分类的是🍎|🍐（反例），如果模型分类错误，那就是假正例（FN）

总而言之，言而总之，在对分类中要计算 TP、FP、TN、FN 要将每一个类别作为对象依次计算。倘若可以得到混淆矩阵，就犹如有手握屠龙宝刀方便多了

那混淆矩阵是啥子嘛

通过将模型的预测结果与真实标签进行比较，可以得出混淆矩阵（Confusion Matrix）。以帮助我们了解模型在不同类别上的分类情况，根据混淆矩阵我们可以计算出真正例（True Positive, TP）、真反例（True Negative, TN）、假正例（False Positive, FP）和假反例（False Negative, FN）。进而计算出准确率（Accuracy）、精确率（Precision）、召回率（Recall）、F1值（F1 Score）

cm = [[50, 0, 1, 3],
      [0, 60, 0, 1],
      [2, 4, 29, 0],
      [4, 4, 1, 57]]
classes = ['cat', 'dog', 'pig', 'bird']
sns.heatmap(data=cm, annot=True,
            xticklabels=classes,
            yticklabels=classes,
            cmap='GnBu')
plt.xlabel('Pred')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()

诸君且看，这张便是混淆矩阵的可视化图。X轴是模型的预测结果，Y轴是正确标签。每一个单元标注了预测正确的数量，笔者的看图方式是，从左到右一列一列竖着看。

cat 的[50, 0, 2, 4]列，即此时的对象为 cat ，正例为 cat

与Y轴的正确标签相比，预测结果与正确标签对应上的是是50个，故TP=50
此时正例为 cat，而剩下的[0, 2, 4]为预测错误的，故FP=0+2+4=6
cat 列[50, 0, 2, 4]已经看完了，剩下的都是反例了。反例中，预测对的就是那几个颜色深的[60, 29, 57]（当然，cat 列里的50不算，因为这是正例） ,故TN=60+29+57=146
至此，TP、FP、TN都已计算出，而FN就是矩阵内数值总和减去TP、FP、TN这三。故FN=216-50-6-146=14

对于 cat 而言，TP=50、FP=6、TN=146、FN=14
混淆矩阵.png

混淆矩阵计算

sklearn.metrics.confusion_matrix 计算

cm = confusion_matrix(y_true=true, y_pred=pred)
print(cm)
===================
输出：
[[3 0 0 0 0]
 [0 2 0 0 0]
 [0 1 2 0 0]
 [0 0 1 3 0]
 [0 0 0 0 3]]

tf.math.confusion_matrix 计算

# 设置预测结果
pred = [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
# 设置正确标签
true = [0, 1, 2, 3, 4, 0, 2, 2, 3, 4, 0, 1, 3, 3, 4]

cm = tf.math.confusion_matrix(labels=true, predictions=pred).numpy()
print(cm)
===================
输出：
[[3 0 0 0 0]
 [0 2 0 0 0]
 [0 1 2 0 0]
 [0 0 1 3 0]
 [0 0 0 0 3]]

计算 TP TF NP NF

cm = [[49, 0, 1, 1, 0, 1, 0, 1, 5, 2, 3, 4],
      [0, 60, 0, 1, 1, 0, 1, 0, 4, 2, 3, 0],
      [2, 0, 33, 0, 1, 2, 1, 2, 1, 0, 1, 4],
      [0, 1, 1, 63, 1, 0, 0, 1, 3, 0, 1, 0],
      [0, 1, 0, 0, 53, 3, 0, 1, 2, 3, 1, 2],
      [0, 0, 0, 1, 0, 75, 0, 0, 0, 3, 3, 1],
      [1, 1, 1, 0, 1, 1, 40, 2, 2, 0, 3, 1],
      [0, 0, 0, 0, 0, 0, 0, 60, 1, 0, 0, 0],
      [1, 0, 0, 0, 0, 0, 1, 0, 75, 0, 2, 1],
      [1, 1, 2, 0, 1, 2, 1, 0, 5, 72, 1, 4],
      [0, 1, 0, 0, 0, 2, 0, 1, 0, 3, 65, 0],
      [1, 1, 0, 1, 1, 0, 1, 0, 5, 0, 1, 51]]
cm = np.array(cm)

# 计算混淆矩阵的总和
total = np.sum(cm)
# 计算那条深色斜线的总和
line = np.sum([cm[i, i] for i in range(len(cm))])
# 储存每个类别的 TP TF NP NF
classes_list = []
for i in range(len(cm)):
    TP = cm[i, i]
    TN = line - TP
    FP = sum(cm[:, i]) - TP
    FN = total - TP - TN - FP
    classes_list.append({i: {'tp': TP, 'tn': TN, 'fp': FP, 'fn': FN}})

classes_list
===================
输出：
[{0: {'tp': 49, 'tn': 647, 'fp': 6, 'fn': 122}}, 
 {1: {'tp': 60, 'tn': 636, 'fp': 6, 'fn': 122}}, 
 {2: {'tp': 33, 'tn': 663, 'fp': 5, 'fn': 123}}, 
 {3: {'tp': 63, 'tn': 633, 'fp': 4, 'fn': 124}},
 {4: {'tp': 53, 'tn': 643, 'fp': 6, 'fn': 122}},
 {5: {'tp': 75, 'tn': 621, 'fp': 11, 'fn': 117}},
 {6: {'tp': 40, 'tn': 656, 'fp': 5, 'fn': 123}},
 {7: {'tp': 60, 'tn': 636, 'fp': 8, 'fn': 120}},
 {8: {'tp': 75, 'tn': 621, 'fp': 28, 'fn': 100}},
 {9: {'tp': 72, 'tn': 624, 'fp': 13, 'fn': 115}},
 {10: {'tp': 65, 'tn': 631, 'fp': 19, 'fn': 109}},
 {11: {'tp': 51, 'tn': 645, 'fp': 17, 'fn': 111}}]

混淆矩阵绘图

方式 1（使用seaborn）

# 定义类12个类别
classes = range(12)
# annot 显示区块的数值
# xticklabels X轴显示内容
# yticklabels Y轴显示内容
sns.heatmap(data=cm, annot=True,
            xticklabels=classes,
            yticklabels=classes,
            cmap='GnBu')

plt.xlabel('Pred')
plt.ylabel('True')
plt.title('Confusion Matrix')
plt.show()

方式 2（使用matplotlib）

# 定义类12个类别
classes = range(12)
for y in range(cm.shape[0]):
    for x in range(cm.shape[1]):
        # 在中心标注数值
        plt.text(y, x, cm[y][x], horizontalalignment='center', verticalalignment='center')

plt.imshow(cm, cmap='GnBu')
plt.colorbar()
plt.xlabel('Pred')
plt.ylabel('True')
plt.xticks(classes)
plt.yticks(classes)
plt.grid(False)
plt.title('Confusion Matrix')
plt.show()