文章来自微信公众号作者Japson https://mp.weixin.qq.com/s/vvCM0vWH5kmRfrRWxqXT8Q

在《机器学习的敲门砖：kNN算法（上）》中，我们了解了非常适合入门机器学习的算法：k近邻算法。

我们学习了kNN算法的流程，并且在jupyter notebook上手动实现了代码，并且在外部也进行了封装。最后我们学习了sklearn中的kNN算法。

在品尝到“实践”的胜利果实后，我们不仅有一个疑问：

思想如此朴素的kNN算法，它的效果怎样样？预测准确率高不高？在机器学习中如何评价一个算法的好坏？ 我们在机器学习过程中还有需要注意那些其他的问题呢？

在这篇文章中，我们使用训练数据集和测试数据集来判断模型的好坏，给出并实现accurcay这一分类问题常用指标。最后我们再探寻超参数的选择对模型的影响。

0x01 判断模型好坏

1.1 训练数据集&测试数据集

我们已经兴致勃勃的训练好了一个模型了，问题是：它能直接拿到生产环境正确使用么？ 我们现在只是能拿到一个预测结果，还不知道这个模型效果怎么样？ 预测的结果准不准 如果拿到真实环境，其实是没有label的，我们怎么对结果进行验证呢？ 实际上，从训练好模型到真实使用，还差着远呢。我们要做的第一步就是： 将原始数据中的一部分作为训练数据、另一部分作为测试数据。使用训练数据训练模型，再用测试数据看好坏。即通过测试数据判断模型好坏，然后再不断对模型进行修改。

1.2 鸢尾花train_test

鸢尾花数据集是UCI数据库中常用数据集。我们可以直接加载数据集，并尝试对数据进行一定探索：

import numpy as np
from sklearn import datasets
import matplotlib.pyplot as plt
iris = datasets.load_iris()
X = iris.data
y = iris.target
X.shape
y.shape

我们下面进行训练数据集、测试数据集的拆分工作（train_test_split）。 一般情况下我们按照0.8:0.2的比例进行拆分，但是有时候我们不能简单地把前n个数据作为训练数据集，后n个作为测试数据集。 比如下面这个，是有顺序的。

y

为了解决这个问题，我们可以将数据集打乱，做一个shuffle操作。但是本数据集的特征和标签是分开的， 也就是说我们分别乱序后，原来的对应关系就不存在了。有两种方法解决这一问题： 将X和y合并为同一个矩阵，然后对矩阵进行shuffle，之后再分解 对y的索引进行乱序，根据索引确定与X的对应关系，最后再通过乱序的索引进行赋值

第一种方法

首先看第一种方法：

#方法一
"""使用concatenate函数进行拼接，因为传入的矩阵必须相同的形状。
因此需要对label进行reshape操作，reshape(-1,1)表示自动计算，1列,-1为系统自动计算。reshape(1,-1) 变成一行
axis=1表示纵向拼接。"""
tempConcat = np.concatenate((X,y.reshape(-1,1)),axis=1) 
tempConcat[:5]

#拼接好后，直接进行乱序操作
np.random.shuffle(tempConcat)
tempConcat[:5]
#再将shuffle后的数组使用split方法拆分
shuffle_X,shuffle_y = np.split(tempConcat,[4],axis=1)
shuffle_X[:5]
shuffle_y[:5]
len(X)
#设置划分的比例
test_ration = 0.2
test_size = int(len(X)*test_ration)
X_train = shuffle_X[test_size:]
y_train = shuffle_y[test_size:]
X_test = shuffle_X[:test_size]
y_test = shuffle_y[:test_size]

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

第二种方法

#方法2
#将x长度这么多的数，返回一个新的打乱顺序的数组，注意，数组中的元素不是原来的数据，而是混乱的索引
shuffle_index = np.random.permutation(len(X))
"""
函数shuffle与permutation都是对原来的数组进行重新洗牌（即随机打乱原来的元素顺序）；
区别在于shuffle直接在原来的数组上进行操作，改变原来数组的顺序，无返回值。
而permutation不直接在原来的数组上进行操作，而是返回一个新的打乱顺序的数组，并不改变原来的数组。
"""
shuffle_index[:5]
#制定测试数据的比例
test_ration = 0.2
test_size = int(len(X)*test_ration)
test_index = shuffle_index[:test_size]
train_index = shuffle_index[test_size:]
X_train = X[train_index]
X_test = X[test_index]
y_train = y[train_index]
y_test = y[test_index]
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

1.3 编写自己的train_test_split

len(X)
%run /home/kesci/work/knn/model-selection1.py

调用

X_train, X_test, y_train, y_test,ration = train_test_split(X, y)
#X_train, X_test, y_train, y_test = train_test_split(X, y)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)
print(ration)
#结果之前是112,38 为了测试返回了比例参数,结果就正常，不知为何
#断言问题解决了 语法中无/ 这是换行符
my_kNNClassifier = kNNClassifier(k=3) #待上传文件
my_kNNClassifier.fit(X_train,y_train)

y_predict = my_kNNClassfier.predict(X_test)
y_predict
y_test
#两个向量的比较，返回一个布尔型向量，对这个不二向量（）
#（faluse=1，true=0）sum，sum(y_predict == y_test)29sum(y_predict == y_test)/len(y_test)0.96666666666667

1.4 sklearn中的train_test_split

from sklearn.model_selection import train_test_split
X.shape
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=888)
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)

0x02 分类准确度accuracy

在划分出测试数据集后，我们就可以验证其模型准确率了。在这了引出一个非常简单且常用的概念：accuracy（分类准确度） accuracy_score：函数计算分类准确率，返回被正确分类的样本比例（default）或者是数量（normalize=False） 在多标签分类问题中，该函数返回子集的准确率，对于一个给定的多标签样本，如果预测得到的标签集合与该样本真正的标签集合严格吻合，则subset accuracy =1.0否则是0.0 因accuracy定义清洗、计算方法简单，因此经常被使用。但是它在某些情况下并不一定是评估模型的最佳工具。精度（查准率）和召回率（查全率）等指标对衡量机器学习的模型性能在某些场合下要比accuracy更好。 当然这些指标在后续都会介绍。在这里我们就使用分类精准度，并将其作用于一个新的手写数字识别分类算法上。

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
# 手写数字数据集，封装好的对象，可以理解为一个字段
digits = datasets.load_digits()
# 可以使用keys()方法来看一下数据集的详情
digits.keys()

我们可以看一下sklearn.datasets提供的数据描述：

# 5620张图片，每张图片有64个像素点即特征（8*8整数像素图像），
#每个特征的取值范围是1～16（sklearn中的不全），对应的分类结果是10个数字
#print(digits['DESCR'])  ??
print(digits.DESCR)
#特征的shape
X = digits.data
X.shape
#标签的shape
y = digits.target
y.shape
#标签分类
digits.target_names
# 去除某一个具体的数据，查看其特征以及标签信息
some_digit = X[666]
some_digit
# 也可以这条数据进行可视化
some_digmit_image = some_digit.reshape(8, 8)
plt.imshow(some_digmit_image, cmap = matplotlib.cm.binary)
plt.show()

2.2 自己实现分类准确度

在分类任务结束后，我们就可以计算分类算法的准确率。其逻辑如下：

X_train, X_test, y_train, y_test = train_test_split(X, y)
knn_clf = KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train, y_train)
y_predict = knn_clf.predict(X_test)
# 比对y_predict和y_test结果是否一致
sum(y_predict == y_test) / len(y_test)

2.3 sklearn中的准确度

更多的时候，我们还是使用sklearn中封装好的方法。我们自己实现一遍，其实是简化版的，只是帮助我们更好地了解其底层原理。

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=666)
knn_clf = KNeighborsClassifier(n_neighbors=3)
knn_clf.fit(X_train, y_train)
y_predict = knn_clf.predict(X_test)
accuracy_score( y_predict,y_test)

knn_clf.score(X_test,y_test)
knn_clf.score(X_train,y_train)

0x03 超参数

3.1 超参数简介
之前我们都是为knn算法传一个默认的k值。在具体使用时应该传递什么值合适呢？

这就涉及了机器学习领域中的一个重要问题：超参数。所谓超参数，就是在机器学习算法模型执行之前需要指定的参数。 （调参调的就是超参数） 如kNN算法中的k。

与之相对的概念是模型参数，即算法过程中学习的属于这个模型的参数（kNN中没有模型参数，回归算法有很多模型参数）

如何选择最佳的超参数，这是机器学习中的一个永恒的问题。在实际业务场景中，调参的难度大很多， 一般我们会业务领域知识、经验数值、实验搜索等方面获得最佳参数。

3.2 寻找好的k

针对于上一小节的手写数字识别分类代码，尝试寻找最好的k值。逻辑非常简单，就是设定一个初始化的分数，然后循环更新k值，找到最好的score

#制定最佳值的分数，初始化为0.0,；设置最佳值k，初始值为-1
best_score = 0.0
best_k = -1
for k in range(1,11):
    #暂且设定到1-11的范围内
    knn_clf = KNeighborsClassifier(n_neighbors=k)
    knn_clf.fit(X_train,y_train)
    score = knn_clf.score(X_test,y_test)
    if score >best_score:
        best_k = k
        best_score = score
    print("best_k",best_k)
    print("best_score =",best_score)

3.2 另一个超参数：权重

在回顾kNN算法思想时，我们应该还记得，对于简单的kNN算法，只需要考虑最近的n个数据是什么即可。但是如果我们考虑距离呢？

如果我们认为，距离样本数据点最近的节点，对其影响最大，那么我们使用距离的倒数作为权重。假设距离样本点最近的三个节点分别是红色、蓝色、蓝色，距离分别是1、4、3。那么普通的k近邻算法：蓝色获胜。考虑权重（距离的倒数）：红色：1，蓝色：1/3 + 1/4 = 7/12，红色胜。

在 sklearn.neighbors 的构造函数 KNeighborsClassifier 中有一个参数：weights，默认是uniform即不考虑距离，也可以写distance来考虑距离权重(默认是欧拉距离，如果要是曼哈顿距离，则可以写参数p（明可夫斯基距离的参数），这个也是超参数)

因为有两个超参数，因此使用双重循环，去查找最合适的两个参数，并打印。

#两种方式进行比较
best_method = ""
best_score = 0.0
best_k = -1
for method in ["uniform","distance"]:
    for k in range(1,11):
        knn_clf = KNeighborsClassifier(n_neighbors=k,weights=method,p=2)
        knn_clf.fit(X_train,y_train)
        score = knn_clf.score(X_test,y_test)
        if score >best_score:
            best_k = k
            best_score = score
            best_method = method
print("best_method = ",method)
print("best_k = ",best_k)
print("best_score=",best_score)

可以看到，最好的k值是4，在我们设定的k的取值范围中间。 需要注意的是，如果我们得到的值正好在边界上，我们需要稍微扩展一下取值范围。因为嘛，你懂的！

3.3 超参数网格搜索
在具体的超参数搜索过程中会需要很多问题，超参数过多、超参数之间相互依赖等等。如何一次性地把我们想要得到最好的超参数组合列出来, sklearn中专门封装了一个超参数网格搜索方法Grid Serach。

在进行网格搜索之前，首先需要定义一个搜索的参数param_search。是一个数组，数组中的每个元素是个字典，字典中的是对应的一组网格搜索， 每一组网格搜索是这一组网格搜索每个参数的取值范围。键是参数的名称，值是键所对应的参数的列表。

param_search = [
    { "weights":["uniform"], "n_neighbors":[i for i in range(1,11)]
    },
    {"weights":["distance"],"n_neighbors":[i for i in range(1,11)],         "p":[i for i in range(1,6)]
    }
]

可以看到，当weights = uniform即不使用距离时，我们只搜索超参数k，当weights = distance即使用距离时，需要看超参数p使用那个距离公式。 下面创建要进行网格搜索所对应的分类算法并调用网格搜索：

knn_clf = KNeighborsClassifier()
#调用网格搜索方法
from sklearn.model_selection import GridSearchCV
#定义网格搜索的对象grid_search,其构造函数的第一个参数表示对哪个分类器进行算法搜索，第二个参数表示网格搜索相应的参数
grid_search = GridSearchCV(knn_clf,param_search)

下面就是针对X_train, y_train，使用grid_search在param_search列表中寻找最佳超参数组：

%%time
grid_search.fit(X_train,y_train)

可以使用网格搜索的评估函数来返回最佳分类起所对应的参数

#返回的是网格搜索搜索到的最佳分类器对应的参数
grid_search.best_estimator_

也可以查看最佳参数的分类器的准确度。

我们会注意到，best_estimator_和best_score参数后面有一个。这是一种常见的语法规范， 不是用户传入的参数，而是根据用户传入的规则，自己计算出来的结果，参数名字后面接

grid_search.best_score_
grid_search.best_params_
knn_clf = grid_search.best_estimator_
knn_clf.score(X_test,y_test)