一、在sklearn中创建KNN分类器

KNeighborsClassifier(n_neighbors=5, weights='uniform', algorithm='auto', leaf_size=30)

看一下这几个参数：

1. n_neighbors：即 KNN 中的 K 值，代表的是邻居的数量。如果K 值比较小，会造成过拟合；如果 K 值比较大，无法将未知物体分类出来。一般我们使用默认值 5。

2. weights：是用来确定邻居的权重，有两种方式：

1. weights=‘uniform’，代表所有邻居的权重相同；
2. weights=‘distance’，代表权重是距离的倒数，即与距离成反比。

3. algorithm：用来规定计算邻居的方法，它有四种方式：

1. algorithm=‘auto’，根据数据的情况自动选择适合的算法，默认情况选择 auto；
2. algorithm=‘kd_tree’，也叫作 KD 树，是多维空间的数据结构，方便对关键数据进行检索，不过 KD 树适用于维度少的情况，一般维数不超过 20，如果维数大于 20 之后，效率反而会下降；
3. algorithm=‘ball_tree’，也叫作球树，它和 KD 树一样都是多维空间的数据结果，不同于 KD 树，球树更适用于维度大的情况；
4. algorithm=‘brute’，也叫作暴力搜索，它和 KD 树不同的地方是在于采用的是线性扫描，而不是通过构造树结构进行快速检索。当训练集大的时候，效率很低。

4.leaf_size：代表构造 KD 树或球树时的叶子数，默认是 30，调整 leaf_size 会影响到树的构造和搜索速度。

创建完 KNN 分类器之后，我们就可以输入训练集对它进行训练，这里我们使用 fit() 函数，传入训练集中的样本特征矩阵和分类标识，会自动得到训练好的 KNN 分类器。然后可以使用 predict() 函数来对结果进行预测，这里传入测试集的特征矩阵，可以得到测试集的预测分类结果。

二、工作流程

我们用 sklearn 自带的手写数字数据集做 KNN 分类，你可以把这个数据集理解成一个简版的 MNIST 数据集，它只包括了 1797 幅数字图像，每幅图像大小是 8*8 像素。

先划分一下流程：

整个训练过程基本上都会包括三个阶段：

1. 数据加载：直接从 sklearn 中加载自带的手写数字数据集；
2. 准备阶段：在这个阶段中，我们需要对数据集有个初步的了解，比如样本的个数、图像长什么样、识别结果是怎样的。你可以通过可视化的方式来查看图像的呈现。通过数据规范化可以让数据都在同一个数量级的维度。另外，因为训练集是图像，每幅图像是个 8*8 的矩阵，我们不需要对它进行特征选择，将全部的图像数据作为特征值矩阵即可；
3. 分类阶段：通过训练可以得到分类器，然后用测试集进行准确率的计算。

三、实战环节

1.导包

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.datasets import load_digits
from sklearn.preprocessing import MinMaxScaler, StandardScaler
from sklearn.model_selection import train_test_split

from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import MultinomialNB
from sklearn.ensemble import AdaBoostClassifier

from sklearn.metrics import accuracy_score

2.加载数据并探索

# 加载数据
digits = load_digits()
data = digits.data

# 数据探索
print(data.shape)
# 查看第一幅图像
print(digits.images[0])
# 第一幅图像代表的数字含义
print(digits.target[0])

# 将第一幅图像显示出来
plt.imshow(digits.images[0])
plt.show()

输出：

(1797, 64)
[[ 0.  0.  5. 13.  9.  1.  0.  0.]
 [ 0.  0. 13. 15. 10. 15.  5.  0.]
 [ 0.  3. 15.  2.  0. 11.  8.  0.]
 [ 0.  4. 12.  0.  0.  8.  8.  0.]
 [ 0.  5.  8.  0.  0.  9.  8.  0.]
 [ 0.  4. 11.  0.  1. 12.  7.  0.]
 [ 0.  2. 14.  5. 10. 12.  0.  0.]
 [ 0.  0.  6. 13. 10.  0.  0.  0.]]
0

我们对原始数据集中的第一幅进行数据可视化，可以看到图像是个 8*8 的像素矩阵，上面这幅图像是一个“0”，从训练集的分类标注中我们也可以看到分类标注为“0”。

3.分割数据集并规范化

sklearn 自带的手写数字数据集一共包括了 1797 个样本，每幅图像都是 8*8 像素的矩阵。因为并没有专门的测试集，所以我们需要对数据集做划分，划分成训练集和测试集。因为 KNN 算法和距离定义相关，我们需要对数据进行规范化处理，采用 Z-Score 规范化，代码如下：

# 数据及目标
data1 = digits.data
target1 = digits.target

# 分割数据，将25%的数据作为测试集，其余作为训练集（你也可以指定其他比例的数据作为训练集）
train_x, test_x, train_y, test_y = train_test_split(data1, target1, test_size=0.25)

# 采用z-score规范化
ss = StandardScaler()
train_ss_scaled = ss.fit_transform(train_x)
test_ss_scaled = ss.transform(test_x)

# 采用0-1归一化
mm = MinMaxScaler()
train_mm_scaled = mm.fit_transform(train_x)
test_mm_scaled = mm.transform(test_x)

这里之所以用了0-1归一化，是因为多项式朴素贝叶斯分类这个模型，传入的数据不能有负数。因为 Z-Score 会将数值规范化为一个标准的正态分布，即均值为 0，方差为 1，数值会包含负数。因此我们需要采用 Min-Max 规范化，将数据规范化到[0,1]范围内。

4.建立模型，并进行比较

这里构造五个分类器， 分别是K近邻，SVM， 多项式朴素贝叶斯， 决策树模型， AdaBoost模型。并分别看看他们的效果。

models = {}
models['knn'] = KNeighborsClassifier()
models['svm'] = SVC()
models['bayes'] = MultinomialNB()
models['tree'] = DecisionTreeClassifier()
models['ada'] = AdaBoostClassifier(base_estimator=models['tree'], learning_rate=0.1)

for model_key in models.keys():
    if model_key == 'knn' or model_key == 'svm' or model_key == 'ada':
        model = models[model_key]
        model.fit(train_ss_scaled, train_y)
        predict = model.predict(test_ss_scaled)
        print(model_key, "准确率：", accuracy_score(test_y, predict))
    else:
        model = models[model_key]
        model.fit(train_mm_scaled, train_y)
        predict = model.predict(test_mm_scaled)
        print(model_key, "准确率: ", accuracy_score(test_y, predict))

输出：

knn 准确率： 0.9777777777777777
svm 准确率： 0.9866666666666667
bayes 准确率:  0.8888888888888888
tree 准确率:  0.8444444444444444
ada 准确率： 0.8355555555555556

你能看出来 KNN 的准确率还是不错的，和 SVM 不相上下。并且竟然比AdaBoost效果都要好，而让我纳闷的是决策树和AdaBoost怎么效果这么差，不可思议。后来我发现了，原来是样本数量的问题，我们最多数据集才1000多照片，数量太少了，AdaBoost的作用发挥不出来，所以我对数据进行扩增，复制了三遍原来的数据：

data2 = np.vstack((data1, data1, data1))
target2 = np.hstack((target1, target1, target1))

变成了5000多张数据，然后再进行测试，结果就是AdaBoost和tree的效果提升了，甚至可以和SVM效果媲美了。

输出：

knn 准确率： 0.9821958456973294
svm 准确率： 0.9970326409495549
bayes 准确率:  0.9013353115727003
tree 准确率:  0.9955489614243324
ada 准确率： 0.9933234421364985