Knn算法学习

最新推荐文章于 2024-07-02 18:16:19 发布
最新推荐文章于 2024-07-02 18:16:19 发布
阅读量1.8k 收藏 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
爱上无名氏
关注
专栏目录
KNN算法学习总结
huangzhijie29的博客
08-26 1174
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码
机器学习入门 —— 超级详细的KNN算法学习笔记、KNN算法的三要素、KNN算法的优缺点
2401_84424257的博客
04-19 882
K近邻 (k-Nearest Neighbors， KNN) 算法是一种分类与回归算法，是机器学习算法中最基础、最简单的算法之一， 1968年由 Cover和 Hart 提出， 应用场景有。
KNeighborsClassifier
02-21
KNeighborsClassifier
【kneighborsclassifier 函数及其参数介绍】
最新发布
武帝为此的博客
07-02 1063
库中 K-近邻算法的实现，用于分类任务。KNN 算法的基本思想是给定一个样本数据集，对于每个输入的新数据点，找到其在样本数据集中最近的 K 个数据点，根据这 K 个邻居的类别来预测新数据点的类别。
KNeighborsClassifier(一):参数说明
On the road to profession
03-25 8950
KNeighborsClassifier又称K最近邻，是一种经典的模式识别分类方法。sklearn库中的该分类器有以下参数： from sklearn.neighbors import KNeighborsClassifier; model = KNeighborsClassifier( n_neighbors=5, weights=’uniform’, alg...
neighbors.KNeighborsClassifier metric_params 参数设置
Data Time
10-17 3362
metric参数 在 sklearn 的文档中可以看到KNeighborsClassifier 类中的 metric 是用于设置距离矩阵的计算方式，然而并没有写清楚具体的有哪几种。具体支持的计算方式有如下几种，详见https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.DistanceMetric.html： ...
【KNN】sklearn.neighbors.KNeighborsClassifier的参数说明
小苏打的学习博客
06-22 1万+
class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform’, algorithm=’auto’, leaf_size=30,p=2, metric=’minkowski’, metric_params=None, n_jobs=1, **kwargs)
卷积神经网络结合KNN算法学习实战源码+项目说明.zip
02-19
【资源说明】 1、该资源包括项目的全部源码，下载可以直接使用！ 2、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...卷积神经网络结合KNN算法学习实战源码+项目说明.zip
机器学习实战 - k近邻算法（KNN算法）总结
04-12
机器学习实战 - k近邻算法（KNN算法）总结 适合机器学习实战入门新手 K-近邻算法，又称为 KNN 算法，是数据挖掘技术中原理最简单的算法。 KNN 的工作原理：给定一个已知类别标签的数据训练集，输入没有标签的新数据...
knn算法学习
qq_21154829的博客
03-13 98
k近邻近邻算法： 多数表决规则等价于经验风险最小化： 损失函数最小化：一训练数据为基础，通过此类分类规则计算得到 一块区域，有k个训练数据，1,2,3个类别。1>2>3 当此区域判为1，损失函数等于2,3个数和 当此区域判为2，损失函数等于1,3个数和 当此区域判为3，损失函数为1,2个数和 选取损失函数最小的，即个数最多的类别。作为此区域类别。所以此区域判别为1. Kd树： 第一步：找到包含点S的叶结点D，以点D作为"近似最近邻"。 从根结点出发，递归向下访问kd树。若目标点S当前维的坐标小于
k-nearest neighbor(kNN,k近邻算法)理论与实操及KNeighborsClassifier参数详解
zero33325的博客
08-22 1万+
1. k-NN算法简介 k近邻法是基本且简单的分类与回归方法，利用数据集对特征向量空间进行划分，可以进行多分类。如下图： 三角形与矩形分别代表两类数据，标签已知。现要对新输入的为分类点(绿色)进行分类，k-NN的做法是寻找与该绿点相邻最近的k个点(k-NN算法的k的含义，图中的距离为欧式距离)，然后通过多数表决的方式把绿点划分到这k个最近点出现频数最高的类。例如如果k取3，则绿点最近的3个点中频数最高为三角形类，所以归为三角形类；若k取5，则距离绿点最近的5个点中频数最高为矩形类，所以归绿点为矩形类。 1.
【机器学习】分类算法 - KNN算法（K-近邻算法）KNeighborsClassifier
wangyuxiang946的博客
08-22 1万+
K-近邻算法的核心思想是根据「邻居」来「推断」你的类别。
KNeighborsClassifier()
少年一贯快马扬帆，道阻且长不转弯； 要盛大，要绚烂，要哗然； 要用理想的泰坦尼克，去撞现实的冰川； 要当烧赤壁的风，而非借鉴草船； 要为了一片海，就肯翻万山。
05-04 1358
Init signature: KNeighborsClassifier( n_neighbors=5, *, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=None, **kwargs, ) Docstring: Classifier implementin.
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个点来投票
sklearn K近邻KNeighborsClassifier参数详解
On the road to profession
03-23 1万+
【原文网址】https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html classsklearn.neighbors.KNeighborsClassifier(n_neighbors=5,weights=’uniform’,algorithm=’auto’,le...
KNN算法学习
qq_62613497的博客
08-15 361
KNN的原理就是当预测一个新的 值x的时候，根据它距离最近的K个点是什么类别来判断x属于哪个类别。先对数据进行处理、分割，再定义运行需要用到的方法，最后引用数据、方法算出结果，并计算准确率。...
KNN算法详解PPT及其代码.rar
12-04
这个压缩包“KNN算法详解PPT及其代码.rar”包含了一个PPT演示文稿和相关代码，为初学者提供了一个易懂的KNN算法学习资源，同时也适合那些准备面试或希望巩固基础知识的人。 PPT部分很可能会涵盖以下知识点： 1. **...
kneighborsclassifier 参数_用于参数调整的K-Fold交叉验证
weixin_39657125的博客
11-24 1270
在本文中，我将解释主要用于超参数调优的K- fold 交叉验证。交叉验证是一种评估预测机器学习模型的技术，它将原始样本分为训练模型的训练集和评估模型的测试集。我将逐步解释k折交叉验证。将数据集拆分为k个相等的分区使用第一个fold为测试数据，将其他folds的并集作为训练数据，并计算测试精度重复步骤1和步骤2。如果我们把数据集分成k个folds。在第一次迭代中，第一个fold将是测试数据，其余的并...
K-近邻算法（knn算法）API参数介绍
weixin_46483785的博客
08-05 588
方法是sklearn库中K近邻算法的分类器实现，它有一些可调参数用于调整模型的行为。
机器学习算法笔记之K近邻算法（KNeighborsClassifier）
热门推荐
smallcases的博客
10-14 6万+
介绍： 在sklearn库中，KNeighborsClassifier是实现K近邻算法的一个类，一般都使用欧式距离进行测量。 这个类的结构如下： sklearn.neighbors.KNeighborsClassifier class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, weights=’uniform
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值