机器学习的敲门砖kNN算法中

共计 10464 个字符，预计需要花费 27 分钟才能阅读完成。

作者 | Japson
来源 | 木东居士

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

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

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

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

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

我们已经兴致勃勃的训练好了一个模型了，问题是：它能直接拿到生产环境正确使用么？

我们现在只是能拿到一个预测结果，还不知道这个模型效果怎么样？
预测的结果准不准
如果拿到真实环境，其实是没有 label 的，我们怎么对结果进行验证呢？

实际上，从训练好模型到真实使用，还差着远呢。我们要做的第一步就是：

将原始数据中的一部分作为训练数据、另一部分作为测试数据。使用训练数据训练模型，再用测试数据看好坏。即通过测试数据判断模型好坏，然后再不断对模型进行修改。

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

import numpy as npfrom sklearn import datasetsimport matplotlib.pyplot as plt

iris = datasets.load_iris()

X = iris.data
y = iris.target

X.shape
输出：(150, 4)

X.shape
输出：(150,)

我们下面进行训练数据集、测试数据集的拆分工作（train_test_split）。

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

比如下面这个，是有顺序的。

为了解决这个问题，我们可以将数据集打乱，做一个 shuffle 操作。但是本数据集的特征和标签是分开的，也就是说我们分别乱序后，原来的对应关系就不存在了。有两种方法解决这一问题：

将 X 和 y 合并为同一个矩阵，然后对矩阵进行 shuffle，之后再分解
对 y 的索引进行乱序，根据索引确定与 X 的对应关系，最后再通过乱序的索引进行赋值

首先看第一种方法：

# 方法 1# 使用 concatenate 函数进行拼接，因为传入的矩阵必须具有相同的形状。因此需要对 label 进行 reshape 操作，reshape(-1,1)表示行数自动计算，1 列。axis= 1 表示纵向拼接。tempConcat = np.concatenate((X, y.reshape(-1,1)), axis=1)# 拼接好后，直接进行乱序操作 np.random.shuffle(tempConcat)# 再将 shuffle 后的数组使用 split 方法拆分 shuffle_X,shuffle_y = np.split(tempConcat, [4], axis=1)# 设置划分的比例 test_ratio = 0.2test_size = int(len(X) * test_ratio)
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)
输出：(120, 4)
(30, 4)
(120, 1)
(30, 1)

# 方法 2# 将 x 长度这么多的数，返回一个新的打乱顺序的数组，注意，数组中的元素不是原来的数据，而是混乱的索引 shuffle_index = np.random.permutation(len(X))# 指定测试数据的比例 test_ratio = 0.2test_size = int(len(X) * test_ratio)
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)

输出：(120, 4)
(30, 4)
(120,)
(30,)

下面我们将编写自己的 train_test_split，并封装成方法。

还记得我们的 github 上的工程吗？https://github.com/japsonzbz/ML_Algorithms

编写一个自己的 train_test_split 方法。这个方法可以放到 model——selection.py 下。因为分割训练集和测试集合，可以帮助我们测试机器学习性能，能够帮助我们更好地选择模型。

import numpy as npdef train_test_split(X, y, test_ratio=0.2, seed=None):
    """将矩阵 X 和标签 y 按照 test_ration 分割成 X_train, X_test, y_train, y_test"""
    assert X.shape[0] == y.shape[0], \        "the size of X must be equal to the size of y"
    assert 0.0 <= test_ratio <= 1.0, \        "test_train must be valid"

    if seed:    # 是否使用随机种子，使随机结果相同，方便 debug
        np.random.seed(seed)    # permutation(n) 可直接生成一个随机排列的数组，含有 n 个元素
    shuffle_index = np.random.permutation(len(X))

    test_size = int(len(X) * test_ratio)
    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]    return X_train, X_test, y_train, y_test

from myAlgorithm.model_selection import train_test_split

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)

输出：(120, 4)
(30, 4)
(120,)
(30,)

再得到分割好的训练数据集和测试数据集以后，下面将其应用于 kNN 算法中。

我们可以简单验证一下，X_train, y_train 通过 fit 传入算法，然后对 X_test 做预测，得到 y_predict。

然后我们可以直观地把 y_predict 和实际的结果 y_test 进行一个比较，看有多少个元素一样。当然我们也可以自己计算一下正确率

from myAlgorithm.kNN import kNNClassifier

my_kNNClassifier = kNNClassifier(k=3)
my_kNNClassifier.fit(X_train, y_train)

y_predict = my_kNNClassifier.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

我们自己写的 train_test_split 其实也是在模仿 sklearn 风格，更多的时候我们可以直接调用。

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=666)

print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)
输出：(112, 4)
(38, 4)
(112,)
(38,)

在划分出测试数据集后，我们就可以验证其模型准确率了。在这了引出一个非常简单且常用的概念：accuracy（分类准确度）

accuracy_score：函数计算分类准确率，返回被正确分类的样本比例（default）或者是数量（normalize=False）
在多标签分类问题中，该函数返回子集的准确率，对于一个给定的多标签样本，如果预测得到的标签集合与该样本真正的标签集合严格吻合，则 subset accuracy =1.0 否则是 0.0

因 accuracy 定义清洗、计算方法简单，因此经常被使用。但是它在某些情况下并不一定是评估模型的最佳工具。精度（查准率）和召回率（查全率）等指标对衡量机器学习的模型性能在某些场合下要比 accuracy 更好。

当然这些指标在后续都会介绍。在这里我们就使用分类精准度，并将其作用于一个新的手写数字识别分类算法上。

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

输出：dict_keys(['data', 'target', 'target_names', 'images', 'DESCR'])

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

# 5620 张图片，每张图片有 64 个像素点即特征（8* 8 整数像素图像），每个特征的取值范围是 1～16（sklearn 中的不全），对应的分类结果是 10 个数字 print(digits.DESCR)

下面我们根据 datasets 提供的方法，进行简单的数据探索。

# 特征的 shapeX = digits.data
X.shape
(1797, 64)# 标签的 shapey = digits.target
y.shape
(1797,)# 标签分类 digits.target_names
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])# 去除某一个具体的数据，查看其特征以及标签信息 some_digit = X[666]
some_digit
array([0.,  0.,  5., 15., 14.,  3.,  0.,  0.,  0.,  0., 13., 15.,  9.,15.,  2.,  0.,  0.,  4., 16., 12.,  0., 10.,  6.,  0.,  0.,  8.,16.,  9.,  0.,  8., 10.,  0.,  0.,  7., 15.,  5.,  0., 12., 11.,0.,  0.,  7., 13.,  0.,  5., 16.,  6.,  0.,  0.,  0., 16., 12.,15., 13.,  1.,  0.,  0.,  0.,  6., 16., 12.,  2.,  0.,  0.])
y[666]0# 也可以这条数据进行可视化 some_digmit_image = some_digit.reshape(8, 8)
plt.imshow(some_digmit_image, cmap = matplotlib.cm.binary)
plt.show()

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

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)0.9955555555555555

下面我们在我们自己的工程文件中添加一个metrics.py，用来度量性能的各种指标。

import numpy as npfrom math import sqrtdef accuracy_score(y_true, y_predict):
    """计算 y_true 和 y_predict 之间的准确率"""
    assert y_true.shape[0] != y_predict.shape[0], \        "the size of y_true must be equal to the size of y_predict"
    return sum(y_true == y_predict) / len(y_true)

这样以后就不用一遍遍地写逻辑了，直接调用我们写好的封装函数。我们再调用一下：

from myAlgorithm.metrics import accuracy_score

accuracy_score(y_test, y_predict)

但在实际情况下，我们有时可能还有这样的需求：用 classifier 将我们的预测值 y_predicr 预测出来了，再去看和真值的比例。但是有时候我们对预测值 y_predicr 是多少不感兴趣，我们只对模型的准确率感兴趣。

可以在 kNN 算法模型中进一步封装一个函数（完整代码见 https://github.com/japsonzbz/ML_Algorithms）

def score(self, X_test, y_test):
    """根据 X_test 进行预测, 给出预测的真值 y_test，计算预测算法的准确度"""
    y_predict = self.predict(X_test)    return accuracy_score(y_test, y_predict)

然后我们就可以直接运行着这命令，直接测出模型分类准确度：

my_knn_clf.score(X_test, y_test)

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

from sklearn.model_selection import train_test_splitfrom 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_test, y_predict)

输出：0.9888888888888889# 不看 y_predictknn_clf.score(X_test,y_test)

输出：0.9888888888888889

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

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

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

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

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

# 指定最佳值的分数，初始化为 0.0；设置最佳值 k，初始值为 -1best_score = 0.0best_k = -1for 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)

输出：best_k =  4best_score =  0.9916666666666667

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

在回顾 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.0best_k = -1for 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)

输出：best_method =  distance
best_k =  4best_score =  0.9916666666666667

在具体的超参数搜索过程中会需要很多问题，超参数过多、超参数之间相互依赖等等。如何一次性地把我们想要得到最好的超参数组合列出来。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)

输出：CPU times: user 2min 21s, sys: 628 ms, total: 2min 21s
Wall time: 2min 23s
GridSearchCV(cv=None, error_score='raise',
       estimator=KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=5, p=2,
           weights='uniform'),
       fit_params=None, iid=True, n_jobs=1,
       param_grid=[{'weights': ['uniform'], 'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]}, {'weights': ['distance'], 'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'p': [1, 2, 3, 4, 5]}],
       pre_dispatch='2*n_jobs', refit=True, return_train_score='warn',
       scoring=None, verbose=0)

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

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

输出：KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=3, p=3,
           weights='distance')

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

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

grid_search.best_score_

输出：0.9853862212943633grid_search.beat_params_

输出：{'n_neighbors':3, 'p':3, 'weights':'distance'}

knn_clf = grid_search.beat_estimator_
knn_clf.score(X_test, y_test)

输出：0.9833333333328

在这篇文章中，我们借助 kNN 分类算法，学习了如下知识点：

为了验证模型的好坏，将数据集划分为训练数据集和测试数据集，这样我们就可以对测试数据集的进行预测，然后使用 label 进行验证。
在我们得到了分类结果之后，就可以使用分类正确的数据点比上总的测试数据点，这样就可以计算出 accuracy 分类精准度。
使用 kNN 算法对手写数字分类当然，不同的评价指标有不同的使用场景，不能乱用。
最后我们以 kNN 算法为例，探究了不同的超参数对模型的影响，使用 sklearn 中封装好的网格搜索算法，可以帮助我们进行基础调参。

现在我们通过 kNN 算法，已经学习到不少机器学习相关的知识和概念了，在下一篇文章中，会一起学习机器学习中的另一个重要概念：数据归一化。并且会对 kNN 的优缺点以及相关的优化算法做一个总结。

搜索进入小程序，可解锁更多精彩资讯和优质内容，不要错过哟！

0x01 前言

0x01 判断模型好坏

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

1.2 鸢尾花 train_test

第一种方法

第二种方法

1.3 编写自己的 train_test_split

编写

调用

1.4 sklearn 中的 train_test_split

0x02 分类准确度 accuracy

2.1 数据探索

2.2 自己实现分类准确度

2.3 sklearn 中的准确度

0x03 超参数

3.1 超参数简介

3.2 寻找好的 k

3.2 另一个超参数：权重

3.3 超参数网格搜索

0xFF 总结

Just My Socks（注册教程内含优惠码）