机器学习算法（分类算法）—k-近邻算法

一、机器学习算法概述

    机器学习算法主要分为监督学习算法，无监督学习算法。其中监督学习算法需要的数据包括样本，如训练样本,和每组数据的标签，即所属的类别；而无监督学习只有样本数据，我们需要构建出样本与样本之间的差异。常见的分类算法，回归算法属于监督学习算法，如K-近邻，决策树，logistic回归，朴素贝叶斯，SVM等；聚类算法属于无监督学习算法，如K-均值等。对于监督学习，机器学习算法需要解决的问题是求解出样本特征与期望输出之间的映射关系。

    机器学习算法的一般流程为：收集数据->准备数据->分析数据->训练算法->测试算法->使用算法。

二、概念的表述

    1、训练样本

    用于训练机器学习算法的样本特征，通常用，其中表示一个样本的特征。表示标签（期望输出）。

    2、测试样本

    用于测试构建好的机器学习算法的性能，格式与训练样本一样。

    3、错误率

    用于评判机器学习算法优劣的标准，

三、K-近邻算法(kNN)

    1、kNN算法概述

    kNN算法是最简单的分类算法，主要的思想是计算待分类样本与训练样本之间的差异性，并将差异按照由小到大排序，选出前面K个差异最小的类别，并统计在K个中类别出现次数最多的类别为最相似的类，最终将待分类样本分到最相似的训练样本的类中。

    2、样本差异性

    比较常用的差异性计算方法为欧式距离。将在后面补充相似性的度量方法。

    欧式距离：样本与样本之间的欧式距离为。

    3、kNN算法的流程

    例如待测样本为

[plain] view plain copy

1. cal the distance between X and T ---> Dis  
2. sort(Dis)  
3. pick fore-K Dis  
4. cal the labels of the K Dis, and find the label with maxnum  
5. define X with the label found above  

可以表述为：1、求距离；2、对距离排序；3、选择前k个距离对应的类别；4、求取前k个点对应的类别的出现频率；5、得到预测的分类结果

四、k-近邻算法的简单Java测试：

[java] view plain copy

1. package org.zzy.test;  
2.   
3. import java.util.Arrays;  
4. //import java.util.IdentityHashMap;  
5. import java.util.Map;  
6. import java.util.TreeMap;  
7.   
8. public class KNNTest {  
9.     public static void main(String[] args) {  
10.         double[][] group = { { 1.0, 1.1 }, { 1.0, 1.0 }, { 0, 0 }, { 0, 0.1 } };  
11.         char[] lable = { 'A', 'A', 'B', 'B' };  
12.   
13.         double[] test = { 0, 0 };  
14.   
15.         int k = 3;  
16.   
17.         double[] theDistance = new double[4];  
18.         for (int i = 0; i < 4; i++) {  
19.             theDistance[i] = createDistance(test, group[i], 2);  
20.         }  
21.           
22.         int[] count = classify(theDistance, lable, k, 4);  
23.         if (count[0] > count[1]){  
24.             System.out.println('A');  
25.         }else{  
26.             System.out.println('B');  
27.         }  
28.     }  
29.   
30.     public static double createDistance(double[] data, double[] group, int n) {  
31.         double tmp = 0;  
32.         for (int i = 0; i < n; i++) {  
33.             tmp += (data[i] - group[i]) * (data[i] - group[i]);  
34.         }  
35.         return Math.sqrt(tmp);  
36.     }  
37.       
38.     public static int[] classify(double[] distance, char[] lable, int k, int n){  
39.         int[] tmp = new int[2];  
40. //      Map<Double, Character> map = new IdentityHashMap<Double, Character>();  
41.         Map<Double, Character> map = new TreeMap<Double, Character>();  
42.         for (int i = 0; i < n; i++){  
43.             map.put(distance[i], lable[i]);  
44.         }  
45.         Arrays.sort(distance);  
46.         char c;  
47.         for (int i = 0; i < k; i++){  
48.             c = map.get(distance[i]);  
49.             if (c == 'A'){  
50.                 tmp[0]++;  
51.             }else{  
52.                 tmp[1]++;  
53.             }  
54.         }  
55.         return tmp;  
56.     }  
57.   
58. }