K近邻算法KNN

一、K 近邻算法原理

1. 监督学习任务的基本流程和架构：

（1）首先准备数据，可以是视频、音频、文本、图片等等

（2）抽取所需要的一些列特征，形成特征向量（Feature Vectors）

（3）将这些特征向量连同标记（Label）一并送入机器学习算法中，训练出一个预测模型（Predictive Model）。

（4）然后，采用同样的特征提取方法作用于新数据，得到用于测试的特征向量。

（5）最后，使用预测模型对这些待测的特征向量进行预测并得到结果（Expected Model）。

根据目标的不同将监督学习任务分为了分类学习及回归预测问题。

2. KNN 原理

KNN（K-Nearest Neihbor，KNN）K近邻是机器学习算法中理论最简单，最好理解的算法，是一个非常适合入门的算法，拥有如下特性：

• 是一种非参的、惰性的算法模型

• 非参：模型不会对数据做出任何假设

• 惰性：没有明确的训练过程，或者说这个过程很快

KNN是监督学习分类算法，主要解决现实生活中分类问题。

算法的思想：通过K个最近的已知分类的样本来判断未知样本的类别

KNN算法描述

输入：训练数据集
xi为实例的特征向量，yi={C1，c2…Ck}为实例类别。

输出：实例x所属的类别y

步骤：

（1）选择参数K

（2）计算测试样本和训练样本中每个样本的的距离（多种方式计算距离），并对距离进行排序

（3）选择最近K个已知实例

（4）根据少数服从多数的原则进行投票，让未知实例归类为K个最近邻中最多数的类别。

总结：KNN算法没有明显的特征训练过程，它的训练阶段仅仅将样本保存起来，训练开销为0，等到收到测试样本后在进行处理（如K值取值和距离计算）。因此，对应于训练阶段的学习该算法是一种懒惰学习（lazy learning）。

KNN三要素

• 距离度量
• K值选择
• 分类决策准则

K近邻算法的优缺点：

• 优点：简单，易于理解，容易实现，预测效果好；适合对稀有事件进行分类
• 缺点：算法复杂度高，计算量较大，结果对K取值敏感，容易受数据分布影响

3. Sklearn API介绍

本小节使用 scikit-learn 的 KNN API 来完成对鸢尾花数据集的预测.

• API介绍

1、sklearn中K近邻算法的对象：

from sklearn.neighbors import KNeighborsClassifier
 estimator = KNeighborsClassifier(n_neighbors=3)  # K的取值通过n_neighbors传递

2、sklearn中大多数算法模型训练的API都是同一个套路

estimator = KNeighborsClassifier(n_neighbors=3) # 创建算法模型对象
estimator.fit(x_, iris.target)  # 调用fit方法训练模型
estimator.predict(x_)           # 用训练好的模型进行预测

3、sklearn中自带几个学习数据集

• 都封装在sklearn.datasets 这个包中
• 加载数据后，通过data属性可以获取特征值，通过target属性可以获取目标值， 通过DESCR属性可以获取数据集的描述信息

4. K 值选择问题

不同取值的影响

K值过小：容易受到异常点的影响

k值过大：受到样本均衡的问题

K=N（N为训练样本个数）：结果只取决于数据集中不同类别数量占比，得到的结果一定是占比高的类别，此时模型过于简单，忽略了训练实例中大量有用信息。

在实际应用中，K一般取一个较小的数值

我们可以采用交叉验证法（把训练数据再分成:训练集和验证集）来选择最优的K值。

使用GridSearchCV 选择k值

使用 scikit-learn 提供的 GridSearchCV 工具, 配合交叉验证法可以搜索参数组合. GridSearchCV 工具可以用来寻找最优的模型超参数，可以用来做KNN中K值的选择

# 1. 加载数据集
x, y = load_iris(return_X_y=True)

# 2. 分割数据集
x_train, x_test, y_train, y_test = \
    train_test_split(x, y, test_size=0.2, stratify=y, random_state=0)

# 3. 创建网格搜索对象
estimator = KNeighborsClassifier()
param_grid = {'n_neighbors': [1, 3, 5, 7]}
estimator = GridSearchCV(estimator, param_grid=param_grid, cv=5, verbose=0)
estimator.fit(x_train, y_train)

# 4. 打印最优参数
print('最优参数组合:', estimator.best_params_, '最好得分:', estimator.best_score_)

# 4. 测试集评估模型
print('测试集准确率:', estimator.score(x_test, y_test))

2. 鸢尾花分类示例代码

鸢尾花数据集

鸢尾花Iris Dataset数据集是机器学习领域经典数据集，鸢尾花数据集包含了150条鸢尾花信息，每50条取自三个鸢尾花中之一：Versicolour、Setosa和Virginica

每个花的特征用如下属性描述：

示例代码:

from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

if __name__ == '__main__':
    # 1. 加载数据集  
    iris = load_iris() #通过iris.data 获取数据集中的特征值  iris.target获取目标值

    # 2. 数据标准化
    transformer = StandardScaler()
    x_ = transformer.fit_transform(iris.data) # iris.data 数据的特征值

    # 3. 模型训练
    estimator = KNeighborsClassifier(n_neighbors=3) # n_neighbors 邻居的数量，也就是Knn中的K值
    estimator.fit(x_, iris.target) # 调用fit方法 传入特征和目标进行模型训练

    # 4. 利用模型预测
    result = estimator.predict(x_) 
    print(result)

二、距离度量方法

1. 机器学习中为什么要度量距离？

机器学习算法中，经常需要 判断两个样本之间是否相似 ，比如KNN，K-means，推荐算法中的协同过滤等等，常用的套路是 将相似的判断转换成距离的计算 ，距离近的样本相似程度高，距离远的相似程度低。所以度量距离是很多算法中的关键步骤。

KNN算法中要求数据的所有特征都用数值表示。若在数据特征中存在非数值类型，必须采用手段将其进行量化为数值。

• 比如样本特征中包含有颜色（红、绿、蓝）一项，颜色之间没有距离可言，可通过将颜色转化为 灰度值来实现距离计算 。
• 每个特征都用数值表示，样本之间就可以计算出彼此的距离来

2. 欧式距离

• 欧几里得度量（euclidean metric）（也称欧氏距离）是一个通常采用的距离定义，指在m维空间中两个点之间的真实距离，或者向量的自然长度（即该点到原点的距离）。在二维和三维空间中的欧氏距离就是两点之间的实际距离。
• 欧氏距离能够体现个体数值特征的绝对差异，所以更多的用于需要从维度的数值大小中体现差异的分析，如使用用户行为指标分析用户价值的相似度或差异；

两点之间的几何距离

3. 曼哈顿距离

两点之间每个维度上的距离

4. 切比雪夫距离(了解)

选择x方向距离的绝对值和y方向的距离绝对值中的最大的

国际象棋棋盘上二个位置间的切比雪夫距离是指王要从一个位置移至另一个位置需要走的步数。(王可以往斜前或斜后方向移动一格)

5. 闵式距离

闵氏距离不是一种距离，而是一组距离的定义，是对多个距离度量公式的概括性的表述。

其中p是一个变参数：

• 当 p=1 时，就是曼哈顿距离；
• 当 p=2 时，就是欧氏距离；
• 当 p→∞ 时，就是切比雪夫距离。

根据 p 的不同，闵氏距离可以表示某一类/种的距离。

三、归一化和标准化

样本中有多个特征，每一个特征都有自己的定义域和取值范围，他们对距离计算也是不同的，如取值较大的影响力会盖过取值较小的参数。因此，为了公平，样本参数必须做一些归一化处理，将不同的特征都缩放到相同的区间或者分布内。

1. 归一化

通过对原始数据进行变换，把数据映射到(默认为[0,1])之间。

scikit-learn 中实现归一化的 API:

from sklearn.preprocessing import MinMaxScaler

def test():

    # 1. 准备数据
    data = [[90, 2, 10, 40],
            [60, 4, 15, 45],
            [75, 3, 13, 46]]

    # 2. 初始化归一化对象
    transformer = MinMaxScaler()

    # 3. 对原始特征进行变换
    data = transformer.fit_transform(data)

    # 4. 打印归一化后的结果
    print(data)

归一化受到最大值与最小值的影响，这种方法容易受到异常数据的影响, 鲁棒性较差，适合传统精确小数据场景

2. 标准化

• mean 为特征的平均值
• σ 为特征的标准差

scikit-learn 中实现标准化的 API:

from sklearn.preprocessing import StandardScaler

def test():

    # 1. 准备数据
    data = [[90, 2, 10, 40],
            [60, 4, 15, 45],
            [75, 3, 13, 46]]

    # 2. 初始化标准化对象
    transformer = StandardScaler()

    # 3. 对原始特征进行变换
    data = transformer.fit_transform(data)

    # 4. 打印归一化后的结果
    print(data)

对于标准化来说，如果出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响并不大

四、分类模型评估方法

1.数据集划分

为了能够评估模型的泛化能力，可以通过实验测试对学习器的泛化能力进行评估，进而做出选择。因此需要使用一个 “测试集” 来测试学习器对新样本的判别能力，以测试集上的 “测试误差” 作为泛化误差的近似。

一般测试集满足:

1. 能代表整个数据集
2. 测试集与训练集互斥
3. 测试集与训练集建议比例: 2比8、3比7 等

1.2 数据集划分的方法

（1）留出法：将数据集划分成两个互斥的集合：训练集，测试集

• 训练集用于模型训练
• 测试集用于模型验证
• 也称之为简单交叉验证

（2）交叉验证：将数据集划分为训练集，验证集，测试集

• 训练集用于模型训练
• 验证集用于参数调整
• 测试集用于模型验证

（3）留一法：每次从训练数据中抽取一条数据作为测试集

（4）自助法：以自助采样（可重复采样、有放回采样）为基础

• 在数据集D中随机抽取m个样本作为训练集
• 没被随机抽取到的D-m条数据作为测试集

1.3 留出法(简单交叉验证)

留出法 (hold-out) 将数据集 D 划分为两个互斥的集合，其中一个集合作为训练集 S，另一个作为测试集 T。

from sklearn.model_selection import train_test_split
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.model_selection import ShuffleSplit
from collections import Counter
from sklearn.datasets import load_iris


def test01():

    # 1. 加载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))

    # 2. 留出法(随机分割)
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
    print('随机类别分割:', Counter(y_train), Counter(y_test))

    # 3. 留出法(分层分割)
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, stratify=y)
    print('分层类别分割:', Counter(y_train), Counter(y_test))


def test02():

    # 1. 加载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
    print('*' * 40)

    # 2. 多次划分(随机分割)
    spliter = ShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
    for train, test in spliter.split(x, y):
        print('随机多次分割:', Counter(y[test]))

    print('*' * 40)

    # 3. 多次划分(分层分割)
    spliter = StratifiedShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
    for train, test in spliter.split(x, y):
        print('分层多次分割:', Counter(y[test]))


if __name__ == '__main__':
    test01()
    test02()

1.4 交叉验证法

K-Fold交叉验证，将数据随机且均匀地分成k分，如上图所示（k为10），假设每份数据的标号为0-9

• 第一次使用标号为0-8的共9份数据来做训练，而使用标号为9的这一份数据来进行测试，得到一个准确率
• 第二次使用标记为1-9的共9份数据进行训练，而使用标号为0的这份数据进行测试，得到第二个准确率
• 以此类推，每次使用9份数据作为训练，而使用剩下的一份数据进行测试
• 共进行10次训练，最后模型的准确率为10次准确率的平均值
• 这样可以避免了数据划分而造成的评估不准确的问题。

from sklearn.model_selection import KFold
from sklearn.model_selection import StratifiedKFold
from collections import Counter
from sklearn.datasets import load_iris

def test():

    # 1. 加载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
    print('*' * 40)

    # 2. 随机交叉验证
    spliter = KFold(n_splits=5, shuffle=True, random_state=0)
    for train, test in spliter.split(x, y):
        print('随机交叉验证:', Counter(y[test]))

    print('*' * 40)

    # 3. 分层交叉验证
    spliter = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    for train, test in spliter.split(x, y):
        print('分层交叉验证:', Counter(y[test]))


if __name__ == '__main__':
    test()

1.5 留一法

留一法( Leave-One-Out，简称LOO），即每次抽取一个样本做为测试集。

from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import LeavePOut
from sklearn.datasets import load_iris
from collections import Counter


def test01():

    # 1. 加载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
    print('*' * 40)

    # 2. 留一法
    spliter = LeaveOneOut()
    for train, test in spliter.split(x, y):
        print('训练集:', len(train), '测试集:', len(test), test)

    print('*' * 40)

    # 3. 留P法
    spliter = LeavePOut(p=3)
    for train, test in spliter.split(x, y):
        print('训练集:', len(train), '测试集:', len(test), test)


if __name__ == '__main__':
    test01()

1.6 自助法

每次随机从D中抽出一个样本，将其拷贝放入D，然后再将该样本放回初始数据集D中，使得该样本在下次采样时仍有可能被抽到；
这个过程重复执行m次后，我们就得到了包含m个样本的数据集D′，这就是自助采样的结果。

import pandas as pd


if __name__ == '__main__':

    # 1. 构造数据集
    data = [[90, 2, 10, 40],
            [60, 4, 15, 45],
            [75, 3, 13, 46],
            [78, 2, 64, 22]]

    data = pd.DataFrame(data)
    print('数据集:\n',data)
    print('*' * 30)

    # 2. 产生训练集
    train = data.sample(frac=1, replace=True)
    print('训练集:\n', train)

    print('*' * 30)

    # 3. 产生测试集
    test = data.loc[data.index.difference(train.index)]
    print('测试集:\n', test)

2.分类算法的评估标准

2.1 分类算法的评估

如何评估分类算法？

• 利用训练好的模型使用测试集的特征值进行预测

• 将预测结果和测试集的目标值比较，计算预测正确的百分比

• 这个百分比就是准确率 accuracy， 准确率越高说明模型效果越好

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
#加载鸢尾花数据
X,y = datasets.load_iris(return_X_y = True)
#训练集 测试集划分
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)
# 创建KNN分类器对象 近邻数为6
knn_clf = KNeighborsClassifier(n_neighbors=6)
#训练集训练模型
knn_clf.fit(X_train,y_train)
#使用训练好的模型进行预测
y_predict = knn_clf.predict(X_test)

计算准确率：

sum(y_predict==y_test)/y_test.shape[0]

2.2 SKlearn中模型评估API介绍

sklearn封装了计算准确率的相关API：

• sklearn.metrics包中的accuracy_score方法: 传入预测结果和测试集的标签， 返回预测准确率
• 分类模型对象的 score 方法：传入测试集特征值，测试集目标值

#计算准确率
from sklearn.metrics import accuracy_score
#方式1：
accuracy_score(y_test,y_predict)
#方式2：
knn_classifier.score(X_test,y_test)

---

KNN案例 - 手写数字识别

1. 数据介绍

数据文件 train.csv 和 test.csv 包含从 0 到 9 的手绘数字的灰度图像。

• 每个图像高 28 像素，宽28 像素，共784个像素。

• 每个像素取值范围[0,255]，取值越大意味着该像素颜色越深

• 训练数据集（train.csv）共785列。第一列为 “标签”，为该图片对应的手写数字。其余784列为该图像的像素值

• 训练集中的特征名称均有pixel前缀，后面的数字（[0,783])代表了像素的序号。

像素组成图像如下：

000 001 002 003 ... 026 027
028 029 030 031 ... 054 055
056 057 058 059 ... 082 083
 | | | | ...... | |
728 729 730 731 ... 754 755
756 757 758 759 ... 782 783

数据集示例如下:

2. 示例代码

import matplotlib.pyplot as plt
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import joblib
from collections import Counter


def show_digit(idx):
  	# 加载数据
    data = pd.read_csv('data/手写数字识别.csv')
    if idx < 0 or idx > len(data) - 1:
        return
    x = data.iloc[:, 1:]
    y = data.iloc[:,0]
    print('当前数字的标签为:',y[idx])
    
    # data 修改为 ndarray 类型
    data_ = x.iloc[idx].values
    # 将数据形状修改为 28*28
    data_ = data_.reshape(28, 28)
    # 关闭坐标轴标签
    plt.axis('off')
    # 显示图像
    plt.imshow(data_)
    plt.show()
    

def train_model():

    # 1. 加载手写数字数据集
    data = pd.read_csv('data/手写数字识别.csv')
    x = data.iloc[:, 1:] / 255
    y = data.iloc[:, 0]
    
    # 2. 打印数据基本信息
    print('数据基本信息:', x.shape)
    print('类别数据比例:', Counter(y))

    # 3. 分割数据集
    split_data = train_test_split(x, y, test_size=0.2, stratify=y, random_state=0)
    x_train, x_test, y_train, y_test = split_data

    # 4. 模型训练
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train, y_train)

    # 5. 模型评估
    acc = estimator.score(x_test, y_test)
    print('测试集准确率: %.2f' % acc)

    # 6. 模型保存
    joblib.dump(estimator, 'model/knn.pth')


def test_model():
    # 读取图片数据
    import matplotlib.pyplot as plt
    import joblib
    img = plt.imread('temp/demo.png')
    plt.imshow(img)
    # 加载模型
    knn = joblib.load('model/knn.pth')
    y_pred = knn.predict(img.reshape(1, -1))
    print('您绘制的数字是:', y_pred)


if __name__ == '__main__':
		# 显示部分数字
    show_digit(1)
    # 训练模型
    train_model()
    # 测试模型
    test_model()