机器学习实战：K-近邻算法（一）

最新推荐文章于 2024-03-31 11:07:30 发布
最新推荐文章于 2024-03-31 11:07:30 发布
阅读量145 收藏
点赞数
分类专栏： 机器学习
原文链接：https://blog.csdn.net/lom9357bye/article/details/73007711
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接： https://blog.csdn.net/lom9357bye/article/details/73007711

工作原理：存在一个样本数据集合，也称为训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一数据与所属分类的对应关系。输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本集中特征最相似数据（最邻近）的分类标签。一般来说，我们只选择样本数据集中前k个最相似数据，这就是k-临近算法的出处，通常k是不大于20的整数。最后选择k个最相似数据中出现次数最多的分类，作为新数据的分类。


算法流程：

（1）收集数据

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

（3）分析数据

（4）训练算法：此步骤不适用于k-临近算法

（5）测试算法：计算错误率

（6）使用算法：首先需要输入样本数据和结构化的输出结果，然后运行k-临近算法判定输入数据分别属于哪个分类，最后应用对计算出的分类执行后续处理。


来看一个例子：


假如有一组数据已经做好了分类，（1，1.1）和（1，1）属于A类，（0，0）（0，0.1）属于B类

现在有一点（1，0），它应该属于哪一类？

思路：

（1）求出（1，0）到四个点之间的距离

（2）找出距离最近的k个点

（3）找出k个点中分类出现次数最多的那个


用到的python知识：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     # -*- coding:utf-8 -*-
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     from numpy 
     
     import *
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     import operator
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #1.shape函数
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     group=array([[
     
     1.0,
     
     1.1],[
     
     1.0,
     
     1.0],[
     
     0,
     
     0],[
     
     0,
     
     0.1]])
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(group.shape[
     
     0])
     
     #输出4，数组行数
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(group.shape[
     
     1])
     
     #输出2，数组列数
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(group)
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #2.tile函数
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     test=[
     
     1,
     
     0]
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(tile(test,(
     
     4,
     
     1)))
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #输出
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #[[1 0]
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     # [1 0]
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     # [1 0]
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     # [1 0]]
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #3.sum函数
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     arr=array([[
     
     1,
     
     2,
     
     3],[
     
     4,
     
     5,
     
     6]])
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(arr.sum(axis=
     
     1))
     
     #将矩阵的每一行相加
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #输出[ 6 15]
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(arr.sum(axis=
     
     0))
     
     #将矩阵的每一列相加
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #输出[5 7 9]
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #4.argsort函数：返回的是数组值从小到大的索引值
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     array1=([
     
     1,
     
     3,
     
     2,
     
     7])
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(argsort(array1))
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #输出[0 2 1 3]
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #5.sorted
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #sorted(iterable, cmp=None, key=None, reverse=False) 
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #iterable:迭代对象，要排序的对象
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #cmp:比较函数
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #key:指定取待排序元素的哪一项进行排序,operator.itemgetter(1)获取对象的第1个域的值,此处是按value值排序
    
    
    
   
   
  37. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #reverse:是否反转,表示是否从高到低排序
    
    
    
   
   
  38. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     dict={
     
     'A':
     
     10,
     
     'B':
     
     5,
     
     'C':
     
     20,
     
     'D':
     
     15}
    
    
    
   
   
  39. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(sorted(dict.items(),key=operator.itemgetter(
     
     1)))
    
    
    
   
   
  40. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #结果：[('B', 5), ('A', 10), ('D', 15), ('C', 20)]
    
    
    
   
   
  41. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #reverse=true结果:[('C', 20), ('D', 15), ('A', 10), ('B', 5)]


python3代码：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     # -*- coding:utf-8 -*-
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     from numpy 
     
     import *
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     import operator
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  5. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     def createDataSet():
    
    
    
   
   
  6. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	group=array([[
     
     1.0,
     
     1.1],[
     
     1.0,
     
     1.0],[
     
     0,
     
     0],[
     
     0,
     
     0.1]])
     
     #数据集
    
    
    
   
   
  7. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	labels=[
     
     'A',
     
     'A',
     
     'B',
     
     'B']
     
     #数据对应的分类
    
    
    
   
   
  8. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return group,labels
    
    
    
   
   
  9. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  10. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #intX：分类的输入向量
    
    
    
   
   
  11. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #dataSet:训练样本
    
    
    
   
   
  12. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #labels：标签向量
    
    
    
   
   
  13. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #k:选择最近邻居的数目
    
    
    
   
   
  14. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     def classify0(intX,dataSet,labels,k):
    
    
    
   
   
  15. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	dataSetSize=dataSet.shape[
     
     0]
     
     #数组行数
    
    
    
   
   
  16. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     #距离计算
    
    
    
   
   
  17. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	diffMat=tile(intX,(dataSetSize,
     
     1))-dataSet
     
     #将输入向量转为行数为dataSetSize的二维数组，并计算与训练样本的差
    
    
    
   
   
  18. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	sqDiffMat=diffMat**
     
     2
     
     #求数组的2次方
    
    
    
   
   
  19. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	sqDistances=sqDiffMat.sum(axis=
     
     1)
     
     #将矩阵的每一行相加
    
    
    
   
   
  20. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	distances=sqDistances**
     
     0.5
     
     #求数组的0.5次幂，也就是求平方根
    
    
    
   
   
  21. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     #选择距离最小的k个点
    
    
    
   
   
  22. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	sortedDistIndicies=distances.argsort()
     
     #根据距离将数组的下标排序
    
    
    
   
   
  23. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	classCount={}
    
    
    
   
   
  24. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     #求出前距离最近的前K个点中出现最多的分类
    
    
    
   
   
  25. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     for i 
     
     in range(k):
    
    
    
   
   
  26. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		voteIlabel=labels[sortedDistIndicies[i]]
     
     #遍历前k个点，获取每个点所属分类
    
    
    
   
   
  27. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     		classCount[voteIlabel]=classCount.get(voteIlabel,
     
     0)+
     
     1
     
     #将类别作为key，出现的次数作为value,计算每个类别出现的次数
    
    
    
   
   
  28. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     #排序
    
    
    
   
   
  29. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     	sortedClassCount=sorted(classCount.items(),key=operator.itemgetter(
     
     1),reverse=
     
     True)
    
    
    
   
   
  30. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
     
     return sortedClassCount[
     
     0][
     
     0]		
    
    
    
   
   
  31. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    	
    
    
    
   
   
  32. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
     
    
    
    
   
   
  33. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     #测试
    
    
    
   
   
  34. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     group,labels=createDataSet()
    
    
    
   
   
  35. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     result=classify0([
     
     1,
     
     0],group,labels,
     
     3)
    
    
    
   
   
  36. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     print(result)



距离计算：

（1）求两个矩阵的差

输入的数据为[1,0]:

训练样本集为:

[[1.0,1.1],

 [1.0,1.0],

 [0, 0],

 [0,0.1]]，是一个二维数组，也可以看作为一个行为4列为2的矩阵，为了两个矩阵可以相减，首先需要将输入向量[1,0]转换为一个行数为4的二维数组

经过tile(intX,(dataSetSize,1))后输入向量变为


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [[
     
     1  
     
     0],
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [
     
     1  
     
     0],
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [
     
     1  
     
     0],
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [
     
     1  
     
     0]]

然后减去训练样本集，求出两个矩阵的差,差值为


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [[ 
     
     0.  
     
     -1.1]
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [ 
     
     0.  
     
     -1. ]
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [ 
     
     1.   
     
     0. ]
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [ 
     
     1.  
     
     -0.1]]


（2）使用欧氏距离公式，计算两个向量点之间的距离

首先求差值的2次方,结果为：


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     [[ 
     
     0.    
     
     1.21]
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [ 
     
     0.    
     
     1.  ]
    
    
    
   
   
  3. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [ 
     
     1.    
     
     0.  ]
    
    
    
   
   
  4. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
      [ 
     
     1.    
     
     0.01]]

然后将矩阵的每一行相加得到：

[ 1.21  1.    1.    1.01]

然后开根 

[ 1.1   1.    1.    1.00498756]


根据距离最近点排序


 
 
  1. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     值  ：  
     
     1     
     
     1    
     
     1.00498756  
     
     1.1
    
    
    
   
   
  2. 
   
   
    
    
    
    
   
   
    
   
   
    
    
    
    
     
     下标：  
     
     1     
     
     2       
     
     3         
     
     0
得到：

[1 2 3 0]


（3）选择距离最小的k个点，此处k=3,也就是前3个点

从上一步得到排序后的下标，取前三个值，然后从lables标签中取下标为1  2  3 的值，分别是A  B  B

求出出现频率最高的类别，B出现两次，A出现1次，因此推测[1,0]的分类结果是B


来自：机器学习实战


python知识参考：

http://blog.csdn.net/sunny2038/article/details/9002531

http://www.cnblogs.com/chamie/p/4847332.html

http://blog.csdn.net/iboxty/article/details/44975575

http://www.cnblogs.com/100thMountain/p/4719503.html

http://www.cnblogs.com/kellyseeme/p/5525052.html

hzq201435
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++实现K最邻近算法(机器学习 KNN KD树)
08-17
C++实现K最邻近算法, 使用KD树来实现, 在面对大量数据时可以提高搜索效率. 代码干净, 整洁, 有注释, 可直接使用.
机器学习实战：k-临近算法（一）
S-H_A-N
06-10 745
工作原理：存在一个样本数据集合，也称为训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一数据与所属分类的对应关系。输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本集中特征最相似数据（最邻近）的分类标签。一般来说，我们只选择样本数据集中前k个最相似数据，这就是k-临近算法的出处，通常k是不大于20的整数。最后选择k个最相似数据中出现次数最多
机器学习-K近邻
weixin_45914620的博客
07-23 1278
K-近邻算法(KNN)概念 K Nearest Neighbor 算法又简称KNN算法，是机器学习里面一个比较经典的算法。 1、定义 中国有句古话，叫做近朱者赤近墨者黑，大概意思是接近好人可以使人变好，接近坏人可以使人变坏，也就是大概可以通过你身边的朋友反映出你是怎么样的一个人啊。 K近邻算法定义：如果一个样本在特征空间中的K个最相似(即特征空间中最近邻)的样本大多数都属于某一个类别，则该样本也属于这个类别。 这是一张北京地图，当你有几个朋友在北京的时候，你第一次去北京，但是你不知道自己是在哪个区，你就可
《机器学习实战》读书笔记—k近邻算法c语言实现（win下）
weixin_34406061的博客
11-09 197
#include <stdio.h> #include <io.h> #include <math.h> #include <stdlib.h> #define K 10 //kNN中选取最近邻居的个数 #define LINE 1024 //每个文件字符数 const char *to...
机器学习：k邻近算法(KNN)
weixin_42479155的博客
11-16 431
title: 机器学习：k邻近算法(KNN) date: 2019-11-16 20:20:41 mathjax: true categories: 机器学习 tags: 机器学习 什么是K邻近算法？ 工作原理是：存在一个样本数 据集合，也称作训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一数据 与所属分类的对应关系。输入没有标签的新数据后，将新数据的每个特征与样本集...
机器学习实战-k-近邻算法改进约会网站的配对效果
08-15
在本实践项目中，我们将深入探讨如何利用机器学习中的k-近邻算法（K-Nearest Neighbors，简称KNN）来改进约会网站的配对效果。KNN是一种非参数监督学习方法，常用于分类和回归任务。在这个案例中，我们将关注其在...
机器学习实战 - k近邻算法（KNN算法）总结
04-12
机器学习实战 - k近邻算法（KNN算法）总结 适合机器学习实战入门新手 K-近邻算法，又称为 KNN 算法，是数据挖掘技术中原理最简单的算法。 KNN 的工作原理：给定一个已知类别标签的数据训练集，输入没有标签的新数据...
Python语言实现机器学习的K-近邻算法
01-21
额、、、最近开始学习机器学习嘛，网上找到一本关于机器学习的书籍，名字叫做《机器学习实战》。很巧的是，这本书里的算法是用Python语言实现的，刚好之前我学过一些Python基础知识，所以这本书对于我来说，无疑是...
机器学习算法-K-近邻算法
最新发布
oracle88888888的博客
03-31 676
K Nearest Neighbor 算法又叫KNN算法，这个算法是机器学习里面一个比较经典的算法，总体来说KNN算法是相对比较容易理解的算法定义如果一个样本在特征空间中的k个最相似（即特征空间中最邻近）的样本中的大多数属于某一个类别，则该样本也属于这个类别。距离公式两个样本的距离可以通过如下公式计算，又叫欧氏距离二维平面上点a(x1,y1)与b(x2,y2)间的欧氏距离：$$$$三维空间点a(x1,y1,z1)与b(x2,y2,z3)间的欧氏距离：$$$$
K-临近算法 机器学习实战
zz133110的博客
04-20 177
K-临近算法 从今天开始，开始挖个坑。学习《机器学习实战》这本书，然后将学习的笔记记录下来。相关代码请参考： https://github.com/pbharrin/machinelearninginaction。里面有数据集和源码。但是这是基于python2编写的代码。我的学习笔记都是基于python3 的。会有一些函数的不同。但是思路是一样的。 k近邻属于最简单的机器学习方法了，属于一种分类的...
K-S算法matlab实现
08-10
近红外光谱快速检测校正集验证集划分方法代码
一、机器学习实战之K-近邻算法
HHHHHHHHHHan的博客
03-25 312
以下代码来自《机器学习实战》，对约会数据，手写数字数据，用KNN进行分类，我在每行代码后添加了详细的注释，以便理解 算法概述：给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的k个实例，这k个实例的多数属于某个类，就把该输入实例分为这个类 优点：精度高、对异常值不敏感、无数据输入假定 缺点：计算复杂度高、空间复杂度高 适用数据范围：数值型和标称型 from nump...
机器学习实战：k-临近算法（二）
S-H_A-N
06-11 632
海伦一直在使用在线约会网站寻找合适自己的约会对象，经过一番总结，海伦整理了以下数据，希望我们的分类软件可以更好地帮助她将匹配对象划分到确切的分类中 1、收集数据 40920 8.326976 0.953952 largeDoses 14488 7.153469 1.673904 smallDoses 26052 1.441871 0.805124 didntLike 75136 13.1473
K临近算法
Marshall的专栏
03-26 1678
邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。 kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几
K近邻算法
cjavacjavacjava的博客
07-20 222
1、收集数据 2、计算目标数据与所有数据的距离 3、取前K个距离最小的数据 4、取3中出现最多的类，则目标数据属于这个类
k-近临算法及代码实现
所有的今天都是为了不后悔的明天
05-21 995
K-最近邻分类（惰性学习法），即KNN。 惰性学习法在提供训练元组时只做少量工作，而在进行分类或数值预测时做更多的工作。惰性学习法不提供多少解释或对数据结构的洞察。但是，惰性学习法天生地支持增量学习。惰性学习法的计算开销可能相当大。 “近邻性”用距离度量，如欧式距离。 在算式之前，需要把每个属性的值规范化，这有助于防止具有较大初始值域的属性（如收入）比具有较小初始值域的属性（
k-近邻算法
apity123的博客
02-06 203
#科学计算包 from numpy import * # 运算符模块 import operator def createDataSet(): group = array([ [1.0,1.1], [1.0,1.0], [0,0], [0,0.1], [0,0.2] ]) #label包含每个...
K邻近算法之最邻近算法代码
点滴
04-26 712
import pandas as pd import numpy as np #使用pandas 读取data train = pd.read_csv("iris-data-training.csv",encoding = "GBK") test = pd.read_csv("iris-data-testing.csv", encoding = "GBK") #将读取的DataFrame格式...
编程实现之k近邻算法
wave2587的博客
09-11 948
kNN学习是一种常用的监督学习方法，原理可以说是相当简单了：给定测试样本，基于某种距离度量找出训练集中与其最靠近的k个训练样本，然后基于这k个“邻居”的信息来进行预测，在分类任务中，一般采用“投票法”。 根据周志华老师在《机器学习》一书中给出的原理，用Python实现这一算法。 距离度量采用欧式距离，预测则采用“投票法”，具体代码如下所示： import numpy as np impor...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值