机器学习---K最近邻(k-Nearest Neighbour，KNN)分类算法

K最近邻(k-Nearest Neighbour，KNN)分类算法

1.K最近邻(k-Nearest Neighbour，KNN)

　　K最近邻(k-Nearest Neighbour，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。该方法的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。用官方的话来说，所谓K近邻算法，即是给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的K个实例（也就是上面所说的K个邻居）， 这K个实例的多数属于某个类，就把该输入实例分类到这个类中。

 

 

 

 

2.算法原理

　　

　　如上图所示，有两类不同的样本数据，分别用蓝色的小正方形和红色的小三角形表示，而图正中间的那个绿色的圆所标示的数据则是待分类的数据。也就是说，现在， 我们不知道中间那个绿色的数据是从属于哪一类（蓝色小正方形or红色小三角形），下面，我们就要解决这个问题：给这个绿色的圆分类。
　　我们常说，物以类聚，人以群分，判别一个人是一个什么样品质特征的人，常常可以从他/她身边的朋友入手，所谓观其友，而识其人。我们不是要判别上图中那个绿色的圆是属于哪一类数据么，好说，从它的邻居下手。但一次性看多少个邻居呢？从上图中，你还能看到：

• 如果K=3，绿色圆点的最近的3个邻居是2个红色小三角形和1个蓝色小正方形，少数从属于多数，基于统计的方法，判定绿色的这个待分类点属于红色的三角形一类。
• 如果K=5，绿色圆点的最近的5个邻居是2个红色三角形和3个蓝色的正方形，还是少数从属于多数，基于统计的方法，判定绿色的这个待分类点属于蓝色的正方形一类。

　　KNN算法中，所选择的邻居都是已经正确分类的对象。该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。KNN 算法本身简单有效，它是一种 lazy-learning 算法，分类器不需要使用训练集进行训练，训练时间复杂度为0。KNN 分类的计算复杂度和训练集中的文档数目成正比，也就是说，如果训练集中文档总数为 n，那么 KNN 的分类时间复杂度为O(n)。

　　KNN方法虽然从原理上也依赖于极限定理，但在类别决策时，只与极少量的相邻样本有关。由于KNN方法主要靠周围有限的邻近的样本，而不是靠判别类域的方法来确定所属类别的，因此对于类域的交叉或重叠较多的待分样本集来说，KNN方法较其他方法更为适合。

　　

　　K 近邻算法使用的模型实际上对应于对特征空间的划分。K 值的选择，距离度量和分类决策规则是该算法的三个基本要素：

　　（1）K 值的选择会对算法的结果产生重大影响。K值较小意味着只有与输入实例较近的训练实例才会对预测结果起作用，但容易发生过拟合；如果 K 值较大，优点是可以减少学习的估计误差，但缺点是学习的近似误差增大，这时与输入实例较远的训练实例也会对预测起作用，是预测发生错误。在实际应用中，K 值一般选择一个较小的数值，通常采用交叉验证的方法来选择最优的 K 值。随着训练实例数目趋向于无穷和 K=1 时，误差率不会超过贝叶斯误差率的2倍，如果K也趋向于无穷，则误差率趋向于贝叶斯误差率。

　　（2）该算法中的分类决策规则往往是多数表决，即由输入实例的 K 个最临近的训练实例中的多数类决定输入实例的类别

　　（3）距离度量一般采用 Lp 距离，当p=2时，即为欧氏距离，在度量之前，应该将每个属性的值规范化，这样有助于防止具有较大初始值域的属性比具有较小初始值域的属性的权重过大。

　　KNN算法不仅可以用于分类，还可以用于回归。通过找出一个样本的k个最近邻居，将这些邻居的属性的平均值赋给该样本，就可以得到该样本的属性。更有用的方法是将不同距离的邻居对该样本产生的影响给予不同的权值(weight)， 如权值与距离成反比。　该算法在分类时有个主要的不足是，当样本不平衡时，如一个类的样本容量很大，而其他类样本容量很小时，有可能导致当输入一个新样本 时，该样本的K个邻居中大容量类的样本占多数。 该算法只计算“最近的”邻居样本，某一类的样本数量很大，那么或者这类样本并不接近目标样本，或者这类样本很靠近目标样本。无论怎样，数量并不能影响运行 结果。可以采用权值的方法（和该样本距离小的邻居权值大）来改进。

3.算法不足

　　该方法的另一个不足之处是计算量较大，因为对每一个待分类的文本都要计算它到全体已知样本的距离，才能求得它的K个最近邻点。目前常用的解决方法是事先对已知样本点进行剪辑，事先去除对分类作用不大的样本。该算法比较适用于样本容量比较大的类域的自动分类，而那些样本容量较小的类域采用这种算法比较容易产生误分。

　　实现 K 近邻算法时，主要考虑的问题是如何对训练数据进行快速 K 近邻搜索，这在特征空间维数大及训练数据容量大时非常必要。

4.程序代码

　　以下两个片段一个是算法的主题，一个是主程序调用

/************************************************************************/
/*KNN分类算法C++实现版本    2015/11/5                                             */
/************************************************************************/
#include<iostream>
#include<fstream>

#include<map>
#include<vector>
#include <string>
#include<cmath>
#include<algorithm>


using namespace std;

typedef string tLabel;    //标签
typedef double tData;    //数据
typedef pair<int,double>  PAIR;    //位置和使用率（概率）
const int MaxColLen = 4;
const int MaxRowLen = 1000;
const int COLNUM = 3;
ifstream fin;
ofstream fout;

class KNN
{
private:
    tData dataSet[MaxRowLen][MaxColLen];    //数据集
    tLabel labels[MaxRowLen];    //分类结果的标签
    tData testData[MaxColLen];//保留测试数据归一化的结果，或者原来的测试数据
    int rowLen;
    int k;    //临近的K值
    int test_data_num;    //测试数据数量
    map<int,double> map_index_dis;    //训练数据集中各个数据到被测试数据的距离，并以训练数据的序号为索引
    map<tLabel,int> map_label_freq;    //KNN中的K个距离最近的特征分类结果与对应的频率
    double get_distance(tData *d1,tData *d2);
public:
    KNN();
    //预处理，获得相应的距离
    void get_all_distance();
    //获取最大的标签使用频率作为最大的概率
    tLabel get_max_freq_label();
    //归一化训练数据
    void auto_norm_data();
    //测试误差率
    void get_error_rate();
    //构造比较器，内部类型
    struct CmpByValue
    {
        bool operator() (const PAIR& lhs,const PAIR& rhs)
        {
            return lhs.second < rhs.second;
        }
    };

    ~KNN();    
};

KNN::~KNN()
{
    fin.close();
    fout.close();
    map_index_dis.clear();
    map_label_freq.clear();
}
/************************************************************************/
/*  KNN算法构造函数                                                     */
/************************************************************************/
KNN::KNN()
{
    this->rowLen = 1000;
    //this->colLen = col;
    this->k = 7;
    test_data_num = 50;
    //训练数据的读取
    fin.open("D:\\VC_WorkSpace\\KNNAlg\\datingTestTrainingData.txt");
    //输出的结果到一个文件中保存
    fout.open("D:\\VC_WorkSpace\\KNNAlg\\result.txt");

    if( !fin || !fout )
    {
        cout << "can not open the file"<<endl;
        exit(0);
    }

    for(int i = 0; i < rowLen; i++)
    {
        for(int j = 0; j < COLNUM; j++)
        {
            //cout << dataSet[i][j] << "_";
            fin >> dataSet[i][j];
            fout << dataSet[i][j] << " ";
        }
        //输入样本中的每个值向量对应的分类结果到“分类结果空间”
        fin >> labels[i];
        fout << labels[i]<< endl;
        //cout << endl;
    }

}

void KNN:: get_error_rate()
{
    int i,j,count = 0;
    tLabel label;
    cout << "please input the number of test data : "<<endl;
    cin >> test_data_num;//测试数据的数量
    //以训练数据的前test_data_num作为测试样本
    for( i = 0; i < test_data_num; i++ )
    {
        for(j = 0; j < COLNUM; j++)
        {
            testData[j] = dataSet[i][j];        
        }
        //训练test_data_num之后的数据作为训练数据
        get_all_distance();
        label = get_max_freq_label();//返回分类结果
        cout << "*******   the lable = " << label << endl;
        if( label != labels[i] )
            count++;//分类失败统计器
        map_index_dis.clear();
        map_label_freq.clear();
    }
    //计算误差
    cout<<"the error rate is = "<<(double)count/(double)test_data_num<<endl;
}
/************************************************************************/
/* 以欧式距离来表示                                                      */
/************************************************************************/
double KNN:: get_distance(tData *d1,tData *d2)
{
    double sum = 0;
    for(int i=0;i<COLNUM;i++)
    {
        sum += pow((d1[i] - d2[i]) , 2);
    }
    //输出结果显示
    //cout<<"the sum is = "<< sum << endl;
    return sqrt(sum);
}

/************************************************************************/
/* 以测试test_data_num序号之后的样本作为训练数据                         */
/************************************************************************/
void KNN:: get_all_distance()
{
    double distance;
    int i;
    for(i = test_data_num; i < rowLen; i++)
    {
        distance = get_distance(dataSet[i],testData);
        map_index_dis[i] = distance;
    }

    //  打开注释，可以查看索引距离集合中的内容
    //    map<int,double>::const_iterator it = map_index_dis.begin();
    //    while(it!=map_index_dis.end())
    //    {
    //        cout<<"index = "<<it->first<<" distance = "<<it->second<<endl;
    //        it++;
    //    }

}

tLabel KNN:: get_max_freq_label()
{
    vector<PAIR> vec_index_dis(map_index_dis.begin(), map_index_dis.end());
    //对结果进行排序操作，由小到大的顺序排列
    sort(vec_index_dis.begin(), vec_index_dis.end(), CmpByValue());
    //取前K个距离最近的特征标签作为分类的参考依据
    for(int i = 0; i < k; i++)
    {
        cout << "Index = " << vec_index_dis[i].first << " Distance = " << vec_index_dis[i].second << " Label = " << labels[vec_index_dis[i].first] << " \nCoordinate(";
        int j;
        for(j=0; j < COLNUM - 1; j++)
        {
            cout << dataSet[vec_index_dis[i].first][j]<<",";
        }
        cout << dataSet[vec_index_dis[i].first][j] << " )" << endl;
        //统计K邻域的使用频率
        map_label_freq[ labels[ vec_index_dis[i].first ]  ]++;
    }

    map<tLabel,int>::const_iterator map_it = map_label_freq.begin();
    tLabel label;    //保留频率最大的分类结果信息
    int max_freq = 0;    //最大的使用频率
    while( map_it != map_label_freq.end())
    {
        if( map_it->second > max_freq)
        {
            max_freq = map_it->second;
            label = map_it->first;
        }
        map_it++;
    }
    cout << "The test data belongs to the : " << label << " label" << endl;
    return label;
}
/************************************************************************/
/* 归一化处理                                                           */
/************************************************************************/
void KNN::auto_norm_data()
{
    tData maxa[COLNUM];    //
    tData mina[COLNUM];
    tData range[COLNUM];
    int i,j;
    //遍历训练数据，找出数据向量的各个极值，为后续归一化处理
    for( i = 0; i < COLNUM; i++ )
    {
        maxa[i] = max(dataSet[0][i],dataSet[1][i]);
        mina[i] = min(dataSet[0][i],dataSet[1][i]);
    }

    for( i = 2; i < rowLen; i++ )
    {
        for(j = 0; j < COLNUM; j++)
        {
            if( dataSet[i][j]>maxa[j] )
            {
                maxa[j] = dataSet[i][j];
            }
            else if( dataSet[i][j]<mina[j] )
            {
                mina[j] = dataSet[i][j];
            }
        }
    }

    for( i = 0; i < COLNUM; i++ )
    {
        range[i] = maxa[i] - mina[i] ; 
        //归一化测试数据
        testData[i] = ( testData[i] - mina[i] )/range[i] ;
    }

    //归一化训练数据的各个分量
    for(i=0;i<rowLen;i++)
    {
        for(j=0;j<COLNUM;j++)
        {
            dataSet[i][j] = ( dataSet[i][j] - mina[j] )/range[j];
        }
    }
}

　　主程序调用

// KNNAlg.cpp : 定义控制台应用程序的入口点。
#include "stdafx.h"
#include <iostream>
#include "knnbody.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{

    cout << "the KNN algothm is running ... " << endl;
    //生成KNN算法对象
    KNN knn = KNN();
    //训练数据的预处理
    knn.auto_norm_data();
    //对测试样本进行分类操作以及进行错误率统计
    knn.get_error_rate();

    system("pause");
    return 0;
}

　　备注：以上代码主要是呈现KNN算法的大致结构，程序中有些许细节不尽完善，后续需要更改。

　　参考网址：

（1）http://baike.baidu.com/link?url=B_MWlciVjI4Oz2UJQaa09C3xkdkOHHH5OOg3uxE1UiMtG_P4Eq3dMlVQiRqqTqpASFZV8sk1jjiS2gmQDPvZ__

（2）http://blog.csdn.net/lavorange/article/details/16924705