sklearn数据集、数据集划分与k-近邻算法_sklearn包含数据集和算法

1 sklearn数据集API

加载获取流行数据集：
（1）datasets.load_XXX()
获取小规模数据集，数据包含在datasets里
（2）datasets.fetch_XXX(data_home=None)
获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录，默认是 ~/scikit_learn_data/

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

data，target，DESCR，feature_names，target_names均为字典的键。

from sklearn.datasets import load_iris

li = load_iris()

print(li.data)	# 括号内也可以写成 li["data"]
print(type(li.data))
print(li.data.shape)
1
2
3
4
5
6
7

输出

# 目标值
print(li.target)
print(type(li.target))
print(len(li.target))
1
2
3
4

输出

# 特征名
print(li.feature_names)

# 标签名
print(li.target_names)
1
2
3
4
5

输出

['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
['setosa' 'versicolor' 'virginica']
1
2

当然，还有li.DESCR，但描述太长，这里不方便显示

获取大规模数据集

from sklearn.datasets import fetch_20newsgroups

# 获取20类新闻数据
news = fetch_20newsgroups(subset='all')

# 特征值
print(type(news.data))
print(len(news.data))

# 目标值
print(type(news.target))
print(news.target.shape)
1
2
3
4
5
6
7
8
9
10
11
12

输出

<class 'list'>
18846
<class 'numpy.ndarray'>
(18846,)
1
2
3
4

如果没有提前下载好数据，那么上面的程序将会运行非常长的时间，因为下载数据很慢。程序运行之后，会在C:\Users\Administrator\scikit_learn_data下有一个文件夹

这就是数据。0

2 数据的分割

train_test_split(*arrays,
                     test_size=None,
                     train_size=None,
                     random_state=None,
                     shuffle=True,
                     stratify=None)
1
2
3
4
5
6

x 数据集的特征值
y 数据集的标签值
test_size 测试集的大小，一般为float，如25%就写0.25
random_state 随机数种子,不同的种子会造成不同的随机
采样结果。相同的种子采样结果相同。

return 训练集特征值，测试集特征值，训练标签，测试标签
(默认随机取)

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

li = load_iris()
train_x, test_x, train_y, test_y = train_test_split(li.data, li.target, test_size=0.1)

# 训练集太大，这里只打印测试集
print(test_x)
print()
print(test_y)
print()
print(test_x.shape)
print()
print(len(test_y))
1
2
3
4
5
6
7
8
9
10
11
12
13
14

输出

[[6.  3.4 4.5 1.6]
 [4.3 3.  1.1 0.1]
 [4.8 3.1 1.6 0.2]
 [5.8 4.  1.2 0.2]
 [6.6 2.9 4.6 1.3]
 [5.5 4.2 1.4 0.2]
 [6.3 2.8 5.1 1.5]
 [6.3 3.3 4.7 1.6]
 [7.2 3.6 6.1 2.5]
 [6.9 3.1 5.4 2.1]
 [4.6 3.2 1.4 0.2]
 [6.3 2.7 4.9 1.8]
 [5.7 3.8 1.7 0.3]
 [6.2 2.2 4.5 1.5]
 [5.  3.4 1.6 0.4]]

[1 0 0 0 1 0 2 1 2 2 0 2 0 1 0]

(15, 4)

15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3 转换器与估计器

（1）转换器

想一下之前做的特征工程的步骤？
1、实例化 (实例化的是一个转换器类(Transformer))
2、调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)

fit_transform=fit + transform前者输入数据，同时进行转换，fit只输入数据，transform则进行转换。

例如在数据标准化过程中

上面的程序中，可以看到fit_transform可以分fit和transform两次调用函数来实现，结果一样，但需要两次的数据相同。
fit有计算均值、方差等功能，transform则按fit得到的均值和方差进行标准化，不会重新计算均值和方差。

（2）估计器

在机器学习中，算法的实现，靠的就是估计器

3 k-近邻算法（KNN）

（1）k-近邻算法原理

假如我们统计六部已知电影中的打斗镜头和接吻镜头，可以看到，爱情片中的接吻镜头明显高出打斗镜头，而动作片则相反，打斗镜头明显多于接吻镜头。

现有一部未知电影，已知它的接吻镜头和打斗镜头数量，判断它为爱情片和动作片中的哪一类，该怎么做？
由图片可以看到，这部未知电影中，接吻镜头的数量，明显多于打斗镜头，根据前面六部电影得出的经验，可以判断其为爱情片，但如何用数学化的语言表示它呢，或者说如何定量去判断？
这里增加一列数据，为已知电影与未知电影的距离，这是欧式距离，
假设某已知电影的打斗镜头数为x1，接吻镜头数是y1，未知电影相应的值分别为x2，y2，
那么两部电影的距离为：


这里我们选取距离最小的三部电影，看看哪种类型数量比较多。根据最后一列的数据可知，California Man，He’s not Really into dues，Beautiful Woman这三部电影是最近的三部电影，他们都是爱情片，因此可以判定位置电影为爱情片。

这就是k-近邻算法的原理，要判断未知点的类别，那就找到k个最近的点，判断这k个点中，哪种类别的数量最多，那就判断未知点属于哪种类别。
上面的例子，k取的是3，还可以取4，取5，但不能取6，因为取6的时候，两种类别一样多，无法判断。
此外，在实际应用中，需要对各个特征进行标准化处理，防止某些特征的值太大，对判断结果造成偏差。

（2）K-NN的API

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

sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')
1

n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数

algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

KNN的步骤如下：

# 实例化一个KNN工具
knn = KNeighborsClassifier()

# 加入已知数据，x_train是特征数据，y_train是目标数据
knn.fit(x_train, y_train)

# 对未知数据的类别进行推断
y_predict = knn.predict(x_test)

# 预测准确率，由预测正确的样本数除以样本总数得到
knn.score(x_test, y_test)
1
2
3
4
5
6
7
8
9
10
11

（3）k-NN案例

本案例数据来自于：https://www.kaggle.com/c/facebook-v-predicting-check-ins/data

图中有很多散点，原项目是根据用户的位置、准确性和时间戳来预测用户要签入哪个业务。
这里先简化一下，输入用户的位置、准确性和时间，来预测要签入的place_id。

导入相关的包和数据

可以看到，data中两千多万条记录。

原来的数据有1.2个G，非常大，这里只取一小部分记录。

可以看到，对记录进行筛选的时候，可以用布尔索引，如果有多个条件，那么每个条件必须用括号括起来。也可以用query方法，字符串里写条件。

我们先看一下data_1的前十条记录，可以发现place_id有些记录一样，有些不一样，即不同的点签入数量不一定相同

把签入数量少于3的记录删除，在这之前必须要按照place_id对记录进行分组，并按频次进行聚合。分组聚合之后，索引就变成place_id，然后把记录多于3的给筛选出来

reset_index()为重置索引，使索引变成从0开始计数，同时将原来的index变成数据列，其他列仍为入住次数
关于reset_index()的使用，可以看这篇博文：https://www.cnblogs.com/keye/p/11229863.html

tf.place_id是取列，和tf[“place_id”]完全一致

这里不能使用tf来代替data_1，因为两者的记录数不一样

筛选完成之后，需要取出数据中的特征值和目标值

data_1中，row_id对样本的分类没有意义，place_id为目标值，其余为特征值


接下来就是划分数据集和测试集，我们取25%的数据为测试集

接下来就是使用k-近邻算法的步骤，注意，在加入数据前，必须对数据进行标准化

查看推断的准确率

可以看到，k-近邻算法的准确率并不是特别高，可能本案例并不是k-近邻的应用场景。

一整套流程下来，我们可以看到，写程序的时候大部分的工作都在处理数据，使用算法仅仅几步就完成了，这要求对numpy、pandas等模块比较熟悉。

（4）总结

a k值有什么影响？

k值取很小：容易受异常点影响
k值取很大：容易受最近数据太多导致比例变化，比如前面判断未知电影类别的例子，如果k取6，则两类电影的数量一样，无法推断。

b 优点：

简单，易于理解，易于实现，无需估计参数，无需训练

c 缺点：

懒惰算法，对测试样本分类时的计算量大，假如已知数据有一千万个点，要推断未知点的类别，那么就分别要计算这个点与一千万个已知点的距离，内存开销大。
必须指定K值，K值选择不当则分类精度不能保证

d 使用场景

小数据场景，几千～几万样本。

（5）使用鸢尾花数据练习KNN

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

# 导入数据
iris = load_iris()

# 划分训练集和测试集
x_train, x_test, y_train, y_test = train_test_split(iris["data"], iris["target"], test_size=0.25)

# 标准化
std = StandardScaler()

# 对测试集和训练集的特征值进行标准化
x_train = std.fit_transform(x_train)

# 使用训练集的均值和方差，对测试集进行标准化
x_test = std.transform(x_test)

# 实例化KNN工具
knn = KNeighborsClassifier(n_neighbors=5)

# 加入已知数据
knn.fit(x_train, y_train)

# 对未知数据的类别进行推断
y_predict = knn.predict(x_test)
print(y_predict)

# 计算准确率
accuracy = knn.score(x_test, y_test)
print(accuracy)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

输出

[1 0 0 0 0 1 2 0 0 2 0 0 0 1 1 1 2 1 2 1 0 2 0 2 0 1 1 0 1 1 2 2 2 1 2 1 2
 0]
0.9736842105263158
1
2
3