R语言与机器学习(1)K-近邻算法

一、R语言包函数kknn简介R语言里的kknn包可以实现最近邻算法——使用其中的kknn函数，具体函数格式如下kknn(formula=formula(train),train,test,na.action=na.omit(),k=7,distance= 2)参数解释：formula:一个回归模型，具体为分类变量~特征变量train：训练集test:测试集na.action:缺失值处理，默认为去掉缺失值k：k值的选择，默认为7distance:这个是明科夫斯基距离。

值为2时为欧氏距离。

当然还有其他的距离，可以参考《统计建模与R》P398的那些距离。

还有其他的一些参数，这里略去。

二、一个简单的例子帮助理解使用该函数我们使用kknn包自带的iris数据集进行实验，完整的代码如下：> library(kknn) #加载该包。

> data(iris) #加载数据#下面我们提取自己的训练数据和测试数据> ir<-iris> ir<-edit(iris) #让你看看数据的机构，好熟悉数据> set.seed(123) #设定随机种子，即实验的可重复> count.train<-round(runif(100,1,150)) #生成100个1-150区间的均匀分布的随机整数，注意可能有重复数值> set.seed(124)> count.test<-round(runif(50,1,150))> train<-ir[count.train,] #生成训练数据> test<-ir[count.test,] #生成测试数据> result.knn<-kknn(Species~.,train,test) #对测试集进行分类。

> summary(result.knn) #查看分类的结果，如下对结果解释，fit：即test中每一个样本对应的类别。

r语言创建knn模型示例
k-最近邻（k-Nearest Neighbors，k-NN）是一种基本的机器学习算法，可以用于分类和回归问题。

在R语言中，你可以使用class或mclust包来创建k-NN 模型。

以下是一个使用class包的基本示例：
在这个例子中，我们创建了一个包含两个类别的数据集，每个类别有10个样本。

然后，我们随机地将数据集分成训练集和测试集。

接着，我们使用训练集训练一个k-NN模型，其中k=3。

最后，我们打印出模型的分类结果。

需要注意的是，knn()函数默认选择类别数目为训练集中样本最多的类别作为预测的类别。

如果你希望改变这个行为，可以使用method参数。

例如，如果你希望使用投票的方式进行分类，可以将method参数设置为"votes"。

机器学习经典分类算法——k-近邻算法（附python实现代码及数据集）⽬录⼯作原理存在⼀个样本数据集合，也称作训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每⼀数据与所属分类的对应关系。

输⼊没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进⾏⽐较，然后算法提取样本集中特征最相似数据（最近邻）的分类特征。

⼀般来说，我们只选择样本数据集中前k个最相似的数据，这就是k-近邻算法中k的出处，通常k是不⼤于20的整数。

最后选择k个最相似数据中出现次数最多的分类，作为新数据的分类。

举个例⼦，现在我们⽤k-近邻算法来分类⼀部电影，判断它属于爱情⽚还是动作⽚。

现在已知六部电影的打⽃镜头、接吻镜头以及电影评估类型，如下图所⽰。

现在我们有⼀部电影，它有18个打⽃镜头、90个接吻镜头，想知道这部电影属于什么类型。

根据k-近邻算法，我们可以这么算。

⾸先计算未知电影与样本集中其他电影的距离（先不管这个距离如何算，后⾯会提到）。

现在我们得到了样本集中所有电影与未知电影的距离。

按照距离递增排序，可以找到k个距离最近的电影。

现在假定k=3，则三个最靠近的电影依次是He's Not Really into Dudes、Beautiful Woman、California Man。

python实现⾸先编写⼀个⽤于创建数据集和标签的函数，要注意的是该函数在实际⽤途上没有多⼤意义，仅⽤于测试代码。

def createDataSet():group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])labels = ['A','A','B','B']return group, labels然后是函数classify0()，该函数的功能是使⽤k-近邻算法将每组数据划分到某个类中，其伪代码如下：对未知类别属性的数据集中的每个点依次执⾏以下操作：（1）计算已知类别数据集中的点与当前点之间的距离；（2）按照距离递增次序排序；（3）选取与当前点距离最⼩的k个点；（4）确定前k个点所在类别的出现频率；（5）返回前k个点出现频率最⾼的类别作为当前点的预测分类。

机器学习之K-近邻算法声明：本篇博⽂是学习《机器学习实战》⼀书的⽅式路程，系原创，若转载请标明来源。

1. K-近邻算法的⼀般流程：（1）收集数据：可以使⽤任何⽅法（如爬⾍）。

（2）准备数据：距离计算所需要的数值，最好是结构化的数据格式。

（3）分析数据：可以使⽤任何⽅法。

（4）测试算法：计算误差率。

（5）使⽤算法：⾸先需要输⼊样本数据和结构化的输出结果，然后运⾏K-近邻算法判定输⼊数据分别属于哪个分类，最后应⽤对计算出的分类执⾏后续的处理。

2. K-近邻算法的伪代码和Python代码对未知类别属性的数据集中的每个点依次执⾏以下操作：（1）计算已知类别数据集中的点与当前点之间的距离。

（2）按照距离递增次序排序。

（3）选取与当前点距离最⼩的k个点。

（4）确定前k个点所在类别的出现频率。

（5）返回前k个点出现频率最⾼的类别作为当前点的预测分类。

程序代码：def classify0(inX, dataSet, labels, k):dataSetSize = dataSet.shape[0]diffMat = tile(inX, (dataSetSize,1)) - dataSetsqDiffMat = diffMat**2sqDistances = sqDiffMat.sum(axis=1)distances = sqDistances**0.5sortedDistIndicies = distances.argsort()classCount={}for i in range(k):voteIlabel = labels[sortedDistIndicies[i]]classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)return sortedClassCount[0][0]代码解释：（1）classify0()函数的四个输⼊参数：inX ⽤于分类的输⼊向量，dataSet是输⼊的训练样本集，labels是标签向量，最后k是⽤于选择最近邻的数⽬，其中标签向量的元素数⽬和矩阵dataSet的⾏数相同。

机器学习：K-近邻算法（KNN）机器学习：K-近邻算法（KNN）⼀、KNN算法概述KNN作为⼀种有监督分类算法，是最简单的机器学习算法之⼀，顾名思义，其算法主体思想就是根据距离相近的邻居类别，来判定⾃⼰的所属类别。

算法的前提是需要有⼀个已被标记类别的训练数据集，具体的计算步骤分为⼀下三步：1、计算测试对象与训练集中所有对象的距离，可以是欧式距离、余弦距离等，⽐较常⽤的是较为简单的欧式距离；2、找出上步计算的距离中最近的K个对象，作为测试对象的邻居；3、找出K个对象中出现频率最⾼的对象，其所属的类别就是该测试对象所属的类别。

⼆、算法优缺点1、优点思想简单，易于理解，易于实现，⽆需估计参数，⽆需训练；适合对稀有事物进⾏分类；特别适合于多分类问题。

2、缺点懒惰算法，进⾏分类时计算量⼤，要扫描全部训练样本计算距离，内存开销⼤，评分慢；当样本不平衡时，如其中⼀个类别的样本较⼤，可能会导致对新样本计算近邻时，⼤容量样本占⼤多数，影响分类效果；可解释性较差，⽆法给出决策树那样的规则。

三、注意问题1、K值的设定K值设置过⼩会降低分类精度；若设置过⼤，且测试样本属于训练集中包含数据较少的类，则会增加噪声，降低分类效果。

通常，K值的设定采⽤交叉检验的⽅式（以K=1为基准）经验规则：K⼀般低于训练样本数的平⽅根。

2、优化问题压缩训练样本；确定最终的类别时，不是简单的采⽤投票法，⽽是进⾏加权投票，距离越近权重越⾼。

四、python中scikit-learn对KNN算法的应⽤#KNN调⽤import numpy as npfrom sklearn import datasetsiris = datasets.load_iris()iris_X = iris.datairis_y = iris.targetnp.unique(iris_y)# Split iris data in train and test data# A random permutation, to split the data randomlynp.random.seed(0)# permutation随机⽣成⼀个范围内的序列indices = np.random.permutation(len(iris_X))# 通过随机序列将数据随机进⾏测试集和训练集的划分iris_X_train = iris_X[indices[:-10]]iris_y_train = iris_y[indices[:-10]]iris_X_test = iris_X[indices[-10:]]iris_y_test = iris_y[indices[-10:]]# Create and fit a nearest-neighbor classifierfrom sklearn.neighbors import KNeighborsClassifierknn = KNeighborsClassifier()knn.fit(iris_X_train, iris_y_train)KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',metric_params=None, n_jobs=1, n_neighbors=5, p=2,weights='uniform')knn.predict(iris_X_test)print iris_y_testKNeighborsClassifier⽅法中含有8个参数（以下前两个常⽤）：n_neighbors : int, optional (default = 5)：K的取值，默认的邻居数量是5；weights：确定近邻的权重，“uniform”权重⼀样，“distance”指权重为距离的倒数，默认情况下是权重相等。

基于 R 语言的 k-最近邻法数字模式识别研究钟志强（鞍山师范学院物理科学与技术学院，辽宁 鞍山 114007）[摘 要] k-最近邻法是常见的机器学习算法，R 语言中通过 kknn 包完成算法实现,但其无法实现图像文件的处理。

为此，本文先将图像文件转换成文本文件，再结合 KNN 算法对文件中数字图像进行模式识别。

实验得出其判断结果达到了预 期指标。

[关键词] k-最近邻法；模式识别；R 语言现以著名鸢尾花（iris ）数据集实现算例：包含五个指标花瓣长度(Petal ．Length)、萼片宽度(Sepal.Width)、花瓣宽度 (Petal.Width)、萼片长度(Sepal.Length)、三种花类型（Species ： setosa ，versicolor ，virginica ）150 笔记录。

其结果见表 1 和图 1。

data(iris)；m<- d im(iris)[1]；val<- s ample(1：m ，size=round (m/3)，replace=FALSE ，prob=rep(1/m ，m))；iris ． learn<- iris[- val ，]；iris ．valid<-iris[val ，]；iris ．kknn<-kknn(Species~．，iris ．learn ，iris ．valid ，distance=1，kernel="triangular")；summary (iris ．kknn)；fit<-fitted(iris ．kknn)；table(iris ．valid$Species ， fit)pcol<- as ． character(as ． numeric(iris ． valid $Species))； pairs(iris ．valid[1：4]，pch=pcol ，col = c("green3"，"red")[(iris ．valid$Species != fit)+1]) 1．k-最近邻法原理k-最近邻法(k-nearest neighbor ，KNN)是最简单的机器学 习算法之一，可以用于分类和回归。

k-近邻分类算法K近邻分类算法是一种基于实例的分类算法，它的主要思想是通过计算每个样本点与其周围的k个最近邻点的距离来确定该点的类别。

该算法主要应用于分类问题中，并且在实际应用过程中具有很好的可用性、易实现性和理解性。

算法原理算法首先通过确定k值来确定分类的邻域大小，以及根据k值的选择来确定分类的准确性和鲁棒性。

之后通过计算每个样本点与其邻域内k个最近邻点之间的距离来确定该样本点所属的分类。

具体流程如下：1.确定数据集中的k值和距离度量标准；2.对于每个待分类的样本点，计算与其邻域中k个最近邻点之间的距离；3.根据邻域中k个最近邻点的类别来确定该样本点所属的类别；4.重复步骤2和3，直到所有待分类的样本点均被分类完毕；5.给出分类结果。

距离度量标准在k-近邻分类算法中，距离度量标准是非常重要的，因为它决定了样本点之间距离的计算方式。

目前常见的距离度量标准有欧式距离、曼哈顿距离和切比雪夫距离。

欧式距离：$d=\sqrt{{\sum_{i=1}^{n}{(x_i-y_i)^2}}}$优缺点1.基于实例，不需要对数据进行任何假设和理论分析；2.算法的可预测性高，具有很好的分类性能；3.没有过拟合的现象，可以对复杂的数据集进行分类；4.整体而言，k-近邻分类算法非常容易理解和实现。

1.计算量比较大，对于大型数据集而言，算法的效率较低；2.对于高维数据集而言，容易出现维数灾难问题，即算法的效果会逐渐降低；3.容易受到异常值的影响，且在分类决策区域方面可能存在不连续的问题。

应用场景k-近邻分类算法广泛应用于模式识别、数据挖掘和生物信息学等领域，特别适合处理较小的数据集。

目前该算法已被应用于医疗诊断、电子商务、物联网等领域，既可以用于分类问题，也可以用于回归问题。

同时，对于分类问题而言，该算法并不适用于类别数比较多或类别间存在相互交叉的情况。

因此，在实际应用过程中，应根据具体情况来选择算法，以达到最佳的分类效果。

R软件K近邻算法函数代码解释K近邻算法是一种非参数的分类和回归方法，用于根据最邻近的训练样本对新的输入进行预测。

在R语言中，有多个函数可以实现K近邻算法，其中最常用的是knn函数。

下面将对knn函数的代码进行详细解释。

knn函数的基本语法如下：```Rknn(train, test, cl, k)```其中，train是训练样本的特征矩阵，test是待分类的测试样本的特征矩阵，cl是训练样本的类别向量，k是指定最近邻的数量。

在knn函数内部，首先会计算测试样本与训练样本之间的距离，常用的距离度量方法有欧氏距离、曼哈顿距离等。

这些距离度量方法可以通过设置参数来选择。

接下来，knn函数会找出距离最近的k个训练样本，然后根据这k个样本的类别进行投票，选取出现频率最高的类别作为测试样本的预测类别。

在这一步中，可以通过设置参数来进行加权投票，即距离越近的样本权重越大。

最后，knn函数会返回测试样本的预测类别向量。

下面是一个示例的knn函数代码解释：```Rlibrary(class)#创建训练样本的特征矩阵train <- matrix(c(1, 2, 3, 4, 5, 6), nrow = 3, ncol = 2)#创建训练样本的类别向量cl <- c("A", "B", "A")#创建待分类的测试样本的特征矩阵test <- matrix(c(2, 3), nrow = 1, ncol = 2)#设置最近邻的个数k<-1#进行K近邻算法分类result <- knn(train, test, cl, k)#输出结果print(result)```在这个示例代码中，首先加载了class包，该包中包含了knn函数。

然后，创建了一个3个样本、每个样本有2个特征的训练样本的特征矩阵train。

接着，创建训练样本的类别向量cl，其中"A"和"B"分别代表两个类别。

r语言中k近邻法插补数据过程K近邻法（K-nearest neighbors，简称KNN）是一种常用的插补数据的方法，它通过寻找与缺失数据最接近的K个邻居的方式来估算缺失值，从而完成数据的插补。

本文将详细介绍R语言中K近邻法插补数据的过程。

1.导入必要的R包在开始之前，首先需要导入一些必要的R包，以便于进行数据处理和KNN插补。

常用的R包包括`impute`、`caret`、`e1071`等。

可以使用以下代码导入这些包：```Rlibrary(impute)library(caret)library(e1071)```2.准备数据在进行KNN插补之前，需要准备一组包含缺失值的数据。

可以使用`read.csv`函数读取一个含有缺失值的数据文件，并将其存储在一个数据框中。

例如：```Rdata <- read.csv("data.csv")```3.处理缺失值在进一步进行KNN插补之前，需要先检查数据中的缺失值情况，并进行必要的处理。

可以使用以下代码检查数据中的缺失值：```Ris.na(data)```如果有缺失值，可以使用合适的缺失值处理方法进行处理，例如删除包含缺失值的行或列，使用其他方法进行插补等。

4.进行KNN插补KNN插补的主要步骤包括计算距离、选择K个最近邻居和插补缺失值。

计算距离：首先需要选择一种距离度量方法来计算数据之间的距离。

在R语言中，常用的距离度量方法有欧氏距离（Euclidean distance）、曼哈顿距离（Manhattan distance）等。

可以使用`dist`函数计算数据之间的距离矩阵，例如：```Rdist_matrix <- dist(data, method = "euclidean")```选择K个最近邻居：根据距离矩阵，可以使用`knn.impute`函数选择K个最近邻居。

该函数会使用距离最近的K个邻居的值来估算缺失值。

机器学习：k-NN算法（也叫k近邻算法）⼀、kNN算法基础# kNN：k-Nearest Neighboors# 多⽤于解决分类问题　1）特点：1. 是机器学习中唯⼀⼀个不需要训练过程的算法，可以别认为是没有模型的算法，也可以认为训练数据集就是模型本⾝；2. 思想极度简单；3. 应⽤数学知识少（近乎为零）；4. 效果少；5. 可以解释机械学习算法使⽤过程中的很多细节问题6. 更完整的刻画机械学习应⽤的流程；　2）思想：根本思想：两个样本，如果它们的特征⾜够相似，它们就有更⾼的概率属于同⼀个类别；问题：根据现有训练数据集，判断新的样本属于哪种类型；⽅法/思路：1. 求新样本点在样本空间内与所有训练样本的欧拉距离；2. 对欧拉距离排序，找出最近的k个点；3. 对k个点分类统计，看哪种类型的点数量最多，此类型即为对新样本的预测类型；　3）代码实现过程：⽰例代码：import numpy as npimport matplotlib.pyplot as pltraw_data_x = [[3.3935, 2.3312],[3.1101, 1.7815],[1.3438, 3.3684],[3.5823, 4.6792],[2.2804, 2.8670],[7.4234, 4.6965],[5.7451, 3.5340],[9.1722, 2.5111],[7.7928, 3.4241],[7.9398, 0.7916]]raw_data_y = [0, 0, 0, 0, 0, 1, 1, 1, 1, 1]# 训练集样本的datax_train = np.array(raw_data_x)# 训练集样本的labely_train = np.array(raw_data_y)# 1）绘制训练集样本与新样本的散点图# 根据样本类型（0、1两种类型），绘制所有样本的各特征点plt.scatter(x_train[y_train == 0, 0], x_train[y_train == 0, 1], color = 'g')plt.scatter(x_train[y_train == 1, 0], x_train[y_train == 1, 1], color = 'r')# 新样本x = np.array([8.0936, 3.3657])# 将新样本的特征点绘制在训练集的样本空间plt.scatter(x[0], x[1], color = 'b')plt.show()# 2）在特征空间中，计算训练集样本中的所有点与新样本的点的欧拉距离from math import sqrt# math模块下的sqrt函数：对数值开平⽅sqrt(number)distances = []for x_train in x_train:d = sqrt(np.sum((x - x_train) ** 2))distances.append(d)# 也可以⽤list的⽣成表达式实现：# distances = [sqrt(np.sum((x - x_train) ** 2)) for x_train in x_train]# 3）找出距离新样本最近的k个点，并得到对新样本的预测类型nearest = np.argsort(distances)k = 6# 找出距离最近的k个点的类型topK_y = [y_train[i] for i in nearest[:k]]# 根据类别对k个点的数量进⾏统计from collections import Countervotes = Counter(topK_y)# 获取所需的预测类型：predict_ypredict_y = votes.most_common(1)[0][0]封装好的Python代码：import numpy as npfrom math import sqrtfrom collections import Counterdef kNN_classify(k, X_train, y_train, x):assert 1 <= k <= X_train.shape[0],"k must be valid"assert X_train.shape[0] == y_train.shape[0], \"the size of X_train nust equal to the size of y_train"assert X-train.shape[1] == x.shape[0],\"the feature number of x must be equal to X_train"distances = [sprt(np.sum((x_train - x) ** 2)) for x_train in X_train]nearest = np.argsort(distances)topK_y = [y_train[i] for i in nearest[:k]]vates = Counter(topK_y)return votes.most_common(1)[0][0] # assert：表⽰声明；此处对4个参数进⾏限定；代码中的其它Python知识：1. math模块下的sprt()⽅法：对数开平⽅；from math import sqrtprint(sprt(9))# 32. collections模块下的Counter()⽅法：对列表中的数据进⾏分类统计，⽣产⼀个Counter对象;from collections import Countermy_list = [0, 0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3]print(Counter(my_list))# ⼀个Counter对象：Counter({0: 2, 1: 3, 2: 4, 3: 5})3. Counter对象的most_common()⽅法：Counter.most_common(n)，返回Counter对象中数量最多的n种数据，返回⼀个list，list的每个元素为⼀个tuple；from collections import Countermy_list = [0, 0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3]votes = Counter(my_list)print(votes.most_common(2))# [(3, 5), (2, 4)]⼆、总结　1）k近邻算法的作⽤ 1、解决分类问题，⽽且天然可以解决多分类问题； 2、也可以解决回归问题，其中scikit-learn库中封装的KNeighborsRegressor，就是解决回归问题；　2）缺点缺点1：效率低下1. 原因：如果训练集有m个样本，n个特征，预测每⼀个新样本，需要计算与m个样本的距离，每计算⼀个距离，要使⽤n个时间复杂度，则计算m个样本的距离，使⽤m * n个时间复杂度；2. 算法的时间复杂度：反映了程序执⾏时间随输⼊规模增长⽽增长的量级，在很⼤程度上能很好反映出算法的优劣与否。

k近邻法（⼀）简介k近邻法(k-nearest neighbors algorigthm) 是⼀种最基本的⽤于分类和回归的⽅法之⼀，当没有关于训练数据的分布时，⾸先最容易想到的就是采⽤k近邻法。

k近邻法输⼊为实例的特征向量，输出为实例的类别。

算法思想是，给定训练数据集，对应输⼊空间的各个数据点，要判断⼀个新的数据点的分类，则取⽬标数据点最近的k个数据点，然后统计这k个数据点中每个分类各占多少，并取数量最多的那个分类作为⽬标数据点的分类。

上⾯说到的“最近”？那么何为最近？k近邻法通常采⽤欧式距离来表征两个数据点的距离，距离越⼩，这两个数据点越近。

假设数据点x具有n维度（n个特征），x=[x1,x2, ... , x n]T数据xi和xj的距离则为当然，还可以采⽤Minkowski距离，这是更⼀般的形式其中，q >= 1.当q=1，为曼哈顿距离（Manhattan distance）当q=2，为欧式距离（Euclidean distance）当q=+∞，为两个点映射到各个坐标距离的最⼤值值得注意的是上⾯所说的距离适⽤于数据点的特征向量的（⾏列式）值是连续的，或者说向量各维度的值是连续的。

对于分类变量（categorical variables），则使⽤汉明距离（Hamming distance），其中，x是n维向量，每个维度的取值为{0,1}，为0或者为1，汉明距离就是统计对应各维度值不等的个数。

k值的选择如果k值较⼩，则使⽤较⼩的邻域中的数据点进⾏预测，则近似误差会减⼩，因为避免了较⼤邻域可能会有⼤量其他分类的数据点来⼲扰预测，然⽽邻域也不能选择太⼩，否则⼀旦出现数据点是噪声（实际应⽤中肯定存在），预测同样会受到噪声⼲扰，此时没有⾜够的正确的数据点来帮助预测分类。

综上算法就是，计算训练数据集中每个数据点与需要预测的数据点的距离，并找出距离最⼩的k个数据点，然后将这k个数据点归类，数量最多的那个分类就是预测的数据点分类然⽽，由于实际中给定的训练数据集可能⽐较⼤，这样每次预测⼀个数据点时，都要经过上⾯的过程计算，会耗费很长时间，所以需要想⽅设法提⾼计算效率，⼀个常见的⽅法如下介绍。

knn算法r语言代码
以下是使用R语言实现k-近邻算法（k-NN）的基本示例代码。

这个代码假设你有一个名为`mydata`的数据集，它有两列：`feature1`和`feature2`，你想预测的目标变量是`target`。

```r
加载所需的库
library(class)
加载数据
data <- mydata
将数据集分为训练集和测试集
set.seed(123) 确保结果的可复现性
train_idx <- sample(1:nrow(data), nrow(data)*0.7)
train_data <- data[train_idx, ]
test_data <- data[-train_idx, ]
使用k-NN算法训练模型
knn_model <- knn(train_data[, -ncol(train_data)], test_data[, -ncol(test_data)], cl = test_data$target, k = 3)
打印模型的结果
print(knn_model)
```
这个代码首先加载了`class`库，然后加载了数据。

然后，它使用70%的数据作为训练集，其余的作为测试集。

`knn()`函数用于训练k-NN模型，其中`cl`参数是目标变量，`k`参数是近邻的数量。

最后，它打印出模型的预测结果。

请注意，这只是一个基本的示例。

在实际应用中，你可能需要对数据进行预处理，例如缺失值填充、特征缩放等，以及调整k值和其他参数以优化模型的性能。

K-近邻算法⼀、概述k-近邻算法（k-Nearest Neighbour algorithm），⼜称为KNN算法，是数据挖掘技术中原理最简单的算法。

KNN 的⼯作原理：给定⼀个已知标签类别的训练数据集，输⼊没有标签的新数据后，在训练数据集中找到与新数据最邻近的k个实例，如果这k个实例的多数属于某个类别，那么新数据就属于这个类别。

可以简单理解为：由那些离X最近的k个点来投票决定X归为哪⼀类。

图1 图1中有红⾊三⾓和蓝⾊⽅块两种类别，我们现在需要判断绿⾊圆点属于哪种类别当k=3时，绿⾊圆点属于红⾊三⾓这种类别；当k=5时，绿⾊圆点属于蓝⾊⽅块这种类别。

举个简单的例⼦，可以⽤k-近邻算法分类⼀个电影是爱情⽚还是动作⽚。

（打⽃镜头和接吻镜头数量为虚构）电影名称打⽃镜头接吻镜头电影类型⽆问西东1101爱情⽚后来的我们589爱情⽚前任31297爱情⽚红海⾏动1085动作⽚唐⼈街探案1129动作⽚战狼21158动作⽚新电影2467？表1 每部电影的打⽃镜头数、接吻镜头数和电影分类表1就是我们已有的数据集合，也就是训练样本集。

这个数据集有两个特征——打⽃镜头数和接吻镜头数。

除此之外，我们也知道每部电影的所属类型，即分类标签。

粗略看来，接吻镜头多的就是爱情⽚，打⽃镜头多的就是动作⽚。

以我们多年的经验来看，这个分类还算合理。

如果现在给我⼀部新的电影，告诉我电影中的打⽃镜头和接吻镜头分别是多少，那么我可以根据你给出的信息进⾏判断，这部电影是属于爱情⽚还是动作⽚。

⽽k-近邻算法也可以像我们⼈⼀样做到这⼀点。

但是，这仅仅是两个特征，如果把特征扩⼤到N个呢？我们⼈类还能凭经验“⼀眼看出”电影的所属类别吗？想想就知道这是⼀个⾮常困难的事情，但算法可以，这就是算法的魅⼒所在。

我们已经知道k-近邻算法的⼯作原理，根据特征⽐较，然后提取样本集中特征最相似数据（最近邻）的分类标签。

那么如何进⾏⽐较呢？⽐如表1中新出的电影，我们该如何判断他所属的电影类别呢？如图2所⽰。

用R语言做数据分析——有权重的K最近邻算法 我们使用kknn()函数来实现有权重的K最近邻算法，虽然与knn()函数一样，都是同时将训练集与测试集一起放入函数，但格式上略有不同，需注意kknn()函数时formula格式的函数，在此之前，我们需要安装并加载所需的kknn包。

我们将规则建立公式Species~.，以及训练集与测试集分别放入函数，设置K为5。

> library(kknn) > set.seed(1234) > ind <- sample(2, nrow(iris), replace=TRUE, prob=c(0.7,0.3)) > data_train <- iris[ind==1,] > data_test <- iris[ind==2,] >#建立有权重的K最近邻判别规则，并对测试集样本进行预测 > fit_pre_kknn <- kknn(Species~., data_train,data_test[,-5], k=5) >#输出在K最近邻判别规则下的判别结果 > summary(fit_pre_kknn) Call: kknn(formula=Species ~ ., train=data_train, test=data_test[, -5], k=5) Response: "nominal" fit prob.setosa prob.versicolor prob.virginica 1 setosa 1 0.0000000 0.00000000 2 setosa 1 0.0000000 0.00000000 3 setosa 1 0.0000000 0.00000000 4 setosa 1 0.0000000 0.00000000 5 setosa 1 0.0000000 0.00000000 6 setosa 1 0.0000000 0.00000000 7 setosa 1 0.0000000 0.00000000 8 setosa 1 0.0000000 0.00000000 9 setosa 1 0.0000000 0.00000000 10 setosa 1 0.0000000 0.00000000 11 versicolor 0 1.0000000 0.00000000 12 versicolor 0 1.0000000 0.00000000 13 versicolor 0 1.0000000 0.00000000 14 versicolor 0 1.0000000 0.00000000 15 versicolor 0 1.0000000 0.00000000 16 versicolor 0 1.0000000 0.00000000 17 versicolor 0 1.0000000 0.00000000 18 versicolor 0 1.0000000 0.00000000 19 versicolor 0 0.9689165 0.03108351 20 versicolor 0 1.0000000 0.00000000 21 versicolor 0 1.0000000 0.00000000 22 versicolor 0 1.0000000 0.00000000 23 virginica 0 0.0984325 0.90156750 24 virginica 0 0.0000000 1.00000000 25 virginica 0 0.0000000 1.00000000 26 virginica 0 0.0984325 0.90156750 27 versicolor 0 1.0000000 0.00000000 28 virginica 0 0.0000000 1.00000000 29 virginica 0 0.0000000 1.00000000 30 virginica 0 0.0000000 1.00000000 31 virginica 0 0.2075319 0.79246807 32 virginica 0 0.0000000 1.00000000 33 versicolor 0 0.6940356 0.30596443 34 virginica 0 0.0000000 1.00000000 35 virginica 0 0.0000000 1.00000000 36 virginica 0 0.0000000 1.00000000 37 virginica 0 0.3713535 0.62864649 38 virginica 0 0.0000000 1.00000000 从上面的结果中，我们可以看到测试集中每一个样本归属于各类别的统招概率，依次记为prob.setosa、prob.versicolor 、prob.virginica，其中，fit记录了该样本最终判定的类别。

R语⾔学习笔记—K近邻算法K近邻算法（KNN)是指⼀个样本如果在特征空间中的K个最相邻的样本中的⼤多数属于某⼀个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。

即每个样本都可以⽤它最接近的k个邻居来代表。

KNN算法适合分类，也适合回归。

KNN算法⼴泛应⽤在推荐系统、语义搜索、异常检测。

KNN算法分类原理图：图中绿⾊的圆点是归属在红⾊三⾓还是蓝⾊⽅块⼀类？如果K=5（离绿⾊圆点最近的5个邻居，虚线圈内），则有3个蓝⾊⽅块是绿⾊圆点的“最近邻居”，⽐例为3/5，因此绿⾊圆点应当划归到蓝⾊⽅块⼀类；如果K=3（离绿⾊圆点最近的3个邻居，实线圈内），则有两个红⾊三⾓是绿⾊圆点的“最近邻居”，⽐例为2/3，那么绿⾊圆点应当划归到红⾊三⾓⼀类。

由上看出，该⽅法在定类决策上只依据最邻近的⼀个或者⼏个样本的类别来决定待分样本所属的类别。

KNN算法实现步骤：1. 数据预处理2. 构建训练集与测试集数据3. 设定参数，如K值（K⼀般选取样本数据量的平⽅根即可，3~10）4. 维护⼀个⼤⼩为K的的按距离（欧⽒距离）由⼤到⼩的优先级队列，⽤于存储最近邻训练元组。

随机从训练元组中选取K个元组作为初始的最近邻元组，分别计算测试元组到这K个元组的距离将训练元组标号和距离存⼊优先级队列5. 遍历训练元组集，计算当前训练元组与测试元组的距离L，将所得距离L与优先级队列中的最⼤距离Lmax6. 进⾏⽐较。

若L>=Lmax，则舍弃该元组，遍历下⼀个元组。

若L < Lmax，删除优先级队列中最⼤距离的元组，将当前训练元组存⼊优先级队列7. 遍历完毕，计算优先级队列中K个元组的多数类，并将其作为测试元组的类别8. 测试元组集测试完毕后计算误差率，继续设定不同的K值重新进⾏训练，最后取误差率最⼩的K值。

R语⾔实现过程：R语⾔中进⾏K近邻算法分析的函数包有class包中的knn函数、caret包中的train函数和kknn包中的kknn函数knn(train, test, cl, k = 1, l = 0, prob = FALSE, use.all = TRUE)参数含义：train：含有训练集的矩阵或数据框test：含有测试集的矩阵或数据框cl：对训练集进⾏分类的因⼦变量k：邻居个数l：有限决策的最⼩投票数prob：是否计算预测组别的概率use.all：控制节点的处理办法，即如果有多个第K近的点与待判样本点的距离相等，默认情况下将这些点都作为判别样本点；当该参数设置为FALSE时，则随机选择⼀个点作为第K近的判别点。

r语言knn算法实例R语言是一种非常流行的数据分析和统计建模工具，其中的k近邻算法（K-Nearest Neighbors，简称KNN）是一种基本的分类和回归算法。

本文将介绍KNN算法的原理、应用场景以及如何在R语言中实现KNN算法。

一、KNN算法原理KNN算法是一种基于实例的学习方法，它的核心思想是通过计算样本之间的距离来确定新样本的分类。

具体来说，KNN算法有以下几个步骤：1. 计算距离：对于给定的新样本，计算它与训练样本集中每个样本之间的距离。

常见的距离度量方法有欧氏距离、曼哈顿距离等。

2. 选择K值：KNN算法中的K表示选择最近邻的个数，即在训练样本集中选择离新样本最近的K个样本。

3. 投票决策：根据选择的K个最近邻样本的类别，采用投票的方式来确定新样本的类别。

通常采用多数表决的方式，即选择K个样本中出现次数最多的类别作为新样本的类别。

二、KNN算法应用场景KNN算法适用于各种数据类型和问题类型，特别适用于以下场景：1. 分类问题：KNN算法可以用于解决分类问题，如根据患者的特征预测其是否患有某种疾病、根据商品的属性判断其所属类别等。

2. 回归问题：KNN算法也可以用于回归问题，如根据房屋的特征预测其价格、根据股票的历史数据预测其未来走势等。

3. 推荐系统：KNN算法可以用于构建基于用户行为的推荐系统，根据用户的历史行为和相似用户的行为给用户推荐合适的商品或内容。

三、在R语言中实现KNN算法在R语言中，可以使用一些现有的包来实现KNN算法，如“class”包和“caret”包。

下面以“class”包为例，介绍如何在R语言中实现KNN算法。

需要安装和加载“class”包：```Rinstall.packages("class")library(class)```接下来，假设我们有一组训练数据train_data和对应的类别train_label，以及一组测试数据test_data。

k-nearest neighbors（k-近邻）是一种简单而有效的监督式学习算法。

该算法在分类和回归问题上都有广泛的应用，并且易于理解和实现。

k-nearest neighbors算法的核心思想是基于输入样本的特征，来预测新样本的分类标签或者数值输出。

k-nearest neighbors算法的原理如下：1. 数据集准备：将训练数据集中的样本按照特征进行标记，这些特征用来决定样本的类别或者数值。

另外，还需要准备测试数据集，用于模型的验证和评估。

2. 计算距离：在预测过程中，计算测试样本与训练样本之间的距离。

通常使用的距离度量包括欧氏距离、曼哈顿距离、闵可夫斯基距离等。

3. 选择k值：选择一个合适的k值，该值表示在预测时将考虑最接近的k个训练样本。

选择合适的k值对算法的性能有着重要影响。

4. 预测：根据测试样本与训练样本的距离，选择最接近的k个训练样本，根据这k个训练样本的标签或数值进行预测。

通常采用投票法（对分类问题）或者平均法（对回归问题）来确定最终的预测结果。

k-nearest neighbors算法的优缺点如下：优点：1. 简单、直观：算法实现简单，易于理解和解释。

2. 适用于多类别问题：对于多分类问题，k-nearest neighbors算法表现良好。

3. 适用于非线性数据：对于非线性数据集，k-nearest neighbors算法也能够取得不错的预测效果。

缺点：1. 计算复杂度高：在大型数据集中，由于需要计算相互之间的距离，算法的计算开销比较大。

2. 对异常值敏感：k-nearest neighbors算法对异常值比较敏感，因此在使用该算法时需要注意异常值的处理。

3. 需要合适的k值：k值的选择对算法的性能有着重要的影响，选择不当会导致预测效果下降。

在使用k-nearest neighbors算法时，需要注意以下几点：1. 数据预处理：在应用k-nearest neighbors算法之前，需要对数据进行一定的预处理。

K-近邻算法原理及举例工作原理：我们知道样本集中每一个数据与所属分类的对应关系，输入没有标签的新数据后，将新数据与训练集的数据对应特征进行比较，找出“距离”最近的k(通常k<20)数据，选择这k个数据中出现最多的分类作为新数据的分类。

算法描述：(1)计算已知类别数据及中的点与当前点的距离;(2)按距离递增次序排序(3)选取与当前点距离最小的k个点(4)确定前K个点所在类别出现的频率(5)返回频率最高的类别作为当前类别的预测这里我们使用最常见欧氏距离作为衡量标准，以鸢尾花数据集为例来说明K-近邻算法：鸢尾花数据集包含150个数据，测量变量为花瓣，花萼的长度与宽度，分类变量为setosa, versicolor,和virginica。

准备数据：为了了解数据，我们先通过作图分析，相关分析来看看数据分类指标的合理性，这一点十分重要，有助于减少分类指标中的噪声。

从上图可以看出，我们通过这2个变量大致是可以把鸢尾花分类的，也就是说分类的特征变量选择是合理的，(同理可以分析另外2个，分类效果不如这两个，但大致上还是能区分的)当然我们也可以选择计算相关系数来看特征变量的合理性。

我们很容易发现，数值差最大的属性对距离的影响最大，所以在特征值等权重的假定下，我们先得归一化特征值，计算公式为：Newvalue=(oldvalue-min)/(max-min)R代码：autonorm<-function(data){for(iin 1:length(data))data[i]<-(data[i]-min(data))/(max(data)-min(data))return(data)}data<-as.matrix(apply(iris[,1:4],2,autonorm))得到了归一化后的数据集，下面计算距离。

我们在这里取三个数据作为验证集来看看分类的效果，首先将验证集归一化：x<-iris[13,1:4]y<-iris[79,1:4]z<-iris[100,1:4]x<-(x-apply(iris[c(-13,-79,-100),1:4],2,min))/(apply(iris[c(-13,-79,-100),1:4],2,max)-apply(iris[c(-13,-79,-100),1:4],2,min))y<-(y-apply(iris[c(-13,-79,-100),1:4],2,min))/(apply(iris[c(-13,-79,-100),1:4],2,max)-apply(iris[c(-13,-79,-100),1:4],2,min))z<-(z-apply(iris[c(-13,-79,-100),1:4],2,min))/(apply(iris[c(-13,-79,-100),1:4],2,max)-apply(iris[c(-13,-79,-100),1:4],2,min))计算距离，仅以x为例，运行代码：(k取5)dis<-rep(0,length(data[,1]))for(iin 1:length(data[,1]))dis[i]<-sqrt(sum((z-data[i,1:4])^2))table(data[order(dis)[1:5],5])x,y,z的输出结果为标签xyyz分类1233频数5415虽然对测试y出现了错误分类，但根据多数投票法x,y,z为setosa,versicolor,和virginica，得到了正确分类结果。