一、概述

  分类模型是机器学习中一种最常见的问题模型，在许多问题场景中有着广泛的运用，是模式识别问题中一种主要的实现手段。分类问题概况起来就是，对一堆高度抽象了的样本，由经验标定了每个样本所属的实际类别，由特定算法训练得到一个分类器，输入样本属性即自动计算出其所属类别，从而完成特定的识别任务。依实现原理的不同，分类算法有很多种，常见的如支持向量机、决策树、k近邻、朴素贝叶斯…，以及设计了的各种人工神经网络等。在特定问题中，算法性能的评价是一个重要的方面，它一般由学习器在测试数据中的性能表现来直接衡定，常见的评价指标有准确率、精准度（查准率）、召回率（查全率）、F1值、ROC-AUC值、Kappa系数等。

二、评价指标——二分类情形

  二分类模型是较常见和较一般化的情形，它预测的混淆矩阵可表示为

其中，
  TP（True Positive,真正例）为被正确划分为正例的样本数；
  FP（False Positive,假正例）为被错误划分为正例的样本数；
  TN（True Negative,真负例）为被正确划分为负例的样本数；
  FN（False Negative,假负例）为被错误划分为负例的样本数。

1.准确率（accuracy）

  准确率是被预测正确的样本数与样本总数$N$的比值，比较直观地反映了学习器的性能。表达式为
$$Accuracy=\frac{TP+TN}{N}$$

2. 精准度(precision)

   精准度是TP（真正例）占预测为正例样本数的百分比，它表征了预测的正例中有多少有效成分，也叫做查准率。表达式为
$$precision=\frac{TP}{TP+FP}$$

3. 召回率(recall)

  召回率是TP（真正例）与真实正样本数的比值，它表征了所有的有效内容有多少被检测了出来，也叫做查全率、灵敏度(sensitive)。表达式为
$$recall=\frac{TP}{TP+FN}$$

4. F度量（F-Measure, F-Score）

  我们希望学习器的查准率和查全率都高，而查准率和查全率往往是一对矛盾的度量，查准率高时，查全率往往偏低；查全率高时，查准率往往偏低。此时可以用F度量来综合评估精准度（查准率）和召回率（查全率），数值越高学习器越理想。它的一般形式记作$F_{\beta }$，表达式为
$$F_{\beta }=\frac{(1+{\beta }^2)\cdot precision\cdot recall}{{\beta }^2\cdot precision+recall}$$
  式中的$\beta$ 值能够表达出对查准率/查全率的不同偏好，如F1分数认为召回率和精准度同等重要，F2分数认为召回率的重要程度是精准度的两倍，而F0.5分数认为召回率的重要程度是精准度的一半。其中，F1度量是最常用的一种，表达式为
$$F_1=\frac{2\cdot precision\cdot recall}{precision+recall}$$

注：
F1由调和平均进行定义： $$\frac{1}{F_1}=\frac{1}{2}\left(\frac{1}{precision}+\frac{1}{recall}\right)$$ $F_{\beta }$由加权调和平均进行定义：
$$\frac{1}{F_{\beta }}=\frac{1}{1+{\beta }^2}\left(\frac{1}{precision}+\frac{{\beta }^2}{recall}\right)$$

5．ROC曲线与AUC值

  ROC(Receiver Operating Characteristic，受试者工作特征)曲线是以真正率（TPR）为纵轴、假正率（FPR）为横轴绘制的曲线，AUC(Area Under ROC Curve)是ROC曲线下的面积，它们能够在一定程度上衡量分类器的性能，示意图如图所示。

  TPR(true positive rate,真正率)、FPR(false positive rate,假正率)表达式为
$$TPR=\frac{TP}{TP+FN}$$
$$FPR=\frac{FP}{FP+TN}$$

  ROC与AUC的度量，对二分类问题来说是更直观的，它直接地关注于正例样本，通过正例样本的整体表现来衡量学习器的性能。而这个正例类的指定，则由实际问题情形而确定。
  ROC曲线的绘制过程为，对测试样本集中的样本，将待考察的类别规定为正例类，学习器计算得到每个样本归属于正例类的概率，对所有样本依概率进行排序，起始时将划分阈值设为最大，即将所有样本划为负样本，此时TPR和FPR均为0，坐标轴上在(0,0)处标定了一个点。然后调整划分阈值，依次将每个样本划为正样本，TPR、FPR值随之增大，连接过程中标定的坐标点即得到ROC曲线。易知，若一个学习器的ROC曲线被另一个学习器的曲线完全包住，则后者的性能优于前者；若两个学习器的曲线发生交叉，则可比较ROC曲线下的面积，即AUC(Area Under ROC Curve)，面积越大，性能越好。
  假定ROC曲线由坐标点{(x1,y1),(x2,y2),…,(xn,yn)}按序连接而成，则AUC值估算的表达式为
$$AUC=\frac{1}{2}\sum _{i=1}^{n-1}\left(x_{i+1}-x_i\right)\cdot \left(y_i+y_{i+1}\right)$$

6.Kappa系数

  Kappa系数是统计分析中一种进行一致性检验的常见方法，能够较大程度上反映出分类算法的性能表现。它的计算同样基于混淆矩阵，反映的是预测结果与实际结果的一致性，其取值范围为[-1,1]，值越大说明一致性越高，性能越好；反之性能越差。假设样本总数为N，Kappa系数定义为
$$kappa=\frac{p_o-p_e}{1-p_e}$$
  其中，$p_o=\frac{1}{N}\left(TP+TN\right)$是整体准确率，
     $p_e=\frac{1}{N^2}\left[\left(TP+FN\right)\cdot \left(TP+FP\right)+\left(FP+TN\right)\cdot \left(FN+TN\right)\right]$表偶然一致性。

三、评价指标——多分类情形

  多分类情形下的混淆矩阵表示为

  多分类问题往往能够转化为多个二分类问题，对它们性能的评价可通过宏计算或微计算的方式进行。

1.准确率（accuracy）

  准确率即混淆矩阵主对角线上的值之和与样本总数N的比值
$$Accuracy=\frac{1}{N}\sum _{i=1}^K{x}_{ii}$$

2.精准度、召回率、F1值

  对于多分类任务，各个类别两两之间即对应了一个混淆矩阵，计算查准率、查全率、F1值的方式有两种，一种是对各混淆矩阵计算得到的指标值对应求平均，得到宏查准率(macro-P)、宏查全率(macro-R)和宏F1值(macro-F1)；另一种是将各混淆矩阵对应位置处的值求平均，记为$\overline{TP}$、$\overline{FP}$、$\overline{TN}$、$\overline{FN}$，由这些平均的值计算得到微查准率(micro-P)、微查全率(micro-R)和微F1值(micro-F1)。假设共有K个类别，那么混淆矩阵数量为$C_K^2=\frac{K\cdot (K-1)}{2}$，记为n，则
  宏计算的指标值表示为
$$macr{o}_{-}P=\frac{1}{n}\sum _{i=1}^{n}precisio{n}_i$$
$$macr{o}_{-}R=\frac{1}{n}\sum _{i=1}^{n}recal{l}_i$$
$$macro{x}_{-}F1=\frac{2\ast macr{o}_{-}P\ast macr{o}_{-}R}{macr{o}_{-}P+macr{o}_{-}R}$$


  微计算的指标值表示为
$$micr{o}_{-}P=\frac{\overline{TP}}{\overline{TP}+\overline{FP}}$$
$$micr{o}_{-}R=\frac{\overline{TP}}{\overline{TP}+\overline{FN}}$$
$$micr{o}_{-}F1=\frac{2\ast micr{o}_{-}P\ast micr{o}_{-}R}{micr{o}_{-}P+micr{o}_{-}R}$$

3. ROC曲线与AUC值

  多分类情形下的ROC与AUC同样可以以“宏”或“微”的形式进行计算。
方式一：
  对于K（K>2）类分类问题，分别将每一个类别视作正例，其余各类别视作负例，在概率预测矩阵中，按当前类别列下的概率值进行排序，随之调整划分阈值，可得到一条ROC曲线，如此，共可得到K条ROC曲线，对各曲线的坐标点求平均，即绘制出一条“宏计算(macro)”的ROC曲线，并可计算出它对应的AUC值。简单地说就是，概率预测矩阵的每一列值排序后都形成一条ROC曲线，再得到平均后的曲线。

方式二：
  对于K（K>2）类分类问题，首先将样本标签one-hot化，得到一个K列的0和1标识的矩阵，将概率预测矩阵和该矩阵分别按行或按列将各自拼接为一维向量，按此概率向量进行排序，随之调整划分阈值，可得到一条“微计算(micro)”的ROC曲线，并可计算出它对应的AUC值。简单地说就是，概率预测矩阵的所有值排序后直接地形成一条ROC曲线。

4.Kappa系数

  Kappa的计算与二分类是一致的，假设样本类别数为K，总样本数为N，实际为i预测为j的样本数为$a_{ij}$，有
$$kappa=\frac{p_o-p_e}{1-p_e}$$
  其中，$p_o=\frac{1}{N}{\sum }_{i=1}^K{a}_{ii}$是整体准确率，$p_e=\frac{1}{N^2}{\sum }_{i=1}^K{a}_{i+}\cdot a_{+i}$ 表偶然一致性。

例如，在某分类问题中，样本真实类别和预测类别分别是
   y_true=[‘A’,‘A’,‘C’,‘B’,‘B’,‘A’,‘C’,‘B’];
   y_pred=[‘C’,‘A’,‘C’,‘B’,‘B’,‘A’,‘B’,‘B’]，
其对应的混淆矩阵为

  则$p_o=\frac{2+3+1}{8}=0.75$，$p_e=\frac{3\times 2+3\times 4+2\times 2}{8\times 8}=0.3438$
  所以$kappa=\frac{0.75-0.3438}{1-0.3438}=0.619$

四、Python实现

二分类情形

import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn import metrics
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
from sklearn.metrics import cohen_kappa_score

## 1.定义数据集

# 训练数据
train_x = [
    [4.8,3,1.4,0.3],
    [5.1,3.8,1.6,0.2],
    [4.6,3.2,1.4,0.2],
    [5.3,3.7,1.5,0.2],
    [5,3.3,1.4,0.2],
    [7,3.2,4.7,1.4],
    [6.4,3.2,4.5,1.5],
    [6.9,3.1,4.9,1.5],
    [5.5,2.3,4,1.3],
    [6.5,2.8,4.6,1.5]
]

# 训练数据标签
train_y = [
    'A',
    'A',
    'A',
    'A',
    'A',
    'B',
    'B',
    'B',
    'B',
    'B'
]


# 测试数据
test_x = [
    [3.1,3.5,1.4,0.2],
    [4.9,3,1.4,0.2],
    [5.1,2.5,3,1.1],
    [6.2,3.6,3.4,1.3]
]

# 测试数据标签
test_y = [
    'A',
    'A',
    'B',
    'B'
]

train_x = np.array(train_x)
train_y = np.array(train_y)
test_x = np.array(test_x)
test_y = np.array(test_y)

## 2.训练分类器
clf_dt = DecisionTreeClassifier(max_depth=None, min_samples_split=2)  # 定义决策树学习器
rclf_dt = clf_dt.fit(train_x,train_y)  # 训练

## 3.数据计算
pre_y = rclf_dt.predict(test_x)
pre_y_proba = rclf_dt.predict_proba(test_x)[:,0] # 预测为类'A'的概率

## 4.性能评价
# (1) 准确率
accuracy = metrics.accuracy_score(test_y,pre_y)

# (2) 精确度（查准率）
precision = metrics.precision_score(test_y,pre_y,pos_label='A') # pos_label指定正例类

# (3) 召回率（查全率）
recall = metrics.recall_score(test_y,pre_y,pos_label='A')

# (4) F1度量
F1 = metrics.f1_score(test_y,pre_y,pos_label='A')

# (5) ROC-AUC值
fpr,tpr,threshold = metrics.roc_curve(test_y,pre_y_proba,pos_label='A')
AUC = metrics.auc(fpr,tpr)

# (6) Kappa系数
kappa = cohen_kappa_score(test_y, pre_y)

## 5.结果输出
print('\naccuracy:', accuracy)
print('\nprecision:', precision)
print('recall:', recall)
print('F1:', F1)
print('\nAUC:', AUC)
print('\nkappa:', kappa)

# ROC曲线绘图
plt.figure()
plt.plot(fpr, tpr, label='ROC curve (area = %0.2f)' % AUC)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Binary Classify ROC')
plt.legend(loc="lower right")
plt.show()

多分类情形

import numpy as np
from sklearn.tree import DecisionTreeClassifier
from sklearn import metrics
from sklearn.preprocessing import OneHotEncoder
from sklearn.metrics import cohen_kappa_score

## 1.定义数据集

# 训练数据
train_x = [
    [4.8,3,1.4,0.3],
    [5.1,3.8,1.6,0.2],
    [4.6,3.2,1.4,0.2],
    [5.3,3.7,1.5,0.2],
    [5,3.3,1.4,0.2],
    [7,3.2,4.7,1.4],
    [6.4,3.2,4.5,1.5],
    [6.9,3.1,4.9,1.5],
    [5.5,2.3,4,1.3],
    [6.5,2.8,4.6,1.5],
    [6.3,3.3,6,2.5],
    [5.8,2.7,5.1,1.9],
    [7.1,3,5.9,2.1],
    [6.3,2.9,5.6,1.8],
    [6.5,3,5.8,2.2]
]

# 训练数据标签
train_y = [
    'A',
    'A',
    'A',
    'A',
    'A',
    'B',
    'B',
    'B',
    'B',
    'B',
    'C',
    'C',
    'C',
    'C',
    'C'
]


# 测试数据
test_x = [
    [5.1,3.5,1.4,0.2],
    [4.9,3,1.4,0.2],
    [5.1,2.5,3,1.1],
    [5.7,2.8,4.1,1.3],
    [6.2,3.4,5.4,2.3],
    [5.9,3,5.1,1.8]
]

# 测试数据标签
test_y = [
    'A',
    'A',
    'C',
    'B',
    'C',
    'C'
]

train_x = np.array(train_x)
train_y = np.array(train_y)
test_x = np.array(test_x)
test_y = np.array(test_y)

## 2.训练分类器
clf_dt = DecisionTreeClassifier(max_depth=None, min_samples_split=2)  # 定义决策树学习器
rclf_dt = clf_dt.fit(train_x,train_y)  # 训练

## 3.数据计算
pre_y = rclf_dt.predict(test_x)
pre_y_proba = rclf_dt.predict_proba(test_x)

## 4.性能评价
# (1) 准确率
accuracy = metrics.accuracy_score(test_y,pre_y)

# (2) P-R度量
precision_macro = metrics.precision_score(test_y,pre_y,average='macro')  #宏精确度（查准率）
recall_macro = metrics.recall_score(test_y,pre_y,average='macro')  #宏召回率（查全率）
F1_macro = metrics.f1_score(test_y,pre_y,average='macro')  #宏F1度量

precision_micro = metrics.precision_score(test_y,pre_y,average='micro')  #微精确度（查准率）
recall_micro = metrics.recall_score(test_y,pre_y,average='micro')  #微召回率（查全率）
F1_micro = metrics.f1_score(test_y,pre_y,average='micro')  #微F1度量

# (3)ROC-AUC值
encoder = OneHotEncoder(sparse_output=False)  # 创建一个OneHotEncoder对象
onehot_test_y = encoder.fit_transform(test_y.reshape(-1, 1)) # 对整数数组进行one-hot编码
AUC_macro = metrics.roc_auc_score(onehot_test_y,pre_y_proba, average='macro', sample_weight=None)
AUC_micro = metrics.roc_auc_score(onehot_test_y,pre_y_proba, average='micro', sample_weight=None)

# (4) Kappa系数
kappa = cohen_kappa_score(test_y, pre_y)

## 5.结果输出
print('\naccuracy: ', accuracy)
print('\nprecision_macro: ',precision_macro)
print('recall_macro:',recall_macro)
print('F1_macro:',F1_macro)
print('\nprecision_micro:',precision_micro)
print('recall_micro:',recall_micro)
print('F1_micro:',F1_micro)
print('\nAUC_macro: ',AUC_macro)
print('AUC_micro:',AUC_micro)
print('\nKappa: ',kappa)

End.


参考:
  周志华. 机器学习. 清华大学出版社.

全文pdf下载