机器学习中的混淆矩阵

在我们的机器学习教程（前面的章节Python和NumPy的神经网络和神经网络从头开始），我们实现的各种算法，但是我们没有正确地测量输出的质量。主要原因是我们使用非常简单的小数据集来学习和测试。在Neural Network: Testing with MNIST一章中，我们将使用大型数据集和 10 个类，因此我们需要适当的评估工具。本章我们将介绍混淆矩阵的概念：

甲混淆矩阵是可用于测量机器学习算法的性能的矩阵（表），通常是一个监督学习一个。混淆矩阵的每一行代表一个实际类的实例，每一列代表一个预测类的实例。这是我们在教程的这一章中保留它的方式，但也可以是相反的方式，即预测类的行和实际类的列。名称混淆矩阵反映了这样一个事实，即它让我们很容易看到我们的分类算法中发生了什么样的混淆。例如，算法应该将样本预测为C一世 因为实际的类是 C一世，但算法出来了 Cj. 在这种错误标记元素的情况下C米[一世,j] 构造混淆矩阵时，将增加 1。

我们将在以下课程中定义计算混淆矩阵、精度和召回率的方法。

2级案例

在 2 类情况下，即“负”和“正”，混淆矩阵可能如下所示：

	预料到的
实际的		消极的	积极的
	消极的	11	0
	积极的	1	12

矩阵的字段含义如下：

	预料到的
实际的		消极的	积极的
	消极的	TN 真阳性	FP 误报
	积极的	FN 假阴性	TP 真阳性

我们现在可以定义机器学习中使用的一些重要性能指标：

准确度：

一个C=吨N+吨磷吨N+F磷+FN+吨磷

准确性并不总是一个足够的性能衡量标准。假设我们有 1000 个样本。其中 995 例为阴性，5 例为阳性。让我们进一步假设我们有一个分类器，它将任何将呈现为否定的内容分类。即使分类器无法识别任何正样本，准确率也会达到惊人的 99.5%。

回想一下。真阳性率：

r电子C一个升升=吨磷FN+吨磷

真负利率：

吨N电阻=F磷吨N+F磷

精度：

pr电子C一世秒一世○n：吨磷F磷+吨磷

多类案例

要衡量机器学习算法的结果，之前的混淆矩阵是不够的。我们需要对多类情况进行概括。

让我们假设我们有一个包含 25 种动物的样本，例如 7 只猫、8 只狗和 10 条蛇，最有可能是蟒蛇。我们识别算法的混淆矩阵可能如下表所示：

	预料到的
实际的		狗	猫	蛇
	狗	6	2	0
	猫	1	6	0
	蛇	1	1	8

在这个混淆矩阵中，系统正确预测了 8 只实际狗中的 6 只，但在两种情况下，它用一只狗代替了一只猫。在 6 个案例中，这 7 只猫被正确识别，但在一个案例中，一只猫被认为是一只狗。通常，很难为狗或猫取蛇，但这就是我们的分类器在两种情况下发生的情况。然而，十分之八的蛇被正确识别。（这个机器学习算法很可能不是用 Python 程序编写的，因为 Python 应该正确识别它自己的物种:-)）

您可以看到所有正确的预测都位于表的对角线上，因此很容易在表中找到预测错误，因为它们将由对角线外的值表示。

我们可以将其推广到多类情况。为此，我们总结了混淆矩阵的行和列。鉴于矩阵如上定向，即矩阵的给定行对应于“真相”的特定值，我们有：

磷r电子C一世秒一世○n一世=米一世一世∑j米j一世电阻电子C一个升升一世=米一世一世∑j米一世j

这意味着，精度是算法正确预测类别 i 在算法预测 i（正确和错误）的所有实例中的比例。另一方面，召回率是算法在所有标记为 i 的案例中正确预测 i 的案例的比例。

让我们将其应用到我们的示例中：

我们动物的精度可以计算为

pr电子C一世秒一世○nd○G秒=6/(6+1+1)=3/4=0.75pr电子C一世秒一世○nC一个吨秒=6/(2+6+1)=6/9=0.67pr电子C一世秒一世○n秒n一个克电子秒=8/(0+0+8)=1

召回率计算如下：

r电子C一个升升d○G秒=6/(6+2+0)=3/4=0.75r电子C一个升升C一个吨秒=6/(1+6+0)=6/7=0.86r电子C一个升升秒n一个克电子秒=8/(1+1+8)=4/5=0.8

例子

我们现在准备将其编码到 Python 中。以下代码显示了具有十个标签的多类机器学习问题的混淆矩阵，例如用于识别手写字符中的十位数字的算法。

如果您不熟悉 Numpy 和 Numpy 数组，我们推荐我们的Numpy教程。

将 numpy 导入为 np

厘米 = 纳米。阵列（
[[ 5825 ，    1 ，   49 ，   23 ，    7 ，   46 ，   30 ，   12 ，   21 ，   26 ]，
 [    1 ， 6654 ，   48 ，   25 ，   10 ，   32 ，   19 ，   62 ，  111 ，   10 ]，
 [    2 ，   20 ,  5561 ,    69 ,    13，   10 ，    2 ，   45 ，   18 ，    2 ]，
 [    6 ，   26 ，   99 ， 5786 ，    5 ，  111 ，    1 ，   41 ，  110 ，   79 ]，
 [    4 ，   10 ，   43 ，    6 ， 5533 ，   32 ，   11 ，   53 ,    34 ,    79 ], 
 [    3 ,     1 ,     2，   56 ，    0 ， 4954 ，   23 ，    0 ，   12 ，    5 ]，
 [   31 ，    4 ，   42 ，   22 ，   45 ，  103 ， 5806 ，    3 ，   34 ，    3 ]，
 [    0 ，    4 ，   30 ，   29 ，    5 ，    6 ,     0 ,  5817 ,     2 ,    28 ], 
 [   35，    6 ，   63 ，   58 ，    8 ，   59 ，   26 ，   13 ， 5394 ，   24 ]，
 [   16 ，   16 ，   21 ，   57 ，  216 ，   68 ，    0 ，  219 ，  115 ， 5693 ]]）

函数“precision”和“recall”计算标签的值，而函数“precision_macro_average”计算整个分类问题的精度。

定义 精度（标签， 混淆矩阵）：
    col  = 混淆矩阵[：， 标签]
    返回 混淆矩阵[标签， 标签]  /  col 。总和()
    
定义 召回（标签， 混淆矩阵）：
    行 = 混淆矩阵[标签， ：]
    返回 混淆矩阵[标签， 标签]  / 行。总和()

def  precision_macro_average （混淆_
    矩阵）：行， 列 = 混淆_矩阵。形状
    sum_of_precisions  =  0
    为 标签 在 范围（行）：
        sum_of_precisions  + = 精度（标签， confusion_matrix ）
    返回 sum_of_precisions  / 行

def 召回宏_平均（混淆矩阵）：
    行， 列 = 混淆矩阵。形状
    sum_of_recalls  =  0
    为 标签 在 范围（列）：
        sum_of_recalls  + = 召回（标签， confusion_matrix ）
    返回 sum_of_recalls  / 列

打印（“标签精度召回” ）
为 标签 在 范围（10 ）：
    打印（˚F “ {标签：图5d } {精度（标签，厘米）：9.3f } {召回（标签，厘米）：6.3F } ” ）    

输出：

标签精确召回
    0 0.983 0.964
    1 0.987 0.954
    2 0.933 0.968
    3 0.944 0.924
    4 0.947 0.953
    5 0.914 0.980
    6 0.981 0.953
    7 0.928 0.982
    8 0.922 0.949
    9 0.957 0.887

打印（“精度总计：” ， precision_macro_average （厘米））

打印（“召回总数：” ， recall_macro_average （厘米））

输出：

总精度：0.9496885564052286
召回总数：0.9514531547877969

定义 精度（混淆_
    矩阵 ）：对角线总和= 混淆_矩阵。跟踪（）
    sum_of_all_elements  = 混淆矩阵。sum ()
    返回 diagonal_sum  /  sum_of_all_elements 

精度（厘米）

输出：

0.9503833333333334