[人工智能]KNN分类模型笔记

KNN分类模型

1.概念

• k-邻近算法采用测量不同特征值之间的距离方法进行分类(k-Nearest Neighbor，KNN)
  

• k值的作用【选择样本数据集中前K个的数据，出现次数最多的分类，作为新(预测)数据的分类】

• 

• 欧几里得距离(Euclidean Distance)

• 

• 注意：

  • 在knn中的k的取值不同会直接导致分类的结果不同。n_neighbors参数表示k值
  • 模型的超参数：模型的参数有不同的取值且不同的取值会导致模型的分类或预测产生直接的影响
  • 在knn算法中，目标数据可以不是数值型。在knn算法原理中，仅仅计算特征数据的距离，不会计算目标数据的距离。

• 示例说明【如何进行电影分类(动作片和爱情片)】

  • 因为动作片中会存在接吻镜头，爱情片中也会存在打斗场景，我们不能单纯依靠是否存在打斗或者亲吻来判断影片的类型。但是爱情片中的亲吻镜头更多，动作片中 的打斗场景也更频繁，基于此类场景在某部电影中出现的次数可以用来进行电影分类。

  • 工作原理

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

  • 下图显示了6部电影的打斗和接吻次数。假如有一部未看过的电影，如何确定它是爱情片还是动作片呢?

  • 首先我们需要知道这个未知电影存在多少个打斗镜头和接吻镜头

  • 

  • 计算未知电影与样本集中其他电影的距离

  • 

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

2.寻找最优k值

import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
import numpy as np
%matplotlib inline
import matplotlib.pyplot as plt
#1.加载数据
df=pd.read_csv('./data/adults.txt')
#2.样本数据提取
target=df['salary']  #提取标签数据，收入
feature=df[['age','education_num','occupation','hours_per_week']] #提取有关特征数据，年龄，教育时间，工作行业，工作小时
#3.数据集拆分
x_train,x_test,y_train,y_test = train_test_split(feature,target,test_size=0.1,random_state=2020)
#4.观察特征数据是否需要进行特征工程
#行业一列为字符串，需要特征值化
one_hot_train=pd.get_dummies(x_train['occupation'])  #对训练集进行one_hot编码
one_hot_test=pd.get_dummies(x_test['occupation'])   #对测试集进行one_hot编码
#连接数据,并把原先的行业一列删除
x_train=pd.concat([x_train,one_hot_train],axis=1).drop(labels='occupation',axis=1)
x_test=pd.concat([x_test,one_hot_test],axis=1).drop(labels='occupation',axis=1)

scores = []
ks = []
#5.循环遍历k值，获取最优的k值
for i in range(5,100):
    knn = KNeighborsClassifier(n_neighbors=i)
    knn.fit(x_train,y_train)
    score = knn.score(x_test,y_test)
    scores.append(score)
    ks.append(i)
    
# 6.将列表转为array数组
scores_arr=np.array(scores)
ks_arr=np.array(ks)

#7.画图，查看大概最优值的位置
plt.plot(ks_arr,scores_arr)
plt.xlabel('k_value')
plt.ylabel('score_value')

#8.获取最优值的下标
max=scores_arr.argmax()
#获取最优质对应的k值
k_value=ks_arr[max]

3.knn案例

• API

  from sklearn.neighbors import KNeighborsClassifier
  

3.1鸢尾花分类的实现

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

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

#2.获取样本数据
feature=iris['data']  #获取特征数据
target=iris['target'] #获取标签数据

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

#4.观察数据集，是否需要特征工程处理【对于数据包里面的数据不用特征工程，数据处理好了】

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

#6.使用训练集数据训练模型
#参数X:训练集的特征数据，特征数据必须是二维，参数y:训练集标签数据
knn.fit(x_train,y_train)

#7.测试模型：使用测试数据
#predict表示使用训练好的模型实现分类或者预测
y_predict=knn.predict(x_test)
#8.打印数据，观察预测结果
print('模型分类结果:',y_predict)
print('真实分类结果:',y_test)
#9.对未知数据预测
knn.predict([[6.1,3.1,4.7,2.1]])

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

import pandas as pd
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
import numpy as np
#1.加载数据
df=pd.read_csv('./data/adults.txt')

#2.样本数据提取
target=df['salary']  #提取标签数据，收入
feature=df[['age','education_num','occupation','hours_per_week']] #提取有关特征数据，年龄，教育时间，工作行业，工作小时

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

#4.观察特征数据是否需要进行特征工程
#行业一列为字符串，需要特征值化
one_hot_train=pd.get_dummies(x_train['occupation'])  #对训练集进行one_hot编码
one_hot_test=pd.get_dummies(x_test['occupation'])   #对测试集进行one_hot编码
#连接数据,并把原先的行业一列删除
x_train=pd.concat([x_train,one_hot_train],axis=1).drop(labels='occupation',axis=1)
x_test=pd.concat([x_test,one_hot_test],axis=1).drop(labels='occupation',axis=1)

#测试评分
knn.score(x_test,y_test)

• 寻找最优k值预测

  import pandas as pd
  from sklearn.preprocessing import MinMaxScaler
  from sklearn.neighbors import KNeighborsClassifier
  import numpy as np
  %matplotlib inline
  import matplotlib.pyplot as plt
  #1.加载数据
  df=pd.read_csv('./data/adults.txt')
  #2.样本数据提取
  target=df['salary']  #提取标签数据，收入
  feature=df[['age','education_num','occupation','hours_per_week']] #提取有关特征数据，年龄，教育时间，工作行业，工作小时
  #3.数据集拆分
  x_train,x_test,y_train,y_test = train_test_split(feature,target,test_size=0.1,random_state=2020)
  #4.观察特征数据是否需要进行特征工程
  #行业一列为字符串，需要特征值化
  one_hot_train=pd.get_dummies(x_train['occupation'])  #对训练集进行one_hot编码
  one_hot_test=pd.get_dummies(x_test['occupation'])   #对测试集进行one_hot编码
  #连接数据,并把原先的行业一列删除
  x_train=pd.concat([x_train,one_hot_train],axis=1).drop(labels='occupation',axis=1)
  x_test=pd.concat([x_test,one_hot_test],axis=1).drop(labels='occupation',axis=1)
  
  scores = []
  ks = []
  #5.循环遍历k值，获取最优的k值
  for i in range(5,100):
      knn = KNeighborsClassifier(n_neighbors=i)
      knn.fit(x_train,y_train)
      score = knn.score(x_test,y_test)
      scores.append(score)
      ks.append(i)
      
  # 6.将列表转为array数组
  scores_arr=np.array(scores)
  ks_arr=np.array(ks)
  
  #7.画图，查看大概最优值的位置
  plt.plot(ks_arr,scores_arr)
  plt.xlabel('k_value')
  plt.ylabel('score_value')
  
  #8.获取最优值的下标
  max=scores_arr.argmax()
  #获取最优质对应的k值
  k_value=ks_arr[max]
  # 9将最优值k，放入训练集，训练模型
  knn=KNeighborsClassifier(n_neighbors=k_value)
  knn.fit(x_train,y_train)
  score=knn.score(x_test,y_test)
  #10.预测
  knn.predict()
  

2.4 约会网站配对效果判定

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.neighbors import KNeighborsClassifier
%matplotlib inline

#1.加载数据
df=pd.read_csv('./data/datingTestSet.txt',header=None,sep='\s+')
#2.样本数据抽取
feature=df[[0,1,2]] #获取特征数据
target=df[3]  #获取标签数据

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

#4.对数据进行归一化处理
mm=MinMaxScaler()
m_x_train=mm.fit_transform(x_train)#对训练特征数据进行归一化处理
m_x_test=mm.transform(x_test)#对测试特征数据进行归一化处理

#5.循环画图求出最优k值
scores=[]
ks=[]
for k in range(3,50):
    knn=KNeighborsClassifier(n_neighbors=k)
    knn.fit(m_x_train,y_train)
    score=knn.score(m_x_test,y_test)
    scores.append(score)
    ks.append(k)
    
scores_arr=np.array(scores)
ks_arr=np.array(ks)
plt.plot(ks_arr,scores_arr)
plt.xlabel('k_value')
plt.ylabel('score_value')
#获取值的最大下标
max=scores_arr.argmax()
#根据下标获取k值
k=ks_arr[max]

#6.基于最优k实例化模型对象，训练模型
knn=KNeighborsClassifier(n_neighbors=k).fit(m_x_train,y_train)
#7.再通过未知类型预测

4.knn取值问题

4.1学习曲线&交叉验证选取k值

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

4.2 K折交叉验证

• 目的：

  • 将样本的训练数据交叉折分出不同的训练集和验证集，使用交叉折分出不同的训练集和验证集分别测试模型的精准度，精准度的均值就是交叉验证的结果。将结果作用到不同的超参数中，选取出精准度最高的超参数作为模型创建的超参数即可

• API

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

• 实现思路

  • 将数据集平均分割成k个等份

  • 使用1份数据作为测试数据，其余为训练数据

  • 计算测试准确率

  • 使用不同的测试集，重复2,3步骤

  • 对精准率求均值，作为对未知数据预测准确率的估计

  • 

• 交叉验证在knn算法的基本使用

  from sklearn.model_selection import cross_val_score,train_test_split
  import sklearn.datasets as datasets
  from sklearn.neighbors import KNeighborsClassifier
  iris=datasets.load_iris()
  feature=iris['data']
  target=iris['target']
  x_train,x_test,y_train,y_test=train_test_split(feature,target,test_size=0.2,random_state=2020)
  knn=KNeighborsClassifier(n_neighbors=5)
  #对训练集进行交叉验证
  cross_val_score(knn,x_train,y_train,cv=5).mean()
  

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

  from sklearn.model_selection import train_test_split
  import sklearn.datasets as datasets
  from sklearn.neighbors import KNeighborsClassifier
  import numpy as np
  import matplotlib.pyplot as plt
  %matplotlib inline
  
  iris=datasets.load_iris()
  feature = iris['data']
  target = iris['target']
  #拆分出训练集和测试集
  x_train,x_test,y_train,y_test = train_test_split(feature,target,test_size=0.2,random_state=2020)
  scores = []
  ks = []
  iris = datasets.load_iris()
  feature = iris['data']
  target = iris['target']
  #拆分出训练集和测试集
  x_train,x_test,y_train,y_test = train_test_split(feature,target,test_size=0.2,random_state=2020)
  
  for k in range(3,20):
      knn = KNeighborsClassifier(n_neighbors=k)
      score = cross_val_score(knn,x_train,y_train,cv=6).mean()
      scores.append(score)
      ks.append(k)
  scores_arr=np.array(scores)
  ks_arr=np.array(ks)
  plt.plot(ks_arr,scores_arr)
  plt.xlabel('k_value')
  plt.ylabel('score_value')
  max=scores_arr.argmax()
  k=ks_arr[max]
  

4.3 模型选择

• 交叉验证也可以帮助我们进行模型选择，使用iris数据，比较和选择KNN和Logistic回归模型

  from sklearn.linear_model import LogisticRegression
  from sklearn.model_selection import train_test_split
  import sklearn.datasets as datasets
  from sklearn.neighbors import KNeighborsClassifier
  
  iris = datasets.load_iris()
  feature = iris['data']
  target = iris['target']
  #拆分出训练集和测试集
  x_train,x_test,y_train,y_test = train_test_split(feature,target,test_size=0.2,random_state=2020)
  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())
  

4.4 K-Fold&交叉验证

• Scikit提供的API

  from sklearn.model_selection import KFold
  KFold(n_solits,shuffle,random_state)
  # n_splits:折数
  # shuffle：是否对数据洗牌
  # random_state：随机种子，固定随机性
  

• 示例

  from numpy import array
  from sklearn.model_selection import KFold
  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.linear_model import LogisticRegression
  from sklearn.model_selection import train_test_split
  import sklearn.datasets as datasets
  from sklearn.neighbors import KNeighborsClassifier
  
  iris = datasets.load_iris()
  feature = iris['data']
  target = iris['target']
  n_folds=5
  kf=KFold(n_folds,shuffle=True,random_state=42).get_n_splits(feature)
  scores=cross_val_score(knn,feature,target,cv=kf)
  scores.mean()