KNN最近邻基于欧几里德距离的JAVA算法实现

最新推荐文章于 2024-06-03 10:49:26 发布
最新推荐文章于 2024-06-03 10:49:26 发布
阅读量8.9k 收藏 8
点赞数
分类专栏： algorithms/recommond 文章标签： java distance string 测试 import exception
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/turkeyzhou/article/details/8044486
版权

本算法只适合学习使用，可以大致了解一下KNN算法的原理。

算法作了如下的假定与简化处理：

1.小规模数据集

2.假设所有数据及类别都是数值类型的

3.直接根据数据规模设定了k值

4.对原训练集进行测试

KNN实现代码如下：

[java] view plain copy print ?
  1. package KNN; 
  2. /**
  3. * KNN结点类，用来存储最近邻的k个元组相关的信息
  4. * @author Rowen
  5. * @qq 443773264
  6. * @mail luowen3405@163.com
  7. * @blog blog.csdn.net/luowen3405
  8. * @data 2011.03.25
  9. */ 
  10. public class KNNNode { 
  11.     private int index; // 元组标号 
  12.     private double distance; // 与测试元组的距离 
  13.     private String c; // 所属类别 
  14.     public KNNNode(int index, double distance, String c) { 
  15.         super(); 
  16.         this.index = index; 
  17.         this.distance = distance; 
  18.         this.c = c; 
  19.     } 
  20.      
  21.      
  22.     public int getIndex() { 
  23.         return index; 
  24.     } 
  25.     public void setIndex(int index) { 
  26.         this.index = index; 
  27.     } 
  28.     public double getDistance() { 
  29.         return distance; 
  30.     } 
  31.     public void setDistance(double distance) { 
  32.         this.distance = distance; 
  33.     } 
  34.     public String getC() { 
  35.         return c; 
  36.     } 
  37.     public void setC(String c) { 
  38.         this.c = c; 
  39.     } 
  40. } 

[java] view plain copy print ?
  1. package KNN; 
  2. import java.util.ArrayList; 
  3. import java.util.Comparator; 
  4. import java.util.HashMap; 
  5. import java.util.List; 
  6. import java.util.Map; 
  7. import java.util.PriorityQueue; 
  8.  
  9. /**
  10. * KNN算法主体类
  11. * @author Rowen
  12. * @qq 443773264
  13. * @mail luowen3405@163.com
  14. * @blog blog.csdn.net/luowen3405
  15. * @data 2011.03.25
  16. */ 
  17. public class KNN { 
  18.     /**
  19.      * 设置优先级队列的比较函数，距离越大，优先级越高
  20.      */ 
  21.     private Comparator<KNNNode> comparator = new Comparator<KNNNode>() { 
  22.         public int compare(KNNNode o1, KNNNode o2) { 
  23.             if (o1.getDistance() >= o2.getDistance()) { 
  24.                 return 1; 
  25.             } else { 
  26.                 return 0; 
  27.             } 
  28.         } 
  29.     }; 
  30.     /**
  31.      * 获取K个不同的随机数
  32.      * @param k 随机数的个数
  33.      * @param max 随机数最大的范围
  34.      * @return 生成的随机数数组
  35.      */ 
  36.     public List<Integer> getRandKNum(int k, int max) { 
  37.         List<Integer> rand = new ArrayList<Integer>(k); 
  38.         for (int i = 0; i < k; i++) { 
  39.             int temp = (int) (Math.random() * max); 
  40.             if (!rand.contains(temp)) { 
  41.                 rand.add(temp); 
  42.             } else { 
  43.                 i--; 
  44.             } 
  45.         } 
  46.         return rand; 
  47.     } 
  48.     /**
  49.      * 计算测试元组与训练元组之前的距离
  50.      * @param d1 测试元组
  51.      * @param d2 训练元组
  52.      * @return 距离值
  53.      */ 
  54.     public double calDistance(List<Double> d1, List<Double> d2) { 
  55.         double distance = 0.00; 
  56.         for (int i = 0; i < d1.size(); i++) { 
  57.             distance += (d1.get(i) - d2.get(i)) * (d1.get(i) - d2.get(i)); 
  58.         } 
  59.         return distance; 
  60.     } 
  61.     /**
  62.      * 执行KNN算法，获取测试元组的类别
  63.      * @param datas 训练数据集
  64.      * @param testData 测试元组
  65.      * @param k 设定的K值
  66.      * @return 测试元组的类别
  67.      */ 
  68.     public String knn(List<List<Double>> datas, List<Double> testData, int k) { 
  69.         PriorityQueue<KNNNode> pq = new PriorityQueue<KNNNode>(k, comparator); 
  70.         List<Integer> randNum = getRandKNum(k, datas.size()); 
  71.         for (int i = 0; i < k; i++) { 
  72.             int index = randNum.get(i); 
  73.             List<Double> currData = datas.get(index); 
  74.             String c = currData.get(currData.size() - 1).toString(); 
  75.             KNNNode node = new KNNNode(index, calDistance(testData, currData), c); 
  76.             pq.add(node); 
  77.         } 
  78.         for (int i = 0; i < datas.size(); i++) { 
  79.             List<Double> t = datas.get(i); 
  80.             double distance = calDistance(testData, t); 
  81.             KNNNode top = pq.peek(); 
  82.             if (top.getDistance() > distance) { 
  83.                 pq.remove(); 
  84.                 pq.add(new KNNNode(i, distance, t.get(t.size() - 1).toString())); 
  85.             } 
  86.         } 
  87.          
  88.         return getMostClass(pq); 
  89.     } 
  90.     /**
  91.      * 获取所得到的k个最近邻元组的多数类
  92.      * @param pq 存储k个最近近邻元组的优先级队列
  93.      * @return 多数类的名称
  94.      */ 
  95.     private String getMostClass(PriorityQueue<KNNNode> pq) { 
  96.         Map<String, Integer> classCount = new HashMap<String, Integer>(); 
  97.         for (int i = 0; i < pq.size(); i++) { 
  98.             KNNNode node = pq.remove(); 
  99.             String c = node.getC(); 
  100.             if (classCount.containsKey(c)) { 
  101.                 classCount.put(c, classCount.get(c) + 1); 
  102.             } else { 
  103.                 classCount.put(c, 1); 
  104.             } 
  105.         } 
  106.         int maxIndex = -1; 
  107.         int maxCount = 0; 
  108.         Object[] classes = classCount.keySet().toArray(); 
  109.         for (int i = 0; i < classes.length; i++) { 
  110.             if (classCount.get(classes[i]) > maxCount) { 
  111.                 maxIndex = i; 
  112.                 maxCount = classCount.get(classes[i]); 
  113.             } 
  114.         } 
  115.         return classes[maxIndex].toString(); 
  116.     } 
  117. } 

[java] view plain copy print ?
  1. package KNN; 
  2. import java.io.BufferedReader; 
  3. import java.io.File; 
  4. import java.io.FileReader; 
  5. import java.util.ArrayList; 
  6. import java.util.List; 
  7. /**
  8. * KNN算法测试类
  9. * @author Rowen
  10. * @qq 443773264
  11. * @mail luowen3405@163.com
  12. * @blog blog.csdn.net/luowen3405
  13. * @data 2011.03.25
  14. */ 
  15. public class TestKNN { 
  16.      
  17.     /**
  18.      * 从数据文件中读取数据
  19.      * @param datas 存储数据的集合对象
  20.      * @param path 数据文件的路径
  21.      */ 
  22.     public void read(List<List<Double>> datas, String path){ 
  23.         try { 
  24.             BufferedReader br = new BufferedReader(new FileReader(new File(path))); 
  25.             String data = br.readLine(); 
  26.             List<Double> l = null; 
  27.             while (data != null) { 
  28.                 String t[] = data.split(" "); 
  29.                 l = new ArrayList<Double>(); 
  30.                 for (int i = 0; i < t.length; i++) { 
  31.                     l.add(Double.parseDouble(t[i])); 
  32.                 } 
  33.                 datas.add(l); 
  34.                 data = br.readLine(); 
  35.             } 
  36.         } catch (Exception e) { 
  37.             e.printStackTrace(); 
  38.         } 
  39.     } 
  40.      
  41.     /**
  42.      * 程序执行入口
  43.      * @param args
  44.      */ 
  45.     public static void main(String[] args) { 
  46.         TestKNN t = new TestKNN(); 
  47.         String datafile = new File("").getAbsolutePath() + File.separator + "datafile"; 
  48.         String testfile = new File("").getAbsolutePath() + File.separator + "testfile"; 
  49.         try { 
  50.             List<List<Double>> datas = new ArrayList<List<Double>>(); 
  51.             List<List<Double>> testDatas = new ArrayList<List<Double>>(); 
  52.             t.read(datas, datafile); 
  53.             t.read(testDatas, testfile); 
  54.             KNN knn = new KNN(); 
  55.             for (int i = 0; i < testDatas.size(); i++) { 
  56.                 List<Double> test = testDatas.get(i); 
  57.                 System.out.print("测试元组: "); 
  58.                 for (int j = 0; j < test.size(); j++) { 
  59.                     System.out.print(test.get(j) + " "); 
  60.                 } 
  61.                 System.out.print("类别为: "); 
  62.                 System.out.println(Math.round(Float.parseFloat((knn.knn(datas, test, 3))))); 
  63.             } 
  64.         } catch (Exception e) { 
  65.             e.printStackTrace(); 
  66.         } 
  67.     } 
  68. } 

训练数据文件：

[java] view plain copy print ?
  1. 1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 1 
  2. 1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 1 
  3. 1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 1 
  4. 1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 0 
  5. 1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 1 
  6. 1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 0 

[java] view plain copy print ?
  1. 1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 
  2. 1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 
  3. 1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 
  4. 1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 
  5. 1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 
  6. 1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 

程序运行结果：

[java] view plain copy print ?
  1. 测试元组: 1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 类别为: 1 
  2. 测试元组: 1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 类别为: 1 
  3. 测试元组: 1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 类别为: 1 
  4. 测试元组: 1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 类别为: 0 
  5. 测试元组: 1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 类别为: 1 
  6. 测试元组: 1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 类别为: 0 

 

turkeyzhou
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
《KNN算法Java实现》KNN算法demo
03-30
KNN算法详解，查看我的博客关于KNN算法的浅析，博客连接：https://blog.csdn.net/wang_xiaogui/article/details/61413594............
数据挖掘：K最近邻(KNN)算法的java实现
beifenggo
03-25 162
KNN算法的介绍见上一篇博文：数据挖掘：k最近邻(KNN)分类法介绍 本算法只适合学习使用，可以大致了解一下KNN算法的原理。 算法作了如下的假定与简化处理： 1.小规模数据集 2.假设所有数据及类别都是数值类型的 3.直接根据数据规模设定了k值 4.对原训练集进行测试 KNN实现代码如下： package KNN; /** * KNN结点类，用来存储最近邻的k个...
近邻算法详解：原理、Java实现及应用场景
最新发布
q_913246828的博客
06-03 800
近邻算法（Nearest Neighbor Algorithm）是一种基于实例的学习方法，主要用于分类和回归问题。本文详细介绍了K近邻算法（K-Nearest Neighbors, KNN）的原理、步骤及其Java实现。KNN的核心思想是通过计算待分类样本与训练样本的距离，选择最近的K个样本，根据它们的类别信息来决定待分类样本的类别。本文提供了Java实现代码，包括数据点类、KNN算法类及测试方法，并详细说明了KNN在图像识别、文本分类、推荐系统和医疗诊断等领域的应用场景。
KNN算法及java实现
weixin_30449239的博客
09-08 124
public class KNNNode { private int index;// 元祖标号 private double distance;// 与测试元祖的距离 private String c;// 所属类别 public KNNNode(int index, double distance, String c) { ...
基于最近邻距离权重的ML-KNN算法
04-30
然后计算最近邻样本的距离权重，并用该权重描述最近邻和其他近邻对预测结果的影响；最后使用新的目标函数为待测样本分类。通过在图片、Web页面文本数据等数据集上的实验表明，所提算法得到了更好的分类结果，并且...
knn.zip_knn_knn算法_实现KNN算法java
09-14
《KNN算法的Java实现详解》 KNN（K-Nearest Neighbors）算法，即K近邻算法，是机器学习领域中最基础且重要的算法之一。它基于实例的学习，通过寻找训练集中与新样本最接近的K个邻居，依据邻居的类别进行投票，从而...
KNN最近邻算法java实现
04-25
KNN算法在Java中的实现涉及到数据预处理、距离计算、选择K值、最近邻搜索和类别投票等多个环节。尽管KNN简单直观，但它的计算复杂度高，不适合大数据集。通过引入空间索引结构和优化策略，可以提高其在大型数据集上...
KNN（K Near Neighbor）最近邻算法
01-07
最近邻算法是一种分类算法，1968年由Cover和Hart提出，应用场景有字符识别、文本分类、图像识别等领域。 该算法的思想是：一个样本与数据集中的k个样本最相似，如果这k个样本中的大多数属于某一个类别，则该样本也...
K最近邻算法(KNN)---sklearn+python实现方式
09-17
K最近邻算法（K-Nearest Neighbors, 简称KNN）是一种基于实例的学习方法，也是非参数监督学习算法的一种。KNN的核心思想是通过寻找与未知类别样本最接近的K个已知类别的样本，根据这K个样本的类别分布来决定未知样本...
这是java实现机器学习算法中的k近邻算法
01-19
这是我自己写的java代码，做任务用数据测试过 这是我自己写的代码，做任务用数据测试过 这是我自己写的代码，做任务用数据测试过
KNN算法java实现
12-14
该KNN算法示例采用java实现，对数据分类算法的学习很有用，而且代码封装很好，简单易懂，极适合初学者
java实现k-近邻算法分类器
02-06
用java实现k-近邻算法分类器的完整工程代码，测试结果正确
【JAVA实现】K-近邻（KNN）分类算法
热门推荐
C_son的专栏
02-26 1万+
KNN算法属于监督学习算法，是一种用于分类的非常简单的算法。简单的说，KNN算法采用测量不同特征值之间的距离方法进行分类。具体算法如下：        1）计算已知类别数据集中的点与当前点之间的距离        2）按照距离递增次序排序        3）选取与当前距离最小的k个点        4）确定前k个点所在类别的出现频率        5）返回前k个点出现频率最高的类别作为当
java 最邻近算法_KNN邻近分类算法
weixin_34739646的博客
02-16 565
K邻近(k-Nearest Neighbor，KNN)分类算法是最简单的机器学习算法了。它采用测量不同特征值之间的距离方法进行分类。它的思想很简单：计算一个点A与其他所有点之间的距离，取出与该点最近的k个点，然后统计这k个点里面所属分类比例最大的，则点A属于该分类。下面用一个例子来说明一下：电影名称打斗次数接吻次数电影类型California Man3104RomanceHe’s Not Real...
KNN算法JAVA实现
一HUA一世界的专栏
09-22 8725
邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。 kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几
k近邻算法的Java实现
weixin_30352191的博客
03-03 504
k近邻算法是机器学习算法中最简单的算法之一，工作原理是：存在一个样本数据集合，即训练样本集，并且样本集中的每个数据都存在标签，即我们知道样本集中每一数据和所属分类的对应关系。输入没有标签的新数据之后，将新数据的每个特征和样本集中数据对应的特征进行比较，然后算法提取样本集中特征最相似数据的分类标签作为新数据的标签。一般来说，我们只选取样本数据中前k个最相似的数据。 Java实现: KNNDa...
【数据挖掘】k-邻近算法
Java&&大数据专栏
08-18 1552
#!/usr/bin/python #-*-encoding:utf-8-*- import numpy as np import operator def classify(vect,dataset,lables,k=5): rows = dataset.shape[0] diffmat = np.tile(vect,(rows,1)) - dataset diffm
大数据环境下优化的ML-KNN算法：基于最近邻距离权重
基于最近邻距离权重的ML-KNN算法通过聚类优化和距离权重调整，实现了对传统ML-KNN算法的改进，提高了分类准确性和运行效率，对于大数据环境下的多标签分类问题提供了更优的解决方案。这一研究对机器学习领域的理论...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值