python数据挖掘实践第一章 KNN算法，以及算法的实现

KNN思路：

1.利用测试集和训练数据的相似性（目标距离的远近），取前K个

2.计算前K个分类的数据多少

3.选择最多的一个分目标分类

算法思路：

   不考虑时间复杂度

1、读取测试集，或者自动生成

2、遍历测试集

3、与训练集的每一行，进行计算距离（采用两点的距离公式），同时保存每一行计算的距离，和分类的值（生成一个新的矩阵或者集合）

4、选取前K个（这里要对距离和分类进行排序，排序算法）

5、要对前K个（已经排好离的分类，进行分组；并对C的数量进行排序，选取最多的就是目标）

下面是python 2.7的实现

from numpy import * 


import operator


from os import listdir
import pylab as pl 


from matplotlib import pyplot as plt


def file2Matrix(filename):
    fr = open(filename)
    numberOfLines = len(fr.readlines())         #get the number of lines in the file
    returnMat = zeros((numberOfLines,3))        #prepare matrix to return
    classLabelVector = []                       #prepare labels return   
    fr = open(filename)
    index = 0
    for line in fr.readlines():
        line = line.strip()
        listFromLine = line.split('\t')
        returnMat[index,:] = listFromLine[0:3]
        classLabelVector.append(int(listFromLine[-1]))
        index += 1
    return returnMat,classLabelVector


##
def createDataSet():
    group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])


    label =['A','A','B','B']


    return label,group




def  classify0(inX,dataSet,labels,k):
    dataSetSize = dataSet.shape[0]


    print 'dataSet.shape[1]',dataSet.shape[1]
    diffMat = tile(inX, (dataSetSize,1)) - dataSet
    sqDiffMat = diffMat**2
    sqDistances = sqDiffMat.sum(axis=1)
    distances = sqDistances**0.5
    sortedDistIndicies = distances.argsort()  
    classCount={}


    for a in range(k):
        voteIlabel=labels[sortedDistIndicies[a]]
        classCount[voteIlabel]=classCount.get(voteIlabel,0)+1
    sortedClassCount = sorted(classCount.iteritems(),key=operator.itemgetter(1),reverse=True)
    return sortedClassCount[0][0]




def classify01(inX, dataSet, labels, k):
    dataSetSize = dataSet.shape[0]
    diffMat = tile(inX, (dataSetSize,1)) - dataSet
    sqDiffMat = diffMat**2
    sqDistances = sqDiffMat.sum(axis=1)
    distances = sqDistances**0.5
    sortedDistIndicies = distances.argsort()     
    classCount={}          
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]




def autoNorm(datamingDataMat):
    minValue = datamingDataMat.min(0)
    maxValue = datamingDataMat.max(0)
    #print minValue
    #print maxValue


    range = maxValue-minValue


    print range
    #print shape(datamingDataMat)


    normDataSet = zeros(shape(datamingDataMat))
    #print  normDataSet
    m = datamingDataMat.shape[0]


    normDataSet = datamingDataMat-tile(minValue,(m,1))


    normDataSet = datamingDataMat/tile(range,(m,1))


    return normDataSet ,range,minValue
    
if __name__ == "__main__":
    label,group = createDataSet()
    print label
    ##pl.plot(group,'o')
    ##pl.show()
    #classify0([0,0],group,label,3)


    #读文件


    #datamingDataMat,datingLabels = file2Matrix('E:\\数据挖掘资料\\《机器学习实战》源代码\\machinelearninginaction\\Ch02\\datingTestSet2.txt')
    #
##    print len(datingLabels)
##    print datamingDataMat




##    fig = plt.figure()
##    ax = fig.add_subplot(111)
##    ax.scatter(datamingDataMat[:,0],datamingDataMat[:,1],
##              15.0*array(datingLabels),15.0*array(datingLabels))
##    plt.show()
##    normMat,ranges,minValue =autoNorm(datamingDataMat)
##
##    #print 'normorize:',normMat,'ranges:',ranges
##
##    m = normMat.shape[0]
##
##    print m
    hoRatio = 0.10      #hold out 10%
    datingDataMat,datingLabels = file2Matrix('E:\\数据挖掘资料\\《机器学习实战》源代码\\machinelearninginaction\\Ch02\\datingTestSet2.txt')       #load data setfrom file
    normMat, ranges, minVals = autoNorm(datingDataMat)
    m = normMat.shape[0]
    numTestVecs = int(m*hoRatio)
    errorCount = 0.0
    for i in range(numTestVecs):
        classifierResult = classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)
        print "the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i])
        if (classifierResult != datingLabels[i]): errorCount += 1.0
    print "the total error rate is: %f" % (errorCount/float(numTestVecs))
    print errorCount

---------------------------------------------------------------------------------------
    

以下是java 代码的实现

public class tztKNN {

/**
* set unique  coparator function,distance biggest,
*/
private static Comparator comparator = new Comparator() {


@Override
public int compare(KNNNode o1, KNNNode o2) {
// TODO Auto-generated method stub
if(o1.getDistance() >=o2.getDistance()){
return -1;
} else{
return 1;
}

}


};


public static void main(String[] args) {
// TODO Auto-generated method stub
   //第一加载文件
String fileName="E:\\数据挖掘资料\\《机器学习实战》源代码\\datingTestSet2.txt";

List>list = ReadFile(fileName);
/* System.out.println(list.get(0).toString());
System.out.println(list.get(1).toString());*/

Listtestlist =new ArrayList();
testlist.add(40920f);
testlist.add(8.326976f);
testlist.add(1.673904f);

//第二步
//可以直接计算距离
PriorityQueue result = new PriorityQueue();

result=Distances(testlist,list,3);
System.out.println("---------result-------");
//在这里计算出现最多的就是目标分类

String classif_re=getMostClass(result);


System.out.println(classif_re);
}


private static  String getMostClass(PriorityQueue result) {
Map classCount = new HashMap<>();
for(int i = 0; i<5; i++){
KNNNode node = result.poll();
String c = node.getC();
System.out.println("c:"+c);
if(classCount.containsKey(c)){
classCount.put(c, classCount.get(c)+1);
}
else{
classCount.put(c, 1);
}
}



        List> list =new ArrayList>(classCount.entrySet());
        //最后通过Collections.sort(List l, Comparator c)方法来进行排序，代码如下：


         Collections.sort(list, new Comparator>() {
                      public int compare(Map.Entry o1,
                       Map.Entry o2) {
                     return (o2.getValue() - o1.getValue());
           }
          });
         return list.get(0).getKey();
// TODO Auto-generated method stub
/*String re="";
Map classCount = new HashMap() ;
    int pqsize = 5;
    for (int i =0; i     KNNNode  node = result.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     if (classCount.get(classes[i])>maxCount){
    maxIndex = i;
    maxCount = classCount.get(classes[i]);
    }
    }*/
    //return (String) classes[maxIndex];
}


private static PriorityQueue Distances(List testlist, List> list,int k) {
// TODO Auto-generated method stub

double distance = 0.00;    
PriorityQueue pq = new PriorityQueue(k,comparator);
// 要存储每个元组的顺序，距离，和他们的分类

for(int i = 0; i List t = list.get(i);
String c = t.get(t.size() - 1).toString();

 for (int j= 0; j < testlist.size(); j++) {
             float test0 = testlist.get(j);
             float base0 = t.get(j);
             distance = (test0- base0)*(test0- base0);
    }  
 System.out.println("the:"+i+" ci:"+"c:"+c+" distace:"+distance);
 KNNNode node = new KNNNode(i,distance,c); 
 pq.add(node);
}


 
   return pq;



}


private static List> ReadFile(String fileName) {
// TODO Auto-generated method stub
List> datasets = new ArrayList<>();
try {
File file = new File(fileName);
if(file.exists()){
InputStreamReader reader=new InputStreamReader(new FileInputStream(file),"GBK" );
BufferedReader bufferedReader = new BufferedReader(reader);

String lineTxt = "";

while((lineTxt =bufferedReader.readLine())!=null){
//System.out.println(lineTxt);
//分离分行数据
ArrayList aa = new ArrayList<>();
String[] shuxing =lineTxt.split(" ");

for (String sx :shuxing){
//System.out.println(sx);
aa.add(Float.parseFloat(sx));
}
datasets.add(aa);
}

  }else{
           System.out.println("找不到指定的文件");
       }


} catch (Exception e) {
// TODO: handle exception
System.out.println("读取文件内容出错");
           e.printStackTrace();
}

return datasets;
}


}