分类模型是机器学习中一种最常见的问题模型，在许多问题场景中有着广泛的运用，是模式识别问题中一种主要的实现手段。分类问题概况起来就是，对一堆高度抽象了的样本，由经验标定了每个样本所属的实际类别，由特定算法训练得到一个分类器，输入样本属性即自动计算出其所属类别，从而完成特定的识别任务。依实现原理的不同，分类算法有很多种，常见的如支持向量机、决策树、k近邻、朴素贝叶斯......，以及设计了的各种人工神经网络等。在特定问题中，算法性能的评价是一个重要的方面，它一般由学习器在测试数据中的性能表现来直接衡定，常见的评价指标有准确率、精准度（查准率）、召回率（查全率）、F1值、ROC-AUC值、Kappa系数等。
二分类模型是较常见和较一般化的情形，它预测的混淆矩阵可表示为
其中，
TP（True Positive,真正例）为被正确划分为正例的样本数；
FP（False Positive,假正例）为被错误划分为正例的样本数；
TN（True Negative,真负例）为被正确划分为负例的样本数；
FN（False Negative,假负例）为被错误划分为负例的样本数。
准确率是被预测正确的样本数与样本总数\(N\)的比值，比较直观地反映了学习器的性能。表达式为
精准度是TP（真正例）占预测为正例样本数的百分比，它表征了预测的正例中有多少有效成分，也叫做查准率。表达式为
召回率是TP（真正例）与真实正样本数的比值，它表征了所有的有效内容有多少被检测了出来，也叫做查全率、灵敏度(sensitive)。表达式为
我们希望学习器的查准率和查全率都高，而查准率和查全率往往是一对矛盾的度量，查准率高时，查全率往往偏低；查全率高时，查准率往往偏低。此时可以用F度量来综合评估精准度（查准率）和召回率（查全率），数值越高学习器越理想。它的一般形式记作\(F_\beta\)，表达式为
式中的\(\beta\) 值能够表达出对查准率/查全率的不同偏好，如F1分数认为召回率和精准度同等重要，F2分数认为召回率的重要程度是精准度的两倍，而F0.5分数认为召回率的重要程度是精准度的一半。其中，F1度量是最常用的一种，表达式为
注：
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)\]
ROC(Receiver Operating Characteristic，受试者工作特征)曲线是以真正率（TPR）为纵轴、假正率（FPR）为横轴绘制的曲线，AUC(Area Under ROC Curve)是ROC曲线下的面积，它们能够在一定程度上衡量分类器的性能，示意图如图所示。
TPR(true positive rate,真正率)、FPR(false positive rate,假正率)表达式为
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值估算的表达式为
Kappa系数是统计分析中一种进行一致性检验的常见方法，能够较大程度上反映出分类算法的性能表现。它的计算同样基于混淆矩阵，反映的是预测结果与实际结果的一致性，其取值范围为[-1,1]，值越大说明一致性越高，性能越好；反之性能越差。假设样本总数为N，Kappa系数定义为
其中，\(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]\)表偶然一致性。
多分类情形下的混淆矩阵表示为
多分类问题往往能够转化为多个二分类问题，对它们性能的评价可通过宏计算或微计算的方式进行。
准确率即混淆矩阵主对角线上的值之和与样本总数N的比值
对于多分类任务，各个类别两两之间即对应了一个混淆矩阵，计算查准率、查全率、F1值的方式有两种，一种是对各混淆矩阵计算得到的指标值对应求平均，得到宏查准率(macro-P)、宏查全率(macro-R)和宏F1值(macro-F1)；另一种是将各混淆矩阵对应位置处的值求平均，记为\(\bar{TP}\)、\(\bar{FP}\)、\(\bar{TN}\)、\(\bar{FN}\)，由这些平均的值计算得到微查准率(micro-P)、微查全率(micro-R)和微F1值(micro-F1)。假设共有K个类别，那么混淆矩阵数量为\(C_{K}^{2}=\frac{K\cdot(K-1)}{2}\)，记为n，则
宏计算的指标值表示为
多分类情形下的ROC与AUC同样可以以“宏”或“微”的形式进行计算。
方式一：
对于K（K>2）类分类问题，分别将每一个类别视作正例，其余各类别视作负例，在概率预测矩阵中，按当前类别列下的概率值进行排序，随之调整划分阈值，可得到一条ROC曲线，如此，共可得到K条ROC曲线，对各曲线的坐标点求平均，即绘制出一条“宏计算(macro)”的ROC曲线，并可计算出它对应的AUC值。简单地说就是，概率预测矩阵的每一列值排序后都形成一条ROC曲线，再得到平均后的曲线。
方式二：
对于K（K>2）类分类问题，首先将样本标签one-hot化，得到一个K列的0和1标识的矩阵，将概率预测矩阵和该矩阵分别按行或按列将各自拼接为一维向量，按此概率向量进行排序，随之调整划分阈值，可得到一条“微计算(micro)”的ROC曲线，并可计算出它对应的AUC值。简单地说就是，概率预测矩阵的所有值排序后直接地形成一条ROC曲线。
Kappa的计算与二分类是一致的，假设样本类别数为K，总样本数为N，实际为i预测为j的样本数为\(a_{ij}\)，有
其中，\(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\)
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.
参考:
周志华. 机器学习. 清华大学出版社.