机器学习入门算法及其java实现-KNN算法

1、算法基本原理：

• 对于一个新点$X_{0}(x_{0},y_{0})$,它的分类$y_{0}$由离它最近的k个点的类别决定；
• 其中训练集为$T\{(x_{1},y_{1}),(x_{2},y_{2}),...,(x_{n},y_{n})\}$,离$X_{0}(x_{0},y_{0})$最近的K个点根据分类决策规则（如多数表决）决定$X_{0}(x_{0},y_{0})$的类别$y_{0}$: $$y_{0}=\arg max_{\xi_{j}}\sum_{x_{j}\in N_{k}(x)}I(y_{i}=c_{j}),i=1,2,...,N;j=1,2,...,K$$
  2、距离度量:
  $\quad\quad$ 特征空间中两个实例点的距离是两个实例点相似程度的反映。K近邻模型的特征空间一般是n维实数向量空间$R^{n}$。使用的距离是欧氏距离或其他距离，如更一般的$L_{p}$距离和Minkowski距离。
  $\quad\quad$设特征空间$\chi$是n维实数向量空间$R^{n}$,$x_{i}$,$x_{j}$$\in\chi$,$x_{i}=(x_{i}^{(1)},x_{i}^{(2)},...,x_{i}^{(n)})^T$,$x_{j}=(x_{j}^{(1)},x_{j}^{(2)},...,x_{j}^{(n)})^T$,$x_{i}$,$x_{j}$的$L_{p}$的距离定义为： $$L_{p}(x_{i},x_{j})=(\sum_{l=1}^{n}|x_{i}^{l}-x_{j}^{l}|^p)^\frac{1}{p}$$ 这里$p\ge1$,当$p=2$时，称为欧式距离，即 $$L_{2}(x_{i},x_{j})=(\sum_{l=1}^{n}|x_{i}^{l}-x_{j}^{l}|^{2})$$ 当$p=1$,称为曼哈顿距离，即： $$L_{1}(x_{i},x_{j})=\sum_{l=1}^{n}|x_{i}^{l}-x_{j}^{l}|*{2}$$
  当$p=\infty$时，它时各个坐标距离的最大值，即 $$L_{\infty}(x_{i},x_{j})=max_{l}|x_{i}^{l}-x_{i}^{l}|$$
  3、K值的选择：
  $\quad\quad$K值的选择会对K近邻法产生重大的影响。
  $\quad\quad$如果选择较小的K值，相当于用较小的领域中的训练实例进行预测，“学习”的近似误差会减小，但学习的估计误差会增大，预测结果会对近邻的实例点非常敏感。
  $\quad\quad$如果选择较大的K值，可以减少估计误差，但是学习的近似误差会增大。
  在应用中，一般取一个较小的值，采用交叉验证的办法取最优的k值。
  4、分类决策规则：
  $\quad\quad$K近邻法中分类决策往往是多数表决，即由输入实例的K个近邻的训练实例中的多数类决定输入实例的类。
  使用平台：eclipse，R
  实验数据：人工数据
  相关程序：
  使用R生成数据，使用Java处理数据：

X<-matrix(1:50,nrow=25,ncol=2)
Y<-matrix(0,nrow=25,ncol=1)
for (i in 1:25){
   if (runif(1)<0.5){
   X[i,1]=exp(runif(1))*1.3  
   X[i,2]=exp(runif(1))*3
   Y[i]=0
}
   else{
   X[i,1]=exp(runif(1))*3
   X[i,2]=exp(runif(1))*3
   Y[i]=1
}
}
data<-cbind(Y,X)
write.table(data,"C:/Users/CJH/Desktop/R程序运行/KNNtest.txt"，row.names=FALSEcol.names
=，FALSE)
#数据生成

KNNtrain<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNtrain.txt",head=FALSE)
KNNtest<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNtest.txt",head=FALSE)
class1<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNanswer1.txt",head=FALSE)
class2<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNanswer2.txt",head=FALSE)
class3<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNanswer3.txt",head=FALSE)
class4<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNanswer4.txt",head=FALSE)
class5<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNanswer5.txt",head=FALSE)
class6<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNanswer6.txt",head=FALSE)
class10<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNanswer10.txt",head=FALSE)
class30<-read.table("C:/Users/CJH/Desktop/R程序运行/KNNanswer30.txt",head=FALSE)
#输入数据及结果

KNNtrain<-data.frame(KNNtrain)
names(KNNtrain)<-c("class","x","y")
KNNtrain$class<-factor(KNNtrain$class)
library(ggplot2)
ggplot(data=KNNtrain,aes(x=KNNtrain$x,y=KNNtrain$y,shape=KNNtrain$class,color=KNNtrain$class))+
geom_point(size=3)+labs(title="TrainData",x="x",y="y")

KNNtest<-data.frame(KNNtest)
names(KNNtest)<-c("class","x","y")
KNNtest$class<-factor(KNNtest$class)
ggplot(data=KNNtest,aes(x=KNNtest$x,y=KNNtest$y,shape=KNNtest$class,color=KNNtest$class))+
geom_point(size=3)+labs(title="TestData",x="x",y="y")
#生成图像

Eclipse程序：
package KNN;

import java.io.*;
import java.util.*;

public class InputData{
    public void loadData(double [][]x,double[]y,String trainfile)throws IOException{
       File file = new File("C:\\Users\\CJH\\Desktop\\R程序运行",trainfile);
       RandomAccessFile raf= new RandomAccessFile(file,"r");
       StringTokenizer tokenizer;   
       int i=0,j=0;
       while(true){
           String line = raf.readLine();
           if(line==null)break;
           tokenizer= new StringTokenizer(line);
           y[i]=Double.parseDouble(tokenizer.nextToken());
           while(tokenizer.hasMoreTokens()){
           x[i][j]=Double.parseDouble(tokenizer.nextToken());
           j++;
           }
           j=0;i++;
       }
       raf.close();
    }

}
//输入数据

package KNN;

public class CrossValidation {
    private int k;
    private int n;
    private int m;
    private int n1;
    public int getK(){
        return k;
        }
    public int getN(){
        return n;
        }
    public int getM(){
        return m;
        }
    public int getN1(){
        return n1;
        }
    public void setK(int b,int a,int t,int p){
         k=b;
         n=a;
         m=t;
         n1=p;
        }
}
//原始参数设置

package KNN;

public class KNN {

public double[] y(double[][] X,double[] Y,double[][] newpoints,int k,double[] c){
    double[][] distance=new double[newpoints.length][X.length];
    double[] y=new double[newpoints.length];
    int[][] rank=new int[newpoints.length][k];
    for (int i=0;i<newpoints.length;i++){
        for(int j=0;j<X.length;j++){
        distance[i][j]=euclid(newpoints[i],X[j]);
       }
    }
    for(int i=0;i<newpoints.length;i++){
        rank[i]=Rank(distance[i],k);
        y[i]=Y[rank[i][0]];
        int t1=count(rank[i],Y,Y[rank[i][0]]);
        for(int j=0;j<c.length;j++){
            int t=count(rank[i],Y,c[j]);
            if(t>t1){
                y[i]=c[j];
            }
        }
    }
    return y;
}

private int count(int[] rank, double[] y, double d) {
    int count=0;
    for (int i=0;i<rank.length;i++){
        if(y[rank[i]]==d){
            count=count+1;
        }
    }
    return count;
}

private int[] Rank(double[] distance,int k) {
    int[] Rank=new int[k];
    int[] temp1= new int[distance.length];
    for(int i=0;i<distance.length;i++){
        temp1[i]=i;
    }
    for (int i=0;i<k;i++){
               double temp=distance[i];
               int temp2=temp1[i];
               for(int j=i+1;j<distance.length;j++){
                   if(temp>distance[j]){
                       temp2=temp1[j];
                       temp1[j]=temp1[i];
                       temp1[i]=temp2;
                       temp=distance[j];
                   }
               if(temp1[i]!=i){
                   distance[j]=distance[i];
                   distance[i]=temp;
               }
        }
    }
               for (int i=0;i<k;i++){
                   Rank[i]=temp1[i];
               }
    return Rank;
}

private double euclid(double[] ds, double[] ds2) {
    double distance=0;
    if (ds.length==ds2.length){
        for(int i=0;i<ds.length;i++){
            distance=distance+Math.pow(ds[i]-ds2[i], 2);
        }
        distance=Math.sqrt(distance);
    }
    else{
        distance=0;
    }
    return distance;
}
}
//KNN算法


package KNN;

import java.io.IOException;

public class KNNmain{
    public static void main(String[] args) throws IOException {
        CrossValidation kvalue=new CrossValidation();
        kvalue.setK(30,100,2,25);
        int k=kvalue.getK();
        int n=kvalue.getN();
        int m=kvalue.getM();
        int n1=kvalue.getN1();
        double[] y=new double[n1];
        double[] Y1=new double[n1];
        double[][] newpoints=new double[n1][m];
        InputData ori=new InputData();
        InputData op=new InputData();
        double[][] X=new double[n][m];
        double[] Y=new double[n];
        ori.loadData(X, Y, "KNNtrain.txt");
        op.loadData(newpoints,Y1,"KNNtest.txt");
        KNN Kdata=new KNN();
        double[] c=new double[2];
        c[0]=0;
        c[1]=1;
        y=Kdata.y(X,Y,newpoints,k,c);
        double temp=0;
        for (int i=0;i<n1;i++){
            if(y[i]!=Y1[i]){
                temp=temp+1;
            }
            System.out.println(y[i]+" ");
        }
        System.out.println(temp/(double)newpoints.length);
    }
}
//主程序，输出分类结果及交叉验证结果

仿真数据：

训练数据

测试数据

k值	k=1	k=2	k=3	k=4	k=5	k=6	k=10	k=30
训练集错误率	0.04	0.04	0.6	0.4	0.56	0.24	0.24	0.30

由上表，该数据中K值取1或者2是最好的。