上文借用了numpy和pandas等模块自编了k-近邻算法python之k-近邻算法（非sklearn版），这次借用sklearn轮子来实现一下
数据还是用上篇文章的数据来https://pan.baidu.com/s/1zIGz6GtEU20UeT6hemP4MQ

一，处理类别数据

上篇文章我们是利用KNN.py中的自编函数panduan在读取数据的过程中来实现的，而这种转变在sklearn中已经有轮子调用了
这里再补充一点：对于类别数据(对于特征值也是适用的),可以分为标称特征（nominal feature）和有序特征(ordinal feature).
对于我们这里的数据largeDoses，smallDoses，didntLike应该是对应着有序特征

#接下来将喜欢的类别中的三类转变为1,2,3
like_order = {"didntLike":1,"smallDoses":2,"largeDoses":3}
df['喜欢的类别'] = df['喜欢的类别'].map(like_order)
df['喜欢的类别'].drop_duplicates()

得到结果：
df['喜欢的类别'].drop_duplicates()
Out[8]: 
0    largeDoses
1    smallDoses
2     didntLike
Name: 喜欢的类别, dtype: object

如果后续转变回来，可以定义一个逆映射字典
inv_like_order = {v:k for k,v in like_order.items()}
df['喜欢的类别'] = df['喜欢的类别'].map(inv_like_order)
df['喜欢的类别'].drop_duplicates()

得到结果：
Out[12]: 
0    largeDoses
1    smallDoses
2     didntLike
Name: 喜欢的类别, dtype: object

如果在这里'喜欢的类别'本身不带有有序的含义的话，即largeDoses，smallDoses，didntLike三个类别没有序别之分，可以借用sklearn里的功能

#自己写
import numpy as np
like_not_order = {label:idx for idx,label in enumerate(np.unique(df['喜欢的类别']))}
df['喜欢的类别'] = df['喜欢的类别'].map(like_not_order)
df['喜欢的类别'].drop_duplicates()

Out[17]: 
0    1
1    2
2    0
Name: 喜欢的类别, dtype: int64

#sklearn 
from sklearn.preprocessing import LabelEncoder
class_le = LabelEncoder()
y = class_le.fit_transform(df['喜欢的类别'].values)
np.unique(y)
Out[22]: array([0, 1, 2], dtype=int64)

##转变回原来的类别
class_le.inverse_transform(y)

可以看到借用sklearn是比较方便的

但是。。。。。但是。。。。以上的0,1,2在算法看来依然是有顺序的，所以我们可以利用独热编码（one-hot encoding），即创建一个新的虚拟特征（dummy feature）

from sklearn.preprocessing import OneHotEncoder
#categorical_features参数指定我们对数据集中第几列进行独热编码
ohe = OneHotEncoder(categorical_features=[3]) 
ohe.fit_transform(df).toarray()

也可以利用pandas里的功能

pd.get_dummies(df) #只对类别性数据有用，会忽略数值型数据

————————————————————————————————————

二、将特征值缩放到相同区间

特征缩放（feature scaling）对于除了决策树和随机森林两个算法没用以外，对其他算法和优化算法来讲都是必不可少的

2.1 归一化（将值缩放到0-1之间）

即上篇文章所涉及到的

image.png

from sklearn.preprocessing import MinMaxScaler
mms = MinMaxScaler()
y = mms.fit_transform(df.iloc[:,0:3])

2.2 标准化（将值缩放到均值为0，方差为1，即标准正态分布）

对于线性模型来讲，标准化更加好，一是符合线性模型对权重的处理，二是保留了异常值的信息

image.png

from sklearn.preprocessing import StandardScaler
stds = StandardScaler()
y = stds.fit_transform(df.iloc[:,0:3])

———————————————————————————————————

三、将数据集划分为训练集和测试集

上篇文章对于此类问题的处理见datingClassTest函数

from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(df.iloc[:,0:3],df.iloc[:,3], \
                                                 test_size=0.1,random_state=0)

image.png

四、k-近邻算法

K-近邻算法被称之为惰性算法，和其他机器学习算法不一样，因为他仅仅是对训练数据集有记忆功能，而不是从训练集中通过学习得到一个判别函数，即不需要训练，看过上篇文章的小伙伴应该会有体会。缺点是计算复杂度会随着样本数量的增长而呈线性增长，除非数据集中特征数量有限

image.png

from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import MinMaxScaler
like_order = {"didntLike":1,"smallDoses":2,"largeDoses":3}
df['喜欢的类别'] = df['喜欢的类别'].map(like_order)
X_train,X_test,y_train,y_test = train_test_split(df.iloc[:,0:3],df.iloc[:,3], \
                                                 test_size=0.1,random_state=0)
#n_neighbors代表近邻数，p=2代表欧式距离，p=1代表曼哈顿距离
#metric='minkowski'代表闵可夫斯基距离，他是对欧氏距离和曼哈顿距离的一种泛化
knn = KNeighborsClassifier(n_neighbors=5,p=2,metric='minkowski')
mms = MinMaxScaler()
X_train_std =  mms.fit_transform(X_train)
knn.fit(X_train_std,y_train)
knn.predict(mms.fit_transform(X_test))