Knn算法学习

最新推荐文章于 2023-08-22 09:05:17 发布
最新推荐文章于 2023-08-22 09:05:17 发布
阅读量1.7k 收藏 6
点赞数
分类专栏： 机器学习 文章标签： 算法 数据挖掘 分类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g_zzh/article/details/121291863
版权

Knn 算法

邻近算法，或者说K最邻近（KNN，K-NearestNeighbor）分类算法是数据挖掘分类技术中最简单的方法之一。
所谓K最近邻，就是K个最近的邻居的意思，说的是每个样本都可以用它最接近的K个邻近值来代表。
近邻算法就是将数据集合中每一个记录进行分类的方法

  • 图解
    在这里插入图片描述

    》存在w1,w2,w3三种可能性结果
》Knn 算法。处理给定预测数据Xu，计算出该预测数据属于哪一类结果的可能性。

    
 方式1：
    1:计算[预测数据]到所有训练集数据的距离
    2:指定K值 取前K个距离最近的数据
    3:评估最近的K个 到各个预测结果的概率 。便可预测数据的类别
    4:调整K值 重复2,3步骤。以得到合适和K和预测的准确性的平衡
  import numpy as np
  from sklearn import datasets
  from sklearn.model_selection import train_test_split
  # 读取iris数据
  iris = datasets.load_iris()
  # 数据源处理
  # data 和 target 进行合并
  iris_data = np.hstack((iris.data, iris.target.reshape(-1, 1)))
  # 拆分数据为 训练集和测试集
  train, test = train_test_split(iris_data, test_size=0.2)
  # 指定K值
  K = 5
  def forecast_data(item):
      forecast = item[:-1]
      distance_arr = []
      for data in train:
          target = data[-1]
          current = data[:-1]
          # 计算预测数据到训练数据的距离
          distance = np.sqrt(np.sum((current - forecast) ** 2))
          distance_arr.append([distance, target])

      distance_arr.sort(key=lambda item: item[0], reverse=False)
      # 取得距离最近的前K个数据
      use_data = distance_arr[0:K]
      result = np.array([0, 0, 0])
      for index in range(K):
          if use_data[index][1] == 0.0:
              result[0] = result[0]+1
          elif use_data[index][1] == 1.0:
              result[1] = result[1]+1
          elif use_data[index][1] == 2.0:
              result[2] = result[2]+1
      # 得到预测结果
      result = np.stack((np.array([0, 1, 2]), result), axis=1).tolist()
      result.sort(
          key=lambda item: item[1], reverse=True)
      return result[0][0]
  # 
  if __name__ == '__main__':
      success, fail = 0, 0
      for item in test:
          exec = item[-1]
          forecast = forecast_data(item)
          if exec == forecast:
              success += 1
          else:
              fail += 1
  print('样本总数:', len(iris.data),'训练样本：'，len(train),'测试样本：',len(test))
  print('success:', success, 'fail:', fail,'预测成功概率:',success/(success+fail))

  # 样本总数: 150 训练样本： 120 测试样本： 30
  # success: 28 fail: 2 预测成功概率: 0.9333333333333333
  

    方式2( 算法不一致 这里对数据进行加权后 计算概率)
1:计算[预测数据]到所有训练集数据的距离
2:评估数据 对各个数据进行加权计算 越近的数据权重越高。
3:评估最近的K个 到各个预测结果的概率 。便可预测数据的类别

import numpy as np
from sklearn import datasets
from sklearn.model_selection import train_test_split

iris = datasets.load_iris()
# 数据源处理
# data 和 target 进行合并
iris_data = np.hstack((iris.data, iris.target.reshape(-1, 1)))
# 拆数据
train, test = train_test_split(iris_data, test_size=0.2)

# 权重计算 给定距离得到各个距离的权重
def weights(distances):
 # print(distances.shape)
	# 上面方式一 为 return np.ones(distances.shape) 就和方式一一样
	# 权重直接影响预测的准确性
	distance_max = np.sum(distances)
	result = np.zeros(distances.shape)
	for index in range(len(distances)):
    	result[index] = (distance_max - distances[index]
                     ) / distance_max

	return result


def forecast_data2(item, K=5):
	forecast = item[:-1]
	# print(train.shape,len(train))
	distance_arr = []
	for data in train:
    	target = data[-1]
    	current = data[:-1]
    	distance = np.sqrt(np.sum((current - forecast) ** 2))
    	distance_arr.append([distance, target])

 	distance_arr.sort(key=lambda item: item[0], reverse=False)
 	distance_list = distance_arr[0:K]
	# 计算权重
	distance_list, result_list = [
    np.ravel(item) for item in np.hsplit(np.array(distance_list), 2)]
	weights_arr = weights(distance_list)
	# 通过权重算出概率权重
	result = np.array([0.0, 0.0, 0.0])
	for index in range(K):
    	target = result_list[index]
   	 wei = weights_arr[index]
   	 print(target, wei)
   	 if target == 0.0:
   	     result[0] = result[0]+wei
   	 elif target == 1.0:
       	 result[1] = result[1]+wei
   	 elif target == 2.0:
      	  result[2] = result[2]+wei
	result = np.stack((np.array([0, 1, 2]), result), axis=1).tolist()
	result.sort(key=lambda item: item[1], reverse=True)
	return result[0][0]

if __name__ == '__main__':
	success, fail = 0, 0
	for item in test:
   	 	exec = item[-1]
    	# Knn 算法之二 加权算法
    	forecast = forecast_data2(item, K=5)
    	if exec == forecast:
       	 success += 1
    	else:
       	 fail += 1
print('样本总数:', len(iris.data), '训练样本：', len(train), '测试样本：', len(test))
print('success:', success, 'fail:', fail,
      '预测成功概率:', success/(success+fail))
# 样本总数: 150 训练样本： 120 测试样本： 30
# success: 29 fail: 1 预测成功概率: 0.9666666666666667


    方式3 使用现有KNN模型进行训练
	from sklearn.neighbors import KNeighborsClassifier
	# 使用 KNeighborsClassifier 对iris 数据进行Knn算法预测
	# n_neighbors: int, 可选参数(默认为 5)
	# weights（权重）: str or callable(自定义类型), 可选参数(默认为 ‘uniform’)
	#         用于预测的权重函数。可选参数如下:
	#                - ‘uniform’ : 统一的权重. 在每一个邻居区域里的点的权重都是一样的。
	#                - ‘distance’ : 权重点等于他们距离的倒数。使用此函数，更近的邻居对于所预测的点的影响更大。
	#                - [callable] : 一个用户自定义的方法，此方法接收一个距离的数组，然后返回一个相同形状并且包含权重的数组。
	# algorithm（算法）: {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, 可选参数（默认为 'auto'）
	#         计算最近邻居用的算法：
	#                - ‘ball_tree’ 使用算法[BallTree](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html#sklearn.neighbors.BallTree)
	#                - ‘kd_tree’ 使用算法[KDTree](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree)
	#                - ‘brute’ 使用暴力搜索.
	#                - ‘auto’ 会基于传入[fit](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.fit)方法的内容，选择最合适的算法。
	#         注意 : 如果传入fit方法的输入是稀疏的，将会重载参数设置，直接使用暴力搜索。
	#  leaf_size（叶子数量）: int, 可选参数(默认为 30)
	#         传入BallTree或者KDTree算法的叶子数量。此参数会影响构建、查询BallTree或者KDTree的速度，以及存储BallTree或者KDTree所需要的内存大小。 此可选参数根据是否是问题所需选择性使用。
	#  p: integer, 可选参数(默认为 2)
	#         用于Minkowski metric（[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)）的超参数。p = 1, 相当于使用[曼哈顿距离](https://zh.wikipedia.org/wiki/%E6%9B%BC%E5%93%88%E9%A0%93%E8%B7%9D%E9%9B%A2) (l1)，p = 2, 相当于使用[欧几里得距离](https://zh.wikipedia.org/wiki/%E6%AC%A7%E5%87%A0%E9%87%8C%E5%BE%97%E8%B7%9D%E7%A6%BB)(l2)  对于任何 p ，使用的是[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)(l_p)
	#  metric（矩阵）: string or callable, 默认为 ‘minkowski’
	#         用于树的距离矩阵。默认为[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)，如果和p=2一块使用相当于使用标准欧几里得矩阵. 所有可用的矩阵列表请查询 DistanceMetric 的文档。
	#  metric_params（矩阵参数）: dict, 可选参数(默认为 None)
	#         给矩阵方法使用的其他的关键词参数。
	#  n_jobs: int, 选参数(默认为 1)
	#         用于搜索邻居的，可并行运行的任务数量。如果为-1, 任务数量设置为CPU核的数量。不会影响[fit](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.fit)方法。

	from sklearn import datasets
	from sklearn.model_selection import train_test_split
	from sklearn.metrics import accuracy_score
	import numpy as np

	iris_data = datasets.load_iris()
	data_all = iris_data.data
	target_all = iris_data.target.reshape(-1, 1)
	data = np.hstack((data_all, target_all))
	# 数据拆分
	train, test = train_test_split(data, test_size=0.2)
	'''
	n_neighbors 对于值
	algorithm:指定算法
	weights 权重函数
	'''
	knn = KNeighborsClassifier(n_neighbors=3)
	train_X = train[:, :4]
	train_Y = train[:, -1]

	# 训练
	knn.fit(train_X, train_Y)

	# 预测
	test_X = test[:, :4]
	test_y = test[:, -1]
	predict_result = knn.predict(test_X)

	print('样本总数:', len(data_all), '训练样本：',len(train), '测试样本：', len(test))
	print('预测成功概率:', accuracy_score(test_y, predict_result))

	样本总数: 150 训练样本： 120 测试样本： 30
	预测成功概率: 0.9333333333333333
爱上无名氏
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习实战 - k近邻算法（KNN算法）总结
04-12
机器学习实战 - k近邻算法（KNN算法）总结 适合机器学习实战入门新手 K-近邻算法，又称为 KNN 算法，是数据挖掘技术中原理最简单的算法。 KNN 的工作原理：给定一个已知类别标签的数据训练集，输入没有标签的新数据后，在训练数据集中找到与新数据最临近的 K 个实例。如果这 K 个实例的多数属于某个类别，那么新数据就属于这个类别。 优点 1简单好用，容易理解，精度高，理论成熟，即可以用来做分类也可以用来做回归 2可用于数值型数据和离散型数据 3无数据输入假定 4适合对稀有事件进行分类 缺点 1计算复杂性高；空间复杂性高 2计算量太大，所以一般数值很大的时候不用这个，但是单个样本又不能太少，否则容易发生误分 3样本不平衡问题（即某些类别的样本数量很多，某些类别的样本数量很少） 4可理解性比较差，无法给出数据的内在含义
KNN算法——基本原理、分类、回归
ws19920726的博客
04-23 1万+
算法原理 KNN算法的核心思维：相似度较高的样本，映射到n维空间后，其距离回避相似度较低的样本在距离上更加接近。 KNN，即K近邻算法，K近邻就是K个最近的邻居，当需要预测一个未知样本的时候，就由与该样本最接近的K个邻居来决定。KNN既可以用于分类问题，也可以用于回归问题。当进行分类预测时，使用K个邻居中，类别数量最多（或加权最多）者，作为预测结果；当进行回归预测时，使用K个邻居的均值（或加权均值...
python:基于KNN算法的电影分类
04-26
使用python实现KNN原理，同时应用到电影分类过程中，训练集和测试集都来自李航的《统计学方法》中KNN那一章。
机器学习实战：一文详解K近邻算法，包括原理解析+实战案例
m0_59596937的博客
01-14 2179
原理：如果一个样本在特征空间中的k个最相似（即特征空间中最邻近）的样本中的大多数属于某一个类别，那么该样本也属于这个类别。简单来说就是，求两点之间的距离，看距离谁是最近的，以此来区分我们要预测的这个数据是属于哪个分类。我们看图来理解一下。蓝色点是属于a类型的样本点，粉色点是属于b类型的样本点。此时新来了一个点（黄色点），怎么判断是属于它是a类型还是b类型呢。方法是：新点找距离自身最近的k个点（k可变）。分别计算新点到其他各个点的距离，按距离从小到大排序，找出距离自身最近的k个点。
机器学习基础算法一：KNN算法回归实验
m0_46501404的博客
11-23 1015
KNN回归实验 一、基础知识 什么是回归： 回归实际上就是“最佳拟合”。根据已有的数据拟合出一条最佳的直线、曲线、超平面或函数等，用于预测其它数据的目标值。如已知一系列的点(x,y)，我们可能就可以拟合出一条最佳的直线y=kx+b。那么如果已知自变量x，要预测目标值y的话，就可以直接带入到该直线方程中求出y。回归的目的就是预测数值型的目标值 分类与回归的区别： 分类是判断对应类别，而回归的输出是一个具体值。 二、算法实现 前期数据处理：import numpy as np import pandas
k-nearest neighbor(kNN,k近邻算法)理论与实操及KNeighborsClassifier参数详解
zero33325的博客
08-22 7682
1. k-NN算法简介 k近邻法是基本且简单的分类与回归方法，利用数据集对特征向量空间进行划分，可以进行多分类。如下图： 三角形与矩形分别代表两类数据，标签已知。现要对新输入的为分类点(绿色)进行分类，k-NN的做法是寻找与该绿点相邻最近的k个点(k-NN算法的k的含义，图中的距离为欧式距离)，然后通过多数表决的方式把绿点划分到这k个最近点出现频数最高的类。例如如果k取3，则绿点最近的3个点中频数最高为三角形类，所以归为三角形类；若k取5，则距离绿点最近的5个点中频数最高为矩形类，所以归绿点为矩形类。 1.
机器学习算法笔记之K近邻算法（KNeighborsClassifier）
热门推荐
smallcases的博客
10-14 6万+
介绍： 在sklearn库中，KNeighborsClassifier是实现K近邻算法的一个类，一般都使用欧式距离进行测量。 这个类的结构如下： sklearn.neighbors.KNeighborsClassifier class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform
KNN算法说明以及sklearn 中 neighbors.KNeighborsClassifier参数说明
qq_34446614的博客
05-30 2万+
文章目录:rose:KNN:rose: sklearn 中 neighbors.KNeighborsClassifier参数说明 ????KNN 概念 k-近邻算法（k-Nearest Neighbour algorithm），又称为KNN算法，是数据挖掘技术中原理最简单的算法。KNN的工作原理：给定一个已知标签类别的训练数据集，输入没有标签的新数据后，在训练数据集中找到与新数据最邻近的k个实例，如果这k个实例的多数属于某个类别，那么新数据就属于这个类别。可以简单理解为：由那些离X最近的k个点来投票
Python实现KNN(K近邻)分类模型(KNeighborsClassifier算法)并应用网格搜索算法寻找最优参数值以及数据标准化均衡化项目实战
京斗码农的博客
11-20 3984
Python实现KNN(K近邻)分类模型(KNeighborsClassifier算法)并应用网格搜索算法寻找最优参数值以及数据标准化均衡化项目实战
【机器学习】分类算法 - KNN算法（K-近邻算法）KNeighborsClassifier
wangyuxiang946的博客
08-22 1万+
K-近邻算法的核心思想是根据「邻居」来「推断」你的类别。
卷积神经网络结合KNN算法学习实战源码+项目说明.zip
02-19
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...卷积神经网络结合KNN算法学习实战源码+项目说明.zip
机器学习之KNN算法
01-06
kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几个样本的类别来...
机器学习算法之KNN算法实现.zip
最新发布
04-20
机器学习算法 机器学习算法之KNN算法实现
机器学习-KNN算法实现
11-02
机器学习knn算法实现，工程使用pycharm建立，包括机器学习实战的代码和自己重写的部分代码，增加部分函数的使用方法介绍。
sklearn中KNN模型参数释义
weixin_42182448的博客
03-18 2万+
在scikit-learn 中，与近邻法这一大类相关的类库都在sklearn.neighbors包之中。KNN分类树的类是KNeighborsClassifier，KNN回归树的类KNeighborsRegressor。除此之外，还有KNN的扩展，即限定半径最近邻分类树的类RadiusNeighborsClassifier和限定半径最近邻回归树的类RadiusNeighborsRegressor，...
PCL点云滤波
chill_chill的博客
06-15 1359
pcl --- Module filtershttps://pointclouds.org/documentation/group__filters.html点云数据类型 sensor_msgs::LaserScan sensor_msgs::PointCloud2 pcl::PCLPointCloud2 是 ROS（机器人操作系统）消息类型，取代旧的 。因此，它只能在与 ROS 进行交互时使用。PCLPointCloud2 --- PointCloud转化 1.体素网格滤波pcl::
KNN算法——梅科尔工作室深度学习第三讲笔记
m0_52056424的博客
08-11 719
KNN（K-Nearest Neighbor）算法，意思是K个最近的邻居，从这个名字我们就能看 出一些KNN算法的蛛丝马迹了。K个最近邻居，毫无疑问，K的取值肯定是至关重要 的。那么最近的邻居又是怎么回事呢？
【机器学习原理】KNN分类算法
ZhShy
01-29 1万+
上一篇：Logistic回归分类算法 文章目录一、KNN分类算法：用多数表决进行分类1. 用“同类相吸”的办法解决分类问题可视化下的分类问题2. KNN分类算法的基本方法：多数表决3. 表决权问题4. KNN的具体含义KNN分类算法原理1. KNN分类算法的基本思路2. 数学解析3. KNN分类算法的具体步骤三、在Python中使用KNN分类算法四、KNN分类算法的使用场景 一、KNN分类算法：用多数表决进行分类 我们已经知道，Logistic回归模型虽然套着“马甲”，但核心算法仍然是线性模型，训练的方法与
KNeighborsClassifier(一):参数说明
On the road to profession
03-25 8817
KNeighborsClassifier又称K最近邻，是一种经典的模式识别分类方法。sklearn库中的该分类器有以下参数： from sklearn.neighbors import KNeighborsClassifier; model = KNeighborsClassifier( n_neighbors=5, weights=’uniform’, alg...
python knn算法 机器人学习
08-13
这些库提供了简单的API接口，使得机器人学习者能够轻松地使用KNN算法进行实验和开发。此外，Python还提供了大量的科学计算和数据处理库，可以方便地进行数据预处理和特征工程，以提高KNN算法的性能。 总而言之，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值