数据挖掘：K最近邻(KNN)算法的java实现

最新推荐文章于 2024-06-19 14:40:49 发布

__承_影__

最新推荐文章于 2024-06-19 14:40:49 发布

阅读量2.4k

点赞数 1

分类专栏：人工智能数据挖掘机器学习文章标签：数据挖掘机器学习

数据挖掘同时被 3 个专栏收录

5 篇文章 0 订阅

订阅专栏

人工智能

4 篇文章 0 订阅

订阅专栏

机器学习

4 篇文章 0 订阅

订阅专栏

1.急切学习与懒惰学习

急切学习：在给定训练元组之后、接收到测试元组之前就构造好泛化（即分类）模型。

属于急切学习的算法有：决策树、贝叶斯、基于规则的分类、后向传播分类、SVM和基于关联规则挖掘的分类等等。

懒惰学习：直至给定一个测试元组才开始构造泛化模型，也称为基于实例的学习法。

属于急切学习的算法有：KNN分类、基于案例的推理分类。

2.KNN的优缺点

优点：原理简单，实现起来比较方便。支持增量学习。能对超多边形的复杂决策空间建模。

缺点：计算开销大，需要有效的存储技术和并行硬件的支撑。

3.KNN算法原理

基于类比学习，通过比较训练元组和测试元组的相似度来学习。

将训练元组和测试元组看作是n维（若元组有n的属性）空间内的点，给定一条测试元组，搜索n维空间，找出与测试

元组最相近的k个点（即训练元组），最后取这k个点中的多数类作为测试元组的类别。

相近的度量方法：用空间内两个点的距离来度量。距离越大，表示两个点越不相似。

距离的选择：可采用欧几里得距离、曼哈顿距离或其它距离度量。多采用欧几里得距离，简单！

4.KNN算法中的细节处理

数值属性规范化：将数值属性规范到0-1区间以便于计算，也可防止大数值型属性对分类的主导作用。

可选的方法有：v' = （v - v_min）/ (v_max - v_min)，当然也可以采用其它的规范化方法

比较的属性是分类类型而不是数值类型的：同则差为0，异则差为1.

有时候可以作更为精确的处理，比如黑色与白色的差肯定要大于灰色与白色的差。

缺失值的处理：取最大的可能差，对于分类属性，如果属性A的一个或两个对应值丢失，则取差值为1；

如果A是数值属性，若两个比较的元组A属性值均缺失，则取差值为1，若只有一个缺失，另一个值为v，

则取差值为｜1-v｜和｜0-v｜中的最大值

确定K的值：通过实验确定。进行若干次实验，取分类误差率最小的k值。

对噪声数据或不相关属性的处理：对属性赋予相关性权重w，w越大说明属性对分类的影响越相关。对噪声数据可以将所在

的元组直接cut掉。

5.KNN算法流程

准备数据，对数据进行预处理
选用合适的数据结构存储训练数据和测试元组
设定参数，如k
维护一个大小为k的的按距离由大到小的优先级队列，用于存储最近邻训练元组
随机从训练元组中选取k个元组作为初始的最近邻元组，分别计算测试元组到这k个元组的距离，将训练元组标号和距离存入优先级队列
遍历训练元组集，计算当前训练元组与测试元组的距离，将所得距离L与优先级队列中的最大距离L_max进行比较。若L>=L_{max，则舍弃该元组，遍历下一个元组。若L <}L_{max，删除优先级队列中最大距离的元组，将当前训练元组存入优先级队列。}
_{遍历完毕，计算优先级队列中k个元组的多数类，并将其作为测试元组的类别。}
_{测试元组集测试完毕后计算误差率，继续设定不同的k值重新进行训练，最后取误差率最小的k值。}

6.KNN算法的改进策略

将存储的训练元组预先排序并安排在搜索树中（如何排序有待研究）
并行实现
部分距离计算，取n个属性的“子集”计算出部分距离，若超过设定的阈值则停止对当前元组作进一步计算。转向下一个元组。
剪枝或精简：删除证明是“无用的”元组。

7.KNN算法java实现

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

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

1.小规模数据集

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

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

4.对原训练集进行测试

KNN实现代码如下：

[java] view plain copy

package KNN;
/**
* KNN结点类，用来存储最近邻的k个元组相关的信息
* @author Rowen
* @qq 443773264
* @mail luowen3405@163.com
* @blog blog.csdn.net/luowen3405
* @data 2011.03.25
*/
public class KNNNode {
private int index; // 元组标号
private double distance; // 与测试元组的距离
private String c; // 所属类别
public KNNNode(int index, double distance, String c) {
super();
this.index = index;
this.distance = distance;
this.c = c;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public double getDistance() {
return distance;
}
public void setDistance(double distance) {
this.distance = distance;
}
public String getC() {
return c;
}
public void setC(String c) {
this.c = c;
}
}

[java] view plain copy

package KNN;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
/**
* KNN算法主体类
* @author Rowen
* @qq 443773264
* @mail luowen3405@163.com
* @blog blog.csdn.net/luowen3405
* @data 2011.03.25
*/
public class KNN {
/**
* 设置优先级队列的比较函数，距离越大，优先级越高
*/
private Comparator<KNNNode> comparator = new Comparator<KNNNode>() {
public int compare(KNNNode o1, KNNNode o2) {
if (o1.getDistance() >= o2.getDistance()) {
return 1;
} else {
return 0;
}
}
};
/**
* 获取K个不同的随机数
* @param k 随机数的个数
* @param max 随机数最大的范围
* @return 生成的随机数数组
*/
public List<Integer> getRandKNum(int k, int max) {
List<Integer> rand = new ArrayList<Integer>(k);
for (int i = 0; i < k; i++) {
int temp = (int) (Math.random() * max);
if (!rand.contains(temp)) {
rand.add(temp);
} else {
i--;
}
}
return rand;
}
/**
* 计算测试元组与训练元组之前的距离
* @param d1 测试元组
* @param d2 训练元组
* @return 距离值
*/
public double calDistance(List<Double> d1, List<Double> d2) {
double distance = 0.00;
for (int i = 0; i < d1.size(); i++) {
distance += (d1.get(i) - d2.get(i)) * (d1.get(i) - d2.get(i));
}
return distance;
}
/**
* 执行KNN算法，获取测试元组的类别
* @param datas 训练数据集
* @param testData 测试元组
* @param k 设定的K值
* @return 测试元组的类别
*/
public String knn(List<List<Double>> datas, List<Double> testData, int k) {
PriorityQueue<KNNNode> pq = new PriorityQueue<KNNNode>(k, comparator);
List<Integer> randNum = getRandKNum(k, datas.size());
for (int i = 0; i < k; i++) {
int index = randNum.get(i);
List<Double> currData = datas.get(index);
String c = currData.get(currData.size() - 1).toString();
KNNNode node = new KNNNode(index, calDistance(testData, currData), c);
pq.add(node);
}
for (int i = 0; i < datas.size(); i++) {
List<Double> t = datas.get(i);
double distance = calDistance(testData, t);
KNNNode top = pq.peek();
if (top.getDistance() > distance) {
pq.remove();
pq.add(new KNNNode(i, distance, t.get(t.size() - 1).toString()));
}
}
return getMostClass(pq);
}
/**
* 获取所得到的k个最近邻元组的多数类
* @param pq 存储k个最近近邻元组的优先级队列
* @return 多数类的名称
*/
private String getMostClass(PriorityQueue<KNNNode> pq) {
Map<String, Integer> classCount = new HashMap<String, Integer>();
for (int i = 0; i < pq.size(); i++) {
KNNNode node = pq.remove();
String c = node.getC();
if (classCount.containsKey(c)) {
classCount.put(c, classCount.get(c) + 1);
} else {
classCount.put(c, 1);
}
}
int maxIndex = -1;
int maxCount = 0;
Object[] classes = classCount.keySet().toArray();
for (int i = 0; i < classes.length; i++) {
if (classCount.get(classes[i]) > maxCount) {
maxIndex = i;
maxCount = classCount.get(classes[i]);
}
}
return classes[maxIndex].toString();
}
}

[java] view plain copy

package KNN;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;
/**
* KNN算法测试类
* @author Rowen
* @qq 443773264
* @mail luowen3405@163.com
* @blog blog.csdn.net/luowen3405
* @data 2011.03.25
*/
public class TestKNN {
/**
* 从数据文件中读取数据
* @param datas 存储数据的集合对象
* @param path 数据文件的路径
*/
public void read(List<List<Double>> datas, String path){
try {
BufferedReader br = new BufferedReader(new FileReader(new File(path)));
String data = br.readLine();
List<Double> l = null;
while (data != null) {
String t[] = data.split(" ");
l = new ArrayList<Double>();
for (int i = 0; i < t.length; i++) {
l.add(Double.parseDouble(t[i]));
}
datas.add(l);
data = br.readLine();
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 程序执行入口
* @param args
*/
public static void main(String[] args) {
TestKNN t = new TestKNN();
String datafile = new File("").getAbsolutePath() + File.separator + "datafile";
String testfile = new File("").getAbsolutePath() + File.separator + "testfile";
try {
List<List<Double>> datas = new ArrayList<List<Double>>();
List<List<Double>> testDatas = new ArrayList<List<Double>>();
t.read(datas, datafile);
t.read(testDatas, testfile);
KNN knn = new KNN();
for (int i = 0; i < testDatas.size(); i++) {
List<Double> test = testDatas.get(i);
System.out.print("测试元组: ");
for (int j = 0; j < test.size(); j++) {
System.out.print(test.get(j) + " ");
}
System.out.print("类别为: ");
System.out.println(Math.round(Float.parseFloat((knn.knn(datas, test, 3)))));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}

训练数据文件：

[java] view plain copy

1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 1
1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 1
1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 1
1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 0
1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 1
1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 0

[java] view plain copy

1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5
1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8
1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2
1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5
1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5
1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5

程序运行结果：

[java] view plain copy

测试元组: 1.0 1.1 1.2 2.1 0.3 2.3 1.4 0.5 类别为: 1
测试元组: 1.7 1.2 1.4 2.0 0.2 2.5 1.2 0.8 类别为: 1
测试元组: 1.2 1.8 1.6 2.5 0.1 2.2 1.8 0.2 类别为: 1
测试元组: 1.9 2.1 6.2 1.1 0.9 3.3 2.4 5.5 类别为: 0
测试元组: 1.0 0.8 1.6 2.1 0.2 2.3 1.6 0.5 类别为: 1
测试元组: 1.6 2.1 5.2 1.1 0.8 3.6 2.4 4.5 类别为: 0

由结果可以看出，分类的测试结果是比较准确的！

转自：http://blog.csdn.net/luowen3405/article/details/6278764

参考：http://blog.csdn.net/xlm289348/article/details/8876353

http://coolshell.cn/articles/8052.html#more-8052

__承_影__

关注

1
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
数据挖掘：K最近邻(KNN)算法的java实现

1.急切学习与懒惰学习急切学习：在给定训练元组之后、接收到测试元组之前就构造好泛化（即分类）模型。属于急切学习的算法有：决策树、贝叶斯、基于规则的分类、后向传播分类、SVM和基于关联规则挖掘的分类等等。懒惰学习：直至给定一个测试元组才开始构造泛化模型，也称为基于实例的学习法。属于急切学习的算法有：KNN分类、基于案例的推理分类。 2.KNN的优缺点优点：原理简单，
复制链接

扫一扫

专栏目录