k邻近算法之 搜索kd树从 最邻近到 k邻近

最新推荐文章于 2024-02-22 18:10:30 发布
最新推荐文章于 2024-02-22 18:10:30 发布
阅读量2.6k 收藏 20
点赞数 4
文章标签： kd树 k邻近搜索 c 最邻近搜索
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32478489/article/details/82972391
版权

  • 写在前面

在一番摸索之下，博主利用国庆的时间，系统地了解k邻近算法。从第一次接触，到完整地用c++代码实现利用kd树来进行 k邻近搜索。弄清了很多细节，但也可能有很多不足之处，小伙伴们尽情板砖。

算法的主体都有详细的程序，只是将样本放在矩阵库（armadillo）中。当然小伙伴们用opencv库更好，博主也打算转用opencv库。

  • k邻近分类算法简述

首先我们有m个样本，每个样本有n个特征，而且每个样本有自己的分类标签。此时，给出一个测试样例，如何去判断该样例是属于什么分类呢。k邻近算法给我们提供了一个思路：找到距离测试样本最近的k个样本。这k个样本大多数属于哪个类别，那么该测试样例属于这个类别的可能性就比较大。这里的距离就使用欧式距离（平方开根号）。

那么如何去找到这k个样本呢？首先想到的办法就是把m个样本全部算一遍距离。这个方案在样本m数据量很大时，会比较耗时。现在有一种方案，就是使用kd树去寻找这k个样本。其精髓与二分查找类似。

  • kd树的建立

kd树的结构与二叉树类似

简述步骤：

  1. 我们有个样本矩阵m行，n列。m是指有m个样本，n指有n维特征。那么首先找到第一个特征的中间值所在的样本（即找到矩阵第一列的中间值所在的行）。
  2. 将这个样本作为根节点。然后将剩余的样本分成两部分，第一部分中样本的第一个特征值都小于根节点的第一个特征值。第二部分中样本的第一个特征值都大于根节点的第一个特征值。
  3. 然后我们同样对这两个矩阵进行分割。此时我们用第二列特征值，同样找到中间值。以此不断分割，直到所有的样本都在kd树的节点上。

我们发现步骤2与步骤三可以用相同的函数实现，这不是勾引我们用递归吗。。当然这与二叉树不是类似吗。

具体实现：直接上代码，代码中用了armadillo矩阵库（只是辅助用，不包含算法），和大多数矩阵用法类似，具体可以参考

http://arma.sourceforge.net/docs.html

 

//kd树节点结构体
struct kdTreeNode{
	mat data;				//节点数据向量 1*n  n为特征数
	kdTreeNode * leftP;		//左子树指针
	kdTreeNode * rightP;	//右子树指针
	kdTreeNode * fatherP;	//父亲节点指针，竟然没用到
	int splitIndex;			//当前节点分割数据的特征索引，目前是轮换特征
	kdTreeNode(){leftP = NULL;rightP = NULL;fatherP = NULL;splitIndex = 0;}//构造函数
};
//使用递归建立kd树
/*
	nodeP 结构体指针
	data  输入数据矩阵，m*n m为样本数 n为特征数
	depth 节点深度
*/
void buildKdTree(kdTreeNode *& nodeP,mat data,int depth)
{
	//如果输入的数据矩阵为空，则返回
	if(data.n_rows == 0)
	{
		return;
	}
	//如果只有一个样本，则直接将数据给节点
	if(data.n_rows == 1)
	{
		nodeP->data = data.row(0);
		return;
	}
	//此时样本数大于等于2
	int splitFeatureIndex = depth % data.n_cols;	//计算分割数据的特征索引
	nodeP->splitIndex = splitFeatureIndex;		
	vec splitFeature = data.col(splitFeatureIndex);	//取得特征列向量
	vec splitOrder = sort(splitFeature);			//排序
	double medianValue = splitOrder[data.n_rows/2]; //取中值
	mat subsetLeft,subsetRight;						//左右矩阵
	//接下来是将样本矩阵分为左右两个矩阵
	for(int i=0;i<data.n_rows;i++)
	{
		if(nodeP->data.empty()&&splitFeature[i] == medianValue)
		{
			//将中间样本给节点
			nodeP->data = data.row(i);
		}else{
			if(splitFeature[i] < medianValue)
			{
				subsetLeft = join_vert( subsetLeft,data.row(i));
			}else{
				subsetRight = join_vert( subsetRight,data.row(i));
			}
		}
	}	
	nodeP->leftP = new kdTreeNode;
	nodeP->leftP->fatherP = nodeP;
	nodeP->rightP = new kdTreeNode;
	nodeP->rightP->fatherP = nodeP;
	//递归进入左右子树
	buildKdTree(nodeP->leftP,subsetLeft,depth+1);
	buildKdTree(nodeP->rightP,subsetRight,depth+1);
}

建立完之后，我们可以写个遍历程序验证下

//中序遍历
void inorder_traverse(kdTreeNode * nodeP)
{
	if(nodeP == NULL || nodeP->data.empty())
	{
		return;
	}		
	inorder_traverse(nodeP->leftP);
	cout<<nodeP->data<<endl;
	inorder_traverse(nodeP->rightP);
}
//前序遍历
void preorder_traverse(kdTreeNode * nodeP)
{
	if(nodeP == NULL || nodeP->data.empty())
	{
		return;
	}	
	cout<<nodeP->splitIndex<<" "<<nodeP->data<<endl;
	preorder_traverse(nodeP->leftP);	
	preorder_traverse(nodeP->rightP);
}

  • 最邻近搜索

现有一个测试目标，为1*n的矩阵，n为特征数，现在就在样本矩阵找到与这个目标距离最近的样本。

搜索就不用迭代了，这样也好理解

具体步骤：

  • 第一步：利用二叉搜索到子节点并将，节点指针顺序压入堆栈stack中

使用测试样本的第一个特征值，与根节点比较，若特征值小于或等于根节点的第一个特征值，则下一步在左子树搜索，反之则在右子树。如此循环直至找到叶子节点。并且在这个过程中，不断将得到的节点压入堆栈中，这就形成我们的初步搜索路径，按照堆栈先进后出的原则，堆栈最顶端的元素将是叶子节点。

  • 第二步：通过保存在堆栈中的搜索路径回溯

首先计算出最后的叶子结点与目标的距离保存为最短距离minDIstance，并将它设置成最邻近样本

（1）从堆栈中取出一个节点

（2）若是叶子结点，则只有一个步骤

                      1.计算与目标的距离，若小于保存的minDistance，则将mindistance替换为当前计算的距离，并将当前样本设置为最邻近样本。若大于则跳过。

         若不是叶子节点，则有三个步骤

                       1.此步骤与叶子结点的那个步骤相同

                      2.计算目标与当前节点划分的超平面的距离（这个可以这么理解：假如在二维直角坐标系中计算某个点与x轴或与x轴平行的一条线的距离，怎么算，这个很显然吧~，同样的，与超平面的距离你应该知道怎么算了）

                     3.假如目标到超平面的距离大于记录的minDistance。则不执行任何操作，等着下一次回溯。反之若小于minDistance,则说明在当前节点的另一个子树中可能有更近的点。这样，我们找到另一个子树的节点，将它压入到堆栈中（即加入到搜索路径中）并且按照 第一步 的方法，一边往下二叉搜索，一边将遇到的节点压入堆栈中。然后就等着下一次回溯（即从堆栈中取节点）

（3）不断循环步骤（2）直到堆栈中的数据都取出，即搜索路径都走了一遍。

代码到贴k邻近再贴吧

  • k 邻近搜索

网上一直没找到关于k邻近的算法步骤，我自己在最邻近的基础上修改了下，发现可行，不知与官方的算法是否有差距。

其中主体算法步骤与最邻近相似。

就说明一下不同之处：

第一点不同：相较于最邻近只需找一个样本，k邻近算法中，我们定义有个结构体数组来记录k个样本

第二点不同：我们不管他是不是真的最近的k个样本先找到k个再说。所以在收集到k个样本之前，无视最邻近算法中是否小于minDistance这个条件，统统收集到数组中，直到找满k个样本。

第三点不同：找到k个样本之后，立刻找出k个样本中的最大距离的样本，此距离记为maxD，因为他最不靠谱。。恢复最邻近算法中的条件，找到一个比maxD距离更小的样本，就可以将它替换。此时重新计算最maxD。直到堆栈为空。

  • 最后

把所有代码都贴上吧。所有代码都在一个文件中。想要运行需要加矩阵库armadillo。x64

如果需要工程文件的，我也上传了。里面包含了矩阵库的lib，dll，头文件，可以直接运行，不需要配置。用的是vs2012 x64

https://download.csdn.net/download/qq_32478489/10707377

#include <iostream>
#include <time.h>
#include <armadillo>
#include <stack>
using namespace std;
using namespace arma;
//kd树节点结构体
struct kdTreeNode{
	mat data;				//节点数据向量 1*n  n为特征数
	kdTreeNode * leftP;		//左子树指针
	kdTreeNode * rightP;	//右子树指针
	kdTreeNode * fatherP;	//父亲节点指针，竟然没用到
	int splitIndex;			//当前节点分割数据的特征索引，目前是轮换特征
	kdTreeNode(){leftP = NULL;rightP = NULL;fatherP = NULL;splitIndex = 0;}//构造函数
};
//使用递归建立kd树
/*
	nodeP 结构体指针
	data  输入数据矩阵，m*n m为样本数 n为特征数
	depth 节点深度
*/
void buildKdTree(kdTreeNode *& nodeP,mat data,int depth)
{
	//如果输入的数据矩阵为空，则返回
	if(data.n_rows == 0)
	{
		return;
	}
	//如果只有一个样本，则直接将数据给节点
	if(data.n_rows == 1)
	{
		nodeP->data = data.row(0);
		return;
	}
	//此时样本数大于等于2
	int splitFeatureIndex = depth % data.n_cols;	//计算分割数据的特征索引
	nodeP->splitIndex = splitFeatureIndex;		
	vec splitFeature = data.col(splitFeatureIndex);	//取得特征列向量
	vec splitOrder = sort(splitFeature);			//排序
	double medianValue = splitOrder[data.n_rows/2]; //取中值
	mat subsetLeft,subsetRight;						//左右矩阵
	//接下来是将样本矩阵分为左右两个矩阵
	for(int i=0;i<data.n_rows;i++)
	{
		if(nodeP->data.empty()&&splitFeature[i] == medianValue)
		{
			//将中间样本给节点
			nodeP->data = data.row(i);
		}else{
			if(splitFeature[i] < medianValue)
			{
				subsetLeft = join_vert( subsetLeft,data.row(i));
			}else{
				subsetRight = join_vert( subsetRight,data.row(i));
			}
		}
	}	
	nodeP->leftP = new kdTreeNode;
	nodeP->leftP->fatherP = nodeP;
	nodeP->rightP = new kdTreeNode;
	nodeP->rightP->fatherP = nodeP;
	//递归进入左右子树
	buildKdTree(nodeP->leftP,subsetLeft,depth+1);
	buildKdTree(nodeP->rightP,subsetRight,depth+1);
}
//中序遍历
void inorder_traverse(kdTreeNode * nodeP)
{
	if(nodeP == NULL || nodeP->data.empty())
	{
		return;
	}		
	inorder_traverse(nodeP->leftP);
	cout<<nodeP->data<<endl;
	inorder_traverse(nodeP->rightP);
}
//前序遍历
void preorder_traverse(kdTreeNode * nodeP)
{
	if(nodeP == NULL || nodeP->data.empty())
	{
		return;
	}	
	cout<<nodeP->splitIndex<<" "<<nodeP->data<<endl;
	preorder_traverse(nodeP->leftP);	
	preorder_traverse(nodeP->rightP);
}
//计算欧氏距离
double EuclidianDis(mat & a,mat & b)
{
	vec v1 = a.row(0).t();
	vec v2 = b.row(0).t();	
	vec c = v1-v2;
	return norm(c,2);
}
struct KNN{
	kdTreeNode * nodeP;
	double distance;
	KNN(){nodeP = NULL;distance = -1;}
};

int isSearched(mat data,mat check)
{
	vec d;
	vec c = check.row(0).t();
	for(int i=0;i<data.n_rows;i++)
	{
		d = data.row(i).t();
		if(all(d==c))
		{
			return 1;
		}
	}
	return 0;
}
void findMaxInNearGroup(KNN *& NearGroup,int K,int & maxInNG)
{
	double maxDis=NearGroup[0].distance;
	int maxN=0;
	for(int i=1;i<K;i++)
	{
		if(maxDis<NearGroup[i].distance)
		{
			maxDis = NearGroup[i].distance;
			maxN = i;
		}
	}
	maxInNG = maxN;
}
//利用kd树搜索k邻近节点
void findNearestK(kdTreeNode * RootNodeP,mat & target,KNN *& NearGroup,int & K)
{
	//如果指针为空，则返回
	if(RootNodeP == NULL) return;
	if(K==0)
	{
	    return;
	}
	/*if(K > RootNodeP.n_rows) 
	{
		K = target.n_rows;
	}	*/
	int KgetN = 0;
	//第一步：利用二叉搜索到子节点并将，节点指针顺序压入堆栈stack中
	kdTreeNode * nodeP = RootNodeP;
	stack <kdTreeNode *> search_path;
	int maxInNGIndex = 0;
	while(nodeP !=NULL && !nodeP->data.empty())//判断遇到空节点，或者节点内无数据，则结束
	{
		search_path.push(nodeP);
		if(target(0,nodeP->splitIndex) <= nodeP->data(0,nodeP->splitIndex))
		{
			nodeP = nodeP->leftP;
		}else{
			nodeP = nodeP->rightP;
		}
	}
	kdTreeNode * firstNodeP = search_path.top();
	NearGroup[0].nodeP= search_path.top();					//将得到的叶子结点记入下来
	NearGroup[0].distance = EuclidianDis(target,NearGroup[0].nodeP->data);	//并计算距离
	KgetN = 1;													//	
	//第二步：然后通过堆栈回溯

	kdTreeNode * back_nodeP;
	while(search_path.empty() == 0)				//直到堆栈为空，即已经回溯完为止
	{
		back_nodeP = search_path.top();
		search_path.pop();
		//若当前回溯节点为叶子节点，只计算与target距离即可。
		//如果距离小于当前记录的最小距离，则更新最小值，否则跳过即可
		if((back_nodeP->leftP == NULL|| back_nodeP->leftP->data.empty())
			&&(back_nodeP->rightP == NULL||back_nodeP->rightP->data.empty()))
		{
			if(back_nodeP != firstNodeP)
			{
				if((KgetN<K)||(EuclidianDis(back_nodeP->data,target)<NearGroup[maxInNGIndex].distance))
				{							
					if(KgetN<K)
					{
						NearGroup[KgetN].nodeP = back_nodeP;
						NearGroup[KgetN].distance = EuclidianDis(back_nodeP->data,target);
						KgetN++;
						if(KgetN==K)
						{
							findMaxInNearGroup(NearGroup,KgetN,maxInNGIndex);
						}
					}else{
						NearGroup[maxInNGIndex].nodeP = back_nodeP;
						NearGroup[maxInNGIndex].distance = 	EuclidianDis(back_nodeP->data,target);
						findMaxInNearGroup(NearGroup,KgetN,maxInNGIndex);
					}
				}
			}			
		}else{
			//若当前回溯点带有子树，不仅需要计算距离，并更新
			//而且需要计算目标到超平面的距离，即特征值相减即可
			if((KgetN<K)||(EuclidianDis(back_nodeP->data,target)<NearGroup[maxInNGIndex].distance))
			{							
				if(KgetN<K)
				{
					NearGroup[KgetN].nodeP = back_nodeP;
					NearGroup[KgetN].distance = EuclidianDis(back_nodeP->data,target);
					KgetN++;
					if(KgetN==K)
					{
						findMaxInNearGroup(NearGroup,KgetN,maxInNGIndex);
					}
				}else{
					NearGroup[maxInNGIndex].nodeP = back_nodeP;
					NearGroup[maxInNGIndex].distance = 	EuclidianDis(back_nodeP->data,target);
					findMaxInNearGroup(NearGroup,KgetN,maxInNGIndex);
				}
			}
			//计算到超品面距离，如果距离小于当前记录的最小距离
			//则需要进入另一个子树，并像第一步一般，不断二叉搜索，并将搜索路径压入堆栈
			if((KgetN<K)||(abs(target(0,back_nodeP->splitIndex)-back_nodeP->data(0,back_nodeP->splitIndex))<NearGroup[maxInNGIndex].distance))
			{
				kdTreeNode * childNodeP;
				if(target(0,back_nodeP->splitIndex) > back_nodeP->data(0,back_nodeP->splitIndex))
				{
					childNodeP = back_nodeP->leftP;
				}else
				{
					childNodeP = back_nodeP->rightP;
				}				
				while(childNodeP !=NULL && !childNodeP->data.empty())
				{
				    search_path.push(childNodeP);
					if(target(0,childNodeP->splitIndex) <= childNodeP->data(0,childNodeP->splitIndex))
					{
						childNodeP = childNodeP->leftP;
					}else{
						childNodeP = childNodeP->rightP;
					}
				}
			}
		}
	}
}
//线性扫描的方法得到最邻近值，用以验证算法
void scanDis(mat & data,mat & target,mat & nearest,double & distance)
{
	mat a = data.row(0);
	mat b = target;
	mat near = data.row(0);
	double minDis=EuclidianDis(a,b);
	for(int i=1;i<data.n_rows;i++)
	{
		a = data.row(i);
		b = target;
		double dis = EuclidianDis(a,b);
		if(dis<minDis)
		{
			minDis = dis;
			near = data.row(i);			
		}
	}
	distance = minDis;
	nearest = near;
}
void main(void)
{
	mat dataTrain,target,nearest,nearest1,searched;
	int nK = 5;
	KNN * nearstK = new KNN[nK];
	double minDistance,minDistance1;
	dataTrain<<2<<3<<endr
			<<5<<4<<endr
			<<9<<6<<endr
			<<4<<7<<endr
			<<8<<1<<endr
			<<7<<2<<endr;
	target<<2<<4.5<<endr;
	/*dataTrain = randu<mat>(50000,5)*100;
	target = randu<mat>(1,5)*100;*/
	
	kdTreeNode * rootP = new kdTreeNode;
	buildKdTree(rootP,dataTrain,0);
//	inorder_traverse(rootP);

	cout<<"target "<<endl<<target<<endl;

    clock_t arithmeticStart = clock();	
	findNearestK(rootP,target,nearstK,nK);
	clock_t arithmeticEnd = clock();
	cout<<"KD Tree result"<<endl;
	for(int i=0;i<nK;i++)
	{
		cout<<nearstK[i].nodeP->data<<endl;
		cout<<nearstK[i].distance<<endl;
	}
	double runTime = (double)(arithmeticEnd - arithmeticStart)/1000;
	cout<<"KD Tree Running Time : "<<runTime<<" s"<<endl;	

	arithmeticStart = clock();	
	scanDis(dataTrain,target,nearest1,minDistance1);
	arithmeticEnd = clock();
	cout<<"Scan result"<<endl<<nearest1<<minDistance1<<endl;
	runTime = (double)(arithmeticEnd - arithmeticStart)/1000;
	cout<<"Scan Running Time : "<<runTime<<" s"<<endl;
	
	cout<<"press any key to terminate.";
	getchar();
}

 

荒草浸风
关注
  • 4
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
KD tree算法（2）－最近邻搜索KD tree
约瑟夫的杂货店
07-07 1622
书接上文，我们这一张来讨论KD Tree的最近邻搜索。首先来看一下《统计学习方法》书中给出的算法描述： 我们用网上很常见的例子进行分析： （7，2），（5，4），（9，6），（2，3），（4，7），（8，1） 待测节点：（2，4.5） 我们先不管在坐标上是怎么划分的，先看看在KD Tree上是如何遍历的。 我们先来进行分析： （1）在kd树中找出包含目标点x的叶节点。 这一步比较简
使用kd树进行k邻近搜索，c++实现
10-08
程序可以直接运行，有代码注释，vs2012 x64环境，使用armadillo矩阵库，已将矩阵库的dll，lib，头文件放在工程中，无需配置。 具体可以看以下博客https://blog.csdn.net/qq_32478489/article/details/82972391
KD树
qq_41745284的博客
03-07 9624
问题导入： k近邻法最简单的实现是线性扫描（穷举搜索），即要计算输入实例与每一个训练实例的距离。计算并存储好以后，再查找K近邻。当训练集很大时，计算非常耗时。 为了提高kNN搜索的效率，可以考虑使用特殊的结构存储训练数据，以减小计算距离的次数。这里介绍的就是KD树 简介： 为了避免每次都重新计算一遍距离，算法会把距离信息保存在一棵树里，这样在计算之前从树里查询距离信息，尽量避免重新计算。其基本原理是，如果A和B距离很远，B和C距离很近，那么A和C的距离也很远。有了这个信息，就可以在合适的时候跳过距离远的点。
C++实现K最邻近算法(机器学习 KNN KD树)
08-17
C++实现K最邻近算法, 使用KD树来实现, 在面对大量数据时可以提高搜索效率. 代码干净, 整洁, 有注释, 可直接使用.
【k近邻】Kd树构造与最近邻搜索示例
Frost_Descent的博客
02-22 447
(4)如此递归，最后得到如上图所示的特征空间划分和如下图所示的。的区域与圆不相交，不可能有最近邻点，故继续返回上一级父结点。树可以省去对大部分数据点的搜索，从而减少搜索的计算量。将空间分为左、右两个子矩形(子结点);该区域在圆内的实例点有点。维空间中的数据进行快速检索的数据结构。维空间划分中的一个超矩形区域,利用。,使用kd树的最近邻搜索算法可以求得。维空间的一个划分，其每个结点对应于。例: 给定一个二维空间的数据集,(图中的右下区域), 以点。更近，成为新的最近邻近似;的区域内搜索最近邻，结点。
KdTreeInPCL-master_kdtree_点云搜索邻近点代码_kdtree算法实现邻近点的搜索_
09-29
基于kdtree 的点云邻近点的匹配与搜索。点的深度搜索。
Elasticsearch：探索 k-nearest neighbor (kNN) 搜索
Elastic 中国社区官方博客
03-29 1955
由于新一代机器学习模型可以将各种内容表示为向量，包括文本、图像、事件等，人们对向量搜索的兴趣激增。通常称为 “嵌入模型（embedding models）”，这些强大的表示可以以超越其表面特征的方式捕获两段内容之间的相似性。k 最近邻 (kNN) 搜索算法在数据集中查找与查询向量最相似的向量。向量搜索有望成为搜索工具箱的重要组成部分，与基于术语的评分等传统技术并驾齐驱。
机器学习 K近邻之KD树 搜索KD树
qq_52045638的博客
12-23 705
机器学习 K近邻之KD树 搜索KD树
kd树的最邻近搜索
随笔
10-26 1546
1. 在k-d树中进行数据的查找也是特征匹配的重要环节，其目的是检索在k-d树中与查询点距离最近的数据点。这里先以一个简单的实例来描述最邻近查找的基本思路。 星号表示要查询的点（2.1,3.1）。通过二叉搜索，顺着搜索路径很快就能找到最邻近的近似点，也就是叶子节点（2,3）。而找到的叶子节点并不一定就是最邻近的，最邻近肯定距离查询点更近，应该位于以查询点为圆心且通过叶子节点的圆域内。为了找到真正的...
【机器学习（二）】K近邻算法：原理、kd树构造和查找、案例分析、代码（机器学习库、自己实现）
qq_39709813的博客
06-11 1151
k近邻算法是一种分类和回归的算法，可以简单认为： 输入：训练的特征向量和标签训练（类） 输出：任意给一个输入，得到这个输入的标签（类） 因此k近邻有三要素：距离度量、k值选择和分类决策。 原理：三要素确定好后，输入一个特征向量，寻找x最近的k个训练特征向量，观察最近的k个特征向量的标签（类），然后选择标签最多的那个标签作为x的标签，输出结果。 三要素一：距离度量 常用的距离度量方式就是欧式距离，但也包含其他距离度量方式，根据最近的k的距离，就可以选择最近的k训练特征向量。 输入特征向量： 距
机器学习——K-临近算法（KNN）
m0_72115396的博客
10-09 412
K临近算法（K-Nearest Neighbor algorithm，简称KNN）是一种常用的分类与回归算法。在分类问题中，KNN根据预先确定的K值，在训练数据集中找到与待分类样本最相似的K个样本，并根据它们的分类标签来确定待分类样本的类别。在回归问题中，KNN则根据预先确定的K值，在训练数据集中找到与待预测样本最相似的K个样本，并根据它们的数值来预测待预测样本的值。KNN主要依据样本之间的距离度量进行分类或回归，并假设离待分类或待预测样本更近的样本具有更高的相似度。
点云 K 临近查找算法：kd 树
大家好~我是SP_FA~
07-09 301
kd 树是一个二叉树，用于高效的查找某个点的 k 临近点，它的每一个节点记载了 特征坐标，切分轴，指向左右子树的指针。
用kd树实现范围搜索
03-28
详细介绍了用kd树进行范围搜索的基本概念和算法。
C#实现KD树建立，K近邻点搜索
02-28
C#实现KD树建立，K近邻点搜索（采用BBF进行了K近邻搜索优化)
kd-tree-rcpp:使用Rcpp编写的KD树实现最邻近算法
03-26
KD树CPP 该程序包使用Rcpp程序包来实现最近邻居算法。
KD树KNN算法源码
06-14
N，再输入一个数字K，程序将会返回距离点N最近的K个点。当 然，在这之间，您首先得从文件中读取坐标点集! Good Luck! 编译环境VC++6.0 有演示程序，有源码～～ 比如：用此算法查找从10万个点当中距离A点最近的2个...
基于Springboot+Vue的墙绘产品展示交易平台毕业源码案例设计.zip
最新发布
04-27
网络技术和计算机技术发展至今，已经拥有了深厚的理论基础，并在现实中进行了充分运用，尤其是基于计算机运行的软件更是受到各界的关注。加上现在人们已经步入信息时代，所以对于信息的宣传和管理就很关键。系统化是必要的，设计网上系统不仅会节约人力和管理成本，还会安全保存庞大的数据量，对于信息的维护和检索也不需要花费很多时间，非常的便利。 网上系统是在MySQL中建立数据表保存信息，运用SpringBoot框架和Java语言编写。并按照软件设计开发流程进行设计实现。系统具备友好性且功能完善。 网上系统在让售信息规范化的同时，也能及时通过数据输入的有效性规则检测出错误数据，让数据的录入达到准确性的目的，进而提升数据的可靠性，让系统数据的错误率降至最低。 关键词：vue；MySQL；SpringBoot框架 【引流】 Java、Python、Node.js、Spring Boot、Django、Express、MySQL、PostgreSQL、MongoDB、React、Angular、Vue、Bootstrap、Material-UI、Redis、Docker、Kubernetes
99-青海大学大数据中心建设分享.pptx
04-27
99-青海大学大数据中心建设分享.pptx
TD-LTE载波聚合方案.docx
04-27
5G通信行业、网络优化、通信工程建设资料。
kdtree最邻近搜索匹配点云
05-24
Kd树是一种用于空间划分和快速最近邻搜索的数据结构。对于点云匹配，可以使用Kd树来找到目标点云中每个点的最邻近点，从而实现两个点云的匹配。 具体实现步骤如下： 1. 建立目标点云的Kd树。 2. 对于源点云中的每个点，找到其在目标点云中的最邻近点。这可以通过在Kd树中进行最邻近搜索来实现。 3. 根据最邻近点的距离和几何特征进行筛选，保留合适的匹配点对。 4. 使用匹配点对进行点云配准。 需要注意的是，Kd树的建立和最邻近搜索是计算密集型的操作，因此在处理大型点云时可能需要考虑优化算法实现或使用并行计算技术来提高效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值