机器学习-KNN+交叉验证

KNN分类模型

分类：将一个未知归类的样本归属到某一个已知的类群中
预测：可以根据数据的规律计算出一个未知的数据

概念：
- 简单地说，K-近邻算法采用测量不同特征值之间的距离方法进行分类（k-Nearest Neighbor，KNN）

#两点间距离

A(x1,y1)
B(x2,y2)
dist(A,B) = ((x1-x2)**2 + (y1-y2)**2)**0.5

k值的作用（用K 画一个范围，比如第一个圈里2个三角1个正方形，那？就分类到三角，第二个圈里3个正方形，2个三角那？就分类到正方形）

欧几里得距离(Euclidean Distance) ：

如何进行电影分类

众所周知，电影可以按照题材分类，然而题材本身是如何定义的?由谁来判定某部电影属于哪个题材?也就是说同一题材的电影具有哪些公共特征?这些都是在进行电影分类时必须要考虑的问题。没有哪个电影人会说自己制作的电影和以前的某部电影类似，但我们确实知道每部电影在风格上的确有可能会和同题材的电影相近。那么动作片具有哪些共有特征，使得动作片之间非常类似，而与爱情片存在着明显的差别呢？动作片中也会存在接吻镜头，爱情片中也会存在打斗场景，我们不能单纯依靠是否存在打斗或者亲吻来判断影片的类型。但是爱情片中的亲吻镜头更多，动作片中的打斗场景也更频繁，基于此类场景在某部电影中出现的次数可以用来进行电影分类。

工作原理

存在一个样本数据集合，也称作训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一数据与所属分类的对应关系。输人没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本集中特征最相似数据（最近邻）的分类标签。一般来说，我们只选择样本数据集中前K个最相似的数据，这就是K-近邻算法中K的出处,通常K是不大于20的整数。最后，选择K个最相似数据中出现次数最多的分类，作为新数据的分类。

回到前面电影分类的例子，使用K-近邻算法分类爱情片和动作片。有人曾经统计过很多电影的打斗镜头和接吻镜头，下图显示了6部电影的打斗和接吻次数。假如有一部未看过的电影，如何确定它是爱情片还是动作片呢？我们可以使用K-近邻算法来解决这个问题。

首先我们需要知道这个未知电影存在多少个打斗镜头和接吻镜头，上图中问号位置是该未知电影出现的镜头数图形化展示，具体数字参见下表。

即使不知道未知电影属于哪种类型，我们也可以通过某种方法计算出来。首先计算未知电影与样本集中其他电影的距离，如图所示。

现在我们得到了样本集中所有电影与未知电影的距离，按照距离递增排序，可以找到K个距离最近的电影。假定k=3，则三个最靠近的电影依次是California Man、He's Not Really into Dudes、Beautiful Woman。K-近邻算法按照距离最近的三部电影的类型，决定未知电影的类型，而这三部电影全是爱情片，因此我们判定未知电影是爱情片。

import pandas as pd
df = pd.read_excel('./datasets/my_films.xlsx')
feature = df[['Action Lens','Love Lens']]
target = df['target']


from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(feature,target)
#使用模型做分类
knn.predict([[30,55]])  #预测一个打斗场景30 爱情场景55的电影

array(['Love'], dtype=object)

在scikit-learn库中使用k-近邻算法

分类问题：from sklearn.neighbors import KNeighborsClassifier

鸢尾花分类的实现

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


#1.捕获鸢尾花数据
iris = datasets.load_iris()

#2.提取样本数据
feature = iris.data
target = iris.target

feature.shape
(150, 4)

target.shape
(150,)

#3.数据集进行拆分
x_train,x_test,y_train,y_test = train_test_split(feature,target,test_size=0.2,random_state=2020)

x_train.shape
y_train.shape
(120,)

#4.观察数据集：看是否需要进行特征工程的处理
x_train

#模型的超参数
#如果模型类中的相关参数的不同，会导致分类或者回归效果的不同，则这些参数叫#做模型的超参数。

#5.实例化模型对象
knn = KNeighborsClassifier(n_neighbors=5)

#6.使用训练集数据训练模型
#X:特征（X为大写表示特征数据的维度必须是二维（表格型数据））
#y:标签
knn.fit(x_train,y_train) #训练集

KNeighborsClassifier()


#7.测试模型：使用测试数据
knn.score(x_test,y_test)
0.9

#8.使用模型进行分类
print('真实的分类结果:',y_test)
print('模型的分类结果:',knn.predict(x_test))

真实的分类结果: [2 0 1 1 1 2 2 1 0 0 2 2 0 2 2 0 1 1 2 0 0 2 1 0 2 1 1 1 0 0]
模型的分类结果: [2 0 1 1 1 1 2 1 0 0 2 1 0 2 2 0 1 1 2 0 0 2 2 0 2 1 1 1 0 0]

预测年收入是否大于50K美元

from sklearn.preprocessing import StandardScaler,MinMaxScaler

df = pd.read_csv('./datasets/adults.txt')
df.head()

#1.提取样本数据
feature = df[['age','education_num','occupation','hours_per_week']]
target = df['salary']

#2.特征工程-特征值化
one_hot_feature = pd.concat((feature[['age','education_num','hours_per_week']],pd.get_dummies(feature['occupation'])),axis=1)

#特征的预处理
s = StandardScaler()
s_feature = s.fit_transform(one_hot_feature)

#3.切分数据集
x_train,x_test,y_train,y_test = train_test_split(s_feature,target,test_size=0.2,random_state=20)

knn = KNeighborsClassifier(30)
knn.fit(x_train,y_train)
knn.score(x_test,y_test)

0.7982496545370796

不用one-hot的形式

#1.提取样本数据
feature = df[['age','education_num','occupation','hours_per_week']]
target = df['salary']


count = 1
dic = {}
for occ in feature['occupation'].unique().tolist():
    dic[occ] = count
    count += 1
feature['occupation'] = feature['occupation'].map(dic)

#数据集切分
x_train,x_test,y_train,y_test = train_test_split(feature,target,test_size=0.2,random_state=20)

knn = KNeighborsClassifier(n_neighbors=30)
knn.fit(x_train,y_train)
knn.score(x_test,y_test)

#使用模型对未知数据分类
print('真实分类结果:',y_test[0:10])
print('模型分类结果:',knn.predict(x_test)[0:10])

真实分类结果: 13376    <=50K
7676      >50K
32188    <=50K
30550    <=50K
18873     >50K
21652     >50K
29911    <=50K
27398    <=50K
5757      >50K
4303     <=50K
Name: salary, dtype: object
模型分类结果: ['>50K' '<=50K' '<=50K' '<=50K' '<=50K' '<=50K' '<=50K' '<=50K' '>50K'
 '<=50K']

k-近邻算法之约会网站配对效果判定（datingTestSet.txt）

df = pd.read_csv('./datasets/datingTestSet.txt',header=None,sep='\t')
df.head()

#样本数据提取
feature_col = [col for col in df.columns if col != 3]
feature = df[feature_col]
target = df[3]

#特征工程
mm = MinMaxScaler()
m_feature = mm.fit_transform(feature)

#数据集切分
x_train,x_test,y_train,y_test = train_test_split(m_feature,target,test_size=0.2,random_state=2020)

knn = KNeighborsClassifier(n_neighbors=10)
knn.fit(x_train,y_train)
knn.score(x_test,y_test)
0.95

学习曲线寻找最优的k值

穷举不同的k值

ks = [5,7,9,12,15,20,25,30,35,40,45,50,60,70,80,90,100]
scores = []
for k in ks:
    knn = KNeighborsClassifier(n_neighbors=k).fit(x_train,y_train)
    score = knn.score(x_test,y_test)
    scores.append(score)

import matplotlib.pyplot as plt

plt.plot(ks,scores)
plt.xlabel('k')
plt.ylabel('score')


#找到了分值最大的元素下标
import numpy as np
arr_scores = np.array(scores)
np.argmax(arr_scores)
4

ks[4] #最高分值对应的k为15
15

#基于最优的k值建模
knn = KNeighborsClassifier(n_neighbors=15)
knn.fit(x_train,y_train)
knn.score(x_test,y_test)
0.965

问题：约会数据中发现标签数据为非数值型数据,可行吗？
- 可行！因为在knn中样本的标签数据是不需要参与运算。

k的取值问题：学习曲线&交叉验证选取K值

- K值较小，则模型复杂度较高，容易发生过拟合，学习的估计误差会增大，预测结果对近邻的实例点非常敏感。
- K值较大可以减少学习的估计误差，但是学习的近似误差会增大，与输入实例较远的训练实例也会对预测起作用，使预测发生错误，k值增大模型的复杂度会下降。
- 在应用中，k值一般取一个比较小的值，通常采用交叉验证法来来选取最优的K值。

适用场景
- 小数据场景，样本为几千，几万的

K折交叉验证

目的：
- 选出最为适合的模型超参数的取值，然后将超参数的值作用到模型的创建中。
思想：
- 将样本的训练数据交叉的拆分出不同的训练集和验证集，使用交叉拆分出不同的训练集和验证集测分别试模型的精准度，然就求出的精准度的均值就是此次交叉验证的结果。将交叉验证作用到不同的超参数中，选取出精准度最高的超参数作为模型创建的超参数即可！
实现思路：
- 将数据集平均分割成K个等份
- 使用1份数据作为测试数据，其余作为训练数据
- 计算测试准确率
- 使用不同的测试集，重复2、3步骤
- 对准确率做平均，作为对未知数据预测准确率的估计

API
- from sklearn.model_selection import cross_val_score
- cross_val_score(estimator,X,y,cv):
  - estimator:模型对象
  - X,y:训练集数据
  - cv：折数

交叉验证在KNN中的基本使用

from sklearn.model_selection import cross_val_score
knn=KNeighborsClassifier(n_neighbors=10)
cross_val_score(knn,x_train,y_train,cv=5).mean() #拆分成5等分 0.798372178061742

使用交叉验证&学习曲线找寻最优的超参数

ks = [5,7,9,12,15,20,25,30,35,40,45,50,60,70,80,90,100]
scores = []
for k in ks:
    knn=KNeighborsClassifier(n_neighbors=k)
    score=cross_val_score(knn,x_train,y_train,cv=5).mean() #均值
    scores.append(score)
plt.plot(ks,scores)
ks[np.argmax(np.array(scores))] #20

交叉验证也可以帮助我们进行模型选择，以下是一组例子，分别使用iris数据，KNN和logistic回归模型进行模型的比较和选择。

from sklearn.linear_model import LogisticRegression
knn = KNeighborsClassifier(n_neighbors=5)
print (cross_val_score(knn, x_train, y_train, cv=10).mean())
lr = LogisticRegression()
print(cross_val_score(lr,x_train,y_train,cv=10).mean())

0.9833333333333332
0.9416666666666667

K-Fold&cross_val_score

Scikit中指供了K-Fold的API
- n-split就是折数
- shuffle指是否对数据洗牌
- random_state为随机种子,固定随机性

from numpy import array
from sklearn.model_selection import KFold
# data sample
data = array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6])
kfold = KFold(n_splits=3, shuffle = True, random_state= 1)
for train, test in kfold.split(data):
    print('train: %s, test: %s' % (data[train], data[test]))

train: [0.1 0.4 0.5 0.6], test: [0.2 0.3]
train: [0.2 0.3 0.4 0.6], test: [0.1 0.5]
train: [0.1 0.2 0.3 0.5], test: [0.4 0.6]

Scikit中提取带K-Fold接口的交叉验证接口sklearn.model_selection.cross_validate，但是该接口没有数据shuffle功能，所以一般结合Kfold一起使用。如果Train数据在分组前已经经过了shuffle处理，比如使用train_test_split分组，那就可以直接使用cross_val_score接口

from sklearn.model_selection import cross_val_score

iris = datasets.load_iris()
X, y = iris.data, iris.target

knn = KNeighborsClassifier(n_neighbors=5)

n_folds = 5
kf = KFold(n_folds, shuffle=True, random_state=42).get_n_splits(X)
scores = cross_val_score(knn, X, y, cv = kf)

scores.mean()

0.9733333333333334

posted @ 2020-07-21 21:14 闲酒肆中听风吟阅读(690) 评论(0) 收藏举报

刷新页面返回顶部