4.2 分类效果的评价

分类模型建立好后，要评价模型在测试集上预测结果的好坏，使用Sklearn库中的metric模块进行计算

表4-1 metrics模块方法的评价方式

评价方式	功能
metrics.accuracy_score	计算模型准确率
metrics.auc	计算ROC曲线下面积AUC，使用梯形原则
metrics.classification_report	建立一个包含主要评价方法结果的报告
metrics.confusion_matrix	计算分类器预测结果的混淆矩阵
metrics.fl_score	计算F-beta得分
metrics.hamming_loss	计算平均汉明损失
metrics.jaccard_similarity_score	计算Jaccard相似系数评分
metrics.precision_recall_curve	针对不同的概率阈值计算精确率和召回率
metrics.roc_auc_score	根据预测百分比计算特征曲线ROC下的面积AUC
metrics.roc_curve	计算ROC的横纵坐标

1.混淆矩阵

metrics.confusion_matrix（真实类别，预测类别）来计算混淆矩阵，将其可视化，使用的分类模型为网络搜索最有参数的K近邻分类模型。可视化使用*sns.heatmap()*绘制热力图

## 加载包
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
## 图像在jupyter notebook中显示
%matplotlib inline
## 显示的图片格式（mac中的高清格式），还可以设置为"bmp"等格式
%config InlineBackend.figure_format = "retina"
## 输出图显示中文
from matplotlib.font_manager import FontProperties
fonts = FontProperties(fname = "D:\Desktop\python在机器学习中的应用\方正粗黑宋简体.ttf",size=14)
from sklearn import metrics
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
## 忽略提醒
import warnings
warnings.filterwarnings("ignore")

## 读取鸢尾花数据集
Iris = load_iris()
## 参数网格搜索
## 切分数据集
train_x,test_x,train_y,test_y = train_test_split(Iris.data,Iris.target,
                                                 test_size = 0.25,random_state = 2)
from sklearn.pipeline import Pipeline #定义模型处理流程 两个步骤标准化（scale）和K近邻模型（KNN）
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
## 定义模型流程
pipe_KNN = Pipeline([("scale",StandardScaler()),
                    ("KNN",KNeighborsClassifier())])
## 定义需要搜索的参数
n_neighbors = np.arange(1,10)
para_grid = [{"scale__with_mean":[True,False],"KNN__n_neighbors" : n_neighbors}]

## 应用到数据上
gs_KNN_ir = GridSearchCV(estimator=pipe_KNN,param_grid=para_grid,
                         cv=10,n_jobs=4)
gs_KNN_ir.fit(train_x,train_y)
## 获取最好的模型
Iris_clf = gs_KNN_ir.best_estimator_
## 用来预测
prey = Iris_clf.predict(test_x)

## 分类模型的结果评估

## 1.混淆矩阵
pd.value_counts(test_y)
## 输出混淆矩阵，并且可视化
metrics.confusion_matrix(test_y,prey)
## 混淆矩阵可视化
confm = metrics.confusion_matrix(test_y,prey)
sns.heatmap(confm.T, square=True, annot=True, fmt='d', 
            cbar=False,cmap=plt.cm.gray_r)
plt.xlabel("真实类别",FontProperties = fonts)
plt.ylabel("预测类别",FontProperties = fonts)
print(metrics.classification_report(test_y,prey))

这个混淆矩阵看起来很好，因为大多数都在主对角线上，这意味着它们被正确地分类了。(1,1)看起来比其他数字稍暗，这可能意味着数据集中(1,1)的较少，或者分类器在(1,1)上的性能不如其他数字
注参数说明

1. precision：精确率（查准率），表示的是预测为正的样本中有多少是真正的正样本
2. recall：召回率（查全率），表示的是样本中的正例有多少被预测正确了
3. f1-score：综合评价指标，表示的是精确率和召回率的调和平均
4. support：指相应的类中有多少样例分类正确

2.AUC和ROC曲线

比较分类器的一种方法是测量曲线下的面积（AUC）。完美分类器的ROC AUC等于1，而纯随机分类器的ROC AUC等于0.5。Scikit Learn提供了一个计算ROC AUC的函数：
metrics.rocauc_score()
多分类任务

## 2.AUC ROC曲线
# 引入库
import numpy as np
import matplotlib.pyplot as plt
from itertools import cycle
from sklearn.metrics import roc_curve, auc
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import label_binarize
from sklearn.multiclass import OneVsRestClassifier
from scipy import interp
from sklearn.pipeline import Pipeline #定义模型处理流程 两个步骤标准化（scale）和K近邻模型（KNN）
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
# 加载数据
iris = datasets.load_iris()
X = iris.data
y = iris.target
# 将标签二值化
y = label_binarize(y, classes=[0, 1, 2])
# 设置种类
n_classes = y.shape[1]
## 参数网格搜索
## 切分数据集
train_x,test_x,train_y,test_y = train_test_split(X,y,
                                                 test_size = 0.25,random_state = 2)
## 定义模型流程
pipe_KNN = Pipeline([("scale",StandardScaler()),
                    ("KNN",KNeighborsClassifier())])
## 定义需要搜索的参数
n_neighbors = np.arange(1,10)
para_grid = [{"scale__with_mean":[True,False],"KNN__n_neighbors" : n_neighbors}]
## 应用到数据上
gs_KNN_ir = GridSearchCV(estimator=pipe_KNN,param_grid=para_grid,
                         cv=10,n_jobs=4)
gs_KNN_ir.fit(train_x,train_y)
## 获取最好的模型
Iris_clf = gs_KNN_ir.best_estimator_
## 用来预测
prey = Iris_clf.predict(test_x)
# 计算每一类的ROC
fpr = dict()
tpr = dict()
roc_auc = dict()
for i in range(n_classes):
    fpr[i], tpr[i], _ = roc_curve(test_y[:, i], prey[:, i])
    roc_auc[i] = auc(fpr[i], tpr[i])
fpr["micro"], tpr["micro"], _ = roc_curve(test_y.ravel(), prey.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])
# 计算 micro-average ROC曲线和ROC 区域 （方法二） 微观
fpr["micro"], tpr["micro"], _ = roc_curve(test_y.ravel(), prey.ravel())
roc_auc["micro"] = auc(fpr["micro"], tpr["micro"])

# 计算 macro-average ROC曲线和ROC 区域 （方法一） 宏观
# 首先汇总所有false positive rates
all_fpr = np.unique(np.concatenate([fpr[i] for i in range(n_classes)]))
# 然后在此点插值所有ROC曲线
mean_tpr = np.zeros_like(all_fpr)
for i in range(n_classes):
    mean_tpr += interp(all_fpr, fpr[i], tpr[i])
# 最后求平均值并计算AUC
mean_tpr /= n_classes
fpr["macro"] = all_fpr
tpr["macro"] = mean_tpr
roc_auc["macro"] = auc(fpr["macro"], tpr["macro"])

#画图AUC
lw=2
plt.figure()
plt.plot(fpr["micro"], tpr["micro"],
         label='micro-average ROC curve (area = {0:0.2f})'
               ''.format(roc_auc["micro"]),
         color='deeppink', linestyle=':', linewidth=4)

plt.plot(fpr["macro"], tpr["macro"],
         label='macro-average ROC curve (area = {0:0.2f})'
               ''.format(roc_auc["macro"]),
         color='navy', linestyle=':', linewidth=4)

colors = cycle(['aqua', 'darkorange', 'cornflowerblue'])
for i, color in zip(range(n_classes), colors):
    plt.plot(fpr[i], tpr[i], color=color, lw=lw,
             label='ROC curve of class {0} (area = {1:0.2f})'
             ''.format(i, roc_auc[i]))

plt.plot([0, 1], [0, 1], 'k--', lw=lw)
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Some extension of Receiver operating characteristic to multi-class')
plt.legend(loc="lower right")
plt.show()