一、简介
K-Nearest-Neighbor 算法是一种常用的监督学习算法，它没有显式的训练过程，是‘懒惰学习’的显著代表，此类学习算法仅在训练阶段将训练集保存起来，训练时间开销为0，待收到测试样本后在进行处理
k近邻模型的三要素： K值选择、距离度量、分类评价规则
二、工作机制
给定测试样本，基于某种距离度量找出训练集中与其最靠近的k个训练样本，然后基于这k个‘邻居’的信息来进行预测。
在分类任务中，可使用“投票法”，即选择这k个样本中出现类别最多的标记作为预测结果；评价分类问题可以使用准确率 score
在回归任务中使用“平均法”，将这k个样本的实值输出标记的平均值作为预测结果；评价回归问题可以使用MSE（均方误差）、MAE（平均绝对值误差），需要注意，语法上y值必须是可以计算的数值类型。
最佳拟合：经验误差和泛化误差相近，泛化误差尽可能小
还可以基于距离远近进行加权平均或加权投票，距离越近，权重越大
距离度量方式：
其中p=2，就是欧氏距离
p=1，就是曼哈顿距离
三、算法实现
K近邻算法的实现最简单的方法是线性扫描，该方法要计算待预测样本与每一个训练实例的距离，当训练集很大时，计算非常耗时，显然这种方法不太可行。故引入kd树
如果实例点是随机分布的，kd树更适用于训练样本数远大于空间维数时的k近邻搜索。当空间维数接近训练实例数时。它的效率会迅速下降，几乎接近线性扫描。
3.1 KD树
Kd-树是K-dimension tree的缩写，是对数据点在k维空间（如二维(x，y)，三维(x，y，z)，k维(x1，y，z…)）中划分的一种数据结构，主要应用于多维空间关键数据的搜索（如：范围搜索和最近邻搜索）。本质上说，Kd-树就是一种平衡二叉树。
构造KD树相当于不断用垂直于坐标轴的超平面将K维空间进行切分，构成一系列的K维超矩形区域，直至子区域没有节点。KD树中的每一个节点对应于一个k维超矩形区域。
通常选择训练实例点再选定坐标轴上的中位数为切分点，这样得到平衡KD树，但平衡KD树不一定就是搜索效率最优的。
3.2 KD树搜索过程
①、在kd树中找出包含目标点的x的叶结点：从根结点出发，递归地向下访问kd树。若目标点x当前维的坐标小于切分点的坐标，则移动到左子结点，否则移动到右子结点。直到子结点为叶结点为止。
②、以此叶结点为“当前最近点”。
③、递归地向上回退，在每个结点进行以下操作：
（a）如果该结点保存的实例点比当前最近点距离目标点更近，则以该实例点为“当前最近点”。
（b）当前最近点一定存在于该节点的一个子结点对应的区域。检查该子结点的父结点的另一子结点对应的区域是否有更近的点。具体地，检查另一子结点对应的区域是否与以目标点为球心、以目标点与“当前最近点的距离为半径的超球体相交。如果相交，可能在另一个子结点对应的区域内存在距离目标点更近的点，移动到另一个子结点。接着，递归地进行最近邻搜索；如果不相交，向上回退。
④、当回退到根结点是，搜索结束，最后的“当前最近点”即为x的最近邻点。
四、简单应用
一般用于小样本集的数据模型，K不能为样本集的容量，K值不能为偶数。K的（经验）取值上限为sqrt（样本容量）
3.1 自定义数据集进行KNN预测（分类）
film:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
# 导入我们自己构建的伪数据集
film = pd.read_excel('C:/Users/Administrator/Desktop/films.xlsx')
# 获取特征向量集合，和标签集合
y = film['类别'].copy()
X = film[['动作镜头','爱情镜头']].copy()
# 生成一组待预测样本
X_test = np.array([[11,6],[5,17]])
# 取X中的数值
X.values
# 绘制样本集在特征空间中的分布状况
plt.figure(figsize=(8,5))
plt.scatter(X['动作镜头'],X['爱情镜头'],s=100,c=y.map({
'动作':0,
'爱情':1
}),cmap=plt.cm.winter)
plt.legend([])
# 显示中文
plt.rcParams['font.sans-serif']=['SimHei']
plt.rcParams['axes.unicode_minus'] = False
# 给空间样本点添加图例描述，因为散点图不支持在绘图时添加图例
action = X.loc[y=='动作']
love = X.loc[y=='爱情']
s = 100
plt.scatter(action['动作镜头'],action['爱情镜头'],s=s,c='blue',label='动作电影')
plt.scatter(love['动作镜头'],love['爱情镜头'],s=s,c='cyan',label='爱情电影')
plt.xlabel('动作镜头')
plt.ylabel('爱情镜头')
plt.legend()
# 绘制测试点散点图
plt.scatter(X_test[:,0],X_test[:,1],s=100,marker='*',color='black')
# 导入 分类模型
from sklearn.neighbors import KNeighborsClassifier
# step1:构建算法对象
clf = KNeighborsClassifier(n_neighbors=3)
# step2: 训练算法对象 目的得到模型，模型有预测能力（本质为一个参数已知的函数）
# 注意：
# X 特征向量集合，必须为二维数组 VSM向量空间模型
# y 标签集合，一般为一维数组，也可能为多维数组
clf.fit(X,y)
# fit 之后clf分类器可以用来预测新数据
# step3：预测数据
clf.predict(X_test)
# 绘制第一二个点
p1 = plt.scatter(X_test[0,0],X_test[0,1],s=100,marker='*',c='blue')
p1 = plt.scatter(X_test[1,0],X_test[1,1],s=100,marker='*',c='cyan')
3.2 使用鸢尾花数据集进行KNN练习（分类）
绘制边界图像：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
from sklearn import datasets
# 导入鸢尾花数据集
iris = datasets.load_iris()
# 特征向量集合
X = iris.data
# 标签集合
y = iris.target
# 字段名
feature_names = iris.feature_names
# 标签说明
target_names = iris.target_names
# 绘制样本数据的分布情况(绘制二维空间)，只取数据集的前两列研究
for i in range(target_names.size):
condition = y ==i
plt.scatter(X[condition][:,0],X[condition][:,1],label=target_names[i])
plt.legend()
plt.show()
# 以鸢尾花的前两列数据作为特征值， 标签作为标签
X = X[:,0:2]
y = y
# 生成鸢尾花训练集分布区间的所有点，作为测试数据
xmin, xmax = X[:,0].min()-0.05, X[:,0].max()+0.05
ymin, ymax = X[:,1].min()-0.05, X[:,1].max()+0.05
x_data = np.linspace(xmin, xmax, 100)
y_data = np.linspace(ymin, ymax, 100)
aa,bb = np.meshgrid(x_data,y_data)
X_test = np.concatenate((aa.reshape(-1,1),bb.reshape(-1,1)),axis=1)
# 绘制测试数据的图像
plt.scatter(X_test[:,0],X_test[:,1])
# 创建k值为3的KNN分类器对象
from sklearn.neighbors import KNeighborsClassifier
knn_3 = KNeighborsClassifier(n_neighbors=3)
knn_3.fit(X,y)
y_3 = knn_3.predict(X_test)
# 创建k值为10的KNN分类器对象
knn_10 = KNeighborsClassifier(n_neighbors=10)
knn_10.fit(X,y)
y_10 = knn_10.predict(X_test)
# 创建k值为样本容量的分类器对象
k = X.shape[0]
knn_all = KNeighborsClassifier(n_neighbors=k)
knn_all.fit(X,y)
y_all = knn_all.predict(X_test)
创建k值为经验上限的KNN分类器对象
k_max = int(np.sqrt(X.shape[0]))+1
knn_max = KNeighborsClassifier(n_neighbors=k_max)
knn_max.fit(X,y)
y_max = knn_max.predict(X_test)
# 封装绘制决策边界的函数
def show_edge(y_,k):
plt.scatter(X_test[:,0],X_test[:,1],c=y_)
for i in range(target_names.size):
condition = y ==i
plt.scatter(X[condition][:,0],X[condition][:,1],label=target_names[i])
plt.legend()
plt.title(label='k={}'.format(k))
plt.show()
# 绘制图像
show_edge(y_3,3)
show_edge(y_10,10)
show_edge(y_max,k_max)
show_edge(y_all,k)
结果展示：
样本数据分布情况：
测试数据分布情况：
K=3,决策边界图像：
K=10,决策边界图像：
K=经验上限，即13,决策边界图像：
K=样本容量,决策边界图像：
使用样本数据评价上述模型
这样得到的准确率较高，一般不采用，通常进行拆分数据集
sklearn中的Classifier对象都有一个score方法，
score方法：对X中数据进行预测，并计算准确率
knn_3.score(X,y)
knn_10.score(X,y)
knn_max.score(X,y)
knn_all.score(X,y)
采用拆分数据集，来优化模型
按比例 37 28 19
大部分数据为训练数据 X_train,y_train 小部分数据为测试数据X_test,y_test
拆分原则：
随机拆分
保证样本均衡
# 将每一类数据前40个作为训练数据，后10个为测试数据
X_train_list = []
X_test_list = []
y_train_list=[]
y_test_list=[]
split=40
for i in range(3):
condition = y==i
X_c = X[condition]
y_c = y[condition]
X_train_list.append(X_c[:split])
X_test_list.append(X_c[split:])
y_train_list.append(y_c[:split])
y_test_list.append(y_c[split:])
X_train = np.concatenate(X_train_list)
X_test = np.concatenate(X_test_list)
y_train = np.concatenate(y_train_list)
y_test = np.concatenate(y_test_list)
# 构造算法对象
knn1 = KNeighborsClassifier(n_neighbors=3)
knn2 = KNeighborsClassifier(n_neighbors=7)
knn3 = KNeighborsClassifier(n_neighbors=11)
# 训练
knn1.fit(X_train,y_train)
knn2.fit(X_train,y_train)
knn3.fit(X_train,y_train)
# 进行准确率评价
knn1.score(X_test,y_test)
knn2.score(X_test,y_test)
knn3.score(X_test,y_test)
寻找最优K
# 生成k值数组
k_list = np.arange(1,13,2)
# 封装调参的函数
def get_best_k(k_list):
score_list=[]
for k in k_list:
knn = KNeighborsClassifier(n_neighbors=k)
knn.fit(X_train,y_train)
score_list.append(knn.score(X_test,y_test))
return np.array(score_list)
# 绘制k值对应准确率的折线图
plt.plot(k_list,get_best_k(k_list))
plt.xticks(k_list)
由此得出K=11，准确率最高，模型最优。
3.3 手写数字识别（分类）
了解sklearn 手写数字数据包 load_digits()：
| key | values |
|---|---|
| feature_names | 特征向量，64列 |
| images | 图像数据，shape=（1797，8，8） |
| target_names | 标签名字 |
| target | 标签 |
| data | 扁平化处理后的图像数据，shape=（1797，64） |
处理图形
图像处理一定要把图像进行扁平处理
图像必须灰度处理
灰度处理方法：
①、聚合：
plt.imshow(audi.mean(axis=2),cmap=‘gray’)
②、加权
plt.imshow(np.dot(audi,np.array([0.3,0.5,0.2])),cmap=‘gray’)
使用KNN分类模型预测手写数字数据集的
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
%matplotlib inline
# 手写数字的数据包
from sklearn.datasets import load_digits
# 保存原图形的形状
image_shape = image[0].shape
# 扁平处理
train = image.reshape(1797,-1)
# 获取数据标签
y = digits.target
# 封装一个拆分函数。sklearn也提供了此函数
def random_split(train,y,test_size,shuffle=False,random_state=None):
if random_state != None:
np.random.seed(random_state)
if shuffle:
shuffle_index = np.random.permutation(y.size)
train = train[shuffle_index]
y = y[shuffle_index]
split = int(y.size*test_size)
X_train = train[split:]
X_test = train[:split]
y_train = y[split:]
y_test = y[:split]
return X_train,X_test,y_train,y_test
# 求一个模型的评分序列
def knn_score(knn,count):
scores = []
for i in range(count):
X_train,X_test,y_train,y_test = random_split(train,y,test_size=0.2,random_state=i)
knn.fit(X_train,y_train)
scores.append(knn.score(X_test,y_test))
return np.array(scores)
# 比较不同的KNN模型的评分
def show_results(k_list,count):
score_mean = []
score_std = []
for k in k_list:
knn = KNeighborsClassifier(n_neighbors=k)
scores = knn_score(knn,count)
score_mean.append(scores.mean())
score_std.append(scores.std())
return pd.DataFrame({
'K':k_list,
'mean':score_mean,
'std':score_std
})
# 获取k值序列
max_k = int(np.sqrt(X_train.shape[0]))
k_list = np.arange(3,max_k,step=4)
# 调用函数
result = show_results(k_list,10)
# 绘制效果图
plt.plot(result['K'],result['mean'],label='mean')
plt.legend()
plt.xticks(result['K'])
plt.show()
plt.plot(result['K'],result['std'],label='std')
plt.legend()
plt.xticks(result['K'])
plt.show()
绘图展示：
抽100个数据，使用最优模型进行预测结果展示：
# 取出样本集的特征向量集合和标签集合
data = digits.data
target = digits.target
# 由上图知道K=3为最优模型
best_model = KNeighborsClassifier(n_neighbors=3)
best_model.fit(data, target)
best_model.score(data, target) # 0.993322203672788
# 取100个特征向量和标签
temp_data = data[:100]
temp_target = target[:100]
# 取100个预测值
y_ = best_model.predict(data)
temp_y_ = y_[:100]
# 绘制100张图像，观察其结果
sns.set_style(style='dark')
plt.figure(figsize=(18,22))
plt.title('RESULT')
for i in range(100):
num_data = temp_data[i]
num_y = temp_target[i]
num_y_ = temp_y_[i]
plt.subplot(10,10,i+1)
title_color = 'blue'
if num_y != num_y_:
title_color = 'red'
plt.title("T:{},P:{}".format(num_y, num_y_), color=title_color)
plt.imshow(num_data.reshape(image_shape))
3.4 自定义数据集进行KNN回归问题的计算
KNN回归问题：语法上y值必须是可以计算的数值类型
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
# 构造平米数x和房价y数据集
x = np.random.random(60)*60 + 60
f = lambda x:3*x + 2
bias = bias*np.array([1,-1])[np.random.randint(0,2,size=60)]
y = f(x) + bias
# 使用二维图像来表示房价与平米的关系，不是特征空间
sns.set()
plt.scatter(x,y)
plt.xlabel('m2')
plt.ylabel('RMB')
# 构造KNN回归模型
knn = KNeighborsRegressor(n_neighbors=5)
# 特征向量的vsm转换
X = x.reshape(-1,1)
knn.fit(X,y)
# 获取测试数据
X_test = np.linspace(X.max(),X.min(),100).reshape(-1,1)
y_ = knn.predict(X_test)
# 绘制图像
plt.plot(X_test,y_,label='predict line',color='red')
plt.scatter(x,y,label='ture line')
plt.xlabel('m2')
plt.ylabel('RMB')
plt.legend()
图像展示：
3.5 波士顿房价模型评价
from sklearn.datasets import load_boston
boston = load_boston()
data = boston.data
target = boston.target
# 获取经验上限k值
max_k = int(np.sqrt(X_train.size))
# 生成k值序列
k_list = np.arange(1,max_k,step=4)
# 封装评价KNN模型的函数
def mse_score(y,y_):
return ((y-y_)**2).mean()
mse_train_list = []
mse_test_list = []
final_train_mse = []
final_test_mse = []
count = 10
# 循环k值序列
for k in k_list:
knn = KNeighborsRegressor(n_neighbors=k)
# 拆分count次样本集
for i in range(count):
X_train,X_test,y_train,y_test = train_test_split(data,target,test_size=0.2,random_state=i)
knn.fit(X_train,y_train)
# 经验误差
y_ = knn.predict(X_train)
mse_train = mse_score(y_train,y_)
mse_train_list.append(mse_train)
# 泛华误差
mse_test = mse_score(y_test,knn.predict(X_test))
mse_test_list.append(mse_test)
mse_train_list_mean = np.array(mse_train_list).mean()
mse_test_list_mean = np.array(mse_test_list).mean()
final_train_mse.append(mse_train_list_mean)
final_test_mse.append(mse_test_list_mean)
result = pd.DataFrame({
'K':k_list,
'train_list':final_train_mse,
'test_list':final_test_mse
})
# 绘制图像
result.set_index('K').plot()
plt.xticks(k_list)
plt.show()
图像展示
1330
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
