日萌社

人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）

1 什么是K-近邻算法

根据你的“邻居”来推断出你的类别

1.1 K-近邻算法(KNN)概念

K Nearest Neighbor算法又叫KNN算法，这个算法是机器学习里面一个比较经典的算法，总体来说KNN算法是相对比较容易理解的算法

定义

如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

来源：KNN算法最早是由Cover和Hart提出的一种分类算法

距离公式

两个样本的距离可以通过如下公式计算，又叫欧式距离，关于距离公式会在后面进行讨论

1.3 KNN算法流程总结

1）计算已知类别数据集中的点与当前点之间的距离

2）按距离递增次序排序

3）选取与当前点距离最小的k个点

4）统计前k个点所在的类别出现的频率

5）返回前k个点出现频率最高的类别作为当前点的预测分类

2 小结

K-近邻算法简介【了解】
- 定义:就是通过你的"邻居"来判断你属于哪个类别
- 如何计算你到你的"邻居"的距离：一般时候,都是使用欧氏距离

1.2 k近邻算法api初步使用

1.获取数据集
2.数据基本处理
3.特征工程
4.机器学习
5.模型评估

1 Scikit-learn工具介绍

Python语言的机器学习工具
Scikit-learn包括许多知名的机器学习算法的实现
Scikit-learn文档完善，容易上手，丰富的API
目前稳定版本0.19.1

1.1 安装

pip3 install scikit-learn==0.19.1

安装好之后可以通过以下命令查看是否安装成功

import sklearn

注：安装scikit-learn需要Numpy, Scipy等库

1.2 Scikit-learn包含的内容

分类、聚类、回归
特征工程
模型选择、调优

2 K-近邻算法API

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5)
- n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数

3 案例

3.1 步骤分析

1.获取数据集
2.数据基本处理（该案例中省略）
3.特征工程（该案例中省略）
4.机器学习
5.模型评估（该案例中省略）

3.2 代码过程

导入模块

from sklearn.neighbors import KNeighborsClassifier

构造数据集

x = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]

机器学习 -- 模型训练

# 实例化API
estimator = KNeighborsClassifier(n_neighbors=2)
# 使用fit方法进行训练
estimator.fit(x, y)

estimator.predict([[1]])

4 小结

sklearn的优势:
- 文档多,且规范
- 包含的算法多
- 实现起来容易
knn中的api
- sklearn.neighbors.KNeighborsClassifier(n_neighbors=5)

问题

1.距离公式，除了欧式距离，还有哪些距离公式可以使用？

2.选取K值的大小？

3.api中其他参数的具体含义？

hello_knn.py

# coding:utf-8

from sklearn.neighbors import KNeighborsClassifier

# 1.构造数据
x = [[1], [2], [10], [20]]
y = [0, 0, 1, 1]

# 2.训练模型
# 2.1 实例化一个估计器对象
estimator = KNeighborsClassifier(n_neighbors=1)

# 2.2 调用fit方法,进行训练
estimator.fit(x, y)

# 3.数据预测
ret = estimator.predict([[0]])
print(ret)

ret1 = estimator.predict([[100]])
print(ret1)

1.3 距离度量

1 距离公式的基本性质

2 常见的距离公式

2.1 欧式距离(Euclidean Distance)：

欧氏距离是最容易直观理解的距离度量方法，我们小学、初中和高中接触到的两个点在空间中的距离一般都是指欧氏距离。

举例:

X=[[1,1],[2,2],[3,3],[4,4]];
经计算得:
d = 1.4142    2.8284    4.2426    1.4142    2.8284    1.4142

2.2 曼哈顿距离(Manhattan Distance)：

在曼哈顿街区要从一个十字路口开车到另一个十字路口，驾驶距离显然不是两点间的直线距离。这个实际驾驶距离就是“曼哈顿距离”。曼哈顿距离也称为“城市街区距离”(City Block distance)。

举例:

X=[[1,1],[2,2],[3,3],[4,4]];
经计算得:
d =   2     4     6     2     4     2

2.3 切比雪夫距离 (Chebyshev Distance)：

国际象棋中，国王可以直行、横行、斜行，所以国王走一步可以移动到相邻8个方格中的任意一个。国王从格子(x1,y1)走到格子(x2,y2)最少需要多少步？这个距离就叫切比雪夫距离。

举例:

X=[[1,1],[2,2],[3,3],[4,4]];
经计算得:
d =   1     2     3     1     2     1

2.4 闵可夫斯基距离(Minkowski Distance)：

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

两个n维变量a(x11,x12,…,x1n)与b(x21,x22,…,x2n)间的闵可夫斯基距离定义为：

其中p是一个变参数：

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

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

小结：

1 闵氏距离，包括曼哈顿距离、欧氏距离和切比雪夫距离，都存在明显的缺点:

e.g. 二维样本(身高[单位:cm],体重[单位:kg]),现有三个样本：a(180,50)，b(190,50)，c(180,60)。

a与b的闵氏距离（无论是曼哈顿距离、欧氏距离或切比雪夫距离）等于a与c的闵氏距离。但实际上身高的10cm并不能和体重的10kg划等号。

2 闵氏距离的缺点：

(1)将各个分量的量纲(scale)，也就是“单位”相同的看待了;

(2)未考虑各个分量的分布（期望，方差等）可能是不同的。

3 “连续属性”和“离散属性”的距离计算

我们常将属性划分为"连续属性" (continuous attribute)和"离散属性" (categorical attribute)，前者在定义域上有无穷多个可能的取值，后者在定义域上是有限个取值.

若属性值之间存在序关系，则可以将其转化为连续值，例如：身高属性“高”“中等”“矮”，可转化为{1, 0.5, 0}。
- 闵可夫斯基距离可以用于有序属性。
若属性值之间不存在序关系，则通常将其转化为向量的形式，例如：性别属性“男”“女”，可转化为{（1,0），（0,1）}。

4 小结

1 距离公式的基本性质：非负性、统一性、对称性、直递性【了解】
2 常见距离公式
- 2.1 欧式距离(Euclidean Distance)【知道】：
  - 通过距离平方值进行计算
- 2.曼哈顿距离(Manhattan Distance)【知道】：
  - 通过距离的绝对值进行计算
- 3.切比雪夫距离 (Chebyshev Distance)【知道】：
  - 维度的最大值进行计算
- 4.闵可夫斯基距离(Minkowski Distance)【知道】：
  - 当p=1时，就是曼哈顿距离；
  - 当p=2时，就是欧氏距离；
  - 当p→∞时，就是切比雪夫距离。
3 属性【知道】
- 连续属性
- 离散属性，
  - 存在序关系，可以将其转化为连续值
  - 不存在序关系，通常将其转化为向量的形式

阶指幂对

闵氏距离到切比雪夫的推导

知识拓展：其他距离公式

1 标准化欧氏距离 (Standardized EuclideanDistance)：

标准化欧氏距离是针对欧氏距离的缺点而作的一种改进。

思路：既然数据各维分量的分布不一样，那先将各个分量都“标准化”到均值、方差相等。

如果将方差的倒数看成一个权重，也可称之为加权欧氏距离(Weighted Euclidean distance)。

举例:

X=[[1,1],[2,2],[3,3],[4,4]];（假设两个分量的标准差分别为0.5和1）
经计算得:
d =   2.2361    4.4721    6.7082    2.2361    4.4721    2.2361

2 余弦距离(Cosine Distance)

几何中，夹角余弦可用来衡量两个向量方向的差异；机器学习中，借用这一概念来衡量样本向量之间的差异。

二维空间中向量A(x1,y1)与向量B(x2,y2)的夹角余弦公式：

两个n维样本点a(x11,x12,…,x1n)和b(x21,x22,…,x2n)的夹角余弦为：

夹角余弦取值范围为[-1,1]。余弦越大表示两个向量的夹角越小，余弦越小表示两向量的夹角越大。当两个向量的方向重合时余弦取最大值1，当两个向量的方向完全相反余弦取最小值-1。

举例:

X=[[1,1],[1,2],[2,5],[1,-4]]
经计算得:
d =   0.9487    0.9191   -0.5145    0.9965   -0.7593   -0.8107

3 汉明距离(Hamming Distance)【了解】：

两个等长字符串s1与s2的汉明距离为：将其中一个变为另外一个所需要作的最小字符替换次数。

例如:

  The Hamming distance between "1011101" and "1001001" is 2. 
  The Hamming distance between "2143896" and "2233796" is 3. 
  The Hamming distance between "toned" and "roses" is 3.

随堂练习：
求下列字符串的汉明距离：

  1011101与 1001001 　

  2143896与 2233796 
　
  irie与 rise

汉明重量：是字符串相对于同样长度的零字符串的汉明距离，也就是说，它是字符串中非零的元素个数：对于二进制字符串来说，就是 1 的个数，所以 11101 的汉明重量是 4。因此，如果向量空间中的元素a和b之间的汉明距离等于它们汉明重量的差a-b。

应用：汉明重量分析在包括信息论、编码理论、密码学等领域都有应用。比如在信息编码过程中，为了增强容错性，应使得编码间的最小汉明距离尽可能大。但是，如果要比较两个不同长度的字符串，不仅要进行替换，而且要进行插入与删除的运算，在这种场合下，通常使用更加复杂的编辑距离等算法。

举例:

X=[[0,1,1],[1,1,2],[1,5,2]]
注：以下计算方式中，把2个向量之间的汉明距离定义为2个向量不同的分量所占的百分比。

经计算得:
d =   0.6667    1.0000    0.3333

4 杰卡德距离(Jaccard Distance)【了解】：

杰卡德相似系数(Jaccard similarity coefficient)：两个集合A和B的交集元素在A，B的并集中所占的比例，称为两个集合的杰卡德相似系数，用符号J(A,B)表示：

杰卡德距离(Jaccard Distance)：与杰卡德相似系数相反，用两个集合中不同元素占所有元素的比例来衡量两个集合的区分度：

举例:

X=[[1,1,0],[1,-1,0],[-1,1,0]]
注：以下计算中，把杰卡德距离定义为不同的维度的个数占“非全零维度”的比例
经计算得:
d =   0.5000    0.5000    1.0000

5 马氏距离(Mahalanobis Distance)【了解】

下图有两个正态分布图，它们的均值分别为a和b，但方差不一样，则图中的A点离哪个总体更近？或者说A有更大的概率属于谁？显然，A离左边的更近，A属于左边总体的概率更大，尽管A与a的欧式距离远一些。这就是马氏距离的直观解释。

马氏距离是基于样本分布的一种距离。

马氏距离是由印度统计学家马哈拉诺比斯提出的，表示数据的协方差距离。它是一种有效的计算两个位置样本集的相似度的方法。

与欧式距离不同的是，它考虑到各种特性之间的联系，即独立于测量尺度。

马氏距离也可以定义为两个服从同一分布并且其协方差矩阵为∑的随机变量的差异程度：如果协方差矩阵为单位矩阵，马氏距离就简化为欧式距离；如果协方差矩阵为对角矩阵，则其也可称为正规化的欧式距离。

马氏距离特性：

1.量纲无关，排除变量之间的相关性的干扰；

2.马氏距离的计算是建立在总体样本的基础上的，如果拿同样的两个样本，放入两个不同的总体中，最后计算得出的两个样本间的马氏距离通常是不相同的，除非这两个总体的协方差矩阵碰巧相同；

3 .计算马氏距离过程中，要求总体样本数大于样本的维数，否则得到的总体样本协方差矩阵逆矩阵不存在，这种情况下，用欧式距离计算即可。

4.还有一种情况，满足了条件总体样本数大于样本的维数，但是协方差矩阵的逆矩阵仍然不存在，比如三个样本点（3，4），（5，6），（7，8），这种情况是因为这三个样本在其所处的二维空间平面内共线。这种情况下，也采用欧式距离计算。

欧式距离&马氏距离：

举例：

1.4 k值的选择

1 K值选择说明

举例说明：

K值过小：
- 容易受到异常点的影响
k值过大：
- 受到样本均衡的问题

K值选择问题，李航博士的一书「统计学习方法」上所说：

1) 选择较小的K值，就相当于用较小的领域中的训练实例进行预测，
- “学习”近似误差会减小，只有与输入实例较近或相似的训练实例才会对预测结果起作用，与此同时带来的问题是“学习”的估计误差会增大，
- 换句话说，K值的减小就意味着整体模型变得复杂，容易发生过拟合；
2) 选择较大的K值，就相当于用较大领域中的训练实例进行预测，
- 其优点是可以减少学习的估计误差，但缺点是学习的近似误差会增大。这时候，与输入实例较远（不相似的）训练实例也会对预测器作用，使预测发生错误。
- 且K值的增大就意味着整体的模型变得简单。
3) K=N（N为训练样本个数），则完全不足取，
- 因为此时无论输入实例是什么，都只是简单的预测它属于在训练实例中最多的类，模型过于简单，忽略了训练实例中大量有用信息。
在实际应用中，K值一般取一个比较小的数值，例如采用交叉验证法（简单来说，就是把训练数据在分成两组:训练集和验证集）来选择最优的K值。

近似误差：
- 对现有训练集的训练误差，关注训练集，
- 如果近似误差过小可能会出现过拟合的现象，对现有的训练集能有很好的预测，但是对未知的测试样本将会出现较大偏差的预测。
- 模型本身不是最接近最佳模型。
估计误差：
- 可以理解为对测试集的测试误差，关注测试集，
- 估计误差小说明对未知数据的预测能力好，
- 模型本身最接近最佳模型。

2 小结

KNN中K值大小选择对模型的影响【知道】
- K值过小：
  - 容易受到异常点的影响
  - 容易过拟合
- k值过大：
  - 受到样本均衡的问题
  - 容易欠拟合
误差
- 近似误差
- 估计误差

1.5 kd树

问题导入：

实现k近邻算法时，主要考虑的问题是如何对训练数据进行快速k近邻搜索。

这在特征空间的维数大及训练数据容量大时尤其必要。

k近邻法最简单的实现是线性扫描（穷举搜索），即要计算输入实例与每一个训练实例的距离。计算并存储好以后，再查找K近邻。当训练集很大时，计算非常耗时。

为了提高kNN搜索的效率，可以考虑使用特殊的结构存储训练数据，以减小计算距离的次数。

1.2 原理

黄色的点作为根节点，上面的点归左子树，下面的点归右子树，接下来再不断地划分，分割的那条线叫做分割超平面（splitting hyperplane），在一维中是一个点，二维中是线，三维的是面。

黄色节点就是Root节点，下一层是红色，再下一层是绿色，再下一层是蓝色。

1.树的建立；

2.最近邻域搜索（Nearest-Neighbor Lookup）

kd树(K-dimension tree)是一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。kd树是一种二叉树，表示对k维空间的一个划分，构造kd树相当于不断地用垂直于坐标轴的超平面将K维空间切分，构成一系列的K维超矩形区域。kd树的每个结点对应于一个k维超矩形区域。利用kd树可以省去对大部分数据点的搜索，从而减少搜索的计算量。

类比“二分查找”：给出一组数据：[9 1 4 7 2 5 0 3 8]，要查找8。如果挨个查找（线性扫描），那么将会把数据集都遍历一遍。而如果排一下序那数据集就变成了：[0 1 2 3 4 5 6 7 8 9]，按前一种方式我们进行了很多没有必要的查找，现在如果我们以5为分界点，那么数据集就被划分为了左右两个“簇” [0 1 2 3 4]和[6 7 8 9]。

因此，根本就没有必要进入第一个簇，可以直接进入第二个簇进行查找。把二分查找中的数据点换成k维数据点，这样的划分就变成了用超平面对k维空间的划分。空间划分就是对数据点进行分类，“挨得近”的数据点就在一个空间里面。

2 构造方法

（1）构造根结点，使根结点对应于K维空间中包含所有实例点的超矩形区域；

（2）通过递归的方法，不断地对k维空间进行切分，生成子结点。在超矩形区域上选择一个坐标轴和在此坐标轴上的一个切分点，确定一个超平面，这个超平面通过选定的切分点并垂直于选定的坐标轴，将当前超矩形区域切分为左右两个子区域（子结点）；这时，实例被分到两个子区域。

（3）上述过程直到子区域内没有实例时终止（终止时的结点为叶结点）。在此过程中，将实例保存在相应的结点上。

（4）通常，循环的选择坐标轴对空间切分，选择训练实例点在坐标轴上的中位数为切分点，这样得到的kd树是平衡的（平衡二叉树：它是一棵空树，或其左子树和右子树的深度之差的绝对值不超过1，且它的左子树和右子树都是平衡二叉树）。

KD树中每个节点是一个向量，和二叉树按照数的大小划分不同的是，KD树每层需要选定向量中的某一维，然后根据这一维按左小右大的方式划分数据。在构建KD树时，关键需要解决2个问题：

（1）选择向量的哪一维进行划分；

（2）如何划分数据；

第一个问题简单的解决方法可以是随机选择某一维或按顺序选择，但是更好的方法应该是在数据比较分散的那一维进行划分（分散的程度可以根据方差来衡量）。

第二个问题中，好的划分方法可以使构建的树比较平衡，可以每次选择中位数来进行划分。

3 案例分析

3.1 树的建立

给定一个二维空间数据集：T={(2,3),(5,4),(9,6),(4,7),(8,1),(7,2)}，构造一个平衡kd树。

（1）思路引导：

根结点对应包含数据集T的矩形，选择x(1)轴，6个数据点的x(1)坐标中位数是6，这里选最接近的(7,2)点，以平面x(1)=7将空间分为左、右两个子矩形（子结点）；接着左矩形以x(2)=4分为两个子矩形（左矩形中{(2,3),(5,4),(4,7)}点的x(2)坐标中位数正好为4），右矩形以x(2)=6分为两个子矩形，如此递归，最后得到如下图所示的特征空间划分和kd树。

3.2 最近领域的搜索

假设标记为星星的点是 test point，绿色的点是找到的近似点，在回溯过程中，需要用到一个队列，存储需要回溯的点，在判断其他子节点空间中是否有可能有距离查询点更近的数据点时，做法是以查询点为圆心，以当前的最近距离为半径画圆，这个圆称为候选超球（candidate hypersphere），如果圆与回溯点的轴相交，则需要将轴另一边的节点都放到回溯队列里面来。

样本集{(2,3),(5,4), (9,6), (4,7), (8,1), (7,2)}

3.2.1 查找点(2.1,3.1)

在(7,2)点测试到达(5,4)，在(5,4)点测试到达(2,3)，然后search_path中的结点为<(7,2),(5,4), (2,3)>，从search_path中取出(2,3)作为当前最佳结点nearest, dist为0.141；

然后回溯至(5,4)，以(2.1,3.1)为圆心，以dist=0.141为半径画一个圆，并不和超平面y=4相交，如上图，所以不必跳到结点(5,4)的右子空间去搜索，因为右子空间中不可能有更近样本点了。

于是再回溯至(7,2)，同理，以(2.1,3.1)为圆心，以dist=0.141为半径画一个圆并不和超平面x=7相交，所以也不用跳到结点(7,2)的右子空间去搜索。

至此，search_path为空，结束整个搜索，返回nearest(2,3)作为(2.1,3.1)的最近邻点，最近距离为0.141。

3.2.2 查找点(2,4.5)

在(7,2)处测试到达(5,4)，在(5,4)处测试到达(4,7)【优先选择在本域搜索】，然后search_path中的结点为<(7,2),(5,4), (4,7)>，从search_path中取出(4,7)作为当前最佳结点nearest, dist为3.202；

然后回溯至(5,4)，以(2,4.5)为圆心，以dist=3.202为半径画一个圆与超平面y=4相交，所以需要跳到(5,4)的左子空间去搜索。所以要将(2,3)加入到search_path中，现在search_path中的结点为<(7,2),(2, 3)>；另外，(5,4)与(2,4.5)的距离为3.04 < dist = 3.202，所以将(5,4)赋给nearest，并且dist=3.04。

回溯至(2,3)，(2,3)是叶子节点，直接平判断(2,3)是否离(2,4.5)更近，计算得到距离为1.5，所以nearest更新为(2,3)，dist更新为(1.5)

回溯至(7,2)，同理，以(2,4.5)为圆心，以dist=1.5为半径画一个圆并不和超平面x=7相交, 所以不用跳到结点(7,2)的右子空间去搜索。

至此，search_path为空，结束整个搜索，返回nearest(2,3)作为(2,4.5)的最近邻点，最近距离为1.5。

4 总结

kd树的构建过程【知道】
- 1.构造根节点
- 2.通过递归的方法，不断地对k维空间进行切分，生成子节点
- 3.重复第二步骤，直到子区域中没有示例时终止
- 需要关注细节：a.选择向量的哪一维进行划分；b.如何划分数据
kd树的搜索过程【知道】
- 1.二叉树搜索比较待查询节点和分裂节点的分裂维的值，（小于等于就进入左子树分支，大于就进入右子树分支直到叶子结点）
- 2.顺着“搜索路径”找到最近邻的近似点
- 3.回溯搜索路径，并判断搜索路径上的结点的其他子结点空间中是否可能有距离查询点更近的数据点，如果有可能，则需要跳到其他子结点空间中去搜索
- 4.重复这个过程直到搜索路径为空

1.6 案例：鸢尾花种类预测--数据集介绍

本实验介绍了使用Python进行机器学习的一些基本概念。在本案例中，将使用K-Nearest Neighbor（KNN）算法对鸢尾花的种类进行分类，并测量花的特征。

本案例目的：

遵循并理解完整的机器学习过程
对机器学习原理和相关术语有基本的了解。
了解评估机器学习模型的基本过程。

1 案例：鸢尾花种类预测

Iris数据集是常用的分类实验数据集，由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集，是一类多重变量分析的数据集。关于数据集的具体介绍：

2 scikit-learn中数据集介绍

2.1 scikit-learn数据集API介绍

sklearn.datasets
- 加载获取流行数据集
- datasets.load_*()
  - 获取小规模数据集，数据包含在datasets里
- datasets.fetch_*(data_home=None)
  - 获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录,默认是 ~/scikit_learn_data/

2.1.1 sklearn小数据集

sklearn.datasets.load_iris()

加载并返回鸢尾花数据集

2.1.2 sklearn大数据集

sklearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train’)
- subset：'train'或者'test'，'all'，可选，选择要加载的数据集。
- 训练集的“训练”，测试集的“测试”，两者的“全部”

2.2 sklearn数据集返回值介绍

load和fetch返回的数据类型datasets.base.Bunch(字典格式)
- data：特征数据数组，是 [n_samples * n_features] 的二维 numpy.ndarray 数组
- target：标签数组，是 n_samples 的一维 numpy.ndarray 数组
- DESCR：数据描述
- feature_names：特征名,新闻数据，手写数字、回归数据集没有
- target_names：标签名

from sklearn.datasets import load_iris
# 获取鸢尾花数据集
iris = load_iris()
print("鸢尾花数据集的返回值：\n", iris)
# 返回值是一个继承自字典的Bench
print("鸢尾花的特征值:\n", iris["data"])
print("鸢尾花的目标值：\n", iris.target)
print("鸢尾花特征的名字：\n", iris.feature_names)
print("鸢尾花目标值的名字：\n", iris.target_names)
print("鸢尾花的描述：\n", iris.DESCR)

2.3 查看数据分布

通过创建一些图，以查看不同类别是如何通过特征来区分的。在理想情况下，标签类将由一个或多个特征对完美分隔。在现实世界中，这种理想情况很少会发生。

seaborn介绍
- Seaborn 是基于 Matplotlib 核心库进行了更高级的 API 封装，可以让你轻松地画出更漂亮的图形。而 Seaborn 的漂亮主要体现在配色更加舒服、以及图形元素的样式更加细腻。
- 安装 pip3 install seaborn
- seaborn.lmplot() 是一个非常有用的方法，它会在绘制二维散点图时，自动完成回归拟合
  - sns.lmplot() 里的 x, y 分别代表横纵坐标的列名,
  - data= 是关联到数据集,
  - hue=*代表按照 species即花的类别分类显示,
  - fit_reg=是否进行线性拟合。
- 参考链接: api链接

%matplotlib inline  
# 内嵌绘图
import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# 把数据转换成dataframe的格式
iris_d = pd.DataFrame(iris['data'], columns = ['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width'])
iris_d['Species'] = iris.target

def plot_iris(iris, col1, col2):
    sns.lmplot(x = col1, y = col2, data = iris, hue = "Species", fit_reg = False)
    plt.xlabel(col1)
    plt.ylabel(col2)
    plt.title('鸢尾花种类分布图')
    plt.show()
plot_iris(iris_d, 'Petal_Width', 'Sepal_Length')

2.4 数据集的划分

机器学习一般的数据集会划分为两个部分：

训练数据：用于训练，构建模型
测试数据：在模型检验时使用，用于评估模型是否有效

划分比例：

训练集：70% 80% 75%
测试集：30% 20% 25%

数据集划分api

sklearn.model_selection.train_test_split(arrays, *options)
- 参数：
  - x 数据集的特征值
  - y 数据集的标签值
  - test_size 测试集的大小，一般为float
  - random_state 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
- return
  - x_train, x_test, y_train, y_test

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
# 1、获取鸢尾花数据集
iris = load_iris()
# 对鸢尾花数据集进行分割
# 训练集的特征值x_train 测试集的特征值x_test 训练集的目标值y_train 测试集的目标值y_test
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
print("x_train:\n", x_train.shape)
# 随机数种子
x_train1, x_test1, y_train1, y_test1 = train_test_split(iris.data, iris.target, random_state=6)
x_train2, x_test2, y_train2, y_test2 = train_test_split(iris.data, iris.target, random_state=6)
print("如果随机数种子不一致：\n", x_train == x_train1)
print("如果随机数种子一致：\n", x_train1 == x_train2)

3 总结

获取数据集【知道】
- 小数据:
  - sklearn.datasets.load_*
- 大数据集:
  - sklearn.datasets.fetch_*
数据集返回值介绍【知道】
- 返回值类型是bunch--是一个字典类型
- 返回值的属性:
  - data：特征数据数组
  - target：标签(目标)数组
  - DESCR：数据描述
  - feature_names：特征名,
  - target_names：标签(目标值)名
数据集的划分【掌握】
- sklearn.model_selection.train_test_split(arrays, *options)
- 参数:
  - x -- 特征值
  - y -- 目标值
  - test_size -- 测试集大小
  - ramdom_state -- 随机数种子
- 返回值:
  - x_train, x_test, y_train, y_test

数据集介绍.py

# coding:utf-8

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.datasets import load_iris, fetch_20newsgroups
from sklearn.model_selection import train_test_split

# 1.数据集获取
# 1.1 小数据集获取
iris = load_iris()
# print(iris)

# 1.2 大数据集获取
# news = fetch_20newsgroups()
# print(news)

# 2.数据集属性描述
# print("数据集特征值是:\n", iris.data)
# print("数据集目标值是:\n", iris["target"])
# print("数据集的特征值名字是:\n", iris.feature_names)
# print("数据集的目标值名字是:\n", iris.target_names)
# print("数据集的描述:\n", iris.DESCR)

# 3.数据可视化
iris_d = pd.DataFrame(data=iris.data, columns=['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width'])
iris_d["target"] = iris.target


# print(iris_d)

def iris_plot(data, col1, col2):
    sns.lmplot(x=col1, y=col2, data=data, hue="target", fit_reg=False)
    plt.title("鸢尾花数据显示")
    plt.show()


# iris_plot(iris_d, 'Sepal_Width', 'Petal_Length')
# iris_plot(iris_d, 'Sepal_Length', 'Petal_Width')

# 4.数据集的划分
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
print("训练集的特征值是:\n", x_train)
print("训练集的目标值是:\n", y_train)
print("测试集的特征值是:\n", x_test)
print("测试集的目标值是:\n", y_test)

print("训练集的目标值的形状是:\n", y_train.shape)
print("测试集的目标值的形状是:\n", y_test.shape)

x_train1, x_test1, y_train1, y_test1 = train_test_split(iris.data, iris.target, test_size=0.2, random_state=2)
x_train2, x_test2, y_train2, y_test2 = train_test_split(iris.data, iris.target, test_size=0.2, random_state=2)

print("测试集的目标值是:\n", y_test)
print("测试集的目标值是:\n", y_test1)
print("测试集的目标值是:\n", y_test2)

1.7 特征工程-特征预处理

1 什么是特征预处理

1.1 特征预处理定义

scikit-learn的解释

provides several common utility functions and transformer classes to change raw feature vectors into a representation that is more suitable for the downstream estimators.

翻译过来：通过一些转换函数将特征数据转换成更加适合算法模型的特征数据过程

为什么我们要进行归一化/标准化？
- 特征的单位或者大小相差较大，或者某特征的方差相比其他的特征要大出几个数量级，容易影响（支配）目标结果，使得一些算法无法学习到其它的特征

举例：约会对象数据

我们需要用到一些方法进行无量纲化，使不同规格的数据转换到同一规格

1.2 包含内容(数值型数据的无量纲化)

归一化
标准化

1.3 特征预处理API

sklearn.preprocessing

2 归一化

2.1 定义

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

2.2 公式

作用于每一列，max为一列的最大值，min为一列的最小值,那么X’’为最终结果，mx，mi分别为指定区间值默认mx为1,mi为0

那么怎么理解这个过程呢？我们通过一个例子

2.3 API

sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… )
- MinMaxScalar.fit_transform(X)
  - X:numpy array格式的数据[n_samples,n_features]
- 返回值：转换后的形状相同的array

2.4 数据计算

我们对以下数据进行运算，在dating.txt中。保存的就是之前的约会对象数据

milage,Liters,Consumtime,target
40920,8.326976,0.953952,3
14488,7.153469,1.673904,2
26052,1.441871,0.805124,1
75136,13.147394,0.428964,1
38344,1.669788,0.134296,1

分析

1、实例化MinMaxScalar

2、通过fit_transform转换

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

def minmax_demo():
    """
    归一化演示
    :return: None
    """
    data = pd.read_csv("./data/dating.txt")
    print(data)
    # 1、实例化一个转换器类
    transfer = MinMaxScaler(feature_range=(2, 3))
    # 2、调用fit_transform
    data = transfer.fit_transform(data[['milage','Liters','Consumtime']])
    print("最小值最大值归一化处理的结果：\n", data)

    return None

返回结果：

     milage     Liters  Consumtime  target
0     40920   8.326976    0.953952       3
1     14488   7.153469    1.673904       2
2     26052   1.441871    0.805124       1
3     75136  13.147394    0.428964       1
..      ...        ...         ...     ...
998   48111   9.134528    0.728045       3
999   43757   7.882601    1.332446       3

[1000 rows x 4 columns]
最小值最大值归一化处理的结果：
 [[ 2.44832535  2.39805139  2.56233353]
 [ 2.15873259  2.34195467  2.98724416]
 [ 2.28542943  2.06892523  2.47449629]
 ..., 
 [ 2.29115949  2.50910294  2.51079493]
 [ 2.52711097  2.43665451  2.4290048 ]
 [ 2.47940793  2.3768091   2.78571804]]

问题：如果数据中异常点较多，会有什么影响？

2.5 归一化总结

注意最大值最小值是变化的，另外，最大值与最小值非常容易受异常点影响，所以这种方法鲁棒性较差，只适合传统精确小数据场景。

怎么办？

3 标准化

3.1 定义

通过对原始数据进行变换把数据变换到均值为0,标准差为1范围内

3.2 公式

作用于每一列，mean为平均值，σ为标准差

所以回到刚才异常点的地方，我们再来看看标准化

对于归一化来说：如果出现异常点，影响了最大值和最小值，那么结果显然会发生改变
对于标准化来说：如果出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响并不大，从而方差改变较小。

3.3 API

sklearn.preprocessing.StandardScaler( )
- 处理之后每列来说所有数据都聚集在均值0附近标准差差为1
- StandardScaler.fit_transform(X)
  - X:numpy array格式的数据[n_samples,n_features]
- 返回值：转换后的形状相同的array

3.4 数据计算

同样对上面的数据进行处理

分析

1、实例化StandardScaler

2、通过fit_transform转换

import pandas as pd
from sklearn.preprocessing import StandardScaler

def stand_demo():
    """
    标准化演示
    :return: None
    """
    data = pd.read_csv("dating.txt")
    print(data)
    # 1、实例化一个转换器类
    transfer = StandardScaler()
    # 2、调用fit_transform
    data = transfer.fit_transform(data[['milage','Liters','Consumtime']])
    print("标准化的结果:\n", data)
    print("每一列特征的平均值：\n", transfer.mean_)
    print("每一列特征的方差：\n", transfer.var_)

    return None

返回结果：

     milage     Liters  Consumtime  target
0     40920   8.326976    0.953952       3
1     14488   7.153469    1.673904       2
2     26052   1.441871    0.805124       1
..      ...        ...         ...     ...
997   26575  10.650102    0.866627       3
998   48111   9.134528    0.728045       3
999   43757   7.882601    1.332446       3

[1000 rows x 4 columns]
标准化的结果:
 [[ 0.33193158  0.41660188  0.24523407]
 [-0.87247784  0.13992897  1.69385734]
 [-0.34554872 -1.20667094 -0.05422437]
 ..., 
 [-0.32171752  0.96431572  0.06952649]
 [ 0.65959911  0.60699509 -0.20931587]
 [ 0.46120328  0.31183342  1.00680598]]
每一列特征的平均值：
 [  3.36354210e+04   6.55996083e+00   8.32072997e-01]
每一列特征的方差：
 [  4.81628039e+08   1.79902874e+01   2.46999554e-01]

3.5 标准化总结

在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。

4 总结

什么是特征工程【知道】
- 定义
  - 通过一些转换函数将特征数据转换成更加适合算法模型的特征数据过程
- 包含内容:
  - 归一化
  - 标准化
归一化【知道】
- 定义:
  - 对原始数据进行变换把数据映射到(默认为[0,1])之间
- api:
  - sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… )
  - 参数:feature_range -- 自己指定范围,默认0-1
- 总结:
  - 鲁棒性比较差(容易受到异常点的影响)
  - 只适合传统精确小数据场景(以后不会用你了)
标准化【掌握】
- 定义:
  - 对原始数据进行变换把数据变换到均值为0,标准差为1范围内
- api:
  - sklearn.preprocessing.StandardScaler( )
- 总结:
  - 异常值对我影响小
  - 适合现代嘈杂大数据场景(以后就是用你了)

preproessing.py

# coding:utf-8

import pandas as pd
from sklearn.preprocessing import MinMaxScaler, StandardScaler


def minmax_demo():
    """
    归一化演示
    :return:None
    """
    data = pd.read_csv("./data/dating.txt")
    print(data)

    # 1.实例化
    transfer = MinMaxScaler(feature_range=(3,5))

    # 2.进行转换, 调用fit_transform
    ret_data = transfer.fit_transform(data[["milage", "Liters", "Consumtime"]])
    print("归一化之后的数据为:\n",ret_data)


def stand_demo():
    """
    标准化演示
    :return:None
    """
    data = pd.read_csv("./data/dating.txt")
    print(data)

    # 1.实例化
    transfer = StandardScaler()

    # 2.进行转换, 调用fit_transform
    ret_data = transfer.fit_transform(data[["milage", "Liters", "Consumtime"]])
    print("标准化之后的数据为:\n",ret_data)
    print("每一列的方差为:\n", transfer.var_)
    print("每一列的平均值为:\n", transfer.mean_)


# minmax_demo()
stand_demo()

1.8 案例：鸢尾花种类预测—流程实现

学习目标

目标
- 知道KNeighborsClassifier的用法

1 再识K-近邻算法API

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')
- n_neighbors：
  - int,可选（默认= 5），k_neighbors查询默认使用的邻居数
- algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}
  - 快速k近邻搜索算法，默认参数为auto，可以理解为算法自己决定合适的搜索算法。除此之外，用户也可以自己指定搜索算法ball_tree、kd_tree、brute方法进行搜索，
    - brute是蛮力搜索，也就是线性扫描，当训练集很大时，计算非常耗时。
    - kd_tree，构造kd树存储数据以便对其进行快速检索的树形数据结构，kd树也就是数据结构中的二叉树。以中值切分构造的树，每个结点是一个超矩形，在维数小于20时效率高。
    - ball tree是为了克服kd树高维失效而发明的，其构造过程是以质心C和半径r分割样本空间，每个节点是一个超球体。

2 案例：鸢尾花种类预测

2.1 数据集介绍

Iris数据集是常用的分类实验数据集，由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集，是一类多重变量分析的数据集。关于数据集的具体介绍：

2.2 步骤分析

1.获取数据集
2.数据基本处理
3.特征工程
4.机器学习(模型训练)
5.模型评估

2.3 代码过程

导入模块

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

先从sklearn当中获取数据集，然后进行数据集的分割

# 1.获取数据集
iris = load_iris()

# 2.数据基本处理
# x_train,x_test,y_train,y_test为训练集特征值、测试集特征值、训练集目标值、测试集目标值
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)

进行数据标准化
- 特征值的标准化

# 3、特征工程：标准化
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

模型进行训练预测

# 4、机器学习(模型训练)
estimator = KNeighborsClassifier(n_neighbors=9)
estimator.fit(x_train, y_train)
# 5、模型评估
# 方法1：比对真实值和预测值
y_predict = estimator.predict(x_test)
print("预测结果为:\n", y_predict)
print("比对真实值和预测值：\n", y_predict == y_test)
# 方法2：直接计算准确率
score = estimator.score(x_test, y_test)
print("准确率为：\n", score)

3 案例小结

在本案例中，具体完成内容有：

使用可视化加载和探索数据，以确定特征是否能将不同类别分开。
通过标准化数字特征并随机抽样到训练集和测试集来准备数据。
通过统计学，精确度度量进行构建和评估机器学习模型。

同学之间讨论刚才完成的机器学习代码,并且确保在自己的电脑运行成功

4 总结

KNeighborsClassifier的使用【知道】
- sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')
  - algorithm（auto,ball_tree, kd_tree, brute） -- 选择什么样的算法进行计算

iris_example.py

# coding:utf-8

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

# 1.获取数据
iris = load_iris()

# 2.数据基本处理
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)

# 3.特征工程 - 特征预处理
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

# 4.机器学习-KNN
# 4.1 实例化一个估计器
estimator = KNeighborsClassifier(n_neighbors=5)
# 4.2 模型训练
estimator.fit(x_train, y_train)

# 5.模型评估
# 5.1 预测值结果输出
y_pre = estimator.predict(x_test)
print("预测值是:\n", y_pre)
print("预测值和真实值的对比是:\n", y_pre==y_test)

# 5.2 准确率计算
score = estimator.score(x_test, y_test)
print("准确率为:\n", score)

cv_demo.py

# coding:utf-8

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

# 1.获取数据
iris = load_iris()

# 2.数据基本处理
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)

# 3.特征工程 - 特征预处理
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

# 4.机器学习-KNN
# 4.1 实例化一个估计器
estimator = KNeighborsClassifier()

# 4.2 模型调优 -- 交叉验证,网格搜索
param_grid = {"n_neighbors": [1, 3, 5, 7]}
estimator = GridSearchCV(estimator, param_grid=param_grid, cv=5)

# 4.3 模型训练
estimator.fit(x_train, y_train)

# 5.模型评估
# 5.1 预测值结果输出
y_pre = estimator.predict(x_test)
print("预测值是:\n", y_pre)
print("预测值和真实值的对比是:\n", y_pre == y_test)

# 5.2 准确率计算
score = estimator.score(x_test, y_test)
print("准确率为:\n", score)

# 5.3 查看交叉验证,网格搜索的一些属性
print("在交叉验证中,得到的最好结果是:\n", estimator.best_score_)
print("在交叉验证中,得到的最好的模型是:\n", estimator.best_estimator_)
print("在交叉验证中,得到的模型结果是:\n", estimator.cv_results_)

1.9 KNN算法总结

k近邻算法优缺点汇总

优点：
- 简单有效
- 重新训练的代价低
- 适合类域交叉样本
  - KNN方法主要靠周围有限的邻近的样本,而不是靠判别类域的方法来确定所属类别的，因此对于类域的交叉或重叠较多的待分样本集来说，KNN方法较其他方法更为适合。
- 适合大样本自动分类
  - 该算法比较适用于样本容量比较大的类域的自动分类，而那些样本容量较小的类域采用这种算法比较容易产生误分。

缺点：
- 惰性学习
  - KNN算法是懒散学习方法（lazy learning,基本上不学习），一些积极学习的算法要快很多
- 类别评分不是规格化
  - 不像一些通过概率评分的分类
- 输出可解释性不强
  - 例如决策树的输出可解释性就较强
- 对不均衡的样本不擅长
  - 当样本不平衡时，如一个类的样本容量很大，而其他类样本容量很小时，有可能导致当输入一个新样本时，该样本的K个邻居中大容量类的样本占多数。该算法只计算“最近的”邻居样本，某一类的样本数量很大，那么或者这类样本并不接近目标样本，或者这类样本很靠近目标样本。无论怎样，数量并不能影响运行结果。可以采用权值的方法（和该样本距离小的邻居权值大）来改进。
- 计算量较大
  - 目前常用的解决方法是事先对已知样本点进行剪辑，事先去除对分类作用不大的样本。

1.10 交叉验证，网格搜索

学习目标

目标
- 知道交叉验证、网格搜索的概念
- 会使用交叉验证、网格搜索优化训练模型

1 什么是交叉验证(cross validation)

交叉验证：将拿到的训练数据，分为训练和验证集。以下图为例：将数据分成4份，其中一份作为验证集。然后经过4次(组)的测试，每次都更换不同的验证集。即得到4组模型的结果，取平均值作为最终结果。又称4折交叉验证。

1.1 分析

我们之前知道数据分为训练集和测试集，但是为了让从训练得到模型结果更加准确。做以下处理

训练集：训练集+验证集
测试集：测试集

1.2 为什么需要交叉验证

交叉验证目的：为了让被评估的模型更加准确可信

问题：这个只是让被评估的模型更加准确可信，那么怎么选择或者调优参数呢？

2 什么是网格搜索(Grid Search)

通常情况下，有很多参数是需要手动指定的（如k-近邻算法中的K值），这种叫超参数。但是手动过程繁杂，所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建立模型。

3 交叉验证，网格搜索（模型选择与调优）API：

sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)
- 对估计器的指定参数值进行详尽搜索
- estimator：估计器对象
- param_grid：估计器参数(dict){“n_neighbors”:[1,3,5]}
- cv：指定几折交叉验证
- fit：输入训练数据
- score：准确率
- 结果分析：
  - bestscore__:在交叉验证中验证的最好结果
  - bestestimator：最好的参数模型
  - cvresults:每次交叉验证后的验证集准确率结果和训练集准确率结果

4 鸢尾花案例增加K值调优

使用GridSearchCV构建估计器

# 1、获取数据集
iris = load_iris()
# 2、数据基本处理 -- 划分数据集
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
# 3、特征工程：标准化
# 实例化一个转换器类
transfer = StandardScaler()
# 调用fit_transform
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)
# 4、KNN预估器流程
#  4.1 实例化预估器类
estimator = KNeighborsClassifier()

# 4.2 模型选择与调优——网格搜索和交叉验证
# 准备要调的超参数
param_dict = {"n_neighbors": [1, 3, 5]}
estimator = GridSearchCV(estimator, param_grid=param_dict, cv=3)
# 4.3 fit数据进行训练
estimator.fit(x_train, y_train)
# 5、评估模型效果
# 方法a：比对预测结果和真实值
y_predict = estimator.predict(x_test)
print("比对预测结果和真实值：\n", y_predict == y_test)
# 方法b：直接计算准确率
score = estimator.score(x_test, y_test)
print("直接计算准确率：\n", score)

然后进行评估查看最终选择的结果和交叉验证的结果

print("在交叉验证中验证的最好结果：\n", estimator.best_score_)
print("最好的参数模型：\n", estimator.best_estimator_)
print("每次交叉验证后的准确率结果：\n", estimator.cv_results_)

最终结果

比对预测结果和真实值：
 [ True  True  True  True  True  True  True False  True  True  True  True
  True  True  True  True  True  True False  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True]
直接计算准确率：
 0.947368421053
在交叉验证中验证的最好结果：
 0.973214285714
最好的参数模型：
 KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=5, p=2,
           weights='uniform')
每次交叉验证后的准确率结果：
 {'mean_fit_time': array([ 0.00114751,  0.00027037,  0.00024462]), 'std_fit_time': array([  1.13901511e-03,   1.25300249e-05,   1.11011951e-05]), 'mean_score_time': array([ 0.00085751,  0.00048693,  0.00045625]), 'std_score_time': array([  3.52785082e-04,   2.87650037e-05,   5.29673344e-06]), 'param_n_neighbors': masked_array(data = [1 3 5],
             mask = [False False False],
       fill_value = ?)
, 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}], 'split0_test_score': array([ 0.97368421,  0.97368421,  0.97368421]), 'split1_test_score': array([ 0.97297297,  0.97297297,  0.97297297]), 'split2_test_score': array([ 0.94594595,  0.89189189,  0.97297297]), 'mean_test_score': array([ 0.96428571,  0.94642857,  0.97321429]), 'std_test_score': array([ 0.01288472,  0.03830641,  0.00033675]), 'rank_test_score': array([2, 3, 1], dtype=int32), 'split0_train_score': array([ 1.        ,  0.95945946,  0.97297297]), 'split1_train_score': array([ 1.        ,  0.96      ,  0.97333333]), 'split2_train_score': array([ 1.  ,  0.96,  0.96]), 'mean_train_score': array([ 1.        ,  0.95981982,  0.96876877]), 'std_train_score': array([ 0.        ,  0.00025481,  0.0062022 ])}

5 总结

交叉验证【知道】
- 定义：
  - 将拿到的训练数据，分为训练和验证集
  - *折交叉验证
- 分割方式：
  - 训练集：训练集+验证集
  - 测试集：测试集
- 为什么需要交叉验证
  - 为了让被评估的模型更加准确可信
  - 注意：交叉验证不能提高模型的准确率
网格搜索【知道】
- 超参数:
  - sklearn中,需要手动指定的参数,叫做超参数
- 网格搜索就是把这些超参数的值,通过字典的形式传递进去,然后进行选择最优值
api【知道】
- sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)
  - estimator -- 选择了哪个训练模型
  - param_grid -- 需要传递的超参数
  - cv -- 几折交叉验证

第一章知识补充：再议数据分割

前面已经讲过，我们可通过实验测试来对学习器的泛化误差进行评估并进而做出选择。

为此，需使用一个“测试集”( testing set)来测试学习器对新样本的判别能力，然后以测试集上的“测试误差” (testing error)作为泛化误差的近似。

通常我们假设测试样本也是从样本真实分布中独立同分布采样而得。但需注意的是，测试集应该尽可能与训练集互斥。

互斥，即测试样本尽量不在训练集中出现、未在训练过程中使用过。

测试样本为什么要尽可能不出现在训练集中呢？为理解这一点，不妨考虑这样一个场景:

老师出了10道习题供同学们练习，考试时老师又用同样的这10道题作为试题，这个考试成绩能否有效反映出同学们学得好不好呢？

答案是否定的，可能有的同学只会做这10道题却能得高分。

回到我们的问题上来，我们希望得到泛化性能强的模型，好比是希望同学们对课程学得很好、获得了对所学知识“举一反三”的能力；训练样本相当于给同学们练习的习题，测试过程则相当于考试。显然，若测试样本被用作训练了，则得到的将是过于“乐观”的估计结果。

可是，我们只有一个包含m个样例的数据集

既要训练，又要测试，怎样才能做到呢？

答案是:通过对D进行适当的处理，从中产生出训练集S和测试集T。（这个也是我们前面一直在做的事情）。

下面我们一起总结一下几种常见的做法：

留出法
交叉验证法
自助法

1 留出法

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

在S上训练出模型后，用T来评估其测试误差，作为对泛化误差的估计。

大家在使用的过程中，需注意的是，训练/测试集的划分要尽可能保持数据分布的一致性，避免因数据划分过程引入额外的偏差而对最终结果产生影响，例如在分类任务中至少要保持样本的类别比例相似。

如果从采样( sampling)的角度来看待数据集的划分过程，则保留类别比例的采样方式通常称为“分层采样”( stratified sampling)。

例如通过对D进行分层样而获得含70%样本的训练集S和含30%样本的测试集T，

若D包含500个正例、500个反例，则分层采样得到的S应包含350个正例、350个反例，而T则包含150个正例和150个反例；

若S、T中样本类别比例差别很大，则误差估计将由于训练/测试数据分布的差异而产生偏差。

另一个需注意的问题是，即便在给定训练测试集的样本比例后，仍存在多种划分方式对初始数据集D进行分割。

例如在上面的例子中，可以把D中的样本排序，然后把前350个正例放到训练集中，也可以把最后350个正例放到训练集中，这些不同的划分将导致不同的训练/测试集，相应的，模型评估的结果也会有差别。

因此，单次使用留出法得到的估计结果往往不够稳定可靠，在使用留出法时，一般要采用若干次随机划分、重复进行实验评估后取平均值作为留出法的评估结果。

例如进行100次随机划分，每次产生一个训练/测试集用于实验评估，100次后就得到100个结果，而留出法返回的则是这100个结果的平均。

此外，我们希望评估的是用D训练出的模型的性能，但留出法需划分训练/测试集，这就会导致一个窘境:

若令训练集S包含绝大多数样本，则训练出的模型可能更接近于用D训练出的模型，但由于T比较小，评估结果可能不够稳定准确；
若令测试集T多包含一些样本，则训练集S与D差别更大了，被评估的模型与用D训练出的模型相比可能有较大差别，从而降低了评估结果的保真性( fidelity)。

这个问题没有完美的解决方案，常见做法是将大约2/3~4/5的样本用于训练，剩余样本用于测试。

使用Python实现留出法：

from sklearn.model_selection import train_test_split
#使用train_test_split划分训练集和测试集
train_X , test_X, train_Y ,test_Y = train_test_split(
        X, Y, test_size=0.2,random_state=0)

在留出法中，有一个特例，叫：留一法( Leave-One-Out，简称LOO），即每次抽取一个样本做为测试集。

显然，留一法不受随机样本划分方式的影响，因为m个样本只有唯一的方式划分为m个子集一每个子集包含个样本；

使用Python实现留一法：

from sklearn.model_selection import LeaveOneOut

data = [1, 2, 3, 4]
loo = LeaveOneOut()
for train, test in loo.split(data):
    print("%s %s" % (train, test))
'''结果
[1 2 3] [0]
[0 2 3] [1]
[0 1 3] [2]
[0 1 2] [3]
'''

留一法优缺点：

优点：

留一法使用的训练集与初始数据集相比只少了一个样本，这就使得在绝大多数情况下，留一法中被实际评估的模型与期望评估的用D训练出的模型很相似。因此，留一法的评估结果往往被认为比较准确。

缺点：

留一法也有其缺陷:在数据集比较大时，训练m个模型的计算开销可能是难以忍受的(例如数据集包含1百万个样本，则需训练1百万个模型，而这还是在未考虑算法调参的情况下。

2 交叉验证法

“交叉验证法”( cross validation)先将数据集D划分为k个大小相似的互斥子集，即

每个子集

都尽可能保持数据分布的一致性，即从D中通过分层抽样得到。

然后，每次用k-1个子集的并集作为训练集，余下的那个子集作为测试集；这样就可获得k组训练/测试集，从而可进行k次训练和测试，最终返回的是这k个测试结果的均值。

显然，交叉验证法评估结果的稳定性和保真性在很大程度上取决于k的取值，为强调这一点，通常把交叉验证法称为“k折交叉验证”(k- fold cross validation)。k最常用的取值是10，此时称为10折交叉验证；其他常用的k值有5、20等。下图给出了10折交叉验证的示意图。

与留出法相似，将数据集D划分为k个子集同样存在多种划分方式。为减小因样本划分不同而引入的差别，k折交叉验证通常要随机使用不同的划分重复p次，最终的评估结果是这p次k折交叉验证结果的均值，例如常见的有 “10次10折交叉验证”。

交叉验证实现方法，除了咱们前面讲的GridSearchCV之外，还有KFold, StratifiedKFold

KFold和StratifiedKFold

from sklearn.model_selection import KFold,StratifiedKFold

用法：
- 将训练/测试数据集划分n_splits个互斥子集，每次用其中一个子集当作验证集，剩下的n_splits-1个作为训练集，进行n_splits次训练和测试，得到n_splits个结果
- StratifiedKFold的用法和KFold的区别是：SKFold是分层采样，确保训练集，测试集中，各类别样本的比例是和原始数据集中的一致。
注意点：
- 对于不能均等分数据集，其前n_samples % n_splits子集拥有n_samples // n_splits + 1个样本，其余子集都只有n_samples // n_splits样本
参数说明：
- n_splits：表示划分几等份
- shuffle：在每次划分时，是否进行洗牌
  - ①若为Falses时，其效果等同于random_state等于整数，每次划分的结果相同
  - ②若为True时，每次划分的结果都不一样，表示经过洗牌，随机取样的
属性：
- ①split(X, y=None, groups=None)：将数据集划分成训练集和测试集，返回索引生成器

import numpy as np
from sklearn.model_selection import KFold,StratifiedKFold

X = np.array([
    [1,2,3,4],
    [11,12,13,14],
    [21,22,23,24],
    [31,32,33,34],
    [41,42,43,44],
    [51,52,53,54],
    [61,62,63,64],
    [71,72,73,74]
])

y = np.array([1,1,0,0,1,1,0,0])

folder = KFold(n_splits = 4, random_state=0, shuffle = False)
sfolder = StratifiedKFold(n_splits = 4, random_state = 0, shuffle = False)

for train, test in folder.split(X, y):
    print('train:%s | test:%s' %(train, test))
    print("")

for train, test in sfolder.split(X, y):
    print('train:%s | test:%s'%(train, test))
    print("")

结果：

# 第一个for，输出结果为：
train:[2 3 4 5 6 7] | test:[0 1]

train:[0 1 4 5 6 7] | test:[2 3]

train:[0 1 2 3 6 7] | test:[4 5]

train:[0 1 2 3 4 5] | test:[6 7]

# 第二个for，输出结果为：
train:[1 3 4 5 6 7] | test:[0 2]

train:[0 2 4 5 6 7] | test:[1 3]

train:[0 1 2 3 5 7] | test:[4 6]

train:[0 1 2 3 4 6] | test:[5 7]

可以看出，sfold进行4折计算时候，是平衡了测试集中，样本正负的分布的；但是fold却没有。

3 自助法

我们希望评估的是用D训练出的模型。但在留出法和交叉验证法中，由于保留了一部分样本用于测试，因此实际评估的模型所使用的训练集比D小，这必然会引入一些因训练样本规模不同而导致的估计偏差。留一法受训练样本规模变化的影响较小，但计算复杂度又太高了。

有没有什么办法可以减少训练样本规模不同造成的影响，同时还能比较高效地进行实验估计呢？

“自助法”( bootstrapping)是一个比较好的解决方案，它直接以自助采样法( bootstrap sampling)为基础。给定包含m个样本的数据集D，我们对它进行采样产生数据集D:

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

即通过自助采样，初始数据集D中约有36.8%的样本未出现在采样数据集D′中。

于是我们可将D′用作训练集，D\D′用作测试集；这样，实际评估的模型与期望评估的模型都使用m个训练样本，而我们仍有数据总量约1/3的、没在训练集中出现的样本用于测试。

这样的测试结果，亦称“包外估计”(out- of-bagestimate）

自助法优缺点：

优点：
- 自助法在数据集较小、难以有效划分训练/测试集时很有用；
- 此外，自助法能从初始数据集中产生多个不同的训练集，这对集成学习等方法有很大的好处。
缺点：
- 自助法产生的数据集改变了初始数据集的分布，这会引入估计偏差。因此，在初始数据量足够时；留出法和交叉验证法更常用一些。

4 总结

综上所述：

当我们数据量足够时，选择留出法简单省时，在牺牲很小的准确度的情况下，换取计算的简便；
当我们的数据量较小时，我们应该选择交叉验证法，因为此时划分样本集将会使训练数据过少；
当我们的数据量特别少的时候，我们可以考虑留一法。

1.11 案例2：预测facebook签到位置

1 项目描述

本次比赛的目的是预测一个人将要签到的地方。 为了本次比赛，Facebook创建了一个虚拟世界，其中包括10公里*10公里共100平方公里的约10万个地方。 对于给定的坐标集，您的任务将根据用户的位置，准确性和时间戳等预测用户下一次的签到位置。 数据被制作成类似于来自移动设备的位置数据。请注意：您只能使用提供的数据进行预测。

2 数据集介绍

数据介绍：

文件说明 train.csv, test.csv
  row id：签入事件的id
  x y：坐标
  accuracy: 准确度，定位精度
  time: 时间戳
  place_id: 签到的位置，这也是你需要预测的内容

官网：https://www.kaggle.com/c/facebook-v-predicting-check-ins

3 步骤分析

对于数据做一些基本处理（这里所做的一些处理不一定达到很好的效果，我们只是简单尝试，有些特征我们可以根据一些特征选择的方式去做处理）
- 1 缩小数据集范围 DataFrame.query()
- 2 选取有用的时间特征
- 3 将签到位置少于n个用户的删除
分割数据集
标准化处理
k-近邻预测

具体步骤：
# 1.获取数据集
# 2.基本数据处理
# 2.1 缩小数据范围
# 2.2 选择时间特征
# 2.3 去掉签到较少的地方
# 2.4 确定特征值和目标值
# 2.5 分割数据集
# 3.特征工程 -- 特征预处理(标准化)
# 4.机器学习 -- knn+cv
# 5.模型评估

4 代码实现

1.获取数据集

# 1、获取数据集
facebook = pd.read_csv("./data/FBlocation/train.csv")

2.基本数据处理

# 2.基本数据处理
# 2.1 缩小数据范围
facebook_data = facebook.query("x>2.0 & x<2.5 & y>2.0 & y<2.5")
# 2.2 选择时间特征
time = pd.to_datetime(facebook_data["time"], unit="s")
time = pd.DatetimeIndex(time)
facebook_data["day"] = time.day
facebook_data["hour"] = time.hour
facebook_data["weekday"] = time.weekday
# 2.3 去掉签到较少的地方
place_count = facebook_data.groupby("place_id").count()
place_count = place_count[place_count["row_id"]>3]
facebook_data = facebook_data[facebook_data["place_id"].isin(place_count.index)]
# 2.4 确定特征值和目标值
x = facebook_data[["x", "y", "accuracy", "day", "hour", "weekday"]]
y = facebook_data["place_id"]
# 2.5 分割数据集
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)

3.特征工程--特征预处理(标准化)

# 3.特征工程--特征预处理(标准化)
# 3.1 实例化一个转换器
transfer = StandardScaler()
# 3.2 调用fit_transform
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

4.机器学习--knn+cv

# 4.机器学习--knn+cv
# 4.1 实例化一个估计器
estimator = KNeighborsClassifier()
# 4.2 调用gridsearchCV
param_grid = {"n_neighbors": [1, 3, 5, 7, 9]}
estimator = GridSearchCV(estimator, param_grid=param_grid, cv=5)
# 4.3 模型训练
estimator.fit(x_train, y_train)

5.模型评估

# 5.模型评估
# 5.1 基本评估方式
score = estimator.score(x_test, y_test)
print("最后预测的准确率为:\n", score)

y_predict = estimator.predict(x_test)
print("最后的预测值为:\n", y_predict)
print("预测值和真实值的对比情况:\n", y_predict == y_test)

# 5.2 使用交叉验证后的评估方式
print("在交叉验证中验证的最好结果:\n", estimator.best_score_)
print("最好的参数模型:\n", estimator.best_estimator_)
print("每次交叉验证后的验证集准确率结果和训练集准确率结果:\n",estimator.cv_results_)

facebook_example.ipynb

In [6]:

import pandas as pd

from sklearn.model_selection import train_test_split, GridSearchCV

from sklearn.preprocessing import StandardScaler

from sklearn.neighbors import KNeighborsClassifier

In [7]:

# 1.获取数据集

# 2.基本数据处理

# 2.1 缩小数据范围

# 2.2 选择时间特征

# 2.3 去掉签到较少的地方

# 2.4 确定特征值和目标值

# 2.5 分割数据集

# 3.特征工程 -- 特征预处理(标准化)

# 4.机器学习 -- knn+cv

# 5.模型评估

In [2]:

# 1.获取数据集

data = pd.read_csv("./data/FBlocation/train.csv")

In [3]:

data.head()

Out[3]:

	row_id	x	y	accuracy	time	place_id
0	0	0.7941	9.0809	54	470702	8523065625
1	1	5.9567	4.7968	13	186555	1757726713
2	2	8.3078	7.0407	74	322648	1137537235
3	3	7.3665	2.5165	65	704587	6567393236
4	4	4.0961	1.1307	31	472130	7440663949

In [4]:

data.describe()

Out[4]:

	row_id	x	y	accuracy	time	place_id
count	2.911802e+07	2.911802e+07	2.911802e+07	2.911802e+07	2.911802e+07	2.911802e+07
mean	1.455901e+07	4.999770e+00	5.001814e+00	8.284912e+01	4.170104e+05	5.493787e+09
std	8.405649e+06	2.857601e+00	2.887505e+00	1.147518e+02	2.311761e+05	2.611088e+09
min	0.000000e+00	0.000000e+00	0.000000e+00	1.000000e+00	1.000000e+00	1.000016e+09
25%	7.279505e+06	2.534700e+00	2.496700e+00	2.700000e+01	2.030570e+05	3.222911e+09
50%	1.455901e+07	5.009100e+00	4.988300e+00	6.200000e+01	4.339220e+05	5.518573e+09
75%	2.183852e+07	7.461400e+00	7.510300e+00	7.500000e+01	6.204910e+05	7.764307e+09
max	2.911802e+07	1.000000e+01	1.000000e+01	1.033000e+03	7.862390e+05	9.999932e+09

In [5]:

data.shape

Out[5]:

(29118021, 6)

In [9]:

# 2.基本数据处理

# 2.1 缩小数据范围

partial_data = data.query("x>2.0 & x<2.5 & y>2.0 & y<2.5")

In [10]:

partial_data.head()

Out[10]:

	row_id	x	y	accuracy	time	place_id
163	163	2.1663	2.3755	84	669737	3869813743
310	310	2.3695	2.2034	3	234719	2636621520
658	658	2.3236	2.1768	66	502343	7877745055
1368	1368	2.2613	2.3392	73	319822	9775192577
1627	1627	2.3331	2.0011	66	595084	6731326909

In [11]:

partial_data.shape

Out[11]:

(71664, 6)

In [13]:

# 2.2 选择时间特征

partial_data["time"].head()

Out[13]:

163     669737
310     234719
658     502343
1368    319822
1627    595084
Name: time, dtype: int64

In [16]:

time = pd.to_datetime(partial_data["time"], unit="s")

# 脱敏

time.head()

Out[16]:

163    1970-01-08 18:02:17
310    1970-01-03 17:11:59
658    1970-01-06 19:32:23
1368   1970-01-04 16:50:22
1627   1970-01-07 21:18:04
Name: time, dtype: datetime64[ns]

In [18]:

time = pd.DatetimeIndex(time)

time

Out[18]:

DatetimeIndex(['1970-01-08 18:02:17', '1970-01-03 17:11:59',
               '1970-01-06 19:32:23', '1970-01-04 16:50:22',
               '1970-01-07 21:18:04', '1970-01-02 03:14:59',
               '1970-01-07 03:45:16', '1970-01-05 03:28:43',
               '1970-01-01 18:59:03', '1970-01-09 07:50:12',
               ...
               '1970-01-09 20:03:34', '1970-01-08 09:26:50',
               '1970-01-07 04:45:59', '1970-01-07 22:36:18',
               '1970-01-06 23:29:43', '1970-01-03 12:31:26',
               '1970-01-04 15:19:20', '1970-01-01 20:49:14',
               '1970-01-03 09:17:37', '1970-01-02 20:34:43'],
              dtype='datetime64[ns]', name='time', length=71664, freq=None)

In [19]:

time.hour

Out[19]:

Int64Index([18, 17, 19, 16, 21,  3,  3,  3, 18,  7,
            ...
            20,  9,  4, 22, 23, 12, 15, 20,  9, 20],
           dtype='int64', name='time', length=71664)

In [20]:

time.day

Out[20]:

Int64Index([8, 3, 6, 4, 7, 2, 7, 5, 1, 9,
            ...
            9, 8, 7, 7, 6, 3, 4, 1, 3, 2],
           dtype='int64', name='time', length=71664)

In [21]:

partial_data["hour"] = time.hour

partial_data["day"] = time.day

partial_data["weekday"] = time.weekday

In [22]:

partial_data.head()

Out[22]:

	row_id	x	y	accuracy	time	place_id	hour	day	weekday
163	163	2.1663	2.3755	84	669737	3869813743	18	8	3
310	310	2.3695	2.2034	3	234719	2636621520	17	3	5
658	658	2.3236	2.1768	66	502343	7877745055	19	6	1
1368	1368	2.2613	2.3392	73	319822	9775192577	16	4	6
1627	1627	2.3331	2.0011	66	595084	6731326909	21	7	2

In [23]:

# 2.3 去掉签到较少的地方

partial_data.head()

Out[23]:

	row_id	x	y	accuracy	time	place_id	hour	day	weekday
163	163	2.1663	2.3755	84	669737	3869813743	18	8	3
310	310	2.3695	2.2034	3	234719	2636621520	17	3	5
658	658	2.3236	2.1768	66	502343	7877745055	19	6	1
1368	1368	2.2613	2.3392	73	319822	9775192577	16	4	6
1627	1627	2.3331	2.0011	66	595084	6731326909	21	7	2

In [31]:

place_count = partial_data.groupby("place_id").count()

In [32]:

place_count.head()

Out[32]:

	row_id	x	y	accuracy	time	hour	day	weekday
place_id
1006234733	1	1	1	1	1	1	1	1
1008823061	4	4	4	4	4	4	4	4
1012580558	3	3	3	3	3	3	3	3
1025585791	21	21	21	21	21	21	21	21
1026507711	220	220	220	220	220	220	220	220

In [36]:

place_count = place_count[place_count["row_id"]>3]

place_count.head()

Out[36]:

	row_id	x	y	accuracy	time	hour	day	weekday
place_id
1008823061	4	4	4	4	4	4	4	4
1025585791	21	21	21	21	21	21	21	21
1026507711	220	220	220	220	220	220	220	220
1032417180	10	10	10	10	10	10	10	10
1040557418	123	123	123	123	123	123	123	123

In [40]:

partial_data = partial_data[partial_data["place_id"].isin(place_count.index)]

In [41]:

partial_data.shape

Out[41]:

(69264, 9)

In [42]:

partial_data.head()

Out[42]:

	row_id	x	y	accuracy	time	place_id	hour	day	weekday
163	163	2.1663	2.3755	84	669737	3869813743	18	8	3
310	310	2.3695	2.2034	3	234719	2636621520	17	3	5
658	658	2.3236	2.1768	66	502343	7877745055	19	6	1
1368	1368	2.2613	2.3392	73	319822	9775192577	16	4	6
1627	1627	2.3331	2.0011	66	595084	6731326909	21	7	2

In [43]:

# 2.4 确定特征值和目标值

x = partial_data[["x", "y", "accuracy", "hour", "day", "weekday"]]

y = partial_data["place_id"]

In [44]:

x.head()

Out[44]:

	x	y	accuracy	hour	day	weekday
163	2.1663	2.3755	84	18	8	3
310	2.3695	2.2034	3	17	3	5
658	2.3236	2.1768	66	19	6	1
1368	2.2613	2.3392	73	16	4	6
1627	2.3331	2.0011	66	21	7	2

In [45]:

y.head()

Out[45]:

163     3869813743
310     2636621520
658     7877745055
1368    9775192577
1627    6731326909
Name: place_id, dtype: int64

In [46]:

# 2.5 分割数据集

x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=2, test_size=0.25)

In [47]:

x_train.head()

Out[47]:

	x	y	accuracy	hour	day	weekday
19509166	2.3217	2.2029	1	0	8	3
20577315	2.4800	2.2129	175	20	7	2
24044078	2.2389	2.3447	79	3	8	3
11279021	2.0850	2.2789	119	1	9	4
19491154	2.2408	2.0092	168	0	8	3

In [48]:

# 3.特征工程 -- 特征预处理(标准化)

transfer = StandardScaler()

x_train = transfer.fit_transform(x_train)

x_test = transfer.fit_transform(x_test)

In [57]:

# 4.机器学习 -- knn+cv

# 4.1 实例化一个训练器

estimator = KNeighborsClassifier()

# 4.2 交叉验证,网格搜索实现

param_grid = {"n_neighbors": [3, 5, 7, 9]}

estimator = GridSearchCV(estimator=estimator, param_grid=param_grid, cv=10, n_jobs=4)

# 4.3 模型训练

estimator.fit(x_train, y_train)

Out[57]:

GridSearchCV(cv=10, 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=4,
       param_grid={'n_neighbors': [3, 5, 7, 9]}, pre_dispatch='2*n_jobs',
       refit=True, return_train_score='warn', scoring=None, verbose=0)

In [62]:

# 5.模型评估

# 5.1 准确率输出

score_ret = estimator.score(x_test, y_test)

print("准确率为:\n", score_ret)

准确率为:
 0.3697158697158697

In [63]:

# 5.2 预测结果

y_pre = estimator.predict(x_test)

print("预测值是:\n", y_pre)

预测值是:
 [3105513359 8980163153 1247398579 ... 1891783132 8169595806 3661555534]

In [64]:

# 5.3 其他结果输出

print("最好的模型是:\n", estimator.best_estimator_)

print("最好的结果是:\n", estimator.best_score_)

print("所有的结果是:\n", estimator.cv_results_)

最好的模型是:
 KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=5, p=2,
           weights='uniform')
最好的结果是:
 0.3621506121506122
所有的结果是:
 {'mean_fit_time': array([0.07974284, 0.06533892, 0.06671908, 0.06837542]), 'std_fit_time': array([0.00468629, 0.00599286, 0.00193125, 0.00476899]), 'mean_score_time': array([0.28204682, 0.27073274, 0.30490429, 0.31999531]), 'std_score_time': array([0.01271002, 0.03878049, 0.03855714, 0.06601039]), 'param_n_neighbors': masked_array(data=[3, 5, 7, 9],
             mask=[False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}], 'split0_test_score': array([0.32790657, 0.34330207, 0.34383295, 0.33781632]), 'split1_test_score': array([0.32915473, 0.34294413, 0.34043696, 0.3357808 ]), 'split2_test_score': array([0.3426484 , 0.3483105 , 0.34703196, 0.34191781]), 'split3_test_score': array([0.34181002, 0.35508601, 0.3539641 , 0.34835453]), 'split4_test_score': array([0.35277192, 0.36524074, 0.36581623, 0.35756762]), 'split5_test_score': array([0.35208783, 0.36522251, 0.36267399, 0.36267399]), 'split6_test_score': array([0.36639393, 0.37457593, 0.3757733 , 0.37557374]), 'split7_test_score': array([0.36424513, 0.37520292, 0.37784091, 0.37581169]), 'split8_test_score': array([0.36011537, 0.37350639, 0.37515451, 0.3710342 ]), 'split9_test_score': array([0.36964248, 0.38595024, 0.3790508 , 0.3759147 ]), 'mean_test_score': array([0.3499076 , 0.36215061, 0.36138061, 0.35739586]), 'std_test_score': array([0.01427792, 0.01416918, 0.01422346, 0.01553481]), 'rank_test_score': array([4, 1, 2, 3], dtype=int32), 'split0_train_score': array([0.61343068, 0.54832927, 0.51104823, 0.48206147]), 'split1_train_score': array([0.61508929, 0.54995255, 0.51332931, 0.48386679]), 'split2_train_score': array([0.61463646, 0.55066383, 0.51165193, 0.48258128]), 'split3_train_score': array([0.61317597, 0.55079399, 0.51032189, 0.48171674]), 'split4_train_score': array([0.61292393, 0.5488392 , 0.50936129, 0.48178025]), 'split5_train_score': array([0.61429761, 0.54829552, 0.50957372, 0.48114073]), 'split6_train_score': array([0.60945523, 0.54611501, 0.50710527, 0.48004772]), 'split7_train_score': array([0.61146321, 0.54674607, 0.50857082, 0.48092301]), 'split8_train_score': array([0.60958933, 0.54503758, 0.50596679, 0.48008239]), 'split9_train_score': array([0.61055868, 0.5450652 , 0.50791901, 0.48018658]), 'mean_train_score': array([0.61246204, 0.54798382, 0.50948483, 0.4814387 ]), 'std_train_score': array([0.00196405, 0.00205248, 0.00209691, 0.00116103])}

zimiao552147572

发布了308 篇原创文章 · 获赞 112 · 访问量 18万+

私信关注

KNN：K-近邻算法

日萌社

1 什么是K-近邻算法

1.1 K-近邻算法(KNN)概念

1.3 KNN算法流程总结

2 小结

1.2 k近邻算法api初步使用

1 Scikit-learn工具介绍

1.1 安装

1.2 Scikit-learn包含的内容

2 K-近邻算法API

3 案例

3.1 步骤分析

3.2 代码过程

4 小结

问题

hello_knn.py

1.3 距离度量

1 距离公式的基本性质

2 常见的距离公式

2.1 欧式距离(Euclidean Distance)：

2.2 曼哈顿距离(Manhattan Distance)：

2.3 切比雪夫距离 (Chebyshev Distance)：

2.4 闵可夫斯基距离(Minkowski Distance)：

3 “连续属性”和“离散属性”的距离计算

4 小结

阶指幂对

闵氏距离到切比雪夫的推导

知识拓展：其他距离公式

1 标准化欧氏距离 (Standardized EuclideanDistance)：

2 余弦距离(Cosine Distance)

3 汉明距离(Hamming Distance)【了解】：

4 杰卡德距离(Jaccard Distance)【了解】：

5 马氏距离(Mahalanobis Distance)【了解】

1.4 k值的选择

1 K值选择说明

2 小结

1.5 kd树

1.2 原理

2 构造方法

3 案例分析

3.1 树的建立

3.2 最近领域的搜索

3.2.1 查找点(2.1,3.1)

3.2.2 查找点(2,4.5)

4 总结

1.6 案例：鸢尾花种类预测--数据集介绍

1 案例：鸢尾花种类预测

2 scikit-learn中数据集介绍

2.1 scikit-learn数据集API介绍

2.2 sklearn数据集返回值介绍

2.3 查看数据分布

2.4 数据集的划分

3 总结

数据集介绍.py

1.7 特征工程-特征预处理

1 什么是特征预处理

1.1 特征预处理定义

1.2 包含内容(数值型数据的无量纲化)

1.3 特征预处理API

2 归一化

2.1 定义

2.2 公式

2.3 API

2.4 数据计算

2.5 归一化总结

3 标准化

3.1 定义

3.2 公式

3.3 API

3.4 数据计算

3.5 标准化总结

4 总结

preproessing.py

1.8 案例：鸢尾花种类预测—流程实现

学习目标

1 再识K-近邻算法API

2 案例：鸢尾花种类预测

2.1 数据集介绍

2.2 步骤分析