Knn算法讲解

已于 2022-02-22 19:05:17 修改
阅读量980 收藏 4
点赞数 2
分类专栏： 机器学习 文章标签： 算法 机器学习 分类
于 2022-02-22 18:12:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51294669/article/details/123071545
版权
本文深入介绍了K-近邻（K-Nearest Neighbor, KNN）算法，包括其基本原理、距离计算方法（如欧式距离和曼哈顿距离）以及懒惰学习的概念。通过实例展示了如何使用KNN算法对鸢尾花数据集进行分类，并提供了Java代码实现，包括数据预处理、训练集与测试集划分、预测及精度评估。此外，还讨论了K值的选择对预测准确性的影响。
摘要由CSDN通过智能技术生成

简介：

  • 全名K-nearest neighber 算法，它是一个根据训练集并且非规则的分类算法。
  • Cover 和 Hart 在 1968年提出的最初的邻近算法
  • 通过测量不同特征值之间的距离方法进行分类
  • 属于懒惰学习方法Lazy learner
  • Eager Learners:接收测试数据之前，对已有的数据构建一个分类模型。
  • Lazy Learners (instance-based learners) : 在训练阶段仅仅把样本保存下来，训练时间开销为零，待接收到测试样本后在进行处理。

算法原理：

存在一个样本集合（训练样本集），并且样本中的每个数据都有标签（也是类别）。

输入没有类别标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后提取样本集最相似的K个分类标签。

选择这个K个标签中次数最多的分类为新数据的分类。

举例：

五列数据分别对应花萼长度、花萼宽度、花瓣长度、花瓣宽度和种类，其中种类分别为山鸢尾、变色鸢尾和维吉尼亚鸢尾三个类别。

5.1,3.5,1.4,0.2,Iris-setosa

4.9,3.0,1.4,0.2,Iris-setosa

4.7,3.2,1.3,0.2,Iris-setosa

4.6,3.1,1.5,0.2,Iris-setosa

7.0,3.2,4.7,1.4,Iris-versicolor

6.4,3.2,4.5,1.5,Iris-versicolor

6.9,3.1,4.9,1.5,Iris-versicolor

5.5,2.3,4.0,1.3,Iris-versicolor

6.3,2.5,5.0,1.9,Iris-virginica

6.5,3.0,5.2,2.0,Iris-virginica

6.2,3.4,5.4,2.3,Iris-virginica

5.9,3.0,5.1,1.8,Iris-virginica

我在这里只选用了每种花的四个数据样本，实际上数据样本可以非常的大。为了方便起见我把它们画在一个平面上（距离可能不准，请理解思路）。

 然后有一个测试数据进来：5.0,3.0,1.6,0.2 不知道它是那种花，因此我们给定一个k值等于三，找出他周围最相邻的三个数据。图中黑球像这样：

 我们直观的看出当 K = 3 时，其中有两个红球，一个蓝球，也就是说我们的待测数据跟红球样本相似度更大，所以判定此花是Iris-setosa。

问题来了：K值是我们给定的，哪我们怎样去判断距离呢？

第一步：明确距离坐标的含义，就是事物的特征值。比如此处的花萼长度、花萼宽度、花瓣长度、花瓣宽度就是坐标中的 x,y,z. 多了画不出来没关系，下面我们将介绍它的距离计算。

第二步：距离计算，我介绍常用的两种。

欧式距离：大家再熟悉熟悉不过了,例如：x=(x1,x2,...,xn) , y = (y1,y2,...,yn) d(x,y) := \sqrt{(x_{1}-y_{1})^{2}+(x_{2}-y_{2})^{2}+\cdot \cdot \cdot +(x_{n}-y_{n})^{2}}

曼哈顿距离：x = (x1,x2) , y = (y1,y2) d = | x1 - y1 | + | x2 - y2 |

 图中橘色的线段便是欧氏距离，而紫色的便是曼哈顿距离。两种距离各有千秋，像我们这道题：给定花的特征判断花的种类，欧式距离比较好，如果是城乡规划路径上的问题曼哈顿距离优势更准确，因为你不能直接越过楼房算位移，我们需要路程。

投票排序：

我们找出了 3 个距待测样本最近的数据后就要进行投票了。比如 第一个球是红色，红球+1，第二球是蓝色，蓝球+1，第三个球是红色红球+1。最终的结果是 ：红（2票），蓝（1票）。代码中体现的是花的种类对应的数组下标。

根据票数我们就知道测试的结果是红球。可这样还不行，这只是预测，我们还需要来估算预测的准确率是多少，它与我们的K选取有关。比如：100个未知数据，我们预测的结果和真实的结果相比较，发现对了99个，那么预测的准确率便是 0.99.

代码：

package machinelearning.knn;

import java.io.FileReader;
import java.util.Arrays;
import java.util.Random;

import weka.core.*;

public class KnnClassification {

	/**
	 * 曼哈顿距离
	 */
	public static final int MANHATTAN = 0;

	/**
	 * 欧式距离
	 */
	public static final int EUCLIDEAN = 1;

	/**
	 * 距离测量
	 */
	public int distanceMeasure = EUCLIDEAN; //现将距离测量置为1

	/**
	 * 生成随机距离
	 */
	public static final Random random = new Random();

	/**
	 * 邻居数目
	 */
	int numNeighbors = 7;

	/**
	 * The whole dataset.
	 */
	Instances dataset;

	/**
	 * 训练场地，由数据索引表示
	 */
	int[] trainingSet;

	/**
	 * 测试集，由数据索引表示
	 */
	int[] testingSet;

	/**
	 * 预测
	 */
	int[] predictions;

    // 导入数据
	public KnnClassification(String paraFilename) {
		try {
			FileReader fileReader = new FileReader(paraFilename);
			dataset = new Instances(fileReader);
			// The last attribute is the decision class.
			dataset.setClassIndex(dataset.numAttributes() - 1);
			fileReader.close();
		} catch (Exception ee) {
			System.out.println("Error occurred while trying to read \'" + paraFilename
					+ "\' in KnnClassification constructor.\r\n" + ee);
			System.exit(0);
		} // Of try
	}// Of the first constructor

	// 获得随机索引，数据随机化
	public static int[] getRandomIndices(int paraLength) {
		int[] resultIndices = new int[paraLength];

		// Step 1. 初始化resultIndices数组
		for (int i = 0; i < paraLength; i++) {
			resultIndices[i] = i;
		} // Of for i

		// Step 2. 随机交换
		int tempFirst, tempSecond, tempValue;
		// for 循环的目的是打乱数组中数字的顺序
		for (int i = 0; i < paraLength; i++) {
			// 生成两个随机索引，tempFirst,tempSecond
			tempFirst = random.nextInt(paraLength);
			tempSecond = random.nextInt(paraLength);

			// Swap. 交换
			tempValue = resultIndices[tempFirst];
			resultIndices[tempFirst] = resultIndices[tempSecond];
			resultIndices[tempSecond] = tempValue;
		} // Of for i

		return resultIndices;
	}// Of getRandomIndices
	
	// 把导入的数据一分为二，训练场地和测试场地
	public void splitTrainingTesting(double paraTrainingFraction) {
		// 
		int tempSize = dataset.numInstances();
		//得到一个测试数组
		int[] tempIndices = getRandomIndices(tempSize);
		int tempTrainingSize = (int) (tempSize * paraTrainingFraction);

		trainingSet = new int[tempTrainingSize];
		testingSet = new int[tempSize - tempTrainingSize];

		for (int i = 0; i < tempTrainingSize; i++) {
			trainingSet[i] = tempIndices[i];
		} // Of for i

		for (int i = 0; i < tempSize - tempTrainingSize; i++) {
			testingSet[i] = tempIndices[tempTrainingSize + i];
		} // Of for i
	}// Of splitTrainingTesting

	// 把预测的结果放在predictions数组中集中起来，后面做准确率计算
	public void predict() {
		predictions = new int[testingSet.length];
		for (int i = 0; i < predictions.length; i++) {
			predictions[i] = predict(testingSet[i]);
		} // Of for i
	}// Of predict

	// 进行预测
	public int predict(int paraIndex) {
		// 1. 找出相邻的 K 个邻居
		int[] tempNeighbors = computeNearests(paraIndex);
		
		// 2. 进行投票找出种类标签（数组下标表示，所以返回的是一个int型）
		int resultPrediction = simpleVoting(tempNeighbors);

		return resultPrediction;
	}// Of predict

       // 距离测量，两种选择，曼哈顿，欧式距离
	public double distance(int paraI, int paraJ) { // 猜测I和J是两个 
		double resultDistance = 0;
		double tempDifference;
		switch (distanceMeasure) {
		case MANHATTAN:
			for (int i = 0; i < dataset.numAttributes() - 1; i++) {
				tempDifference = dataset.instance(paraI).value(i) - dataset.instance(paraJ).value(i);
				if (tempDifference < 0) {
					resultDistance -= tempDifference;
				} else {
					resultDistance += tempDifference;
				} // Of if
			} // Of for i
			break;

		case EUCLIDEAN:
			for (int i = 0; i < dataset.numAttributes() - 1; i++) {
				tempDifference = dataset.instance(paraI).value(i) - dataset.instance(paraJ).value(i);
				resultDistance += tempDifference * tempDifference;
			} // Of for i
			break;
		default:
			System.out.println("Unsupported distance measure: " + distanceMeasure);
		}// Of switch

		return resultDistance;
	}// Of distance

	// 精确度
	public double getAccuracy() {
		
		double tempCorrect = 0;
		
		// 把正确的预测统计出来
		for (int i = 0; i < predictions.length; i++) {
			if (predictions[i] == dataset.instance(testingSet[i]).classValue()) {
				tempCorrect++;
			} // Of if
		} // Of for i

		return tempCorrect / testingSet.length;
	}// Of getAccuracy

	// 获得最近的 k 个邻居放入数组中
	public int[] computeNearests(int paraCurrent) {
		int[] resultNearests = new int[numNeighbors];
		boolean[] tempSelected = new boolean[trainingSet.length];
		double tempDistance;
		double tempMinimalDistance;
		int tempMinimalIndex = 0;

		// 借用循环找出距离最短的邻居下标
		for (int i = 0; i < numNeighbors; i++) {
			
			// 需要找的第 i 个邻居（共 K 个）
			tempMinimalDistance = Double.MAX_VALUE;
			
			// 从训练场地比较筛选
			for (int j = 0; j < trainingSet.length; j++) {
				
				// 如果这个结点被确定了最近结点中的一个，索引对应值true,跳过比较
				if (tempSelected[j]) {
					continue;
				} // Of if

				tempDistance = distance(paraCurrent, trainingSet[j]);
				if (tempDistance < tempMinimalDistance) {
					tempMinimalDistance = tempDistance;
					tempMinimalIndex = j;
				} // Of if
			} // Of for j

			resultNearests[i] = trainingSet[tempMinimalIndex];
			tempSelected[tempMinimalIndex] = true;
		} // Of for i

		System.out.println("The nearest of " + paraCurrent + " are: " + Arrays.toString(resultNearests));
		return resultNearests;
	}// Of computeNearests

	// 进行投票比较
	public int simpleVoting(int[] paraNeighbors) {
		int[] tempVotes = new int[dataset.numClasses()];
		// 投票
		for (int i = 0; i < paraNeighbors.length; i++) {
			tempVotes[(int) dataset.instance(paraNeighbors[i]).classValue()]++;
		} // Of for i

		int tempMaximalVotingIndex = 0;
		int tempMaximalVoting = 0;
		// 比较找出票数最多的
		for (int i = 0; i < dataset.numClasses(); i++) {
			if (tempVotes[i] > tempMaximalVoting) {
				tempMaximalVoting = tempVotes[i];
				tempMaximalVotingIndex = i;
			} // Of if
		} // Of for i

		return tempMaximalVotingIndex;
	}// Of simpleVoting

	// 测试程序入口
	public static void main(String args[]) {
		KnnClassification tempClassifier = new KnnClassification("D:/data/iris.arff");
		tempClassifier.splitTrainingTesting(0.8);
		tempClassifier.predict();
		System.out.println("The accuracy of the classifier is: " + tempClassifier.getAccuracy());
	}// Of main

}// Of class KnnClassification

给出了详细的代码，其中的要点已经最大化的详细了。

四川兔兔
关注
专栏目录
分类算法中决策树和KNN算法讲解及对iris数据集分类实战（附源码）
showswoller的博客
01-17 2090
分类算法中决策树和KNN算法讲解及对iris数据集分类实战（附源码）
KNN算法详细介绍
10-22
不可多得的关于kNN算法的资料，讲解通俗易懂!
KNN算法理解
热门推荐
jmydream的专栏
03-06 9万+
一、算法概述 1、kNN算法又称为k近邻分类(k-nearest neighbor classification)算法。 最简单平凡的分类器也许是那种死记硬背式的分类器，记住所有的训练数据，对于新的数据则直接和训练数据匹配，如果存在相同属性的训练数据，则直接用它的分类来作为新数据的分类。这种方式有一个明显的缺点，那就是很可能无法找到完全匹配的训练记录。 kNN算法则是从训练集中找
KNN算法简介
huidaoyinhe的博客
04-01 4919
KNN（k-nearest neighbor）是一个简单而经典的机器学习分类算法，通过度量”待分类数据”和”类别已知的样本”的距离（通常是欧氏距离）对样本进行分类。 这话说得有些绕口，且来分解一番： （1）分类问题都是监督（supervised）问题，也就是说一定数量的样本类别是已知的。 （2）既然我们已经有了一批分好类的样本，那么接下来的工作自然应该是通过已知样本训练分类器（通过调节分类器的
KNN算法讲解
LOVE_105的博客
01-14 436
KNN算法讲解定义算法详解代码实现 定义 kNN算法又称为k近邻分类(k-nearest neighbor classification)算法。 最简单平凡的分类器也许是那种死记硬背式的分类器，记住所有的训练数据，对于新的数据则直接和训练数据匹配，如果存在相同属性的训练数据，则直接用它的分类来作为新数据的分类。这种方式有一个明显的缺点，那就是很可能无法找到完全匹配的训练记录。 kNN算法是从训练集中找到和新数据最接近的k条记录，然后根据他们的主要分类来决定新数据的类别。该算法涉及3个主要因素：训练集、距离或
KNN算法详解，从0到1，入门到就职只需这一篇
weixin_52733693的博客
09-28 3572
什么是KNN算法，这篇文章含有KNN的全部知识，让你从KNN小白到大神只需要这一篇
knn.zip_knn_knn算法_实现KNN算法java
09-14
在本篇文章中，我们将深入探讨KNN算法的原理，并重点讲解如何用Java语言实现这一算法。 一、KNN算法简介 KNN算法的核心思想是“物以类聚，人以群分”，其工作流程如下： 1. 计算新样本与所有训练样本的距离。 2. ...
《机器学习》算法实例-KNN算法-海伦约会案例
11-24
【案例描述】 海伦使用约会网站寻找约会对象。经过一段时间之后，她发现曾交往过三种类型的人: 不喜欢的人 魅力一般的人 极具魅力的人 ...【注】本实例对于每步都有详细讲解，若有不理解部分，可私信解答。
KNN算法介绍
weixin_58512942的博客
07-08 8484
KNN（K- Nearest Neighbor）法即K最邻近法，最初由 Cover和Hart于1968年提出，是最简单的机器学习算法之一，属于有监督学习中的分类算法。算法思路简单直观：分类问题：如果一个样本在特征空间中的K个最相似（即特征空间中最邻近）的样本中的大多数属于某一个类别，则该样本也属于这个类别。...
KNN算法详解
qq_42847843的博客
08-17 228
一些自己的见解，记录下方便日后复习 # encoding:utf-8 from numpy import * import operator def createDataSet(): # 生成二维矩阵，每行表示一个样本 group = array([[1.0, 0.9], [1.0, 1.0], [0.1, 0.2], [0.0, 0.1]]) # 划分四个样本所属的类别...
机器学习实战：KNN算法讲解
疯是一种精神
09-05 2312
机器学习实战：KNN算法讲解     KNN算法本章内容来至于《统计学习与方法》李航,《机器学习》周志华,以及《机器学习实战》Peter HarringTon,相互学习,不足之处请大家多多指教     1.1 KNN算法的优缺点     1.2 KNN算法的工作机制     1.3 KNN算法的python实现     1.4 我对KNN算法的理解 1.1 KNN算法的优缺点    
【KNN算法详解（用法，优缺点，适用场景）及应用】
分享关于数据的知识。
04-01 1万+
KNN（K Near Neighbor）：k个最近的邻居，即每个样本都可以用它最接近的k个邻居来代表。KNN算法属于监督学习方式的分类算法，我的理解就是计算某给点到每个点的距离作为相似度的反馈。简单来讲，KNN就是“近朱者赤，近墨者黑”的一种分类算法。KNN是一种基于实例的学习，属于懒惰学习，即没有显式学习过程。要区分一下聚类（如Kmeans等），KNN是监督学习分类，而Kmeans是无监督学习的聚类，聚类将无标签的数据分成不同的簇。
【机器学习】KNN 算法介绍
weixin_44211968的博客
12-26 9882
本文介绍了机器学习模型：KNN 算法
机器学习（一）KNN算法介绍
weixin_45781143的博客
07-30 1524
KNN算法介绍 算法概述 KNN的全称是K-Nearest-Neighbors(最邻近规则分类)，是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是K个最近的邻居的意思，说的是每个样本都可以用它最接近的K个邻近值来代表。近邻算法就是将数据集合中每一个记录进行分类的方法。 如图假设图中绿色的点就要预测的那个点，假设K=3。那么KNN算法就会找到与它距离最近的三个点（这里用圆圈圈起），通过比较哪种类别多一些，来将预测的点归为周围最多的类别。（比如这个例子中是蓝色三角形多一些，新来的绿色点就归类到蓝三角
KNN算法（k近邻算法）原理及总结
最新发布
m0_74405427的博客
10-09 8万+
KNN 算法，或者称 k最邻近算法，是有监督学习中的分类算法。它可以用于分类或回归问题，但它通常用作分类算法。
KNN算法
niuxiaolei的博客
01-29 194
机器学习实战中的KNN算法问题 import numpy as np import operator def creatDataSet(): """ 创建数据集 :return: 数据集与标签 """ group = np.array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]]) labels = ['A','A'
KNN算法的简述
vendetta_gg的博客
06-07 4463
KNN算法的简述 1.什么是KNN算法。 KNN（K-Nearest Neighbor)是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻近值来代表。算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。 可以通俗的理解为“物以类聚人以群分和近朱者赤近墨者黑”。 2.KNN算法的原理 KNN的原理就是当预测一个新的样本x的时候，根据它距离最近的K个点是什么类别来
KNN算法具体分析及讲解
06-04
KNN算法是一种基于实例的学习方法，它的基本思想是：对于一个未知实例，通过与已知实例的距离来确定它属于哪个类别。KNN算法的核心是距离度量和K值的选择。 距离度量：KNN算法中常用的距离度量方法有欧式距离、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值